cutelyst  3.9.0
A C++ Web Framework built on top of Qt, using the simple approach of Catalyst (Perl) framework.
validatorbefore.cpp
1 /*
2  * SPDX-FileCopyrightText: (C) 2017-2022 Matthias Fehring <mf@huessenbergnetz.de>
3  * SPDX-License-Identifier: BSD-3-Clause
4  */
5 
6 #include "validatorbefore_p.h"
7 
8 #include <QtCore/QLoggingCategory>
9 
10 using namespace Cutelyst;
11 
12 Q_LOGGING_CATEGORY(C_VALIDATORBEFORE, "cutelyst.utils.validator.before", QtWarningMsg)
13 
14 ValidatorBefore::ValidatorBefore(const QString &field,
15  const QVariant &comparison,
16  const QString &timeZone,
17  const char *inputFormat,
18  const ValidatorMessages &messages,
19  const QString &defValKey)
20  : ValidatorRule(*new ValidatorBeforePrivate(field,
21  comparison,
22  timeZone,
23  inputFormat,
24  messages,
25  defValKey))
26 {
27 }
28 
29 ValidatorBefore::~ValidatorBefore()
30 {
31 }
32 
33 ValidatorReturnType ValidatorBefore::validate(Context *c, const ParamsMultiMap &params) const
34 {
35  ValidatorReturnType result;
36 
37  Q_D(const ValidatorBefore);
38 
39  const QString v = value(params);
40 
41  if (!v.isEmpty()) {
42 
43  const QTimeZone tz = d->extractTimeZone(c, params, d->timeZone);
44 
45  const QVariant _comp =
46  (d->comparison.userType() == QMetaType::QString)
47  ? d->extractOtherDateTime(c, params, d->comparison.toString(), tz, d->inputFormat)
48  : d->comparison;
49 
50  if (_comp.userType() == QMetaType::QDate) {
51 
52  const QDate odate = _comp.toDate();
53  if (Q_UNLIKELY(!odate.isValid())) {
54  qCWarning(
55  C_VALIDATOR,
56  "ValidatorBefore: Invalid comparison date and time for field %s at %s::%s.",
57  qPrintable(field()),
58  qPrintable(c->controllerName()),
59  qPrintable(c->actionName()));
60  result.errorMessage = validationDataError(c);
61  } else {
62  const QDate date = d->extractDate(c, v, d->inputFormat);
63  if (Q_UNLIKELY(!date.isValid())) {
64  qCWarning(
65  C_VALIDATOR,
66  "ValidatorBefore: Can not parse input date \"%s\" for field %s at %s::%s.",
67  qPrintable(v),
68  qPrintable(field()),
69  qPrintable(c->controllerName()),
70  qPrintable(c->actionName()));
71  result.errorMessage = parsingError(c, odate);
72  } else {
73  if (Q_UNLIKELY(date >= odate)) {
74  qCDebug(C_VALIDATOR,
75  "ValidatorBefore: Validation failed at %s::%s for field %s: Input "
76  "date \"%s\" is not before \"%s\".",
77  qPrintable(c->controllerName()),
78  qPrintable(c->actionName()),
79  qPrintable(field()),
80  qPrintable(date.toString()),
81  qPrintable(odate.toString()));
82  result.errorMessage = validationError(c, odate);
83  } else {
84  result.value.setValue(date);
85  }
86  }
87  }
88 
89  } else if (_comp.userType() == QMetaType::QDateTime) {
90 
91  const QDateTime odatetime = _comp.toDateTime();
92  if (Q_UNLIKELY(!odatetime.isValid())) {
93  qCWarning(
94  C_VALIDATOR,
95  "ValidatorBefore: Invalid comparison date and time for field %s at %s::%s.",
96  qPrintable(field()),
97  qPrintable(c->controllerName()),
98  qPrintable(c->actionName()));
99  result.errorMessage = validationDataError(c);
100  } else {
101  const QDateTime datetime = d->extractDateTime(c, v, d->inputFormat, tz);
102  if (Q_UNLIKELY(!datetime.isValid())) {
103  qCWarning(C_VALIDATOR,
104  "ValidatorBefore: Can not parse input date and time \"%s\" for field "
105  "%s at %s::%s.",
106  qPrintable(v),
107  qPrintable(field()),
108  qPrintable(c->controllerName()),
109  qPrintable(c->actionName()));
110  result.errorMessage = parsingError(c, odatetime);
111  } else {
112  if (Q_UNLIKELY(datetime >= odatetime)) {
113  qCDebug(C_VALIDATOR,
114  "ValidatorBefore: Validation failed at %s::%s for field %s: Input "
115  "date and time \"%s\" is not before \"%s\".",
116  qPrintable(c->controllerName()),
117  qPrintable(c->actionName()),
118  qPrintable(field()),
119  qPrintable(datetime.toString()),
120  qPrintable(odatetime.toString()));
121  result.errorMessage = validationError(c, odatetime);
122  } else {
123  result.value.setValue(datetime);
124  }
125  }
126  }
127 
128  } else if (_comp.userType() == QMetaType::QTime) {
129 
130  const QTime otime = _comp.toTime();
131  if (Q_UNLIKELY(!otime.isValid())) {
132  qCWarning(C_VALIDATOR,
133  "ValidatorBefore: Invalid comparison time for field %s at %s::%s.",
134  qPrintable(field()),
135  qPrintable(c->controllerName()),
136  qPrintable(c->actionName()));
137  result.errorMessage = validationDataError(c);
138  } else {
139  const QTime time = d->extractTime(c, v, d->inputFormat);
140  if (Q_UNLIKELY(!time.isValid())) {
141  qCWarning(
142  C_VALIDATOR,
143  "ValidatorBefore: Can not parse input time \"%s\" for field %s at %s::%s.",
144  qPrintable(v),
145  qPrintable(field()),
146  qPrintable(c->controllerName()),
147  qPrintable(c->actionName()));
148  result.errorMessage = parsingError(c, otime);
149  } else {
150  if (Q_UNLIKELY(time >= otime)) {
151  qCDebug(C_VALIDATOR,
152  "ValidatorBefore: Validation failed at %s::%s for field %s: Input "
153  "time \"%s\" is not before \"%s\".",
154  qPrintable(c->controllerName()),
155  qPrintable(c->actionName()),
156  qPrintable(field()),
157  qPrintable(time.toString()),
158  qPrintable(otime.toString()));
159  result.errorMessage = validationError(c, otime);
160  } else {
161  result.value.setValue(time);
162  }
163  }
164  }
165 
166  } else {
167  qCWarning(C_VALIDATOR)
168  << "ValidatorBefore: Invalid validation data for field" << field() << "at"
169  << c->controllerName() << "::" << c->actionName() << ":" << d->comparison;
170  result.errorMessage = validationDataError(c);
171  }
172  } else {
173  defaultValue(c, &result, "ValidatorAfter");
174  }
175 
176  return result;
177 }
178 
179 QString ValidatorBefore::genericValidationError(Cutelyst::Context *c,
180  const QVariant &errorData) const
181 {
182  QString error;
183 
184  const QString _label = label(c);
185  if (_label.isEmpty()) {
186 
187  switch (errorData.userType()) {
188  case QMetaType::QDate:
189  error =
190  QStringLiteral("Has to be before %1.")
191  .arg(errorData.toDate().toString(c->locale().dateFormat(QLocale::ShortFormat)));
192  break;
193  case QMetaType::QDateTime:
194  error = QStringLiteral("Has to be before %1.")
195  .arg(errorData.toDateTime().toString(
196  c->locale().dateTimeFormat(QLocale::ShortFormat)));
197  break;
198  case QMetaType::QTime:
199  error =
200  QStringLiteral("Has to be before %1.")
201  .arg(errorData.toTime().toString(c->locale().timeFormat(QLocale::ShortFormat)));
202  break;
203  default:
204  error = validationDataError(c);
205  break;
206  }
207 
208  } else {
209 
210  switch (errorData.userType()) {
211  case QMetaType::QDate:
212  error =
213  c->translate("Cutelyst::ValidatorBefore",
214  "The date in the “%1” field must be before %2.")
215  .arg(_label,
216  errorData.toDate().toString(c->locale().dateFormat(QLocale::ShortFormat)));
217  break;
218  case QMetaType::QDateTime:
219  error = c->translate("Cutelyst::ValidatorBefore",
220  "The date and time in the “%1” field must be before %2.")
221  .arg(_label,
222  errorData.toDateTime().toString(
223  c->locale().dateTimeFormat(QLocale::ShortFormat)));
224  break;
225  case QMetaType::QTime:
226  error =
227  c->translate("Cutelyst::ValidatorBefore",
228  "The time in the “%1” field must be before %2.")
229  .arg(_label,
230  errorData.toTime().toString(c->locale().timeFormat(QLocale::ShortFormat)));
231  break;
232  default:
233  error = validationDataError(c);
234  break;
235  }
236  }
237 
238  return error;
239 }
240 
241 QString ValidatorBefore::genericValidationDataError(Context *c, const QVariant &errorData) const
242 {
243  QString error;
244 
245  Q_UNUSED(errorData)
246  error =
247  c->translate("Cutelyst::ValidatorBefore",
248  "The comparison value is not a valid date and/or time, or cannot be found.");
249 
250  return error;
251 }
252 
253 QString ValidatorBefore::genericParsingError(Context *c, const QVariant &errorData) const
254 {
255  QString error;
256 
257  Q_D(const ValidatorBefore);
258 
259  const QString _label = label(c);
260  if (d->inputFormat) {
261  if (_label.isEmpty()) {
262  //: %1 will be replaced by the datetime format
263  error =
264  c->translate(
265  "Cutelyst::ValidatorBefore",
266  "Could not be parsed according to the following date and/or time format: %1")
267  .arg(c->translate(d->translationContext.data(), d->inputFormat));
268  } else {
269  //: %1 will be replaced by the field label, %2 will be replaced by the datetime format
270  error = c->translate("Cutelyst::ValidatorBefore",
271  "The value of the “%1” field could not be parsed according to the "
272  "following date and/or time format: %2")
273  .arg(_label, c->translate(d->translationContext.data(), d->inputFormat));
274  }
275  } else {
276 
277  if (_label.isEmpty()) {
278  switch (errorData.userType()) {
279  case QMetaType::QDateTime:
280  error = c->translate("Cutelyst::ValidatorBefore",
281  "Could not be parsed as date and time.");
282  break;
283  case QMetaType::QTime:
284  error = c->translate("Cutelyst::ValidatorBefore", "Could not be parsed as time.");
285  break;
286  case QMetaType::QDate:
287  error = c->translate("Cutelyst::ValidatorBefore", "Could not be parsed as date.");
288  break;
289  default:
290  error = validationDataError(c);
291  break;
292  }
293  } else {
294  switch (errorData.userType()) {
295  case QMetaType::QDateTime:
296  //: %1 will be replaced by the field label
297  error = c->translate(
298  "Cutelyst::ValidatorBefore",
299  "The value in the “%1” field could not be parsed as date and time.")
300  .arg(_label);
301  break;
302  case QMetaType::QTime:
303  //: %1 will be replaced by the field label
304  error = c->translate("Cutelyst::ValidatorBefore",
305  "The value in the “%1” field could not be parsed as time.")
306  .arg(_label);
307  break;
308  case QMetaType::QDate:
309  //: %1 will be replaced by the field label
310  error = c->translate("Cutelyst::ValidatorBefore",
311  "The value in the “%1” field could not be parsed as date.")
312  .arg(_label);
313  break;
314  default:
315  error = validationDataError(c);
316  break;
317  }
318  }
319  }
320 
321  return error;
322 }
Cutelyst::Context
The Cutelyst Context.
Definition: context.h:39
Cutelyst::Context::locale
QLocale locale() const noexcept
Definition: context.cpp:460
Cutelyst::Context::translate
QString translate(const char *context, const char *sourceText, const char *disambiguation=nullptr, int n=-1) const
Definition: context.cpp:484
Cutelyst::ValidatorBefore
Checks if a date, time or datetime is before a comparison value.
Definition: validatorbefore.h:84
Cutelyst::ValidatorBefore::genericValidationDataError
QString genericValidationDataError(Context *c, const QVariant &errorData=QVariant()) const override
Returns a generic error if comparison data was invalid.
Definition: validatorbefore.cpp:241
Cutelyst::ValidatorBefore::genericValidationError
QString genericValidationError(Context *c, const QVariant &errorData=QVariant()) const override
Returns a generic error if validation failed.
Definition: validatorbefore.cpp:179
Cutelyst::ValidatorBefore::validate
ValidatorReturnType validate(Context *c, const ParamsMultiMap &params) const override
Performs the validation and returns the result.
Definition: validatorbefore.cpp:33
Cutelyst::ValidatorBefore::~ValidatorBefore
~ValidatorBefore() override
Deconstructs the before validator.
Definition: validatorbefore.cpp:29
Cutelyst::ValidatorBefore::genericParsingError
QString genericParsingError(Context *c, const QVariant &errorData=QVariant()) const override
Returns a generic error if the input value could not be parsed.
Definition: validatorbefore.cpp:253
Cutelyst::ValidatorRule
Base class for all validator rules.
Definition: validatorrule.h:301
Cutelyst::ValidatorRule::label
QString label(Context *c) const
Returns the human readable field label used for generic error messages.
Definition: validatorrule.cpp:52
Cutelyst::ValidatorRule::field
QString field() const
Returns the name of the field to validate.
Definition: validatorrule.cpp:29
Cutelyst::ValidatorRule::parsingError
QString parsingError(Context *c, const QVariant &errorData=QVariant()) const
Returns an error message if an error occurred while parsing input.
Definition: validatorrule.cpp:98
Cutelyst::ValidatorRule::defaultValue
void defaultValue(Context *c, ValidatorReturnType *result, const char *validatorName) const
I a defValKey has been set in the constructor, this will try to get the default value from the stash ...
Definition: validatorrule.cpp:162
Cutelyst::ValidatorRule::value
QString value(const ParamsMultiMap &params) const
Returns the value of the field from the input params.
Definition: validatorrule.cpp:35
Cutelyst::ValidatorRule::validationDataError
QString validationDataError(Context *c, const QVariant &errorData=QVariant()) const
Returns an error message if any validation data is missing or invalid.
Definition: validatorrule.cpp:130
Cutelyst::ValidatorRule::validationError
QString validationError(Context *c, const QVariant &errorData=QVariant()) const
Returns a descriptive error message if validation failed.
Definition: validatorrule.cpp:66
Cutelyst
The Cutelyst namespace holds all public Cutelyst API.
Definition: Mainpage.dox:8
QDate::isValid
bool isValid() const const
QDate::toString
QString toString(Qt::DateFormat format) const const
QDateTime::isValid
bool isValid() const const
QDateTime::toString
QString toString(Qt::DateFormat format) const const
QLocale::dateFormat
QString dateFormat(QLocale::FormatType format) const const
QLocale::dateTimeFormat
QString dateTimeFormat(QLocale::FormatType format) const const
QLocale::timeFormat
QString timeFormat(QLocale::FormatType format) const const
QString::arg
QString arg(qlonglong a, int fieldWidth, int base, QChar fillChar) const const
QString::isEmpty
bool isEmpty() const const
QTime::isValid
bool isValid() const const
QTime::toString
QString toString(Qt::DateFormat format) const const
QVariant::setValue
void setValue(const T &value)
QVariant::toDate
QDate toDate() const const
QVariant::toDateTime
QDateTime toDateTime() const const
QVariant::toTime
QTime toTime() const const
QVariant::userType
int userType() const const
Cutelyst::ValidatorMessages
Stores custom error messages and the input field label.
Definition: validatorrule.h:141
Cutelyst::ValidatorReturnType
Contains the result of a single input parameter validation.
Definition: validatorrule.h:49
Generated by doxygen 1.9.1