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); }