public static async Task Returns_newly_created_user() { var returnedUser = CreateUser.With( userId: "User1", alternativeRegistrationNumber: "__ALTERNATIVE_REG__", commuteDistance: 99, emailAddress: "__EMAIL_ADDRESS__", firstName: "__FIRST_NAME__", lastName: "__LAST_NAME__", registrationNumber: "__REG__"); var mockUserRepository = new Mock <IUserRepository>(); mockUserRepository .Setup(r => r.CreateUser(It.IsAny <User>())) .ReturnsAsync(returnedUser); var controller = new UsersController(mockUserRepository.Object); var request = new UserPostRequest("Z999ABC", 12.3M, "*****@*****.**", "John", "Doe", "AB12CDE"); var result = await controller.PostAsync(request); var resultValue = GetResultValue <SingleUserResponse>(result); Assert.NotNull(resultValue.User); CheckResult( resultValue.User, "User1", "__ALTERNATIVE_REG__", 99, "__FIRST_NAME__", "__LAST_NAME__", "__REG__"); }
public static async Task Creates_new_user() { var mockUserRepository = new Mock <IUserRepository>(); mockUserRepository .Setup(r => r.CreateUser(It.IsAny <User>())) .ReturnsAsync(CreateUser.With(userId: "User1")); var controller = new UsersController(mockUserRepository.Object); var request = new UserPostRequest("Z999ABC", 12.3M, "*****@*****.**", "John", "Doe", "AB12CDE"); await controller.PostAsync(request); mockUserRepository.Verify(r => r.CreateUser(It.Is <User>(u => u.AlternativeRegistrationNumber == "Z999ABC" && u.CommuteDistance == 12.3m && u.EmailAddress == "*****@*****.**" && u.FirstName == "John" && u.LastName == "Doe" && u.RegistrationNumber == "AB12CDE" && u.RequestReminderEnabled == true && u.ReservationReminderEnabled == true))); mockUserRepository.VerifyNoOtherCalls(); }
public ActionResult Post([FromBody] UserPostRequest userPostRequest) { var entity = userPostRequest.TO <UserPost>(); var result = _repository.Add(entity); return(CreatedAtAction(nameof(Get), new { id = result.PostId }, result.TO <UserPostResponse>())); }
public async Task Register_Succeeded_ReturnsOkResult() { UserPostRequest model = new UserPostRequest() { Email = "*****@*****.**", Password = "******", }; var user = new ApplicationUser() { UserName = model.Email, Email = model.Email }; var roleName = "role1"; var role = new ApplicationRole(roleName); var userClaims = new List <Claim>() { new Claim("userClaim", "user claim value 1") }; var roleClaims = new List <Claim>() { new Claim("roleClaim", "role claim value 1") }; this.userManagerMoq.Setup(s => s.CreateAsync(It.IsAny <ApplicationUser>(), model.Password)) .ReturnsAsync(new IdentityResultMoq(true)); this.userManagerMoq.Setup(s => s.GetClaimsAsync(It.IsAny <ApplicationUser>())) .ReturnsAsync(userClaims); this.userManagerMoq.Setup(s => s.GetRolesAsync(It.IsAny <ApplicationUser>())).ReturnsAsync(new string[] { roleName }); this.roleManagerMoq.Setup(s => s.Roles) .Returns(new List <ApplicationRole>() { role }.AsQueryable()); this.roleManagerMoq.Setup(s => s.GetClaimsAsync(role)) .ReturnsAsync(roleClaims); this.signInManagerMoq.Setup(s => s.SignInAsync(It.IsAny <ApplicationUser>(), true, null)).Returns(Task.CompletedTask); var token = Guid.NewGuid().ToString(); this.tokenHelperMoq.Setup(s => s.BuildToken(It.IsAny <IList <Claim> >())).Returns(token); var controller = this.CreateUserController(); var response = await controller.Register(model).ConfigureAwait(false); Assert.IsAssignableFrom <OkObjectResult>(response); var okResult = (OkObjectResult)response; Assert.IsAssignableFrom <LoginResponse>(okResult.Value); var loginResponse = (LoginResponse)okResult.Value; Assert.Equal(loginResponse.Token, token); Assert.Equal(2, loginResponse.Claims.Count); Assert.Equal("user claim value 1", loginResponse.Claims[0].Value); }
public object Get(UserPostRequest request) { UserPostResponse Response = new UserPostResponse(); var posts = Response.Get(request); if (posts == null) { base.Response.StatusCode = (int)HttpStatusCode.NoContent; return Response; } string response = JsonConvert.SerializeObject(posts, Formatting.Indented); return response; }
public ActionResult Put(Guid id, [FromBody] UserPostRequest userPostRequest) { var entity = _repository.Get(id); if (entity != null) { entity = userPostRequest.CopyTo(entity); _repository.Update(entity); return(new OkObjectResult(entity.TO <UserPostResponse>())); } return(new NoContentResult()); }
public object Patch(UserPostRequest request) { UserPostResponse Response = new UserPostResponse(); var posts = Response.Patch(request); if (posts == null) { base.Response.StatusCode = (int)HttpStatusCode.NoContent; return(Response); } string response = JsonConvert.SerializeObject(posts, Formatting.Indented); return(response); }
public async Task Register_NotSucceeded_ThrowsException() { UserPostRequest model = new UserPostRequest(); this.localizationMoq.SetupGet(x => x.GetLocalizer <UserController>()[Moq.It.IsAny <string>()]).Returns(new LocalizedString("sometext", "sometext")); this.userManagerMoq.Setup(s => s.CreateAsync(It.IsAny <ApplicationUser>(), It.IsAny <string>())) .ReturnsAsync(new IdentityResultMoq(false)); var controller = this.CreateUserController(); await Assert.ThrowsAsync <OneFrameWebException>(() => controller.Register(model)).ConfigureAwait(false); this.localizationMoq.Verify(x => x.GetLocalizer <UserController>()[Moq.It.IsAny <string>()], Times.Once()); }
private async void post_Clicked(object sender, EventArgs e) { loading.IsVisible = true; Busy(); try { var post = new UserPostRequest { title = postTitle.Text, content = Content.Text, mediaUrl = UploadedUrl.Text, tenantId = App.AppKey, posterId = Preferences.Get("userId", string.Empty), //image = Picture }; //UploadImage(_mediaFile.GetStream()); if (postIndex > -1) { post.postCategoryId = Categories[postIndex].postCategoryId; } var res = await ApiServices.UserPost(post); if (res) { //MessageDialog.Show("Add Post", "Your Post has been saved successfully", "Ok"); message.LongAlert("Your Post has been saved successfully"); MessageDialog.Show("Note", "Your Post is pending for approval, it will be visible after it has been approved", "Ok"); await Shell.Current.GoToAsync("../.."); } else { MessageDialog.Show("Error!", "Error occured while saving Post", "Ok"); await Shell.Current.GoToAsync("../.."); } loading.IsVisible = false; NotBusy(); } catch (Exception) { loading.IsVisible = false; NotBusy(); } }
public static async Task <bool> UserPost(UserPostRequest req) { TokenValidator.CheckTokenValidity(); var client = new HttpClient(); var json = JsonConvert.SerializeObject(req); var content = new StringContent(json, Encoding.UTF8, "application/json"); client.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("bearer", Preferences.Get("token", string.Empty)); var response = await client.PostAsync(createpostUrl, content); if (!response.IsSuccessStatusCode) { return(false); } return(true); }
public async Task <IActionResult> Create(UserPostRequest model) { try { if (!ModelState.IsValid) { throw new Exception("Petición de alta inválida"); } ClaimsPrincipal currentUser = User; return(Ok(await _userService.CreateAsync(model, _userManager, currentUser))); } catch (Exception e) { return(StatusCode(500, e.Message)); } }
public async Task <IActionResult> Post([FromBody] UserPostRequest request) { if (request.Name == null || request.Email == null || request.ConfirmPassword == null || request.Password == null || request.Role == null) { return(BadRequest(new ApiResponse { ErrorCode = ErrorCodes.MISSING_FIELD, Success = false })); } ApiResponse <TokenDto> response = await _userService.Create(request); if (response.Success) { return(CreatedAtAction(nameof(Get), new { id = response.Data.UserId }, response)); } if (response.ErrorCode == ErrorCodes.ACCOUNT_EXISTS) { return(Conflict(response)); } return(BadRequest(response)); }
public async Task <IActionResult> Post(UserPostRequest signupRequest) { await _service.Signup(signupRequest.ToUser()); return(Ok()); }
public async Task <UserDTO> CreateAsync(UserPostRequest model, UserManager <ApplicationUser> userManager, ClaimsPrincipal currentUser) { try { ApplicationUser claimUser = await userManager.GetUserAsync(currentUser); if (await userManager.IsInRoleAsync(claimUser, "SuperUser") || await userManager.IsInRoleAsync(claimUser, "Admin")) { var userFound = await userManager.FindByEmailAsync(model.Email); if (userFound != null) { throw new Exception($"Ya existe un usuario en el sisitema con el Email {model.Email}"); } userFound = await userManager.FindByNameAsync(model.Username); if (userFound != null) { throw new Exception($"Ya existe un usuario en el sisitema con el Usuario {model.Username}"); } ApplicationUser applicationUser = new ApplicationUser { UserName = model.Username, Email = model.Email, PhoneNumber = model.PhoneNumber, Name = model.Name, Surname = model.Surname, CreationDate = DateTime.Now, IsActive = model.IsActive }; var createResult = await userManager.CreateAsync(applicationUser, model.Password); if (!createResult.Succeeded) { throw new Exception($"ERROR dando de alta el usuario - {createResult.Errors}"); } var user = await userManager.FindByEmailAsync(applicationUser.Email); var roleresult = await userManager.AddToRoleAsync(user, model.Role); if (!roleresult.Succeeded) { await userManager.DeleteAsync(user); throw new Exception($"ERROR asignando el rol de usuario {model.Role} - {roleresult.Errors}"); } return(new UserDTO { Id = user.Id, Name = user.Name, Surname = user.Surname, IsActive = user.IsActive, UserName = user.UserName, Email = user.Email, Role = model.Role, PhoneNumber = user.PhoneNumber, CreationDate = user.CreationDate }); } else { throw new Exception($"No tienes permisos para crear usuarios"); } } catch (Exception e) { throw new Exception(e.Message); } }
public static async Task <ValidationResult> ValidateAsync(this UserPostRequest request) { var validator = new UserPostRequestValidator(); return(await validator.ValidateAsync(request)); }
public async Task <ApiResponse <TokenDto> > Create(UserPostRequest request) { if (request.Password != request.ConfirmPassword) { return(new ApiResponse <TokenDto> { Success = false, ErrorCode = ErrorCodes.PASSWORDS_DONT_MATCH }); } if (request.Name == null || request.Name.Length < 3) { return(new ApiResponse <TokenDto> { Success = false, ErrorCode = ErrorCodes.INVALID_NAME }); } if (request.Role == null) { request.Role = UserRoles.USER; } else { request.Role = request.Role.ToLowerInvariant(); } if (request.Role != UserRoles.OWNER && request.Role != UserRoles.USER) { request.Role = UserRoles.USER; } try { var auth = await _firebaseService.GetFirebaseAuthProvider().CreateUserWithEmailAndPasswordAsync(request.Email, request.Password, request.Name, false); var additionalClaims = new Dictionary <string, object>() { { Claims.ROLE, request.Role }, }; await FirebaseAuth.DefaultInstance.SetCustomUserClaimsAsync(auth.User.LocalId, additionalClaims); auth = await _firebaseService.GetFirebaseAuthProvider().SignInWithEmailAndPasswordAsync(request.Email, request.Password); return(new ApiResponse <TokenDto> { Success = true, Data = new TokenDto { Token = auth.FirebaseToken, RefreshToken = auth.RefreshToken, Name = auth.User.DisplayName, Email = auth.User.Email, UserId = auth.User.LocalId, ExpiresIn = auth.ExpiresIn, CreatedAt = auth.Created, Role = request.Role } }); }catch (Firebase.Auth.FirebaseAuthException ex) { return(new ApiResponse <TokenDto> { Success = false, ErrorCode = _firebaseService.ConvertErrorCode(ex.Reason) }); }catch { return(new ApiResponse <TokenDto> { Success = false, ErrorCode = ErrorCodes.UNKNOWN_ERROR }); } }