public UserForCreateDto AddUser(UserForCreateDto user)
{
try
{
Console.WriteLine($"Inside AddUser - UserService");
var createuser = AutoMapper.Mapper.Map <Entities.User>(user);
_userRepository.AddUser(createuser);
if (!_userRepository.Save())
{
throw new Exception("Error occurred during Save() of User ...");
}
var createdUser = _userRepository.GetCreatedUser();
if (createuser != null)
{
var createdUserEntry = AutoMapper.Mapper.Map <Models.UserForCreateDto>(createuser);
return(createdUserEntry);
}
return(null);
}
catch (Exception e)
{
Console.WriteLine($"Error in AddUser() : {e.Message}");
throw e;
}
}
public async Task <IActionResult> Update(UserForCreateDto update)
{
var model = _mapper.Map <UserForCreateDto, User>(update);
byte[] passwordHash, passwordSalt;
if (update.Password != string.Empty || update.Password != null)
{
CreatePasswordHash(update.Password, out passwordHash, out passwordSalt);
model.PasswordHash = passwordHash;
model.PasswordSalt = passwordSalt;
}
if (_repoUser.FindAll().FirstOrDefault(x => x.Username == update.Username) == null)
{
return(BadRequest());
}
try
{
_repoUser.Update(model);
await _repoUser.SaveAll();
return(NoContent());
}
catch
{
return(BadRequest());
}
}
public ActionResult <UserForReadDto> CreateUser(UserForCreateDto userForCreateDto)
{
var userModel = _mapper.Map <User>(userForCreateDto);
_repo.CreateUser(userModel);
_repo.SaveChanges();
var userForReadDto = _mapper.Map <UserForReadDto>(userModel);
return(CreatedAtRoute(nameof(GetUserById), new { Id = userForReadDto.Id }, userForReadDto));
//return Ok(userForReadDto);
}
public async Task <IActionResult> CreateUser(UserForCreateDto userForCreatingDto)
{
var userToCreate = _mapper.Map <User>(userForCreatingDto);
_repo.Add(userToCreate);
if (await _repo.SaveAll())
{
return(NoContent());
}
throw new Exception($"Updating user failed on save");
}
public async Task <IActionResult> Register(UserForCreateDto userForCreateDto)
{
userForCreateDto.Username = userForCreateDto.Username.ToLower();
if (await _authRepository.UserExists(userForCreateDto.Username))
{
return(BadRequest("User already exists"));
}
var userToCreate = new User
{
Username = userForCreateDto.Username
};
var createdUser = await _authRepository.Register(userToCreate, userForCreateDto.Password);
return(StatusCode(201));
}
public async Task <IActionResult> Register(UserForCreateDto userForCreateDto)
{
userForCreateDto.Name = userForCreateDto.Name.ToLower();
if (await _authRepository.UserExists(userForCreateDto.Email))
{
return(BadRequest("User already exists"));
}
var user = new User
{
Email = userForCreateDto.Email,
Name = userForCreateDto.Name,
Phone = userForCreateDto.Phone,
CreatedAt = userForCreateDto.CreatedAt
};
await _authRepository.Register(user, userForCreateDto.Password);
return(StatusCode(201));
}
public async Task <IActionResult> CreateUser(UserForCreateDto userForCreateDto)
{
var userToCreate = new ApplicationUser()
{
UserName = userForCreateDto.UserName,
Created = userForCreateDto.Created,
LastActive = userForCreateDto.LastActive
};
var result = await _userManager.CreateAsync(userToCreate, userForCreateDto.Password);
var userToReturn = new UserForDetailedDto()
{
Id = userToCreate.Id,
UserName = userToCreate.UserName,
FirstName = userToCreate.FirstName,
MiddleName = userToCreate.MiddleName,
LastName = userToCreate.LastName,
Email = userToCreate.Email,
PhoneNumber = userToCreate.PhoneNumber,
Created = userToCreate.Created,
LastActive = userToCreate.LastActive
};
if (result.Succeeded)
{
IEnumerable <string> defaultRolesList = new List <string>()
{
"Member"
};
var resultForRole = await _userManager.AddToRolesAsync(userToCreate, defaultRolesList);
if (!resultForRole.Succeeded)
{
return(BadRequest(resultForRole.Errors));
}
return(CreatedAtRoute("GetUser", new { controller = "Users", Id = userToCreate.Id }, userToReturn));
}
return(BadRequest(result.Errors));
}
public async Task <ActionResult <UserForReturnDto> > CreateUser(UserForCreateDto newUser)
{
try
{
var userToCreate = _mapper.Map <User>(newUser);
userToCreate.DateRegistered = DateTime.Now;
await _repo.Create(userToCreate);
if (await _repo.Save())
{
return(CreatedAtAction(nameof(GetUserById), new { id = userToCreate.Id, name = userToCreate.Username }, _mapper.Map <UserForReturnDto>(userToCreate)));
}
}
catch (Exception e)
{
return(this.StatusCode(StatusCodes.Status500InternalServerError,
$"Failed to create user. Exception thrown when attempting to retrieve data from the database: {e.Message}"));
}
return(BadRequest());
}
public IActionResult CreateUser([FromBody] UserForCreateDto user)
{
try
{
var createduser = _userService.AddUser(user);
if (createduser == null)
{
return(Ok(new { status = "Error", message = "Null object returned from create user, check logs for issue" }));
}
return(Ok(createduser));
}
catch (Exception e)
{
Console.WriteLine($"Error in CreateUser() {e.Message}");
_logger.LogError($"Error in CreateUser() {e.Message} ");
return(StatusCode(500, $"Error in CreateUser() {e.Message}"));
}
}
public async Task <IActionResult> CreateUser([FromBody] UserForCreateDto userDto)
{
try
{
var user = new User
{
Name = userDto.Name,
UserName = userDto.Email,
Email = userDto.Email,
EmailConfirmed = true,
PhoneNumberConfirmed = true,
SecurityStamp = Guid.NewGuid().ToString(),
};
var doesUserNameAlreadyExist = await userManager.FindByEmailAsync(userDto.Email);
if (doesUserNameAlreadyExist == null)
{
await userManager.CreateAsync(user);
foreach (var r in userDto.RoleId)
{
var role = await roleManager.FindByIdAsync(r.ToString());
var result = await userManager.AddToRoleAsync(user, role.Name.ToUpperInvariant());
}
}
else
{
return(Ok(new DtoOutput <int>(0, "Email already exists. UnSuccessful.", 0)));
}
}
catch (Exception e)
{
throw new Exception("Could not create USer with ROle");
}
return(Ok(new DtoOutput <int>(0, "user with role created", 0)));
}
public async Task <IActionResult> Register([FromBody] UserForCreateDto userForCreateDto)
{
// Check if user exists
if (!string.IsNullOrEmpty(userForCreateDto.Username))
{
userForCreateDto.Username = userForCreateDto.Username.ToLower();
}
var exists = await _repo.UserExists(userForCreateDto.Username);
if (exists)
{
ModelState.AddModelError("Username", "Username already exists");
}
// Validate request
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
// Create user
var userToCreate = new User
{
Username = userForCreateDto.Username,
Email = userForCreateDto.Email,
Address = userForCreateDto.Address
};
var user = await _repo.Register(userToCreate, userForCreateDto.Password);
// Generate token
var token = GenerateToken(user);
return(Ok(new { token, user }));
// return CreatedAtRoute("GetUser", new { controller = "Users", id = createdUser.Id }, userToReturn);
}
public async Task <ActionResult <UserForReturnDto> > UpdateUserById(int id, UserForCreateDto userDto)
{
try
{
User existingUser = await _repo.GetById(id);
if (existingUser == null)
{
return(NotFound($"Could not find a user with id: {id}"));
}
User userToUpdate = _mapper.Map(userDto, existingUser);
_repo.Update(userToUpdate);
if (await _repo.Save())
{
return(CreatedAtAction(nameof(GetUserById), new { id = userToUpdate.Id, name = userToUpdate.Username }, _mapper.Map <UserForReturnDto>(userToUpdate)));
}
}
catch (Exception e)
{
return(this.StatusCode(StatusCodes.Status500InternalServerError,
$"Failed to update user. Exception thrown when attempting to retrieve data from the database: {e.Message}"));
}
return(BadRequest());
}
public IActionResult CreateUser([FromBody] UserForCreateDto dto)
{
if (dto == null)
{
return(BadRequest());
}
if (dto.Login == null || !dto.Login.All(char.IsLetterOrDigit))
{
ModelState.AddModelError(nameof(dto.Login), "Логин должен состоять только из цифробукв");
}
if (!ModelState.IsValid)
{
return(UnprocessableEntity(ModelState));
}
var userEntity = _mapper.Map <UserEntity>(dto);
var entityWithId = _userRepository.Insert(userEntity);
return(CreatedAtRoute(
nameof(GetUserById),
new { userId = entityWithId.Id },
entityWithId.Id));
}
