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()); }; }