public HttpResponseMessage AddEmployee(NewEmployeeDto employee)
{
var employeeInfo = new EmployeeRepository();
var createNewEmployee = employeeInfo.AddNewEmployee(employee);
return(Request.CreateResponse(HttpStatusCode.Created, employeeInfo));
}
internal Employee AddToProject(int id, NewEmployeeDto employeeDto)
{
Employee employee = employeeService.GetEmployee(employeeDto.employeeId);
GetProjectById(id).Employees.Add(employee);
context.SaveChanges();
return(employee);
}
public Employee AddEmployee(NewEmployeeDto newEmployeeDto)
{
ValidateNames(newEmployeeDto.Firstname, newEmployeeDto.Surname);
var employee = new Employee
{
Firstname = newEmployeeDto.Firstname,
Surname = newEmployeeDto.Surname
};
return(_employeeRepository.AddEmployee(employee));
}
public async Task <NewEmployeeDto> Create(NewEmployeeDto newEmployeeDto)
{
if (newEmployeeDto == null)
{
throw new ArgumentNullException(nameof(newEmployeeDto));
}
var password = newEmployeeDto.Password;
if (string.IsNullOrWhiteSpace(password))
{
throw new Exception("Password is required");
}
if (_repository.FindByEmail(newEmployeeDto.Email).Result != null)
{
throw new Exception("Email \"" + newEmployeeDto.Email + "\" is already taken");
}
var newEmployee = _mapper.Map <Employee>(newEmployeeDto);
if (!newEmployeeDto.IsManualHolidaysInput)
{
var currentTime = _timeService.GetCurrentTime();
var workedTime = _timeService.GetWorkDays(newEmployee.WorksFromDate, currentTime);
var workDaysPerYear = _timeService.GetCurrentYearWorkDays();
newEmployee.FreeWorkDays = Math.Round(workedTime * ((double)newEmployee.DaysOfVacation / workDaysPerYear), 2);
}
else
{
if (newEmployeeDto.FreeWorkDays is null)
{
throw new ArgumentNullException();
}
newEmployee.FreeWorkDays = (double)newEmployeeDto.FreeWorkDays;
}
newEmployee.CurrentAvailableLeaves = newEmployee.ParentalLeaveLimit;
newEmployee.NextMonthAvailableLeaves = newEmployee.ParentalLeaveLimit;
await _repository.Create(newEmployee);
await _userService.Create(newEmployee, newEmployeeDto);
await _notificationSettingsService.Create(newEmployee.Id);
var employeeDto = _mapper.Map <NewEmployeeDto>(newEmployee);
return(employeeDto);
}
public EmployeeViewModel AddEmployee(NewEmployeeDto newEmployee)
{
try {
var employee = _factory.EmployeeForInsert(newEmployee);
_database.Employee.Add(employee);
_database.Save();
return(_factory.EmployeeForView(employee));
} catch (Exception e) {
_logger.LogError(1, e.Message, e);
return(null);
}
}
public Employee EmployeeForInsert(NewEmployeeDto updateData)
{
try {
var employee = new Employee();
employee.FirstName = updateData.FirstName;
employee.LastName = updateData.LastName;
return(employee);
} catch (Exception e) {
_logger.LogError(1, e.Message, e);
return(null);
}
}
public async Task <ActionResult> CreateEmployee([FromBody] NewEmployeeDto newEmployee)
{
ResponseDto <EmployeeDto> response = new ResponseDto <EmployeeDto>()
{
statusCode = "400"
};
if (!ModelState.IsValid)
{
return(BadRequest(response));
}
if (newEmployee.Password != newEmployee.ConfirmPassword)
{
response.message = "passwords do not match";
return(BadRequest(response));
}
if (!employeeRepository.IsEmployeeInTransit(newEmployee.Username, newEmployee.LaundryId))
{
response.message = "Unauthorized Registration please contact your employer";
response.statusCode = "401";
return(Unauthorized(response));
}
try
{
EmployeeDto employeeDto = await employeeRepository.CreateEmployeeAsync(newEmployee);
return(StatusCode(201, new ResponseDto <EmployeeDto>()
{
statusCode = "201", data = employeeDto
}));
}
catch (Exception e)
{
if (e.Message == ErrorMessage.UsernameAlreadyExist)
{
response.message = ErrorMessage.UsernameAlreadyExist;
return(BadRequest(response));
}
response.statusCode = "500";
return(StatusCode(500, response));
}
}
public async Task <User> Create(Employee newEmployee, NewEmployeeDto newEmployeeDto)
{
var newUser = new User
{
Employee = newEmployee,
Email = newEmployee.Email,
UserName = newEmployee.Email
};
var result = await _userManager.CreateAsync(newUser, newEmployeeDto.Password);
if (result.Succeeded)
{
await _userManager.AddToRoleAsync(newUser, newEmployeeDto.Role);
return(newUser);
}
return(null);
}
public static NewEmployeeDto NewEmployeeDto(int clientId, string password, string email)
{
var newEmployeeDto = new NewEmployeeDto
{
ClientId = clientId,
Email = email,
Password = password,
Name = "EmployeeNameNew",
Surname = "EmployeeSurnameNew",
WorksFromDate = new DateTime(2019, 07, 06),
DaysOfVacation = 20,
BirthdayDate = new DateTime(1988, 07, 06),
ParentalLeaveLimit = 30,
Role = "Employee",
Position = "Position"
};
return(newEmployeeDto);
}
public bool AddNewEmployee(NewEmployeeDto employee)
{
using (var db = new SqlConnection(ConfigurationManager.ConnectionStrings["Main"].ConnectionString))
{
db.Open();
var newEmployeeRecord = db.Execute(@"INSERT INTO [dbo].[Employees]
([FirstName]
,[LastName]
,[DepartmentId]
,[HireDate])
VALUES
(@FirstName
,@LastName
,@DepartmentId
,@HireDate)", employee);
return(newEmployeeRecord == 1);
}
}
public IActionResult AddEmploeeRecord([FromBody] NewEmployeeDto newEmployee)
{
if (ModelState.IsValid && newEmployee != null)
{
try {
var employee = _command.AddEmployee(newEmployee);
if (employee != null)
{
return(StatusCode(201, employee));
}
else
{
return(StatusCode(422, "One or more required fields missing for employee"));
}
} catch (System.Exception) {
return(StatusCode(500, "Unkown Error Occured while processing Request, Try Again"));
}
}
else
{
return(StatusCode(422, "One or more required fields missing for employee"));
}
}
public ApiResponse <bool> CreateNewEmployee(NewEmployeeDto employee)
{
if (employee == null)
{
return(new ApiResponse <bool>(responseStatusCode: RestStatusCode.AccountCreationFailed));
}
var person = _uow.UserRepository.GetAll(false)
.Where(x => x.Email == employee.Email).FirstOrDefault();
if (person != null)
{
return(new ApiResponse <bool>(responseStatusCode: RestStatusCode.EmailExist));
}
var personRepo = employee.ToRepo <Person>();
var userRepo = employee.ToRepo <User>();
byte[] passwordHash, passwordSalt;
CreatePasswordHash(employee.Password, out passwordHash, out passwordSalt);
userRepo.PasswordHash = passwordHash;
userRepo.PasswordSalt = passwordSalt;
personRepo.PersonType = PersonTypeEnum.Employee;
personRepo.Active = true;
using (_uow.BeginTransaction())
{
long personId = _uow.PersonRepository.Create(personRepo);
userRepo.PersonId = personId;
_uow.UserRepository.Create(userRepo);
_uow.CommitTransaction();
}
return(new ApiResponse <bool>(true));
}
public async Task <IActionResult> Post(NewEmployeeDto newEmployeeDto)
{
var createdEmployee = await _employeesService.Create(newEmployeeDto);
return(Ok(createdEmployee));
}
public Employee AddToProject(int id, NewEmployeeDto employeeDto)
{
return(projectService.AddToProject(id, employeeDto));
}
public IActionResult AddEmployee([FromBody] NewEmployeeDto newEmployeeDto)
{
var employeeDto = _employeeLogic.AddEmployee(newEmployeeDto);
return(Created($"v1/employees/{employeeDto.Id}", employeeDto));
}
public async Task <IActionResult> CreateNewEmployee(NewEmployeeDto employee)
{
return(await Task.Run(() => CallApi(() => _garageService.CreateNewEmployee(employee))));
}
//private readonly LaundryApiContext _context;
//private readonly IMapper mapper;
//private readonly IRepositoryHelper repositoryHelper;
//private readonly IMailService mailService;
//public EmployeeRepository(LaundryApiContext _context, IMapper mapper,IRepositoryHelper repositoryHelper, IMailService mailService)
//{
// this._context = _context;
// this.mapper = mapper;
// this.mailService = mailService;
// this.repositoryHelper = repositoryHelper;
//}
//public async Task<EmployeeDto> FindEmployeeAsync(Guid id)
//{
// try
// {
// var employee = await _context.Employees.FindAsync(id);
// if (employee == null)
// throw new Exception(ErrorMessage.UserDoesNotExist);
// var employeeDto = mapper.Map<EmployeeDto>(employee);
// return employeeDto;
// }
// catch(Exception e)
// {
// if (e.Message == ErrorMessage.UserDoesNotExist)
// throw new Exception(ErrorMessage.UserDoesNotExist);
// throw new Exception(ErrorMessage.FailedDbOperation);
// }
//}
//public async Task<EmployeeDto> CreateEmployeeAsync(NewEmployeeDto newEmployeeDto)
//{
// try
// {
// //update new employee info
// var employee = mapper.Map<Employee>(newEmployeeDto);
// employee.PasswordHash = HashPassword(newEmployeeDto.Password);
// employee.CreatedAt = DateTime.Now;
// employee.UpdatedAt = DateTime.Now;
// employee.UsernameHash = HashPassword(newEmployeeDto.Username);
// employee.ForgotPasswordTime = null;
// employee.PasswordResetId = null;
// employee.Name = newEmployeeDto.Name.ToLower();
// //add employee to db context
// await _context.Employees.AddAsync(employee);
// //complete db transaction
// await _context.SaveChangesAsync();
// //update employeeDto object
// var employeeDto = mapper.Map<EmployeeDto>(employee);
// employeeDto.Password = newEmployeeDto.Password;
// return employeeDto;
// }
// catch (Exception e)
// {
// if (e.InnerException.ToString().Contains("Cannot insert duplicate key row in object 'dbo.Employees'"))
// throw new Exception(ErrorMessage.UsernameAlreadyExist);
// throw new Exception(ErrorMessage.FailedDbOperation);
// }
//}
//public async Task<bool> DeleteEmployee (Guid employeeId,string laundryUsername)
//{
// try
// {
// Employee employeeInDb= await ValidateRequestParam(employeeId, laundryUsername);
// employeeInDb.IsDeleted = true;
// await _context.SaveChangesAsync();
// return true;
// }
// catch(Exception e)
// {
// if (e.Message == ErrorMessage.EmployeeNotOwnedByUser)
// throw new Exception(ErrorMessage.EmployeeNotOwnedByUser);
// else if (e.Message == ErrorMessage.UserDoesNotExist)
// throw new Exception(ErrorMessage.UserDoesNotExist);
// throw new Exception(ErrorMessage.FailedDbOperation);
// }
//}
//public async Task<EmployeeDto> UpdateEmployee(EmployeeDto employee,string laundryUsername)
//{
// Employee employeeInDb=await ValidateRequestParam(employee.Id, laundryUsername);
// employeeInDb.Address = employee.Address;
// employeeInDb.Name = employee.Name;
// employeeInDb.PhoneNumber = employee.PhoneNumber;
// employeeInDb.UpdatedAt = DateTime.Now;
// _context.SaveChanges();
// employee = mapper.Map<EmployeeDto>(employeeInDb);
// employee.Laundry = null;
// return employee;
//}
//public async Task<bool> SendEmployeeRegistrationLink(string employeeEmail,string laundryUsername)
//{
// Laundry laundry = _context.Laundries.SingleOrDefault(x => x.Username == laundryUsername);
// try
// {
// AddEmployeeToTransit(employeeEmail, laundry.Id);
// string url = "http://localhost:3000/employee/registration?id=" + laundry.Id;
// string mailContent = $"<p> Hi ,</p> <p> Please click <a href='{url}'>here</a> to register as an employee of {laundry.LaundryName} laundry";
// await mailService.SendMailAsync(employeeEmail, mailContent, "Employee Registration");
// return true;
// }
// catch(Exception e)
// {
// if(e.Message==ErrorMessage.UsernameAlreadyExist)
// {
// string url = "http://localhost:3000/employee/registration?id=" + laundry.Id;
// string mailContent = $"<p> Hi ,</p> <p> Please click <a href='{url}'>here</a> to register as an employee of {laundry.LaundryName} laundry";
// await mailService.SendMailAsync(employeeEmail, mailContent, "Employee Registration");
// return true;
// }
// return false;
// }
//}
//private void AddEmployeeToTransit (string employeeEmail, Guid laundryId)
//{
// try
// {
// EmployeeInTransit e = new EmployeeInTransit() { Email = employeeEmail, LaundryId = laundryId };
// _context.EmployeesInTransit.Add(e);
// _context.SaveChanges();
// return;
// }
// catch(Exception e)
// {
// if (e.InnerException.Message.Contains("Violation of UNIQUE KEY constraint 'AK_EmployeesInTransit_Email_LaundryId'"))
// throw new Exception(ErrorMessage.UsernameAlreadyExist);
// throw new Exception(ErrorMessage.FailedDbOperation);
// }
//}
//public bool IsEmployeeInTransit(string employeeEmail,Guid laundryId)
//{
// return _context.EmployeesInTransit.SingleOrDefault(x=> x.Email==employeeEmail && x.LaundryId==laundryId) != null ;
//}
//public PagedList<EmployeeDtoPartial> GetPage(int pageSize, string laundryUsername,int pageNumber = 1,string searchParam="")
//{
// var laundry=repositoryHelper.GetLaundryByUsername(laundryUsername);
// var employeeList = _context.Employees.Where(x=> x.IsDeleted==false && x.LaundryId==laundry.Id).ToList();
// if (searchParam != "")
// employeeList = employeeList.Where(x => x.Name.Contains(searchParam.ToLower())).ToList();
// var page = employeeList.Skip((pageNumber - 1) * pageSize).Take(pageSize);
// var maxPage = employeeList.Count / (decimal)pageSize;
// PagedList<EmployeeDtoPartial> obj = new PagedList<EmployeeDtoPartial>()
// {
// Data = mapper.Map<IEnumerable<EmployeeDtoPartial>>(page),
// PageIndex = pageNumber,
// PageSize = pageSize,
// };
// if ( maxPage < 1)
// obj.MaxPageIndex = 1;
// else
// {
// int _num;
// try
// {
// _num = Convert.ToInt32(Convert.ToString(maxPage).Split(".")[1]);
// }
// catch
// {
// _num = 0;
// }
// obj.MaxPageIndex = _num > 0 ? Convert.ToInt32(maxPage + 1) : Convert.ToInt32(maxPage);
// }
// return obj;
//}
//private async Task<Employee> ValidateRequestParam(Guid employeeId, string laundryUsername)
//{
// Laundry laundry = _context.Laundries.SingleOrDefault(x => x.Username == laundryUsername);
// Employee employeeInDb = await _context.Employees.FindAsync(employeeId);
// if (employeeInDb == null)
// throw new Exception(ErrorMessage.UserDoesNotExist);
// if (employeeInDb.LaundryId != laundry.Id)
// throw new Exception(ErrorMessage.EmployeeNotOwnedByUser);
// return employeeInDb;
//}
public Task <EmployeeDto> CreateEmployeeAsync(NewEmployeeDto newEmployeeDto)
{
throw new NotImplementedException();
}
