public async Task <IActionResult> SignUp(SignUpModel model)
{
EmployerDTO employer = _mapper.Map <EmployerDTO>(model);
await _signUpService.SingUp(employer);
return(Ok());
}
public async Task <bool> UpdateAsync(EmployerDTO user)
{
if (user == null)
{
return(false);
}
try
{
EmployerModel employer = new EmployerModel()
{
Address = user.Address,
Email = user.Email,
Gender = user.Gender,
PhoneNumber1 = user.PhoneNumber1,
PhoneNumber2 = user.PhoneNumber2,
State = user.State,
Surname = user.Surname,
LastName = user.LastName
};
using (var context = _context)
{
_context.Employer.Attach(employer);
await _context.SaveChangesAsync();
return(Task.CompletedTask.IsCompleted);
}
}
catch (Exception ex) { }
return(Task.CompletedTask.IsCanceled);
}
public async Task <EmployerDTO> GetByIdAsync(int id)
{
if (string.IsNullOrEmpty(id.ToString()))
{
return(null);
}
EmployerModel user = null;
using (var context = _context)
{
user = await _context.Employer.AsNoTracking().FirstOrDefaultAsync(c => c.Id == id);
}
EmployerDTO result = new EmployerDTO
{
DateCreated = user.DateCreated,
Id = user.Id,
Address = user.Address,
Email = user.Email,
FirstName = user.FirstName,
Gender = user.Gender,
LastName = user.LastName,
PhoneNumber1 = user.PhoneNumber1,
PhoneNumber2 = user.PhoneNumber2,
State = user.State,
Surname = user.Surname,
};
return(result);
}
public bool Add(EmployerDTO employerDto)
{
Employer temp = _unitOfWork.Employers.Find(e => e.PhoneNumber.Equals(employerDto.PhoneNumber)).SingleOrDefault();
if (temp != null)
{
return(false);
}
if (employerDto.Username == null)
{
employerDto.Username = employerDto.PhoneNumber;
}
if (employerDto.Password == null)
{
employerDto.Password = "******";
}
if (employerDto.Active == null)
{
employerDto.Active = "Active";
}
var employer = _mapper.Map <EmployerDTO, Employer>(employerDto);
_unitOfWork.Employers.Add(employer);
_unitOfWork.Complete();
return(true);
}
public async Task <IHttpActionResult> RegisterEmployer(EmployerDTO model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = new ApplicationUser()
{
UserName = model.Email, Email = model.Email
};
IdentityResult result = await UserManager.CreateAsync(user, model.Password);
if (!result.Succeeded)
{
return(GetErrorResult(result));
}
var roleStore = new RoleStore <IdentityRole>(new ApplicationDbContext());
var roleManager = new RoleManager <IdentityRole>(roleStore);
roleManager.Create(new IdentityRole("Employer"));
UserManager.AddToRole(user.Id, "Employer");
var employerId = helper.RegisterEmployer(model);
return(Ok(employerId));
}
public ActionResult PostEmployer(EmployerDTO employerDTO)
{
if (!_employerService.Add(employerDTO))
{
return(BadRequest(new { success = false, message = "Số điện thoại đã tồn tại" }));
}
return(Ok(new { success = true, message = "Thêm thành công" }));
}
public async Task <IActionResult> Create([FromBody] EmployerDTO employerDto)
{
var employer = _mapper.Map <EmployerDTO, Employer>(employerDto);
await _employerRepository.AddAsync(employer);
var employerResource = _mapper.Map <Employer, EmployerResource>(employer);
return(Json(employerResource));
}
public List <EmployerDTO> Pagination(EmployerDTO filters)
{
try
{
return(this.employerDAO.Pagination(filters));
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public EmployerDTO Save(EmployerDTO employerDTO)
{
try
{
return(this.employerDomainObject.Save(employerDTO));
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public async Task <IActionResult> GetEmployerByIdAsync(int employerId)
{
EmployerDTO employer = await _employerFeature.GetEmployerByIdAsync(employerId);
if (employer == null)
{
return(NotFound());
}
return(Ok(employer));
}
public EmployerDTO Update(EmployerDTO employerDTO)
{
try
{
return(this.employerDAO.Update(employerDTO));
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public void Update(int id, EmployerDTO employerDto)
{
var employer = _unitOfWork.Employers.GetBy(id);
if (employer == null)
{
return;
}
employer.Password = employerDto.Password;
//_mapper.Map<EmployerDTO, Employer>(employerDto, employer);
_unitOfWork.Complete();
}
public async Task SingUp(EmployerDTO employerDTO)
{
Employer employer = await _employerRepository.GetEmployer(employerDTO.Email);
if (null == employer)
{
string hashedPassword = _hashPasswordService.GenerateHashForPassword(employerDTO.Password);
employer = _mapper.Map <Employer>(employerDTO);
employer.Password = hashedPassword;
await _employerRepository.CreateEmployer(employer);
}
}
public JsonResult UpdateEmployer(EmployerDTO model)
{
if (ModelState.IsValid)
{
if (model != null)
{
return(Json(_employer.UpdateAsync(model).GetAwaiter().GetResult() ? "Done" : "Failed"));
}
}
return(Json("Null value"));
}
public async Task <EmployerDTO> GetEmployerByIdAsync(int employerId)
{
var employer = await _dataService.EmployersRepository.GetEmployerByIdAsync(employerId);
if (employer == null)
{
return(null);
}
EmployerDTO employerResource = _mapper.Map <EmployerDTO>(employer);
return(employerResource);
}
public async Task <string> SingIn(EmployerDTO employerDTO)
{
Employer employer = await _employerRepository.GetEmployer(employerDTO.Email);
if ((null != employer) && (_hashPasswordService.CheckPassword(employerDTO.Password, employer.Password)))
{
employerDTO.Id = employer.Id;
return(GenerateJWTToken(employer));
}
else
{
return(null);
}
}
public ActionResult <EmployerDTO> Save([FromBody] EmployerDTO employerDTO)
{
try
{
var result = this._employerManager.Save(employerDTO);
return(Created("", result));
}
catch (Exception ex)
{
return(Conflict(new ErrorResponse {
Message = ex.Message.ToString()
}));
}
}
public ActionResult <EmployerDTO> Update(int id, [FromBody] EmployerDTO employerDTO)
{
try
{
var result = this._employerManager.Update(employerDTO);
return(Ok(result));
}
catch (Exception ex)
{
return(Conflict(new ErrorResponse {
Message = ex.Message.ToString()
}));
}
}
public EmployerDTO Update(EmployerDTO employerDTO)
{
try
{
return(this.ExecuteCreateOrUpdate(2, employerDTO));
}
catch (SqlException sqlE)
{
throw new Exception(sqlE.Message);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public void Block(EmployerDTO employerDto)
{
var employer = _unitOfWork.Employers.GetBy(employerDto.EmployerId);
if (employer == null)
{
return;
}
if (employer.Active == "Active")
{
employer.Active = "Block";
}
else
{
employer.Active = "Active";
}
_unitOfWork.Complete();
}
public async Task <IActionResult> UpdateEmployerPasswordAsync(EmployerDTO st, int id)
{
if (!ModelState.IsValid)
{
return(BadRequest("Fill all fields"));
}
Employer employer = await _repos.GetById(id);
if (await _repos.HasEntity(employer))
{
if (await(_repos as EmployersRepository).UpdatePassword(employer, st.Password))
{
return(Ok(new { message = "Updated" }));
}
return(BadRequest("Failed to update employer"));
}
return(BadRequest("This employer is not in database"));
}
public ActionResult Login(EmployerDTO employer)
{
var temp = _employerService.Find(employer.Username);
if (temp == null)
{
return(BadRequest(new { success = false, message = "Tên đăng nhập không tồn tại" }));
}
if (!temp.Password.Equals(employer.Password))
{
return(BadRequest(new { success = false, message = "Password sai" }));
}
if (temp.Active == "Block")
{
return(BadRequest(new { success = false, message = "Tài khoản đã bị khóa" }));
}
return(Ok(new { success = true, data = temp }));
}
public async Task <IActionResult> UpdateEmployerCompanyAsync(EmployerDTO em, int id)
{
if (!ModelState.IsValid)
{
return(BadRequest("Fill all fields"));
}
Employer employer = await _repos.GetById(id);
if (await _repos.HasEntity(employer))
{
employer.CompanyName = em.CompanyName;
if (await _repos.Update(employer))
{
return(Ok("Updated employer"));
}
return(BadRequest("Failed to update employer"));
}
return(BadRequest("This employer is not in database"));
}
public bool RegisterEmployer(EmployerDTO employerDTO)
{
try
{
var employer = new Employer()
{
Description = employerDTO.Description,
EmployerName = employerDTO.EmployerName,
EstablishmentDate = employerDTO.EstablishmentDate,
};
database.CreateEmployer(employer);
return(true);
}
catch (Exception ex)
{
Console.WriteLine(ex);
return(false);
}
}
public EmployerDTO EmployerByUserName(string userName)
{
var userToMap = _userRepo.EmployerByUserName(userName);
EmployerDTO userToReturn;
if (userToMap.JobRequests != null)
{
return(userToReturn = new EmployerDTO()
{
UserName = userToMap.UserName,
FirstName = userToMap.FirstName,
LastName = userToMap.LastName,
Email = userToMap.Email,
PhoneNumber = userToMap.PhoneNumber,
Img = userToMap.Img,
Company = userToMap.Company,
Position = userToMap.Position,
IsEmployer = true,
JobRequests = (from j in userToMap.JobRequests
where j.Complete == false
select new JobDTO()
{
Id = j.Id,
Title = j.Title,
Description = j.Description.Substring(0, 25) + ("..."),
Complete = false
}).ToList()
});
}
return(userToReturn = new EmployerDTO()
{
UserName = userToMap.UserName,
FirstName = userToMap.FirstName,
LastName = userToMap.LastName,
Email = userToMap.Email,
PhoneNumber = userToMap.PhoneNumber,
Img = userToMap.Img,
Company = userToMap.Company,
Position = userToMap.Position,
IsEmployer = true
});
}
public async Task <IActionResult> RegisterEmployer(EmployerDTO em)
{
if (!ModelState.IsValid)
{
return(BadRequest(new { message = "Fill all fields" }));
}
var employer = new Employer()
{
FirstName = em.FirstName,
LastName = em.LastName,
Email = em.Email,
Role = "user",
CompanyName = em.CompanyName
};
var company = await _companyRepos.GetCompanyByName(em.CompanyName);
if (company == null)
{
return(BadRequest(new { message = "Such company doesn't exist" }));
}
if (await _authRepos.UserExists(employer))
{
return(BadRequest(new { message = "This user already exists" }));
}
employer.CompanyId = company.CompanyId;
employer.CompanyName = company.Name;
employer = await _authRepos.Register(employer, em.Password);
if (employer == null)
{
return(BadRequest(new { message = "Failed to register" }));
}
var identity = await CreateEmployerIdentity(em.Email, em.Password);
string token = TokenCreatingService.CreateToken(identity, out string identityName, Configuration);
HttpContext.Session.SetString("Token", token);
HttpContext.Session.SetInt32("Id", employer.EmployerId);
HttpContext.Session.SetString("Name", employer.FirstName);
HttpContext.Session.SetString("Company", employer.CompanyName);
return(Ok(new { token = token, name = identityName }));
}
public async Task <IActionResult> Update(int id, [FromBody] EmployerDTO employerDto)
{
var sourceEmployer = await _employerRepository.GetByIdAsync(id, true);
if (sourceEmployer == null)
{
return(NotFound());
}
var entryEmployer = _mapper.Map <EmployerDTO, Employer>(employerDto);
entryEmployer.Id = sourceEmployer.Id;
entryEmployer.Projects = sourceEmployer.Projects;
var resultEmployer = _mapper.Map(entryEmployer, sourceEmployer);
await _employerRepository.UpdateAsync(resultEmployer);
return(Json(Ok()));
}
public async Task <IActionResult> SignIn(SignInModel model)
{
EmployerDTO employer = _mapper.Map <EmployerDTO>(model);
string token = await _signInService.SingIn(employer);
if (token != null)
{
var response = new
{
jwt = token,
userEmail = model.Email,
id = employer.Id
};
return(Ok(response));
}
else
{
return(Unauthorized());
}
}
public string CreateToken(EmployerDTO employerDTO)
{
var tokenHandler = new JwtSecurityTokenHandler();
var key = Encoding.ASCII.GetBytes(this._config.GetSection("Jwt:Secret").Value);
var name = string.Format("{0} {1} {2}", employerDTO.Name, employerDTO.LastName, employerDTO.MotherLastName);
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(new Claim[]
{
new Claim(ClaimTypes.PrimarySid, employerDTO.Id.ToString()),
new Claim(ClaimTypes.Name, name),
}),
Expires = DateTime.UtcNow.AddMinutes(60),
SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256Signature)
};
var token = tokenHandler.CreateToken(tokenDescriptor);
return(tokenHandler.WriteToken(token));
}
private EmployerDTO ExecuteCreateOrUpdate(int typeCrud, EmployerDTO employerDTO)
{
try
{
var storeProcedure = string.Format("EXEC {0} {1}, {2}, {3}, {4}, {5}, {6}, {7}, {8}, {9}, {10}, {11}, {12}, {13}, {14}, {15}, {16}, {17}, {18}",
StoreProcedureConstants.CreateOrUpdateEmployer,
ParametersConstants.TypeScrud,
ParametersConstants.ID,
ParametersConstants.Email,
ParametersConstants.Password,
ParametersConstants.Role,
ParametersConstants.Name,
ParametersConstants.LastName,
ParametersConstants.MotherLastName,
ParametersConstants.Status,
ParametersConstants.AdmissionDate,
ParametersConstants.BaseIncome,
ParametersConstants.BreakfastDeduction,
ParametersConstants.SavingsDeduction,
ParametersConstants.GasolineCard,
ParametersConstants.CreatedAt,
ParametersConstants.CreatedBy,
ParametersConstants.UpdatedAt,
ParametersConstants.UpdatedBy
);
if (!employerDTO.Password.Equals(""))
{
var salt = BCrypt.Net.BCrypt.GenerateSalt(12);
employerDTO.Password = BCrypt.Net.BCrypt.HashPassword(employerDTO.Password, salt);
}
var listParameters = new List <SqlParameter>
{
new SqlParameter(ParametersConstants.TypeScrud, SqlDbType.Int)
{
Value = typeCrud
},
new SqlParameter(ParametersConstants.ID, SqlDbType.Int)
{
Value = employerDTO.Id
},
new SqlParameter(ParametersConstants.Email, SqlDbType.VarChar, 200)
{
Value = employerDTO.Email
},
new SqlParameter(ParametersConstants.Password, SqlDbType.VarChar, 250)
{
Value = employerDTO.Password
},
new SqlParameter(ParametersConstants.Role, SqlDbType.Int)
{
Value = employerDTO.Role
},
new SqlParameter(ParametersConstants.Name, SqlDbType.VarChar, 60)
{
Value = employerDTO.Name
},
new SqlParameter(ParametersConstants.LastName, SqlDbType.VarChar, 60)
{
Value = employerDTO.LastName
},
new SqlParameter(ParametersConstants.MotherLastName, SqlDbType.VarChar, 60)
{
Value = employerDTO.MotherLastName
},
new SqlParameter(ParametersConstants.Status, SqlDbType.Bit)
{
Value = employerDTO.Status
},
new SqlParameter(ParametersConstants.AdmissionDate, SqlDbType.DateTime)
{
Value = employerDTO.AdmissionDate
},
new SqlParameter(ParametersConstants.BaseIncome, SqlDbType.Decimal)
{
Value = employerDTO.BaseIncome, Precision = 14, Scale = 2
},
new SqlParameter(ParametersConstants.BreakfastDeduction, SqlDbType.Decimal)
{
Value = employerDTO.BreakfastDeduction, Precision = 14, Scale = 2
},
new SqlParameter(ParametersConstants.SavingsDeduction, SqlDbType.Decimal)
{
Value = employerDTO.SavingsDeduction, Precision = 14, Scale = 2
},
new SqlParameter(ParametersConstants.GasolineCard, SqlDbType.Decimal)
{
Value = employerDTO.GasolineCard, Precision = 14, Scale = 2
},
new SqlParameter(ParametersConstants.CreatedAt, SqlDbType.DateTime)
{
Value = DateTime.Now
},
new SqlParameter(ParametersConstants.CreatedBy, SqlDbType.Int)
{
Value = employerDTO.CreatedBy
},
new SqlParameter(ParametersConstants.UpdatedAt, SqlDbType.DateTime)
{
Value = DateTime.Now
},
new SqlParameter(ParametersConstants.UpdatedBy, SqlDbType.Int)
{
Value = employerDTO.UpdatedBy
}
};
var result = this._dataBaseContext.Employer.FromSql(storeProcedure, listParameters.ToArray()).ToList();
return(result.Count() > 0 ? result[0] : null);
}
catch (SqlException sqlE)
{
throw new Exception(sqlE.Message);
}
catch (Exception ex)
{
throw new Exception(ex.Message.ToString());
};
}
