private ResponseModel CreateUser(EmployeeRegistrationModel model)
{
var userModel = _userCredential.GetByLoginID(model.PhoneNumber, UserType.ResourceTrackerAdmin);
if (userModel != null)
{
return new ResponseModel {
Message = "This mobile number already exists."
}
}
;
var p = GeneratePassword();
var password = CryptographyHelper.CreateMD5Hash(p);
var response = _userCredential.Save(new UserCredentialModel
{
FullName = model.UserFullName,
UserTypeId = (int)UserType.ResourceTrackerUser,
Email = model.Email,
ContactNo = model.PhoneNumber,
LoginID = model.PhoneNumber,
IsActive = true,
Password = password
});
if (response.Success)
{
Task.Run(() => SendMailToUser(model.Email, model.PhoneNumber, p));
}
return(new ResponseModel {
Success = response.Success, Message = response.Success?p:string.Empty, ReturnCode = response.ReturnCode
});
}
public async Task <ActionResult> Add(EmployeeRegistrationModel employee)
{
if (ModelState.IsValid)
{
using (HttpClient httpClient = new HttpClient())
{
string endPoint = CommonHelper.GetSiteUrl() + "API/Account/register";
HttpContent content = new FormUrlEncodedContent(new[]
{
new KeyValuePair <string, string>("firstName", employee.firstName),
new KeyValuePair <string, string>("lastName", employee.lastName),
new KeyValuePair <string, string>("email", employee.email),
new KeyValuePair <string, string>("password", employee.password),
new KeyValuePair <string, string>("confirmPassword", employee.confirmPassword),
new KeyValuePair <string, string>("departmentId", employee.departmentId.ToString()),
new KeyValuePair <string, string>("gender", employee.gender),
new KeyValuePair <string, string>("cityId", employee.cityId.ToString()),
new KeyValuePair <string, string>("countryId", employee.countryId.ToString()),
});
HttpResponseMessage result = await httpClient.PostAsync(endPoint, content);
string resultContent = result.Content.ReadAsStringAsync().Result;
var response = JsonConvert.DeserializeObject <AddEmployeeResponse>(resultContent);
if (!string.IsNullOrEmpty(response.data.id.ToString()))
{
ViewBag.Added = "true";
}
}
}
ViewBag.DepartmentId = new SelectList(await DepartmentBAL.getDepartment(), "Id", "DepartmentName");
ViewBag.CountryId = new SelectList(entity.Countries, "Id", "CountryName");
ViewBag.CityId = new SelectList(entity.Cities, "Id", "CityName");
return(View(employee));
}
public static Employee EmployeMap(EmployeeRegistrationModel model)
{
Employee employee = new Employee();
employee.FirstName = model.firstName;
employee.LastName = model.lastName;
employee.UserId = model.userId;
employee.EmailId = model.email;
employee.Password = model.password;
employee.DepartmentId = model.departmentId;
employee.Gender = model.gender;
employee.CityId = model.cityId;
employee.CountryId = model.countryId;
return(employee);
}
public IHttpActionResult CreateEmployee(EmployeeRegistrationModel json)
{
if (json == null || json.CompanyId == 0)
{
return(Ok(new { Success = false, Message = "Please create a company from setting menu." }));
}
var model = new EmployeeRegistrationModel
{
Email = json.Email,
PhoneNumber = json.PhoneNumber,
Password = json.Password,
UserName = json.UserName,
Gender = json.Gender,
UserFullName = json.UserFullName,
UserType = json.UserType,
Designation = json.Designation,
DepartmentId = json.DepartmentId,
CompanyId = json.CompanyId,
IsAutoCheckPoint = json.IsAutoCheckPoint,
AutoCheckPointTime = json.AutoCheckPointTime,
MaximumOfficeHours = json.MaximumOfficeHours,
OfficeOutTime = json.OfficeOutTime
};
var response = CreateUser(model);
if (!response.Success)
{
return(Ok(response));
}
EmployeeUser empUser = new EmployeeUser
{
UserId = response.ReturnCode,
UserName = model.UserFullName,
PhoneNumber = model.PhoneNumber,
Designation = model.Designation,
DepartmentId = Convert.ToInt32(model.DepartmentId),
CompanyId = model.CompanyId,
IsAutoCheckPoint = model.IsAutoCheckPoint,
AutoCheckPointTime = model.AutoCheckPointTime,
MaximumOfficeHours = model.MaximumOfficeHours,
OfficeOutTime = model.OfficeOutTime
};
var userResponse = _employeeRepository.Create(empUser);
return(Ok(new { Success = true, Message = response.Message }));
}
public async Task <IActionResult> Register(EmployeeRegistrationModel employeeModel)
{
if (!ModelState.IsValid)
{
return(View());
}
var employee = _mapper.Map <Employee>(employeeModel);
var result = await _userManager.CreateAsync(employee, employeeModel.Password);
if (!result.Succeeded)
{
foreach (var error in result.Errors)
{
ModelState.TryAddModelError(error.Code, error.Description);
}
return(View(employeeModel));
}
await _userManager.AddToRoleAsync(employee, employeeModel.Role);
return(RedirectToAction(nameof(HomeController.Index), "Home"));
}
public async Task <IHttpActionResult> Register(EmployeeRegistrationModel model)
{
ResponseStatusModel <EmployeeRegistrationModel> response = new ResponseStatusModel <EmployeeRegistrationModel>();
try
{
if (ModelState.IsValid)
{
var isEmailExist = await UserBAL.isEmailExist(model.email);
if (!isEmailExist)
{
var newApplicationUser = new ApplicationUser()
{
UserName = model.email, Email = model.email
};
IdentityResult result = await UserManager.CreateAsync(newApplicationUser, model.password);
if (result.Succeeded)
{
model.userId = newApplicationUser.Id;
long employeeId = await UserBAL.addEmployee(model);
if (employeeId > 0)
{
model.id = employeeId;
response.code = Convert.ToInt32(HttpStatusCode.OK);
response.status = true;
response.data = model;
response.message = "Record saved successfully.";
return(Content(HttpStatusCode.OK, response));
}
else
{
await UserManager.DeleteAsync(newApplicationUser);
response.code = Convert.ToInt32(HttpStatusCode.BadRequest);
response.status = false;
response.message = "Email is already exist.";
return(Content(HttpStatusCode.BadRequest, response));
}
}
else
{
var applicationUser = await UserManager.FindByEmailAsync(model.email);
if (applicationUser != null)
{
await UserManager.DeleteAsync(applicationUser);
}
response.code = Convert.ToInt32(HttpStatusCode.Conflict);
response.status = false;
response.message = "Email is already exist.";
return(Content(HttpStatusCode.Conflict, response));
}
}
else
{
response.code = Convert.ToInt32(HttpStatusCode.Conflict);
response.status = false;
response.message = "User email already exist.";
return(Content(HttpStatusCode.Conflict, response));
}
}
else
{
response.code = Convert.ToInt32(HttpStatusCode.BadRequest);
response.status = false;
response.message = CommonHelper.GetModalErrorResult(ModelState);
return(Content(HttpStatusCode.BadRequest, response));
}
}
catch (Exception ex)
{
var applicationUser = await UserManager.FindByEmailAsync(model.email);
if (applicationUser != null)
{
await UserManager.DeleteAsync(applicationUser);
}
response.code = Convert.ToInt32(HttpStatusCode.BadRequest);
response.status = false;
response.message = ex.InnerException.Message;
return(Content(HttpStatusCode.BadRequest, response));
}
}
public static async Task <long> addEmployee(EmployeeRegistrationModel model)
{
Employee employee = Mapping.EmployeMap(model);
return(await UserDAL.addEmployee(employee));
}
