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