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;
}
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 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);
}
}
// Remove spaces, only for input masks
WT_USTRING WLineEdit::removeSpaces(const WT_USTRING& text) const
{
if (!raw_.empty() && !text.empty()) {
std::u32string result = text;
std::size_t i = 0;
for (std::size_t j = 0; j < raw_.length(); ++i, ++j) {
while (j < raw_.length() &&
result[j] == spaceChar_ &&
mask_[j] != '_') {
++j;
}
if (j < raw_.length()) {
if (i != j) {
result[i] = result[j];
}
} else {
--i;
}
}
result = result.substr(0, i);
return WT_USTRING(result);
} else {
return text;
}
}
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 WTimeValidator::validate(const WT_USTRING& input) const
{
if (input.empty())
return WValidator::validate(input);
for (unsigned i = 0; i < formats_.size(); ++i) {
try {
WTime d = WTime::fromString(input, formats_[i]);
if (d.isValid()) {
if (!bottom_.isNull())
if (d < bottom_)
return Result(Invalid, invalidTooEarlyText());
if (!top_.isNull())
if (d > top_)
return Result(Invalid, invalidTooLateText());
return Result(Valid);
}
} catch (std::exception& e) {
LOG_WARN("validate(): " << e.what());
}
}
return Result(Invalid, invalidNotATimeText());
}
void WSlider::setValueText(const WT_USTRING& value)
{
try {
value_ = Utils::stoi(value.toUTF8());
} catch (std::exception& e) {
}
}
WValidator::Result WRegExpValidator::validate(const WT_USTRING& input) const
{
if (input.empty())
return WValidator::validate(input);
if (!regexp_ || regexp_->exactMatch(input))
return Result(Valid);
else
return Result(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);
}
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);
}
WValidator::Result WLengthValidator::validate(const WT_USTRING& input) const
{
if (input.empty())
return WValidator::validate(input);
#ifndef WT_TARGET_JAVA
#ifndef WT_NO_STD_WSTRING
std::wstring text = input.value();
#else
std::string text = input.narrow();
#endif
#else
std::string text = input;
#endif
if ((int)text.length() < minLength_)
return Result(Invalid, invalidTooShortText());
else if ((int)text.length() > maxLength_)
return Result(Invalid, invalidTooLongText());
else
return Result(Valid);
}
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 WMatchValidator::validate(const WT_USTRING& strInput) const
{
if(0 == m_pCompareWidget) {
return Result(Invalid, invalidDataText());
}
if(strInput.empty()) {
return WValidator::validate(strInput);
}
if(strInput != m_pCompareWidget->valueText()) {
return Result(Invalid, mismatchText());
}
return Result(Valid);
}
// Unless the given text is empty, input the text as if it was
// entered character by character on the client side, applying
// the input mask, if present.
WT_USTRING WLineEdit::inputText(const WT_USTRING& text) const
{
if (!raw_.empty() && !text.empty()) {
std::u32string newText = text;
std::u32string result = raw_;
char32_t chr;
bool hadIgnoredChar = false;
std::size_t j = 0, i = 0;
for (i = 0; i < newText.length(); ++i) {
std::size_t previousJ = j;
chr = newText[i];
while (j < mask_.length() && !acceptChar(chr, j)) {
++j; /* Try to move forward as long as this characer is not
* accepted in this position
*/
}
if (j == mask_.length()) {
j = previousJ;
hadIgnoredChar = true;
} else {
if (raw_[j] != chr) {
if (case_[j] == '>') {
chr = toupper(chr);
} else if (case_[j] == '<') {
chr = tolower(chr);
}
result[j] = chr;
}
++j;
}
}
if (hadIgnoredChar) {
LOG_INFO("Input mask: not all characters in input '" + text + "' complied with "
"input mask " + inputMask_ + " and were ignored. Result is '" + result + "'.");
}
return WT_USTRING(result);
}
return text;
}
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;
}
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();
}
