public async Task <IActionResult> Register([FromBody] UserForRegistrationDTO userToRegisterDTO)
{
if (!string.IsNullOrEmpty(userToRegisterDTO.Username))
{
userToRegisterDTO.Username = userToRegisterDTO.Username.ToLower();
}
//Validate Request
if (await _repo.UserExists(userToRegisterDTO.Username))
{
ModelState.AddModelError("Username", "Username is already taken");
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var userToCreate = new User
{
Username = userToRegisterDTO.Username
};
var createdUser = await _repo.Register(userToCreate, userToRegisterDTO.Password);
return(StatusCode(201));
}
public async Task <IActionResult> RegisterUser([FromBody] UserForRegistrationDTO userForRegistration)
{
if (userForRegistration.Roles.Contains("Administrator"))
{
return(BadRequest("Access denied"));
}
var user = _mapper.Map <User>(userForRegistration);
var result = await _userManager.CreateAsync(user, userForRegistration.Password);
if (!result.Succeeded)
{
foreach (var error in result.Errors)
{
ModelState.TryAddModelError(error.Code, error.Description);
}
return(BadRequest(ModelState));
}
await _userManager.AddToRolesAsync(user, userForRegistration.Roles);
return(StatusCode(201));
}
public async Task <IActionResult> Register(UserForRegistrationDTO userForRegistration)
{
var userToCreate = _mapper.Map <User>(userForRegistration);
var result = await _userManager.CreateAsync(userToCreate, userForRegistration.Password);
var userToReturn = _mapper.Map <UserForDetailedDTO>(userToCreate);
if (result.Succeeded)
{
return(CreatedAtRoute("GetUser", new { Controller = "users", id = userToCreate.Id }, userToReturn));
}
return(BadRequest(result.Errors));
}
public async Task <IActionResult> Register(UserForRegistrationDTO userForRegistrationDTO)
{
var exists = await _repo.UserExists(userForRegistrationDTO.UserName);
if (exists)
{
return(BadRequest("we have that user in our repo !"));
}
var user = await _repo.Register(new User()
{
UserName = userForRegistrationDTO.UserName
}, userForRegistrationDTO.Passwor);
return(StatusCode(201));
}
public async Task <IActionResult> Register(UserForRegistrationDTO userForRegistrationDTO)
{
userForRegistrationDTO.Username = userForRegistrationDTO.Username.ToLower();
if (await _repo.UserExists(userForRegistrationDTO.Username))
{
return(BadRequest("Username already exist."));
}
var userToCreate = mapper.Map <User>(userForRegistrationDTO);
var createdUser = await _repo.Register(userToCreate, userForRegistrationDTO.Password);
var userToReturn = mapper.Map <UserForDetailedDTO>(createdUser);
return(CreatedAtRoute("GetUser", new { controoler = "Users", id = createdUser.Id }, userToReturn));
}
public async Task <IActionResult> Register([FromBody] UserForRegistrationDTO userForRegistrationDTO)
{
if (!await _roleManager.RoleExistsAsync(Role.AdminUsr))
{
await _roleManager.CreateAsync(new IdentityRole(Role.AdminUsr));
}
if (!await _roleManager.RoleExistsAsync(Role.AreaManagerUsr))
{
await _roleManager.CreateAsync(new IdentityRole(Role.AreaManagerUsr));
}
if (!await _roleManager.RoleExistsAsync(Role.GeneralUsr))
{
await _roleManager.CreateAsync(new IdentityRole(Role.GeneralUsr));
}
var userToCreate = new AppUser
{
UserName = userForRegistrationDTO.UserName,
Email = userForRegistrationDTO.UserName,
Name = userForRegistrationDTO.FullName
};
// if(!ModelState.IsValid)
// {
// return BadRequest(userToCreate);
// }
if (await _userManager.FindByNameAsync(userForRegistrationDTO.UserName) != null)
{
return(BadRequest("User name already exists!"));
}
var createdUser = await _userManager.CreateAsync(userToCreate, userForRegistrationDTO.Password);
if (createdUser.Succeeded)
{
if (userForRegistrationDTO.Role == "Rescuer")
{
await _userManager.AddToRoleAsync(userToCreate, Role.GeneralUsr);
}
if (userForRegistrationDTO.Role == "Manager")
{
await _userManager.AddToRoleAsync(userToCreate, Role.AreaManagerUsr);
}
return(Ok(createdUser));
}
//Create User
return(BadRequest(ModelState));
}
public async Task <ResponseDTO> RegisterUser(UserForRegistrationDTO userForRegistrationDto)
{
var response = await _client.PostAsJsonAsync("Account/register", userForRegistrationDto);
if (!response.IsSuccessStatusCode)
{
var content = await response.Content.ReadAsStringAsync();
var result = JsonSerializer.Deserialize <ResponseDTO>(content, _options);
return(result);
}
return(new ResponseDTO {
IsSuccessfulRegistration = true
});
}
public async Task <IActionResult> Register([FromBody] UserForRegistrationDTO model)
{
model.Username = model.Username.ToLower();
if (await _authRepository.UserExists(model.Username))
{
return(BadRequest("Username already exists"));
}
var newUser = _mapper.Map <User>(model);
await _authRepository.Register(newUser, model.Password);
var userToReturn = _mapper.Map <UserForDetailsDTO>(newUser);
return(CreatedAtRoute("GetUser", new { controller = "Users", id = newUser.Id }, userToReturn));
}
public async Task <IActionResult> register(UserForRegistrationDTO userDto) //n background .net'i e bind( e krijon instancen edhe ja jep vlerat qe ja qojm n request)
{
userDto.Username = userDto.Username.ToLower();
if (await repo.userExists(userDto.Username))
{
return(BadRequest("Username already exists"));
}
var userToCreate = new User
{
Username = userDto.Username
};
var createdUser = await repo.register(userToCreate, userDto.Password);
return(StatusCode(201));
}
public async Task <IActionResult> Registration(UserForRegistrationDTO userRegistrationDto)
{
//role create
if (!await _roleManager.RoleExistsAsync(Role.SuperAdmin))
{
await _roleManager.CreateAsync(new IdentityRole(Role.SuperAdmin));
}
if (!await _roleManager.RoleExistsAsync(Role.User))
{
await _roleManager.CreateAsync(new IdentityRole(Role.User));
}
//create user
var userForCreate = new AppUser
{
UserName = userRegistrationDto.UserName,
Email = userRegistrationDto.Email
};
if (await _userManager.FindByEmailAsync(userRegistrationDto.Email) != null)
{
return(BadRequest("this email already used"));
}
var createdUser = await _userManager.CreateAsync(userForCreate, userRegistrationDto.Password);
// role assign
if (createdUser.Succeeded)
{
if (userRegistrationDto.Role == "Admin")
{
await _userManager.AddToRoleAsync(userForCreate, Role.SuperAdmin);
}
else if (userRegistrationDto.Role == "User")
{
await _userManager.AddToRoleAsync(userForCreate, Role.User);
}
else
{
return(BadRequest("role is not matched"));
}
return(Ok(createdUser));
}
return(BadRequest(ModelState));
}
public async Task <IActionResult> Register(UserForRegistrationDTO userForRegistrationDTO)
{
userForRegistrationDTO.Username = userForRegistrationDTO.Username.ToLower();
//Verifica se o usuario existe no Banco
if (await _repo.UserExists(userForRegistrationDTO.Username))
{
return(BadRequest("Usuario Cadastrado"));
}
//Passa o parametro recebido do usuario para o objeto do Model
var UserToModel = new User
{
UserName = userForRegistrationDTO.Username
};
//Grava o objeto do Model no Banco de Dados
var UserToBD = await _repo.Register(UserToModel, userForRegistrationDTO.Password);
return(StatusCode(201));
}
public async Task <IActionResult> Register(UserForRegistrationDTO userForRegistrationDTO)
{
// convert username to lowercase for consistency
userForRegistrationDTO.Username = userForRegistrationDTO.Username.ToLower();
// check if user exists
if (await _repository.UserExists(userForRegistrationDTO.Username))
{
return(BadRequest("Username already exists"));
}
// create the user
var userToCreate = _mapper.Map <User>(userForRegistrationDTO);
// Register the user
var createdUser = await _repository.Register(userToCreate, userForRegistrationDTO.Password);
var userToReturn = _mapper.Map <UserForDetailDto>(createdUser);
return(CreatedAtRoute("GetUser", new { controller = "Users", id = createdUser.Id }, userToReturn));
}
public async Task <IActionResult> RegisterUser([FromBody] UserForRegistrationDTO userForRegistrationDTO)
{
_logger.LogInformation($"Registration attempt for {userForRegistrationDTO.Email}");
if (userForRegistrationDTO == null || !ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = new ApiUser
{
UserName = userForRegistrationDTO.Email,
Email = userForRegistrationDTO.Email
};
var result = await _userManager.CreateAsync(user, userForRegistrationDTO.Password);
if (!result.Succeeded)
{
//foreach (var error in result.Errors)
//{
// ModelState.AddModelError(error.Code, error.Description);
//}
//return BadRequest(ModelState);
var errors = result.Errors.Select(e => e.Description);
return(BadRequest(new ResponseDTO {
Errors = errors
}));
}
await _userManager.AddToRoleAsync(user, "User");
return(StatusCode(201));
//_logger.LogError(ex, $"Something went wrong in the {nameof(RegisterUser)}");
//return Problem($"Something went wrong in the {nameof(RegisterUser)}", statusCode: 500);
}
public async Task <IActionResult> Registration(UserForRegistrationDTO userRegistrationDto)
{
//role create
if (!await _roleManager.RoleExistsAsync(Role.SuperAdmin))
{
await _roleManager.CreateAsync(new IdentityRole(Role.SuperAdmin));
}
if (!await _roleManager.RoleExistsAsync(Role.User))
{
await _roleManager.CreateAsync(new IdentityRole(Role.User));
}
//create claim
//create user
var userForCreate = new AppUser
{
UserName = userRegistrationDto.UserName,
Name = userRegistrationDto.UserName,
Email = userRegistrationDto.Email
};
if (await _userManager.FindByEmailAsync(userRegistrationDto.Email) != null)
{
return(BadRequest("this email already used"));
}
if (userRegistrationDto.Role.Contains("Admin") || userRegistrationDto.Role.Contains("User"))
{
var createdUser = await _userManager.CreateAsync(userForCreate, userRegistrationDto.Password);
// role assign
if (createdUser.Succeeded)
{
if (userRegistrationDto.Role.Contains("Admin"))
{
await _userManager.AddToRoleAsync(userForCreate, Role.SuperAdmin);
}
if (userRegistrationDto.Role.Contains("User"))
{
await _userManager.AddToRoleAsync(userForCreate, Role.User);
// await _userManager.AddClaimAsync(userForCreate, new Claim("Create Role", "Create Role"));
}
else
{
return(BadRequest("role is not matched"));
}
// verify email address
var user = await _userManager.FindByEmailAsync(userRegistrationDto.Email);
var token = await _userManager.GenerateEmailConfirmationTokenAsync(user);
var confirmationLink = Url.Action(nameof(ConfirmEmail), nameof(AuthController), new { token, email = user.Email }, Request.Scheme);
var message = new Message(new string[] { user.Email }, "Confirmation email link", confirmationLink, null);
await _emailSender.SendEmailAsync(message);
return(Ok(new { createdUser, token }));
}
else
{
return(StatusCode(400, createdUser.Errors));
}
}
return(StatusCode(500, "Internal server error"));
}
public async Task <IActionResult> Registration(UserForRegistrationDTO userForRegistrationDTO)
{
//SuperAdmin
if (!await _roleManager.RoleExistsAsync(Role.SuperAdmin))
{
await _roleManager.CreateAsync(new IdentityRole(Role.SuperAdmin));
}
//CourierOwner
if (!await _roleManager.RoleExistsAsync(Role.CourierOwner))
{
await _roleManager.CreateAsync(new IdentityRole(Role.CourierOwner));
}
//BookingOfficer
if (!await _roleManager.RoleExistsAsync(Role.BookingOfficer))
{
await _roleManager.CreateAsync(new IdentityRole(Role.BookingOfficer));
}
//Marchant
if (!await _roleManager.RoleExistsAsync(Role.Marchant))
{
await _roleManager.CreateAsync(new IdentityRole(Role.Marchant));
}
//DelivaryMan
if (!await _roleManager.RoleExistsAsync(Role.DelivaryMan))
{
await _roleManager.CreateAsync(new IdentityRole(Role.DelivaryMan));
}
//Client
if (!await _roleManager.RoleExistsAsync(Role.Client))
{
await _roleManager.CreateAsync(new IdentityRole(Role.Client));
}
//Create User Object
var userToCreate = new AppUser
{
UserName = userForRegistrationDTO.UserName,
Email = userForRegistrationDTO.UserName
};
if (await _userManager.FindByNameAsync(userForRegistrationDTO.UserName) != null)
{
return(BadRequest("User name already exists!"));
}
var createdUser = await _userManager.CreateAsync(userToCreate, userForRegistrationDTO.Password);
if (createdUser.Succeeded)
{
if (userForRegistrationDTO.Role == "SuperAdmin")
{
await _userManager.AddToRoleAsync(userToCreate, Role.SuperAdmin);
}
else if (userForRegistrationDTO.Role == "CourierOwner")
{
await _userManager.AddToRoleAsync(userToCreate, Role.CourierOwner);
}
else if (userForRegistrationDTO.Role == "Marchant")
{
await _userManager.AddToRoleAsync(userToCreate, Role.Marchant);
}
else if (userForRegistrationDTO.Role == "BookingOfficer")
{
await _userManager.AddToRoleAsync(userToCreate, Role.BookingOfficer);
}
else if (userForRegistrationDTO.Role == "DelivaryMan")
{
await _userManager.AddToRoleAsync(userToCreate, Role.DelivaryMan);
}
else if (userForRegistrationDTO.Role == "Client")
{
await _userManager.AddToRoleAsync(userToCreate, Role.Client);
}
else
{
return(BadRequest());
}
return(Ok(createdUser));
}
//Create User
return(BadRequest(ModelState));
}
public async Task <IActionResult> Registration(UserForRegistrationDTO userRegistrationDto)
{
//role create
if (!await _roleManager.RoleExistsAsync(Role.SuperAdmin))
{
await _roleManager.CreateAsync(new IdentityRole(Role.SuperAdmin));
}
if (!await _roleManager.RoleExistsAsync(Role.User))
{
await _roleManager.CreateAsync(new IdentityRole(Role.User));
}
//create claim
//create user
var userForCreate = new AppUser
{
UserName = userRegistrationDto.UserName,
Name = userRegistrationDto.UserName,
Email = userRegistrationDto.Email,
Created = DateTime.Now,
LastActive = DateTime.Now,
Gender = userRegistrationDto.Gender,
DateOfBirth = userRegistrationDto.DateOfBirth
};
if (await _userManager.FindByEmailAsync(userRegistrationDto.Email) != null)
{
return(StatusCode(400, $"{userRegistrationDto.Email} email already used"));
}
if (userRegistrationDto.Role.Contains("Admin") || userRegistrationDto.Role.Contains("User"))
{
var createdUser = await _userManager.CreateAsync(userForCreate, userRegistrationDto.Password);
// role assign
if (createdUser.Succeeded)
{
if (userRegistrationDto.Role.Contains("Admin"))
{
await _userManager.AddToRoleAsync(userForCreate, Role.SuperAdmin);
}
if (userRegistrationDto.Role.Contains("User"))
{
await _userManager.AddToRoleAsync(userForCreate, Role.User);
// await _userManager.AddClaimAsync(userForCreate, new Claim("Create Role", "Create Role"));
}
else
{
return(BadRequest("role is not matched"));
}
return(StatusCode(200, createdUser));
}
else
{
return(StatusCode(400, createdUser.Errors));
}
}
return(StatusCode(500, "Internal server error"));
}
