public async Task <UsersLoginResultDto> RegisterManager(ManagerCreateDto managerDto)
{
await ValidateManagerCreateDto(managerDto);
var manager = _mapper.Map <AppUser>(managerDto.User);
manager.Company = _mapper.Map <Company>(managerDto.Company);
manager.Company.ChangeDate = DateTime.Now;
manager.UserName = managerDto.User.Login;
manager.Company.Subscriptions = new List <Subscription>()
{
new Subscription
{
StartDate = DateTime.UtcNow,
EndDate = DateTime.UtcNow.AddDays(7),
TariffId = 2,
Active = true
}
};
manager.Created = DateTime.UtcNow;
var result = _userManager.CreateAsync(manager, managerDto.User.Password).Result;
if (!result.Succeeded)
{
var validationErrors = new List <ValidationResult>();
foreach (var error in result.Errors)
{
validationErrors.Add(new ValidationResult(error.Description));
}
var ex = new Exceptions.ValidationException("Ошибка регистрации", validationErrors);
throw ex;
}
var user = _userManager.FindByNameAsync(manager.UserName).Result;
await _userManager.AddToRoleAsync(user, "manager");
var token = await GenerateJwtToken(user);
return(new UsersLoginResultDto {
Name = user.UserName, Token = token
});
}
/// <summary>
/// Stores the errors in a ValidationException object to the specified modelstate dictionary.
/// </summary>
public static void AddValidationException(this ModelStateDictionary modelState,
Exceptions.ValidationException exception)
{
if (!string.IsNullOrEmpty(exception.Message))
{
modelState.AddModelError(string.Empty, exception.Message);
}
foreach (var failure in exception.Failures)
{
var key = failure.MemberName;
if (!modelState.ContainsKey(key) || modelState[key].Errors.All(i => i.ErrorMessage != failure.Message))
{
modelState.AddModelError(key, failure.Message);
}
}
}
public void Domain_validation_exception_should_take_into_account_IValidatableObject()
{
// Arrange
var obj = new User();
// Act
Exceptions.ValidationException validationException = null;
try
{
Saritasa.Tools.Domain.Exceptions.ValidationException.ThrowFromObjectValidation(obj);
}
catch (Exceptions.ValidationException ex)
{
validationException = ex;
}
// Assert
Assert.NotNull(validationException);
Assert.Equal(1, validationException.SummaryErrors.Count());
Assert.Equal(2, validationException.Errors.Count);
}
public void Domain_validation_exception_should_throw_on_not_valid_object()
{
// Arrange
var obj = new Product();
// Act
Exceptions.ValidationException validationException = null;
try
{
Saritasa.Tools.Domain.Exceptions.ValidationException.ThrowFromObjectValidation(obj);
}
catch (Exceptions.ValidationException ex)
{
validationException = ex;
}
// Assert
Assert.NotNull(validationException);
Assert.Equal(0, validationException.SummaryErrors.Count());
Assert.Equal(1, validationException.Errors.Count);
}
public void Domain_validation_should_work_on_MetadataType_attribute()
{
// Arrange
var obj = new Job();
// Act
Exceptions.ValidationException.UseMetadataType = true;
Exceptions.ValidationException validationException = null;
try
{
Saritasa.Tools.Domain.Exceptions.ValidationException.ThrowFromObjectValidation(obj);
}
catch (Exceptions.ValidationException ex)
{
validationException = ex;
}
// Assert
Assert.NotNull(validationException);
Assert.Equal(0, validationException.SummaryErrors.Count());
Assert.Equal(2, validationException.Errors.Count);
}
/// <summary>
/// Validates Model automatically
/// </summary>
/// <param name="context"></param>
/// <inheritdoc />
public override void OnActionExecuting(ActionExecutingContext context)
{
string traceId = Guid.NewGuid().ToString();
_logger.LogInformation("({traceId}): Start validation OnActionExecuting", traceId);
if (context == null)
{
Exception exception = new Exception("ConsistentApiResponseErrors ValidateModelStateAttribute: The context is null");
_logger.LogError(exception, exception.Message + " ({traceId})", traceId);
throw exception;
}
List <ValidationFailure> allErrors = new List <ValidationFailure>();
// Validate the basic model state
if (!context.ModelState.IsValid)
{
// 2020-01-04: Use the "Exceptions.ValidationException" to convert ModelState to Fluent-ValidationFailures
Exceptions.ValidationException validationException = new Exceptions.ValidationException("bad_request", context.ModelState, traceId);
allErrors.AddRange(validationException.ValidationFailures);
}
else if (context.ActionArguments != null)
{
// Get the fluent validator for each argument and perform validation:
foreach (KeyValuePair <string, object> ActionArgument in context.ActionArguments)
{
if (ActionArgument.Value == null)
{
Exception exception = new Exception("ConsistentApiResponseErrors ValidateModelStateAttribute: The ActionArgument.Value is null");
_logger.LogError(exception, exception.Message + " ({traceId})", traceId);
throw exception;
}
IValidator validator = _validatorFactory.GetValidator(ActionArgument.Value.GetType());
if (validator == null)
{
// Add log if no validator is found:
_logger.LogWarning("{traceId}: The validator is null for type {ActionArgumentType}", traceId, ActionArgument.Value.GetType().ToString());
continue;
}
ValidationResult result = validator.Validate(ActionArgument.Value);
if (!result.IsValid)
{
allErrors.AddRange(result.Errors);
}
// Add log for the validation result:
_logger.LogInformation("({traceId}): The validation result: {IsResultValid} for value \"{ActionArgumentValue}\"", traceId, result.IsValid.ToString(), ActionArgument.Value.ToString());
}
}
// When errors exist return a BadRequestObjectResult
if (allErrors.Count > 0)
{
// Log validation errors with this specific traceID:
_logger.LogWarning("({traceId}): Validation Errors: {ValidationErrors}", traceId, allErrors);
context.Result = new BadRequestObjectResult(new ValidationError(allErrors, traceId));
}
// Add log for the validation result:
_logger.LogInformation("({traceId}): OnActionExecuting: End validation", traceId);
}
