private async Task <IActionResult> RegisterUser(RegistrationRequestModel request, string roleName)
{
var user = await _userManager.CreateAsync(new ApplicationUser()
{
Email = request.Email,
PhoneNumber = request.PhoneNumber,
UserName = request.Email
}, request.Password);
if (user.Succeeded)
{
var nowInsertedUser = await _userManager.FindByEmailAsync(request.Email);
var roleInsert = await _userManager.AddToRoleAsync(nowInsertedUser, roleName);
return(Ok(new
{
Success = true,
Message = "User created successfully."
}));
}
return(BadRequest(user.Errors));
}
public async Task <IActionResult> Registration(RegistrationRequestModel userDB)
{
try
{
var data = await this._userBL.Registration(userDB);
bool status;
string message;
if (data != null)
{
if (IsFieldEmpty(userDB))
{
status = true;
message = "Successfully added";
return(this.Ok(new { status, message, data }));
}
else
{
status = false;
message = "field cannot be empty";
return(this.BadRequest(new { status, message }));
}
}
else
{
status = false;
message = "failed to add";
return(this.BadRequest(new { status, message }));
}
}
catch (Exception e)
{
return(this.BadRequest(e.Message));
}
}
/// <summary>
/// Service End Point to register new user
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public Task <RegistrationResposeModel> RegisterNewUserContract(RegistrationRequestModel request)
{
return(_registrationManagement.RegisterNewUser(request));
}
public async Task <IActionResult> CustomerRegister(RegistrationRequestModel request)
{
return(await RegisterUser(request, "customer"));
}
public async Task <IActionResult> ManagerRegistration(RegistrationRequestModel request)
{
return(await RegisterUser(request, "manager"));
}
public HttpResponseMessage CreateAccount(RegistrationRequestModel account)
{
if (account == null)
{
return(ToolsBoxResponse.OK(new BasicResponseModel
{
Message = "Request is empty",
Status = HttpStatusCode.BadRequest
}));
}
if (!ToolsBox.IsEmailValid(account.email))
{
return(ToolsBoxResponse.OK(new BasicResponseModel
{
Message = "email not valid",
Status = HttpStatusCode.BadRequest
}));
}
if (string.IsNullOrEmpty(account.password))
{
return(ToolsBoxResponse.OK(new BasicResponseModel
{
Message = "No password provided",
Status = HttpStatusCode.BadRequest
}));
}
if (string.IsNullOrEmpty(account.username))
{
return(ToolsBoxResponse.OK(new BasicResponseModel
{
Message = "No username provided",
Status = HttpStatusCode.BadRequest
}));
}
var response = AccountHelper.AddAccount(new DataProvider.Models.Account
{
email = account.email,
password = account.password,
username = account.username
});
if (response == null)
{
return(ToolsBoxResponse.OK(new BasicResponseModel
{
Message = "Account can't be created, retry later.",
Status = HttpStatusCode.InternalServerError
}));
}
switch (response.Status)
{
case HttpStatusCode.OK:
return(ToolsBoxResponse.OK(new RegistrationResponseModel
{
Token = TokenProvider.Generate(account.username, account.password),
Id = response.Id,
Status = HttpStatusCode.OK
}));
case HttpStatusCode.BadRequest:
return(ToolsBoxResponse.OK(new BasicResponseModel
{
Message = response.Message,
Status = HttpStatusCode.BadRequest
}));
default:
return(ToolsBoxResponse.OK(new BasicResponseModel
{
Message = response.Message,
Status = HttpStatusCode.InternalServerError
}));
}
}
//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);
}
}
public RegistrationResposeModel RegisterNewUserContract(RegistrationRequestModel composite)
{
return(_registrationManagement.RegisterNewUser(composite).Result);
}
public async Task <IActionResult> Register(RegistrationRequestModel userData) => Json(await accountService.RegisterAsync(userData));
public async Task <IActionResult> EditProfile(RegistrationRequestModel model, int Id)
{
try
{
bool mailChanged = false;
var base64 = "";
if (model.Avatar != null)
{
var tempImage = System.Drawing.Image.FromStream(model.Avatar.OpenReadStream());
var result = Utility.ResizeImage(tempImage, 300, 300);
base64 = string.Format("data:image/jpg; base64, {0}", Convert.ToBase64String(Utility.ImageToByte2(result)));
model.UserImage = base64;
}
var user = _context.RegistrationRequests.FirstOrDefault(a => a.Id == Id);
user.Name = string.IsNullOrEmpty(model.Name) ? user.Name : model.Name;
user.SurName = string.IsNullOrEmpty(model.SurName) ? user.SurName : model.SurName;
user.Phone = string.IsNullOrEmpty(model.Phone) ? user.Phone : model.Phone;
user.About = string.IsNullOrEmpty(model.About) ? user.About : model.About;
user.Image = string.IsNullOrEmpty(model.UserImage) ? user.Image : model.UserImage;
IdentityUser currentUser = await _userManager.FindByEmailAsync(user.Email);
if (!string.IsNullOrEmpty(model.Password))
{
await _userManager.ChangePasswordAsync(currentUser, user.Password, model.Password);
user.Password = model.Password;
}
if (!model.Email.Equals(user.Email))
{
mailChanged = true;
string token = await _userManager.GenerateChangeEmailTokenAsync(currentUser, model.Email);
await _userManager.ChangeEmailAsync(currentUser, model.Email, token);
await _userManager.SetUserNameAsync(currentUser, model.Email);
user.Email = model.Email;
}
_context.Update(user);
await _context.SaveChangesAsync();
if (mailChanged)
{
return(RedirectToAction("SignOut"));
}
if (User.IsInRole("Admin"))
{
return(RedirectToAction("UserRequestIndex"));
}
return(RedirectToAction("Profile", new { UserName = user.Email }));
}
catch (Exception ex)
{
string strMsg = "Something Went Wrong or not all required fileds are filled try again";
string script = "<script language=\"javascript\" type=\"text/javascript\">alert('" + strMsg + "'); window.location='EditProfile'; </script>";
await Response.WriteAsync(script);
return(View(model));
}
}
public async Task <RegistrationResponseModel> RegisterAsync([FromBody] RegistrationRequestModel request)
{
var result = await _adminUserService.RegisterAsync(_mapper.Map <RegistrationRequestDto>(request));
return(_mapper.Map <RegistrationResponseModel>(result));
}
public void SaveEditedChanges(RegistrationRequestModel model, int id)
{
throw new NotImplementedException();
}
private void SetupAccountServiceRegisterMock(RegistrationRequestModel registrationRequestModel, RegistrationResponseModel registrationResponseModel) => accountServiceMock .Setup(service => service.RegisterAsync(registrationRequestModel)) .ReturnsAsync(registrationResponseModel);
public async Task <bool> RegisterAsync(RegistrationRequestModel model)
{
model.Id = await SendRequestFor <int>(API.METHOD.REGISTER, model);
return(model.Id != -1);
}
public RegistrationResposeModel Register(RegistrationRequestModel request)
{
return(_authService.RegisterNewUserContract(request));
}
