AbstractPasswordService::StrengthValidatorResult
PasswordStrengthValidator::evaluateStrength(const WT_USTRING& password,
const WT_USTRING& loginName,
const std::string& email) const
{
passwdqc_params_qc_t params;
for (unsigned i = 0; i < 5; ++i)
params.min[i] = minLength_[i];
params.passphrase_words = passPhraseWords_;
params.match_length = minMatchLength_;
params.similar_deny = false;
params.random_bits = 0;
params.max = 256;
std::string login_utf8 = loginName.toUTF8();
passwdqc_user_t user;
user.pw_name = login_utf8.c_str();
user.pw_email = email.c_str();
int index = passwdqc_check(¶ms, password.toUTF8().c_str(), 0, &user);
WString message
= WString::tr(std::string("Wt.Auth.passwdqc.reason-") + reasons[index]);
bool valid = index == 0;
AbstractPasswordService::StrengthValidatorResult result(valid,
message,
valid ? 5 : 0);
return result;
}
void WTableRow::addStyleClass(const WT_USTRING& style)
{
std::string currentClass = styleClass_.toUTF8();
Utils::SplitSet classes;
Utils::split(classes, currentClass, " ", true);
if (classes.find(style.toUTF8()) == classes.end()) {
styleClass_ = WT_USTRING::fromUTF8(Utils::addWord(styleClass_.toUTF8(),
style.toUTF8()));
table_->repaintRow(this);
}
}
void WSlider::setValueText(const WT_USTRING& value)
{
try {
value_ = Utils::stoi(value.toUTF8());
} catch (std::exception& e) {
}
}
bool WAbstractSpinBox::parseValue(const WT_USTRING& text)
{
std::string textUtf8 = text.toUTF8();
bool valid = true;
if (!nativeControl()) {
valid = false;
std::string prefixUtf8 = prefix_.toUTF8();
std::string suffixUtf8 = suffix_.toUTF8();
if (boost::starts_with(textUtf8, prefixUtf8)) {
textUtf8 = textUtf8.substr(prefixUtf8.length());
if (boost::ends_with(textUtf8, suffixUtf8)) {
textUtf8 = textUtf8.substr(0, textUtf8.length() - suffixUtf8.length());
valid = true;
}
}
}
if (valid)
valid = textUtf8.length() > 0;
if (valid)
valid = parseNumberValue(textUtf8);
return valid;
}
WValidator::Result WRegExpValidator::validate(const WT_USTRING& input) const
{
if (input.empty())
return WValidator::validate(input);
if (std::regex_match(input.toUTF8(), regex_))
return Result(ValidationState::Valid);
else
return Result(ValidationState::Invalid, invalidNoMatchText());
}
void WLink::setInternalPath(const WT_USTRING& internalPath)
{
type_ = InternalPath;
std::string path = internalPath.toUTF8();
if (boost::starts_with(path, "#/"))
path = path.substr(1);
value_ = path;
}
int WLocale::toInt(const WT_USTRING& value) const
{
if (groupSeparator_.empty())
return boost::lexical_cast<int>(value);
std::string v = value.toUTF8();
Utils::replace(v, groupSeparator_, "");
return boost::lexical_cast<int>(v);
}
double WLocale::toDouble(const WT_USTRING& value) const
{
if (isDefaultNumberLocale())
return boost::lexical_cast<double>(value);
std::string v = value.toUTF8();
if (!groupSeparator_.empty())
Utils::replace(v, groupSeparator_, "");
if (decimalPoint_ != ".")
Utils::replace(v, decimalPoint_, ".");
return boost::lexical_cast<double>(v);
}
WValidator::Result WIntValidator::validate(const WT_USTRING& input) const
{
if (input.empty())
return WValidator::validate(input);
std::string text = input.toUTF8();
try {
int i = WLocale::currentLocale().toInt(text);
if (i < bottom_)
return Result(Invalid, invalidTooSmallText());
else if (i > top_)
return Result(Invalid, invalidTooLargeText());
else
return Result(Valid);
} catch (boost::bad_lexical_cast& e) {
return Result(Invalid, invalidNotANumberText());
}
}
void WLineEdit::updateDom(DomElement& element, bool all)
{
if (all || flags_.test(BIT_CONTENT_CHANGED)) {
WT_USTRING t = content_;
if (!mask_.empty() && (inputMaskFlags_.test(
InputMaskFlag::KeepMaskWhileBlurred)))
t = displayContent_;
if (!all || !t.empty())
element.setProperty(Wt::Property::Value, t.toUTF8());
flags_.reset(BIT_CONTENT_CHANGED);
}
if (all || flags_.test(BIT_ECHO_MODE_CHANGED)) {
element.setAttribute("type", echoMode_ == EchoMode::Normal
? "text" : "password");
flags_.reset(BIT_ECHO_MODE_CHANGED);
}
if (all || flags_.test(BIT_AUTOCOMPLETE_CHANGED)) {
if (!all || !autoComplete_) {
element.setAttribute("autocomplete",
autoComplete_ == true ? "on" : "off");
}
flags_.reset(BIT_AUTOCOMPLETE_CHANGED);
}
if (all || flags_.test(BIT_TEXT_SIZE_CHANGED)) {
element.setAttribute("size", std::to_string(textSize_));
flags_.reset(BIT_TEXT_SIZE_CHANGED);
}
if (all || flags_.test(BIT_MAX_LENGTH_CHANGED)) {
if (!all || maxLength_ > 0)
element.setAttribute("maxLength", std::to_string(maxLength_));
flags_.reset(BIT_MAX_LENGTH_CHANGED);
}
WFormWidget::updateDom(element, all);
}
void WRegExpValidator::setRegExp(const WT_USTRING& pattern)
{
regex_.assign(pattern.toUTF8());
pattern_ = pattern;
repaint();
}
WRegExpValidator::WRegExpValidator(const WT_USTRING& pattern)
: regex_(pattern.toUTF8())
{ }
void WLink::setInternalPath(const WT_USTRING& internalPath)
{
type_ = InternalPath;
value_ = internalPath.toUTF8();
}
WDate::RegExpInfo WDate::formatToRegExp(const WT_USTRING& format)
{
RegExpInfo result;
std::string f = format.toUTF8();
int currentGroup = 1;
result.dayGetJS = "return 1";
result.monthGetJS = "return 1";
result.yearGetJS = "return 2000";
bool inQuote = false;
bool gotQuoteInQuote = false;
static const std::string regexSpecial = "/[\\^$.|?*+()";
int d = 0, M = 0, y = 0;
for (unsigned i = 0; i < f.length(); ++i) {
if (inQuote) {
if (f[i] != '\'') {
if (gotQuoteInQuote) {
gotQuoteInQuote = false;
inQuote = false;
} else
result.regexp += f[i];
} else {
if (gotQuoteInQuote) {
gotQuoteInQuote = false;
result.regexp += f[i];
} else
gotQuoteInQuote = true;
}
}
if (!inQuote) {
switch (f[i]) {
case 'd':
if (d == 0)
writeRegExpLast(result, d, M, y, format, currentGroup);
++d;
break;
case 'M':
if (M == 0)
writeRegExpLast(result, d, M, y, format, currentGroup);
++M;
break;
case 'y':
if (y == 0)
writeRegExpLast(result, d, M, y, format, currentGroup);
++y;
break;
default:
writeRegExpLast(result, d, M, y, format, currentGroup);
if (f[i] == '\'') {
inQuote = true;
gotQuoteInQuote = false;
} else if (regexSpecial.find(f[i]) != std::string::npos) {
result.regexp += "\\";
result.regexp += f[i];
} else
result.regexp += f[i];
}
}
}
writeRegExpLast(result, d, M, y, format, currentGroup);
return result;
}
