public async Task <IActionResult> Register([FromBody] RegisterUserDto registerUserDto)
{
if (registerUserDto == null)
{
return(BadRequest(_config["Errors:Base:ModelInValid"]));
}
//Validation model dto
var validatorDto = new RegisterUserDtoValidator();
var resultValidateDto = validatorDto.Validate(registerUserDto);
if (!resultValidateDto.IsValid)
{
return(BadRequest(ValidationDto.GetMessagesByErrors(resultValidateDto.Errors)));
}
//Check user exists
var userExists = await _userService.UserExists(registerUserDto.UserName);
if (userExists)
{
return(BadRequest(_config["Errors:User:Exist"]));
}
//Register user
var isOk = await _userService.Register(registerUserDto);
return(Ok(isOk));
}
public async Task <ActionResult> Edit(Guid id, [FromBody] EditUserDto editUserDto)
{
if (id == Guid.Empty || editUserDto == null)
{
return(BadRequest(_config["Errors:Base:ModelInValid"]));
}
//Validation model dto
var validatorDto = new EditUserDtoValidator();
var resultValidateDto = validatorDto.Validate(editUserDto);
if (!resultValidateDto.IsValid)
{
return(BadRequest(ValidationDto.GetMessagesByErrors(resultValidateDto.Errors)));
}
//Set Config
SetConfig();
//Edit user
var isOk = await _userService.Edit(id, editUserDto);
return(Ok(isOk));
}
public async Task <IActionResult> SignUp([FromBody] SignUpModel signUpModel)
{
var result = await _accountRepository.SignUpAsync(signUpModel);
if (result.Succeeded)
{
return(Ok(result.Succeeded));
}
else
{
if (result.Errors.Any())
{
List <ValidationDto> temp = new List <ValidationDto>();
foreach (var error in result.Errors)
{
ValidationDto vDto = new ValidationDto()
{
Error = error.Code,
Expected = error.Description
};
temp.Add(vDto);
}
return(BadRequest(temp));
}
}
return(BadRequest());
}
public async Task <IActionResult> Login([FromBody] LoginUserDto loginUserDto)
{
if (loginUserDto == null)
{
return(BadRequest(_config["Errors:Base:ModelInValid"]));
}
// Validation model dto
var validatorDto = new LoginUserDtoValidator();
var resultValidateDto = validatorDto.Validate(loginUserDto);
if (!resultValidateDto.IsValid)
{
return(BadRequest(ValidationDto.GetMessagesByErrors(resultValidateDto.Errors)));
}
// Verify Account
var userDto = await _userService.VerifyAccount(loginUserDto);
if (userDto == null)
{
return(BadRequest(_config["Errors:User:Incorrect"]));
}
// Create Refresh Token
RefreshTokenDto refreshTokenDto = await _tokenService.CreateRefreshTokenByUserDtoAsync(userDto);
// Generate token
var tokenDto = GenerateToken(userDto, refreshTokenDto.RefreshToken);
return(Ok(tokenDto));
}
public async Task PasswordResetAsync(ValidationDto dto)
{
var validationResult = await tokenService.ValidateTokenAsync(dto.Token);
if (!validationResult.IsValid)
{
throw new SecurityTokenException();
}
if (dto.NewPassword != dto.ConfirmPassword)
{
throw new PasswordMismatchException("Passwords are different!");
}
var user = await context.Users.SingleOrDefaultAsync(auth => auth.Id == validationResult.User.Id);
if (user is null)
{
throw new EntityNotFoundException <ApplicationUser>();
}
if (!passwordUtils.VerifyHash(dto.OldPassword, user.PasswordHash, user.PasswordSalt))
{
throw new EntityNotFoundException <ApplicationUser>();
}
var securedPassword = passwordUtils.CreateHash(dto.NewPassword);
user.SetHashAndSalt(securedPassword.Hash, securedPassword.Salt);
await UpdateAsync(user);
}
public IActionResult ValidateParticipants([FromBody] Dictionary <string, string> santas)
{
if (Request.Headers.Authorization != AdminSecret)
{
return(Unauthorized());
}
var response = new ValidationDto();
using (var db = new SantaContext())
{
foreach (var santa in santas)
{
response.Santas.Add(santa.Key);
var thisSanta = db.Santas?.Find(Guid.Parse(santa.Value));
if (thisSanta == null)
{
return(UnprocessableEntity("EI KLAPI"));
}
var symmetricEncryptDecrypt = new EncryptionFactory();
var decryptedName = symmetricEncryptDecrypt.Decrypt(thisSanta.DesignatedPerson, thisSanta.IVBase64, EncryptionKey);
response.Receivers.Add(decryptedName);
}
}
response.Santas = response.Santas.OrderBy(x => x).ToList();
response.Receivers = response.Receivers.OrderBy(x => x).ToList();
return(Ok(response));
}
public static ValidationDto <DateRange> GetDateRange(DateTime startDate, DateTime endDate)
{
try
{
var dateRange = new DateRange(startDate, endDate);
var response = new ValidationDto <DateRange>()
{
Success = true,
Message = "Success",
Result = dateRange
};
return(response);
}
catch (Exception e)
{
Console.WriteLine(e);
var response = new ValidationDto <DateRange>()
{
Success = false,
Message = e.Message,
Result = new DateRange(DateTime.MinValue, DateTime.MaxValue)
};
return(response);
}
}
public void DoValidations(ValidationDto parameter)
{
_bookingBalanceDueSpecification.IsValid(new BookingBalanceDueDto()
{
AmountToRefund = parameter.AmountToRefund,
BalanceDue = parameter.Booking.BalanceDue
});
}
public async Task <ValidationDto> ValidateUsernameAsync(string username)
{
ValidationDto validationDto = new ValidationDto(false, "Username is unavailable");
// check for special case if username
// starts with unicorn since this is a
// reserved string used for generating usernames
// see GenerateUsername() method inside EventHandler.cs
if (username.StartsWith("unicorn"))
{
validationDto.Valid = false;
validationDto.Reason = "Username is unavailable";
return(validationDto);
}
if (!_user.ValidUsernameMaxLength(username))
{
validationDto.Valid = false;
validationDto.Reason = "Your username must be shorter than 15 characters.";
return(validationDto);
}
if (!_user.ValidUsernameMinLength(username))
{
validationDto.Valid = false;
validationDto.Reason = "Your username must be at least 1 character.";
return(validationDto);
}
if (!_user.ValidUsernameCharacters(username))
{
validationDto.Valid = false;
validationDto.Reason = "Your username can only contain letters, numbers and '_'";
return(validationDto);
}
var user = await _userStorage.FindAsync(u => u.Username == username);
if (user == null)
{
validationDto.Valid = true;
validationDto.Reason = "Username is available";
return(validationDto);
}
return(validationDto);
}
public IActionResult extend([FromBody] ValidationDto validation)
{
try
{
if (validation == null)
{
_logger.LogError("id object sent from client is null.");
return(BadRequest("id object is null"));
}
var result = connector.extendTimer(validation.access_token);
return(Ok(result));
}
catch (Exception ex)
{
_logger.LogError($"Something went wrong inside CreateUser action: {ex.Message}");
return(StatusCode(500, "Internal server error"));
}
}
public IEnumerable <ValidationDto> GetValidations(string DtoName)
{
List <ValidationDto> validations = new List <ValidationDto>();
var FolderName = DtoName.Replace("Dto", "");
var type = Type.GetType($"AbpCompanyName.AbpProjectName.{FolderName}s.Dto.{DtoName}", false, true);
var Properties = type.GetProperties();
foreach (var prop in Properties)
{
var DisplayAttr = (prop.GetCustomAttribute(typeof(DisplayAttribute))) as DisplayAttribute;
ValidationDto VDto = new ValidationDto()
{
Name = prop.Name
};
if (DisplayAttr is null)
{
VDto.DisplayName = prop.Name;
}
else
{
VDto.DisplayName = DisplayAttr.Name;
}
var attributes = (IEnumerable <ValidationAttribute>)prop.GetCustomAttributes(typeof(ValidationAttribute));
if (attributes.Count() > 0)
{
List <ValidationTypes> VT = new List <ValidationTypes>();
foreach (var attr in attributes)
{
if (attr is RequiredAttribute)
{
VT.Add(new ValidationTypes
{
ValidationName = "Required",
ErrorMessage = attr.ErrorMessage is null ? $"{prop.Name} Is Required" : attr.ErrorMessage
});
public async Task ValidateUsername_CallWithMockedIUtilities_ReturnOkObjectResult()
{
// Arrange
var utilitiesMock = new Mock <IUtilities>();
var notifierMock = new Mock <INotifier>();
var username = "******";
var usernameDto = new UsernameDto()
{
Username = username
};
var validationDto = new ValidationDto(true, "username valid");
utilitiesMock.Setup(u => u.ValidateUsernameAsync(username)).ReturnsAsync(validationDto);
var controller = new UtilitiesController(utilitiesMock.Object, notifierMock.Object);
// Act
var result = await controller.ValidateUsername(usernameDto);
var response = (OkObjectResult)result;
// Assert
Assert.IsType <OkObjectResult>(result);
Assert.IsType <ResponseDto <ValidationDto> >(response.Value);
}
public async Task <ValidationDto> ValidateUsernameAsync(string username)
{
ValidationDto validationDto = new ValidationDto(false, "Username is unavailable");
if (!_user.ValidUsernameMaxLength(username))
{
validationDto.Valid = false;
validationDto.Reason = "Your username must be shorter than 15 characters.";
return(validationDto);
}
if (!_user.ValidUsernameMinLength(username))
{
validationDto.Valid = false;
validationDto.Reason = "Your username must be at least 1 character.";
return(validationDto);
}
if (!_user.ValidUsernameCharacters(username))
{
validationDto.Valid = false;
validationDto.Reason = "Your username can only contain letters, numbers and '_'";
return(validationDto);
}
var user = await _storage.FindAsync(u => u.Username == username);
if (user == null)
{
validationDto.Valid = true;
validationDto.Reason = "Username is available";
return(validationDto);
}
return(validationDto);
}
public async Task <QueryResults <GardenDto> > ChangeGardenValidation(Guid gardenId, ValidationDto val)
{
var garden = await db.Gardens.Include(g => g.Photos)
.Include(g => g.Location)
.Include(g => g.Criteria)
.Include(g => g.Owner)
.GetByIdAsync(gardenId) ?? throw new NotFoundApiException();
if (!garden.Validation.Equals(Status.Pending))
{
throw new UnauthorizeApiException();
}
garden.Validation = val.Status;
db.Gardens.Update(garden);
await db.SaveChangesAsync();
return(new QueryResults <GardenDto>
{
Data = garden.ConvertToDto()
});
}
public async Task <IActionResult> UpdateGardenValidation([FromRoute(Name = "id")] Guid gardenId, [FromBody] ValidationDto valid)
{
return(Ok(await gardensService.ChangeGardenValidation(gardenId, valid)));
}
public void DoValidations(ValidationDto parameter)
{
ValidationStrategy.DoValidations(parameter);
}
