validate method

Implementation

@override
FutureOr<Map<JsonPath, List<ValidationError>>> validate(
    {required bool skipIfUnmodified}) async {
  try {
    final subforms = [...this._subforms];

    List<ValidationError> validationErrors = [];
    for (final subform in subforms) {
      try {
        final errs =
            await subform!.validate(skipIfUnmodified: skipIfUnmodified);
        validationErrors += errs.values.flatten();
      } on BadRequestException catch (e) {
        validationErrors += e.validationErrors;
      }
    }

    List<ValidationError> myErrors;
    if (_isModified || skipIfUnmodified != true) {
      // Do the inline validation
      final inlineValidators = validators
          .mapEntries((JsonPath path, FormFieldValidator validator) {
        final response = validator(get(path));
        if (response != null) {
          return ValidationError(path: path, message: response);
        } else {
          return null;
        }
      }).notNull();

      final processingErrors =
          await _formValidators.entries.map((entry) async {
        try {
          final validator = entry.value;
          final errors = await validator.call(this);
          return errors;
        } on BadRequestException catch (e) {
          return e.validationErrors;
        } catch (e, stack) {
          log.severe("An unexpected error while validating: $e", stack);
          return [
            ValidationError.ofString(
              JsonPath.root(),
              "Unknown error validating form",
              debugMessage: "$e",
            ),
          ];
        }
      }).awaitAll();

      myErrors = [
        ...inlineValidators,
        ...processingErrors.flatten(),
      ];

      myErrors.forEach((err) {
        addError(err.path, err, source: AttributeSource.model);
      });
    } else {
      myErrors = [];
    }

    return [...validationErrors, ...myErrors].groupBy(((e) => e.path));
  } catch (e) {
    log.severe("An unexpected error while validating: $e");
    rethrow;
  }
}