public async Task <RegistrationResponseModel> UserRegistration(Registration registration)
{
RegistrationResponseModel registrationResponse = new RegistrationResponseModel();
if (registration != null)
{
if (ModelState.IsValid)
{
try
{
var Sucess = await userInterface.AddPost(registration);
if (Sucess.StatusCode == 200)
{
registrationResponse.Status = true;
registrationResponse.StatusCode = 200;
}
else
{
registrationResponse.Status = false;
}
}
catch (Exception ex)
{
registrationResponse.Status = false;
}
}
else
{
registrationResponse.Status = false;
}
}
return(registrationResponse);
}
public async Task <ActionResult> Index(RegistrationModel model)
{
RegistrationResponse response = _registrationService.Registration(model);
RegistrationResponseModel respModel = new RegistrationResponseModel();
respModel.Model = model;
respModel.RegReponse = response;
if (response.AuthToken != Guid.Empty)
{
AppUser user = new AppUser(response.AuthToken);
UserInfoResponse userInfo = _authService.GetUserData(response.AuthToken);
user.FIO = userInfo.User.Name;
user.City = userInfo.User.City;
user.RoleChangeDateTime = response.RoleChangeDateTime;
user.Status = userInfo.User.UserStatus;
var result = await userManager.CreateAsync(user);
if (result.Succeeded)
{
await SignIn(user, userInfo.User.UserRoles);
}
Session["userId"] = user.Id;
//FormsAuthentication.SetAuthCookie(response.AuthToken.ToString(), false);
}
if (Request.IsAjaxRequest())
{
return(Json(response, JsonRequestBehavior.AllowGet));
}
return(View(respModel));
}
/// <summary>
///
/// </summary>
/// <param name="newuser"></param>
/// <param name="password"></param>
/// <returns></returns>
public async Task <RegistrationResponseModel> Create(UserViewModel newuser, string password)
{
var user = new ApplicationUser
{
UserName = newuser.UserName,
Email = newuser.Email,
FirstName = newuser.FirstName,
LastName = newuser.LastName,
DOB = newuser.DOB
};
if ((newuser.UserName == null) || (newuser.UserName.Length == 0))
{
newuser.UserName = newuser.Email;
}
var responseStatus = new RegistrationResponseModel();
var responseErrors = new List <RegistrationErrorResponseModel>();
var result = await _userManager.CreateAsync(user, password);
responseStatus.IsSuccessful = result.Succeeded;
if (result.Succeeded)
{
_logger.LogInformation("User created a new account with password.");
//var code =
await _userManager.GenerateEmailConfirmationTokenAsync(user);
_logger.LogInformation("User created a new account with password.");
// add additional claims for this new user..
var newClaims = new List <Claim>()
{
new Claim(ClaimTypes.GivenName, user.FirstName),
new Claim(ClaimTypes.Surname, user.LastName),
new Claim(ClaimTypes.DateOfBirth, user.DOB.ToShortDateString())
};
await _userManager.AddClaimsAsync(user, newClaims);
responseStatus.userinfo.Id = user.Id;
_logger.LogInformation("Claims added for user.");
}
else
{
foreach (IdentityError err in result.Errors)
{
responseErrors.Add(new RegistrationErrorResponseModel()
{
ErrorCode = err.Code,
ErrorDescription = err.Description
});
}
responseStatus.errors = responseErrors;
}
return(responseStatus);
}
/// <summary>
/// This Method is used For Forget Password
/// </summary>
/// <param name="forgotPassword">It contains the Object of Forget Password Model</param>
/// <returns>It returns message</returns>
public object ForgetPassword(ForgotPasswordModel forgotPassword)
{
try
{
RegistrationResponseModel responseModel = new RegistrationResponseModel();
// create the object of SqlCommand and send the command and connection object
SqlCommand sqlCommand = this.StoreProcedureConnection("spForgetPassword", this.sqlConnection);
// Add the First Name Value to database
sqlCommand.Parameters.AddWithValue("@EmailId", forgotPassword.EmailId);
// Opens the Sql Connection
this.sqlConnection.Open();
int status = 1;
// Read the employee data from database using SqlDataReader
SqlDataReader sqlDataReader = sqlCommand.ExecuteReader();
while (sqlDataReader.Read())
{
status = sqlDataReader.GetInt32(0);
if (status == 0)
{
return(null);
}
// Read the Employee Id and convert it into integer
responseModel.Id = Convert.ToInt32(sqlDataReader["Id"]);
// Read the Email Id
responseModel.EmailId = sqlDataReader["EmailId"].ToString();
}
// close Sql Connection
this.sqlConnection.Close();
if (responseModel.EmailId != null)
{
TokenGenerator tokenGenerator = new TokenGenerator(this.configuration);
var token = tokenGenerator.CreateToken(responseModel);
////create the object of MSMQSender class
ForgetPasswordSender msmqSender = new ForgetPasswordSender();
////call the method ForgetPasswordMessage
msmqSender.ForgetPasswordMessage(forgotPassword.EmailId, token);
return("Token Has Been Sent");
}
else
{
return(null);
}
}
catch (Exception exception)
{
throw new Exception(exception.Message);
}
}
public async Task RegisterTest()
{
RegistrationRequestModel registrationRequestModel = CreateRegistrationRequestModel();
RegistrationResponseModel expected = CreateRegistrationResponseModel();
SetupAccountServiceRegisterMock(registrationRequestModel, expected);
var actual = (JsonResult)await accountApiController.Register(registrationRequestModel);
Assert.AreEqual(expected, actual.Value);
}
public async Task <AuthorizationResponseModel> RegisterAsync(AuthorizationRequestModel registrationModel)
{
RoleData role = applicationRoleRepository.Get(registrationModel.Role);
RegistrationResponseModel response = new RegistrationResponseModel()
{
IsSuccessful = false, Message = string.Empty
};
var userData = new UserData
{
Email = registrationModel.Email,
Password = registrationModel.Password,
RoleId = role.Id
};
IdentityResult userCreatingResult = await applicationUserRepository.CreateAsync(userData);
if (!userCreatingResult.Succeeded)
{
// pushing message of first error in array
response.Message = GetErrorMessage(userCreatingResult);
return(response);
}
userData = await applicationUserRepository.FindByEmailAsync(userData.Email);
ClientData client = new ClientData()
{
Name = registrationModel.UserName,
Surname = registrationModel.Surname,
PhotoPath = "default/profile.png",
UserId = userData.Id
};
ClientData addedClient = await clientRepository.AddAsync(client);
if (addedClient == null)
{
response.Message = "Client not added";
}
response.IsSuccessful = true;
string token = javascriptWebTokenFactory.Create(userData.Id);
var sessionData = new SessionData
{
UserId = userData.Id,
Token = token,
};
await sessionRepository.CreateAsync(sessionData);
response.Token = token;
return(response);
}
/// <summary>
///
/// </summary>
/// <param name="registrationRequest"></param>
/// <returns></returns>
public async Task <RegistrationResponseModel> AddPost(Registration registrationRequest)
{
RegistrationResponseModel registrationResponse = new RegistrationResponseModel();
if (registrationRequest != null)
{
await dBContext.registrations.AddAsync(registrationRequest);
await dBContext.SaveChangesAsync();
registrationResponse.StatusCode = 200;
}
return(registrationResponse);
}
/// <summary>
/// This Method is used generate Token
/// </summary>
/// <param name="responseModel">It is an Object of Registration Response Model</param>
/// <returns>It returns JWT Token</returns>
public string CreateToken(RegistrationResponseModel responseModel)
{
try
{
var symmetricSecuritykey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(configuration["Jwt:Key"]));
var signingCreds = new SigningCredentials(symmetricSecuritykey, SecurityAlgorithms.HmacSha256);
var claims = new List <Claim>();
claims.Add(new Claim("EmailId", responseModel.EmailId.ToString()));
claims.Add(new Claim("Id", responseModel.Id.ToString()));
var token = new JwtSecurityToken(
claims: claims,
expires: DateTime.Now.AddHours(1),
signingCredentials: signingCreds);
return(new JwtSecurityTokenHandler().WriteToken(token));
}
catch (Exception e)
{
throw new Exception(e.Message);
}
}
public async Task RegisterAsyncTest()
{
string token = string.Empty;
RoleData roleData = CreateRoleData();
UserData userData = CreateUserData(roleData);
ClientData clientData = CreateClientData(userData);
SessionData sessionData = CreateSessionData();
RegistrationResponseModel expected = new RegistrationResponseModel()
{
IsSuccessful = true
};
SetupApplicationRoleRepositoryGetMock(roleData);
SetupApplicationUserRepositoryCreateAsyncMock(userData);
SetupApplicationUserRepositoryFindByEmailAsyncMock(userData);
SetupClientRepositoryAddAsyncMock(clientData);
SetupJavascriptWebTokenFactoryCreateMock(userData.Id, token);
SetupSessionRepositoryCreateAsyncMock(sessionData);
RegistrationResponseModel actual = await accountService.RegisterAsync(registrationModel);
Assert.AreEqual(expected, actual);
}
//private IConfiguration configuration;
/// <summary>
/// This Method is used to User Registration
/// </summary>
/// <param name="userModel">It contains the Object of User Model</param>
/// <returns>If User Registered Successfully it returns true</returns>
public RegistrationResponseModel UserRegistration(RegistrationRequestModel registrationModel)
{
try
{
RegistrationResponseModel responseModel = new RegistrationResponseModel();
// create the object of SqlCommand and send the command and connection object
SqlCommand sqlCommand = this.StoreProcedureConnection("spUserRegister", this.sqlConnection);
// Add the First Name Value to database
sqlCommand.Parameters.AddWithValue("@FirstName", registrationModel.FirstName);
// Add the Last Name Value to database
sqlCommand.Parameters.AddWithValue("@LastName", registrationModel.LastName);
// Add the Gender Value to database
sqlCommand.Parameters.AddWithValue("@Gender", registrationModel.Gender);
// Add the Email Id Value to database
sqlCommand.Parameters.AddWithValue("@EmailId", registrationModel.EmailId);
// Add the Phone Number Value to database
sqlCommand.Parameters.AddWithValue("@PhoneNumber", registrationModel.PhoneNumber);
// Add the City Value to database
sqlCommand.Parameters.AddWithValue("@City", registrationModel.City);
// Add the Registration Date to database
//sqlCommand.Parameters.AddWithValue("@RegistrationDate", DateTime.Now);
// this varibale strores the Encrypted password
string password = this.encryptDecrypt.EncodePasswordToBase64(registrationModel.Password);
// Add the Encrypted password to database
sqlCommand.Parameters.AddWithValue("@Password", password);
// Opens the Sql Connection
this.sqlConnection.Open();
int status = 1;
// Read the employee data from database using SqlDataReader
SqlDataReader sqlDataReader = sqlCommand.ExecuteReader();
while (sqlDataReader.Read())
{
status = sqlDataReader.GetInt32(0);
if (status == 0)
{
return(responseModel);
}
// Read the Employee Id and convert it into integer
responseModel.Id = Convert.ToInt32(sqlDataReader["Id"]);
// Read the First Name
responseModel.FirstName = sqlDataReader["FirstName"].ToString();
// Read the Last Name
responseModel.LastName = sqlDataReader["LastName"].ToString();
// Read the Email Id
responseModel.EmailId = sqlDataReader["EmailId"].ToString();
// Read the Gender
responseModel.Gender = sqlDataReader["Gender"].ToString();
// Read the Phone Number
responseModel.PhoneNumber = sqlDataReader["PhoneNumber"].ToString();
// Read the City
responseModel.City = sqlDataReader["City"].ToString();
responseModel.Password = sqlDataReader["Password"].ToString();
// Read the Registration date and convert into Date Time
responseModel.RegistrationDate = Convert.ToDateTime(sqlDataReader["RegistrationDate"]);
//responseModel.UpdationDate = Convert.ToDateTime(sqlDataReader["UpdationDate"]);
}
// close Sql Connection
this.sqlConnection.Close();
// return the Ilist
return(responseModel);
}
catch (Exception e)
{
throw new Exception(e.Message);
}
}
private void SetupAccountServiceRegisterMock(RegistrationRequestModel registrationRequestModel, RegistrationResponseModel registrationResponseModel) => accountServiceMock .Setup(service => service.RegisterAsync(registrationRequestModel)) .ReturnsAsync(registrationResponseModel);
