public async Task <IActionResult> PostAsync([FromBody] SaveUserResource resource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.GetErrorMessages()));
}
var user = mapper.Map <SaveUserResource, User>(resource);
var result = await userService.SaveAsync(user);
if (!result.Success)
{
return(BadRequest(result.Message));
}
var userResource = mapper.Map <User, UserResource>(result.User);
return(Ok(userResource));
}
public async Task <IActionResult> Register(SaveUserResource userForRegister)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
userForRegister.Username = userForRegister.Username.ToLower();
if (await _repo.UserExists(userForRegister.Username))
{
return(BadRequest("Username already exists"));
}
var UserToAdd = _mapper.Map <SaveUserResource, User>(userForRegister);
var createdUser = _repo.Register(UserToAdd, userForRegister.Password);
await _unitofwork.CompleteAsync();
return(StatusCode(201));
}
public async Task <IActionResult> SaveAsync([FromBody] SaveUserResource resource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = _mapper.Map <User>(resource);
var result = await _userService.AddAsync(user);
if (!result.Success)
{
return(BadRequest(new ErrorResource(result.Message)));
}
var userResource = _mapper.Map <UserResource>(result.Resource);
return(Ok(userResource));
}
public async Task<IActionResult> PutAsync(short id,[FromBody] SaveUserResource resource)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState.GetErrorMessages());
}
var user = this.mapper.Map<SaveUserResource, UserModel>(resource);
var result = await this.usersService.UpdateAsync(id, user);
if (!result.Success)
{
return BadRequest(result.Message);
}
var userResource = this.mapper.Map<UserModel, UserResource>(result.User);
return Ok(userResource);
}
public async Task <IActionResult> PostAsync([FromBody] SaveUserResource resource)
{
if (!ModelState.IsValid)
{
return(BadRequest(new ErrorResource(StatusCodes.Status400BadRequest, ModelState.GetErrorMessages())));
}
var user = _mapper.Map <SaveUserResource, User>(resource);
var response = await _userService.SaveAsync(user, resource.Password);
if (!response.Success)
{
return(StatusCode(response.StatusCode,
new ErrorResource(response.StatusCode, response.Message)));
}
var userResource = _mapper.Map <User, UserResource>(response.Resource);
return(StatusCode(response.StatusCode, userResource));
}
public async Task <IActionResult> Register([FromBody] SaveUserResource userResource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var userIdentity = mapper.Map <ApplicationUser>(userResource);
userIdentity.DateRegistered = DateTime.Now;
var result = await userManager.CreateAsync(userIdentity, userResource.Password);
if (!result.Succeeded)
{
return(BadRequest(ModelState.AddIdentityResultErrors(result)));
}
return(Ok(mapper.Map <PlainUserResource>(userIdentity)));
}
public async Task <IActionResult> Create(SaveUserResource resource)
{
var response = new SingleModelResponse <UserGridResource>();
if (resource == null)
{
response.DidError = true;
response.ErrorMessage = "Input cannot be null.";
return(response.ToHttpResponse());
}
try
{
var user = new User();
_mapper.Map(resource, user);
if (_userRepository.Query().Any(x => x.Email == resource.UserInfo.Email))
{
response.DidError = true;
response.ErrorMessage = "This email is already register.";
return(response.ToHttpResponse());
}
user.CreateDate = DateTime.Now;
var md5Hash = MD5.Create();
user.Password = PasswordManager.GetMd5Hash(md5Hash, resource.UserInfo.Password);
var entity = await _userRepository.AddAsync(user);
var entityMap = await GetUserWithRelated(entity.Id);
response.Model = _mapper.Map <User, UserGridResource>(entityMap);
response.Message = "The data was saved successfully.";
}
catch (Exception ex)
{
response.DidError = true;
response.ErrorMessage = ex.ToString();
}
return(response.ToHttpResponse());
}
public async Task <ActionResult <UserResource> > CreateUser([FromBody] SaveUserResource model)
{
var validator = new SaveUserResourceValidator();
var validationResult = validator.Validate(model);
if (!validationResult.IsValid)
{
return(BadRequest(validationResult.Errors));
}
var userToCreate = _mapper.Map <SaveUserResource, User>(model);
var newUser = await _userService.CreateUser(userToCreate);
var user = await _userService.GetUserById(newUser.Id);
var userResource = _mapper.Map <User, UserResource>(user);
return(Ok());
}
public IActionResult RegisterUser([FromBody] SaveUserResource userAccount)
{
var user = new User()
{
Email = userAccount.Email,
UserName = userAccount.UserName
};
userManager.CreateAsync(user, userAccount.Password).Wait();
var registeredUser = userManager.FindByNameAsync(user.UserName).Result;
userManager.AddToRoleAsync(registeredUser, Policies.Moderator).Wait();
return(Ok(new
{
registeredUser.Id,
registeredUser.Email,
registeredUser.UserName,
Roles = userManager.GetRolesAsync(registeredUser).Result,
}));
}
public IActionResult Login([FromBody] SaveUserResource userAccount)
{
var userFromDb = userManager.FindByEmailAsync(userAccount.Email).Result;
var result = signInManager.CheckPasswordSignInAsync(userFromDb, userAccount.Password, false).Result;
if (result.Succeeded)
{
var tokenString = GenerateJSONWebToken(userFromDb);
return(Ok(new
{
userFromDb.Id,
userFromDb.Email,
userFromDb.UserName,
Roles = userManager.GetRolesAsync(userFromDb).Result,
tokenString
}));
}
return(Unauthorized());
}
public User UpdateUser(SaveUserResource user, string id)
{
var uri = baseUri.ToString() + "/" + id;
client.BaseUrl = new Uri(uri);
var request = new RestRequest(Method.PATCH);
request.AddHeader("authorization", "Bearer " + apiToken);
request.AddHeader("content-type", "application/json");
request.AddJsonBody(user);
logger.LogInformation("USER PATCH REQUEST WITH CREDENTIALS: " + JsonConvert.SerializeObject(user));
IRestResponse response = client.Execute(request);
logger.LogInformation(response.Content);
return(GetUser(id));
}
public async Task <IActionResult> PutAsync(int id, [FromBody] SaveUserResource resource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.GetErrorMessages()));
}
var topping = mapper.Map <SaveUserResource, User>(resource);
topping.Id = id;
var result = await userService.UpdateAsync(topping);
if (!result.Success)
{
return(BadRequest(result.Message));
}
var userResource = mapper.Map <User, UserResource>(result.User);
return(Ok(userResource));
}
public async Task <IActionResult> PutAsync(int id, [FromBody] SaveUserResource resource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.GetErrorMessages()));
}
var us = await userService.ListAsync();
var i = us.Where(x => x.Login == resource.Login);
if (i == null)
{
return(BadRequest(ModelState.GetErrorMessages()));
}
var user = mapper.Map <SaveUserResource, User>(resource);
var userResponse = await userService.UpdateAsync(id, user);
var userResource = mapper.Map <User, UserResourse>(userResponse.User);
var result = userResponse.GetResponseResult(userResource);
return(Ok(result));
}
public async Task <IActionResult> Register(SaveUserResource userResource)
{
// validation
var validation = new SaveUserResourceValidation();
var validationResult = await validation.ValidateAsync(userResource);
if (!validationResult.IsValid)
{
return(BadRequest(validationResult.Errors));
}
var user = _mapper.Map <SaveUserResource, User>(userResource);
// mappage
var userSave = await _serviceUser.Create(user, userResource.Password);
//send tocken
var tokenHandler = new JwtSecurityTokenHandler();
var key = Encoding.ASCII.GetBytes(_config.GetValue <string>("AppSettings:Secret"));
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(new Claim[]
{
new Claim(ClaimTypes.Name, user.Id.ToString())
}),
Expires = DateTime.UtcNow.AddDays(7),
SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256Signature)
};
var token = tokenHandler.CreateToken(tokenDescriptor);
var tokenString = tokenHandler.WriteToken(token);
return(Ok(new
{
Id = user.Id,
Username = user.Username,
FirstName = user.FirstName,
LastName = user.LastName,
Token = tokenString
}));
}
public async Task <IActionResult> UpdateUser(int id, [FromBody] SaveUserResource userResource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = await repository.GetUser(id);
if (user == null)
{
return(NotFound());
}
mapper.Map <SaveUserResource, User>(userResource, user);
await unitOfWork.CompleteAsync();
user = await repository.GetUser(user.Id);
var result = mapper.Map <User, UserResource>(user);
return(Ok(result));
}
public UsersControllerTests(ITestOutputHelper output, Request <Startup> request, DbContextFactory contextFactory)
{
this.output = output;
this.request = request;
this.nieuweStroomPocDbContext = contextFactory.nieuweStroomPocDbContext;
var role = new Role {
Description = "Description"
};
nieuweStroomPocDbContext.Roles.Add(role);
nieuweStroomPocDbContext.SaveChanges();
nieuweStroomPocDbContext = contextFactory.GetRefreshContext();
userResource = new SaveUserResource
{
Email = "*****@*****.**",
Name = "12345",
Lastname = "1233456",
Password = "******",
};
userResource.Roles.Add(role.Id);
}
public async Task <IActionResult> UpdateUser(int id, [FromBody] SaveUserResource userResource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = await context.Users
.Include(p => p.Competitions)
.ThenInclude(p => p.Competition)
.ThenInclude(p => p.CreatedBy)
.SingleOrDefaultAsync(p => p.Id == id);
if (user == null)
{
return(NotFound());
}
mapper.Map(userResource, user);
await context.SaveChangesAsync();
return(Ok(mapper.Map <User, IUserResource>(user)));
}
public async Task <IActionResult> Update(int id, [FromBody] SaveUserResource resource)
{
return(await _userService.Update(id, resource));
}
public static void AssertEquals(SaveUserResource saveUserResource, UserResource userResource)
{
Assert.Equal(saveUserResource.Email, userResource.Email);
Assert.Equal(saveUserResource.FirstName, userResource.FirstName);
Assert.Equal(saveUserResource.LastName, userResource.LastName);
}
public async Task <IActionResult> Create([FromBody] SaveUserResource resource)
{
return(await _userService.Create(resource));
}
public async Task <IActionResult> CreateUser(SaveUserResource saveUserResource)
{
UserResource userResource = await usersService.CreateUserAsync(saveUserResource);
return(Ok(userResource));
}
