public async Task <IResponse> AddUserWithRole(RegisterationModel user, string Role, string rootPath)
{
AppUser newAppUser = new AppUser
{
UserName = user.UserName,
Email = user.Email,
EmailConfirmed = true,
CostPerHour = user.CostPerHour,
JobTitle = user.JobTitle
};
var result = await userManager.CreateAsync(newAppUser, user.Password);
if (result.Succeeded)
{
await userManager.AddToRoleAsync(newAppUser, Role);
if (!String.IsNullOrEmpty(user.Base64))
{
newAppUser.Photo = file.SaveImage(user.Base64, newAppUser.Id + "", "Images/Users", rootPath);
await userManager.UpdateAsync(newAppUser);
}
}
else
{
response.error_EN = result.Errors.Select(e => e.Description).FirstOrDefault();
response.status = false;
}
return(response);
}
/// <summary>
/// This Method is used for Registeration
/// </summary>
/// <param name="registerationModel">It contains the Object of Registeration Model</param>
/// <returns>It returns Registeration Response Model</returns>
public RegisterationResponseModel UserRegistration(RegisterationModel registerationModel)
{
try
{
// this varibale stores the Encrypted password
string password = this.encryptDecrypt.EncodePasswordToBase64(registerationModel.Password);
var result = this.dbContext.UserRegistrations.FirstOrDefault(value => ((value.FirstName == registerationModel.FirstName)) && ((value.LastName == registerationModel.LastName)) && ((value.EmailId == registerationModel.EmailId)));
if (result == null)
{
userModel.FirstName = registerationModel.FirstName;
userModel.LastName = registerationModel.LastName;
userModel.EmailId = registerationModel.EmailId;
userModel.PhoneNumber = registerationModel.PhoneNumber;
userModel.Password = password;
userModel.Role = registerationModel.Role;
userModel.RegistrationDate = DateTime.Now;
this.dbContext.UserRegistrations.Add(userModel);
this.dbContext.SaveChanges();
userResponse = Response(userModel);
}
else
{
return(userResponse);
}
return(userResponse);
}
catch (Exception e)
{
throw new Exception(e.Message);
}
}
public IActionResult UserRegistration(RegisterationModel registerationModel)
{
try
{
if (registerationModel.FirstName == null || registerationModel.LastName == null || registerationModel.Role == null || registerationModel.EmailId == null || registerationModel.PhoneNumber == null || registerationModel.Password == null)
{
throw new BookStoreException(BookStoreException.ExceptionType.NULL_FIELD_EXCEPTION, "Null Field");
}
else if (registerationModel.FirstName == "" || registerationModel.LastName == "" || registerationModel.Role == "" || registerationModel.EmailId == "" || registerationModel.PhoneNumber == "" || registerationModel.Password == "")
{
throw new BookStoreException(BookStoreException.ExceptionType.EMPTY_FIELD_EXCEPTION, "Empty Field");
}
// Call the User Registration Method of User Business classs
var response = userBusiness.UserRegistration(registerationModel);
// check if Id is not equal to zero
if (response.Id.Equals(0))
{
bool status = false;
var message = "User already Present";
return(this.Conflict(new { status, message }));
}
else
{
bool status = true;
var message = "User Registered Successfully";
return(this.Ok(new { status, message, data = response }));
}
}
catch (Exception e)
{
return(this.BadRequest(new { status = false, message = e.Message }));
}
}
public async Task <AuthModel> RegisterAsync(RegisterationModel model)
{
if (await _userManager.FindByEmailAsync(model.Email) is not null)
{
return new AuthModel()
{
Message = "email is already registered"
}
}
;
if (await _userManager.FindByNameAsync(model.UserName) is not null)
{
return new AuthModel()
{
Message = "username is already registered"
}
}
;
var user = new ApplicationUser
{
UserName = model.UserName,
FirstName = model.FirstName,
LastName = model.LastName,
Email = model.Email
};
var result = await _userManager.CreateAsync(user, model.Password);
if (!result.Succeeded)
{
var errors = string.Empty;
foreach (var error in result.Errors)
{
errors += $"{error.Description},";
}
return(new AuthModel {
Message = errors.Remove(errors.LastIndexOf(","))
});
}
await _userManager.AddToRoleAsync(user, Roles.User.ToString());
var securityToken = await GenerateJwtToke(user);
return(new AuthModel
{
Email = user.Email,
UserName = user.UserName,
isAuthenticated = true,
Roles = new List <string> {
Roles.User.ToString()
},
Token = new JwtSecurityTokenHandler().WriteToken(securityToken),
ExpiredOn = securityToken.ValidTo,
});
}
public async Task <ActionResult> CreateVisistor(RegisterationModel visitor)
{
var response = await service.CreateVisitor(visitor);
if (response.status == true)
{
return(Ok(response));
}
return(BadRequest(response));
}
public async Task <IActionResult> register(RegisterationModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(model));
}
var result = await account.RegisterAsync(model);
return(Ok(result));
}
public async Task <ActionResult> CreateResource(RegisterationModel Resource)
{
var response = await service.AddUserWithRole(Resource, "RESOURCE", pathRoot);
if (response.status == true)
{
return(Ok(response));
}
return(BadRequest(response));
}
public async Task <ActionResult> CreateAdmin(RegisterationModel Admin)
{
var response = await service.AddUserWithRole(Admin, "ADMIN", pathRoot);
if (response.status == true)
{
return(Ok(response));
}
return(BadRequest(response));
}
/// <summary>
/// This Method is used to User Registration
/// </summary>
/// <param name="registrationModel">It contains the Object of Registration Request Model</param>
/// <returns>If User Registered Successfully it returns User response Model</returns>
public UserResponseModel UserRegistration(RegisterationModel registerationModel)
{
try
{
// Call the User Register Method of User Repository Class
var response = this.userRepository.UserRegistration(registerationModel);
return(response);
}
catch (Exception exception)
{
throw new Exception(exception.Message);
}
}
public async Task <IResponse> CreateVisitor(RegisterationModel visitor)
{
AppUser newAppUser = new AppUser
{
UserName = visitor.UserName,
Email = visitor.Email,
EmailConfirmed = true,
};
var result = await userManager.CreateAsync(newAppUser, visitor.Password);
if (result.Succeeded)
{
await userManager.AddToRoleAsync(newAppUser, "VISITOR");
}
else
{
response.error_EN = result.Errors.Select(e => e.Description).FirstOrDefault();
response.status = false;
}
return(response);
}
public IActionResult OnPost(RegisterationModel model)
{
try
{
if (!model.IsValid())
{
return(null);
}
else
{
var res = registerCommand.Execute(model);
return(RedirectToPage("Login"));
}
}
catch (Exception ex)
{
ErrorHandling errorHandling = new ErrorHandling();
var res = errorHandling.GetErrorMessage(ex);
TempData["ErrorMessage"] = res;
return(null);
}
}
