// POST: api/Employee
/// <summary>
/// Method to insert/save employee record
/// </summary>
/// <param name="employee">Employee records to be inserted/saved</param>
/// <returns></returns>
public HttpResponseMessage Post(EmployeeDTO employeeDTO)
{
if (true)//TODO: replace this with validation logic ModelState.IsValid
{
var employee = Mapper.Map<Employee>(employeeDTO);
_employeeService.Add(employee);
HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.Created, employee);
response.Headers.Location = new Uri(Url.Link("DefaultApi", new { id = employee.Id }));
return response;
}
else
{
return Request.CreateResponse(HttpStatusCode.BadRequest);
}
}
public ActionResult AddEmployee(string firstName, string lastName, string title)
{
using (var proxy = new TimeCardServiceClient())
{
var employee = new EmployeeDTO
{
FirstName = firstName,
LastName = lastName,
Title = title
};
proxy.AddEmployee(employee);
}
return Json("result: 'success'");
}
static void Main(string[] args)
{
Service1Client proxy = new Service1Client();
EmployeeDTO emp = new EmployeeDTO
{
Name = "dj",
City = "Delhi",
Id = "E99"
};
proxy.AddEmployee(emp);
var result = proxy.GetEmployee();
foreach (var r in result)
{
Console.WriteLine(r.Name);
}
Console.ReadKey(true);
}
public void Update(EmployeeDTO employee, int id)
{
EmployeeDAL DALEmployee = ToDALConverter(employee);
_employeeReposirory.Update(DALEmployee, id);
}
public async Task <IActionResult> CreateUser([FromBody] EmployeeDTO request)
{
var response = await _employeeManager.CreateEmployee(request);
return(Ok(response));
}
public void GetScheduleOnProjectWorkTest()
{
ScheduleServise scheduleServise = new ScheduleServise(uow, new Map <Schedule, ScheduleDTO>(), new Map <ScheduleDay, ScheduleDayDTO>());
EmployeeService employeeService = new EmployeeService(uow, new Map <Employee, EmployeeDTO>());
ProjectService projectService = new ProjectService(uow, new Map <Project, ProjectDTO>());
ProjectWorkService projectWorkService = new ProjectWorkService(uow, new Map <ProjectWork, ProjectWorkDTO>());
EmployeeDTO employee = new EmployeeDTO
{
EmployeeName = "Екатерина",
EmployeeSurname = "Антонович",
EmployeePatronymic = "Алексеевна",
RoleId = 3,
Email = "*****@*****.**",
};
var employeeOnWork = employeeService.CreateEmployee(employee);
var em = employeeService.GetEmployeeById(employeeOnWork.Id);
ProjectDTO project = new ProjectDTO
{
ProjectName = "проект 1",
ProjectDescription = "проект номер один",
ProjectStartDate = new DateTimeOffset(2021, 10, 6, 10, 15, 35, new TimeSpan(3, 0, 0)),
ProjectEndDate = new DateTimeOffset(2021, 10, 21, 10, 15, 35, new TimeSpan(3, 0, 0))
};
var proj = projectService.CreateProject(project);
var pr = projectService.GetProjectById(proj.Id);
ProjectWorkDTO projectWork = new ProjectWorkDTO
{
EmployeeId = em.Id,
ProjectId = pr.Id,
ProjectRoleId = 3
};
var pWork = projectWorkService.CreateProjectWork(projectWork);
var prw = projectWorkService.GetProjectWorkById(pWork.Id);
ScheduleDTO schedule1 = new ScheduleDTO
{
ProjectWorkId = prw.Id,
ScheduleDayId = 1
};
var sch1 = scheduleServise.CreateSchedule(schedule1);
ScheduleDTO actual1 = scheduleServise.GetScheduleById(sch1.Id);
ScheduleDTO schedule2 = new ScheduleDTO
{
ProjectWorkId = prw.Id,
ScheduleDayId = 3
};
var sch2 = scheduleServise.CreateSchedule(schedule2);
ScheduleDTO actual2 = scheduleServise.GetScheduleById(sch2.Id);
var expected = scheduleServise.GetScheduleOnProjectWork(prw.Id).ToList();
Assert.IsTrue(expected.Count == 2);
scheduleServise.DeleteScheduleById(actual1.Id);
scheduleServise.DeleteScheduleById(actual2.Id);
projectWorkService.DeleteProjectWorkById(prw.Id);
employeeService.DeleteEmployeeById(em.Id);
projectService.DeleteProjectById(pr.Id);
}
public static int UpdateEmployee(EmployeeDTO empDto)
{
using (var context = new EmployeeDBContext())
{
if (empDto.EmployeeId == 0)
{
var employee = new Employee();
employee.Name = empDto.EmployeeName;
employee.DepartmentID = empDto.DepartmentId;
employee.CreatedBy = empDto.CreatedBy;
employee.CreatedDate = DateTime.Now;
context.Employees.Add(employee);
var employeeDetail = new EmployeeDetail();
employeeDetail.EmployeeID = employee.EmployeeID;
employeeDetail.Email = empDto.Email;
employeeDetail.Address = empDto.Address;
employeeDetail.Gender = empDto.Gender;
employeeDetail.Salary = empDto.Salary;
employeeDetail.CreatedBy = empDto.CreatedBy;
employeeDetail.CreatedDate = DateTime.Now;
employeeDetail.Salary = empDto.Salary;
employee.EmployeeDetails.Add(employeeDetail);
}
else
{
var employee = context.Employees.Where(x => x.EmployeeID == empDto.EmployeeId).FirstOrDefault();
if (employee != null)
{
if (employee.Name != empDto.EmployeeName || employee.DepartmentID != empDto.DepartmentId)
{
employee.Name = empDto.EmployeeName;
employee.DepartmentID = empDto.DepartmentId;
employee.EditBy = empDto.CreatedBy;
employee.EditDate = DateTime.Now;
}
}
var employeeDetail = context.EmployeeDetails.Where(x => x.EmployeeID == empDto.EmployeeId).FirstOrDefault();
if (employee != null)
{
if (employeeDetail.Email != empDto.Email ||
employeeDetail.Address != empDto.Address ||
employeeDetail.Gender != empDto.Gender ||
employeeDetail.Salary != empDto.Salary)
{
employeeDetail.Email = empDto.Email;
employeeDetail.Address = empDto.Address;
employeeDetail.Gender = empDto.Gender;
employeeDetail.Salary = empDto.Salary;
employeeDetail.EditBy = empDto.CreatedBy;
employeeDetail.EditDate = DateTime.Now;
}
}
}
context.SaveChanges();
return(empDto.EmployeeId);
}
}
public SaleNTO(Sale sale, EmployeeDTO employeeDto)
{
Sale = sale;
EmployeeDto = employeeDto;
}
public void Create(EmployeeDTO employee)
{
_employees.Add(Mapper.Map<EmployeeDTO, Employee>(employee));
}
/// <summary>
/// Method to update employee
/// </summary>
/// <param name="employee">Employee record to be updated</param>
/// <returns></returns>
public IHttpActionResult Put(EmployeeDTO value)
{
if (true)//TODO: replace this with validation logic ModelState.IsValid
{
var searchedEmployee = _employeeService.FindBy(t => t.Id == value.Id);
if (value == null)
{
return BadRequest("Cannot update employee/Employee not found");
}
var toBeUpdatedRecord = Mapper.Map<Employee>(value);
_employeeService.Update(toBeUpdatedRecord);
return Ok();
}
else
{
return BadRequest();
}
}
public async Task AddEmployee(EmployeeDTO employee)
{
if (employee == null)
{
throw await _serviceHelper.GetExceptionAsync("invalid parameter");
}
if (employee.TerminalId != null && !await IsValidTerminal(employee.TerminalId))
{
throw await _serviceHelper.GetExceptionAsync(ErrorConstants.TERMINAL_NOT_EXIST);
}
if (employee.DepartmentId != null && !await IsValidDepartment(employee.DepartmentId))
{
throw await _serviceHelper.GetExceptionAsync(ErrorConstants.DEPARTMENT_NOT_EXIST);
}
employee.EmployeeCode = employee.EmployeeCode.Trim();
if (await _repo.ExistAsync(v => v.EmployeeCode == employee.EmployeeCode))
{
throw await _serviceHelper.GetExceptionAsync(ErrorConstants.EMPLOYEE_EXIST);
}
try {
_unitOfWork.BeginTransaction();
var user = new User
{
FirstName = employee.FirstName,
LastName = employee.LastName,
MiddleName = employee.MiddleName,
Gender = employee.Gender,
Email = employee.Email,
PhoneNumber = employee.PhoneNumber,
Address = employee.Address,
NextOfKinName = employee.NextOfKin,
NextOfKinPhone = employee.NextOfKinPhone,
EmailConfirmed = true,
PhoneNumberConfirmed = true,
UserName = employee.Email,
ReferralCode = CommonHelper.GenereateRandonAlphaNumeric()
};
var creationStatus = await _userSvc.CreateAsync(user, "123456");
if (creationStatus.Succeeded)
{
var dbRole = await _roleSvc.FindByIdAsync(employee.RoleId);
if (dbRole != null)
{
await _userSvc.AddToRoleAsync(user, dbRole.Name);
}
_repo.Insert(new Employee
{
UserId = user.Id,
EmployeeCode = employee.EmployeeCode,
DateOfEmployment = employee.DateOfEmployment,
DepartmentId = employee.DepartmentId,
TerminalId = employee.TerminalId,
CreatorUserId = _serviceHelper.GetCurrentUserId()
});
await SendAccountEmail(user);
}
else
{
_unitOfWork.Rollback();
throw await _serviceHelper
.GetExceptionAsync(creationStatus.Errors.FirstOrDefault()?.Description);
}
_unitOfWork.Commit();
}
catch (Exception) {
_unitOfWork.Rollback();
throw;
}
}
public EmployeeDTO UserLogin(EmployeeDTO employeeDTO)
{
return(loginManager.CheckUserAndPassword(employeeDTO));
}
public void AddEmployee(EmployeeDTO dto)
{
employees.Add(dto);
}
public Employee TranslateObject(EmployeeDTO obj)
{
return(JsonConvert.DeserializeObject <Employee>(JsonConvert.SerializeObject(obj)));
}
// get list of DTO employee by its id
public EmployeeDTO getEmployeeById(string id)
{
Employee e = db.Employees.Where(i => i.empID == id).FirstOrDefault();
Address a = db.Addresses.Where(x => x.Id == e.Address_Id).FirstOrDefault();
EmployeeDTO ed = new EmployeeDTO();
if (e != null)
{
ed.EmployeeID = e.empID;
ed.AddressID = e.Address_Id;
ed.FirstName = e.fname;
ed.LastName = e.lname;
ed.Status = e.status;
ed.Type = e.type;
ed.Rate = e.rate.ToString();
ed.WorkPhone = e.workPhone;
ed.HomePhone = e.homePhone;
ed.MobilePhone = e.mobilePhone;
ed.HireDate = e.hireDate.ToString();
ed.RemoveDate = e.removeDate.ToString();
ed.Rate = e.rate.ToString();
ed.Email1 = e.email1;
ed.Email2 = e.email2;
ed.Bldg = a.bldg.ToString();
ed.Unit = a.unit.ToString();
ed.Street = a.street;
ed.City = a.city;
ed.Postal = a.postal;
return ed;
}
else
return null;
}
public void GetAllEmployeesHistoriesOnProjectTest()
{
ParticipationHistoryService participationHistoryService = new ParticipationHistoryService(uow, new Map <ParticipationHistory, ParticipationHistoryDTO>());
EmployeeService employeeService = new EmployeeService(uow, new Map <Employee, EmployeeDTO>());
ProjectService projectService = new ProjectService(uow, new Map <Project, ProjectDTO>());
ProjectWorkService projectWorkService = new ProjectWorkService(uow, new Map <ProjectWork, ProjectWorkDTO>());
EmployeeDTO employee = new EmployeeDTO
{
EmployeeName = "Екатерина",
EmployeeSurname = "Антонович",
EmployeePatronymic = "Алексеевна",
RoleId = 3,
Email = "*****@*****.**",
};
var employeeOnWork = employeeService.CreateEmployee(employee);
var em = employeeService.GetEmployeeById(employeeOnWork.Id);
EmployeeDTO employee2 = new EmployeeDTO
{
EmployeeName = "Иван",
EmployeeSurname = "Иванов",
EmployeePatronymic = "Иванович",
RoleId = 2,
Email = "*****@*****.**",
};
var employeeOnWork2 = employeeService.CreateEmployee(employee2);
var em2 = employeeService.GetEmployeeById(employeeOnWork2.Id);
ProjectDTO project = new ProjectDTO
{
ProjectName = "проект 1",
ProjectDescription = "проект номер один",
ProjectStartDate = new DateTimeOffset(2021, 10, 6, 10, 15, 35, new TimeSpan(3, 0, 0)),
ProjectEndDate = new DateTimeOffset(2021, 11, 21, 10, 15, 35, new TimeSpan(3, 0, 0))
};
var proj = projectService.CreateProject(project);
var pr = projectService.GetProjectById(proj.Id);
ProjectWorkDTO projectWork = new ProjectWorkDTO
{
EmployeeId = em.Id,
ProjectId = pr.Id,
ProjectRoleId = 3
};
var pWork = projectWorkService.CreateProjectWork(projectWork);
var prw = projectWorkService.GetProjectWorkById(pWork.Id);
ProjectWorkDTO projectWork2 = new ProjectWorkDTO
{
EmployeeId = em2.Id,
ProjectId = pr.Id,
ProjectRoleId = 2
};
var pWork2 = projectWorkService.CreateProjectWork(projectWork2);
var prw2 = projectWorkService.GetProjectWorkById(pWork2.Id);
ParticipationHistoryDTO participationHistory1 = new ParticipationHistoryDTO
{
ProjectWorkId = prw.Id,
StartDate = new DateTimeOffset(2021, 10, 16, 10, 15, 35, new TimeSpan(3, 0, 0)),
EndDate = new DateTimeOffset(2021, 11, 04, 11, 15, 35, new TimeSpan(3, 0, 0))
};
var errors = phvalidator.Validate(participationHistory1);
var history1 = participationHistoryService.CreateHistory(participationHistory1);
var actual1 = participationHistoryService.GetHistoryById(history1.Id);
ParticipationHistoryDTO participationHistory2 = new ParticipationHistoryDTO
{
ProjectWorkId = prw.Id,
StartDate = new DateTimeOffset(2021, 11, 05, 10, 15, 35, new TimeSpan(3, 0, 0)),
EndDate = new DateTimeOffset(2021, 11, 21, 11, 15, 35, new TimeSpan(3, 0, 0))
};
var errors2 = phvalidator.Validate(participationHistory2);
var history2 = participationHistoryService.CreateHistory(participationHistory2);
var actual2 = participationHistoryService.GetHistoryById(history2.Id);
ParticipationHistoryDTO participationHistory3 = new ParticipationHistoryDTO
{
ProjectWorkId = prw2.Id,
StartDate = new DateTimeOffset(2021, 11, 05, 10, 15, 35, new TimeSpan(3, 0, 0)),
EndDate = new DateTimeOffset(2021, 11, 21, 11, 15, 35, new TimeSpan(3, 0, 0))
};
var errors3 = phvalidator.Validate(participationHistory3);
var history3 = participationHistoryService.CreateHistory(participationHistory3);
var actual3 = participationHistoryService.GetHistoryById(history3.Id);
var actual = participationHistoryService.GetAllEmployeesHistoriesOnProject(prw.Id).ToList();
Assert.AreEqual(actual.Count, 2);
participationHistoryService.DeleteHistoryById(actual1.Id);
participationHistoryService.DeleteHistoryById(actual2.Id);
participationHistoryService.DeleteHistoryById(actual3.Id);
projectWorkService.DeleteProjectWorkById(prw.Id);
projectWorkService.DeleteProjectWorkById(prw2.Id);
employeeService.DeleteEmployeeById(em.Id);
employeeService.DeleteEmployeeById(em2.Id);
projectService.DeleteProjectById(pr.Id);
}
public async Task <EmployeeDTO> Add(EmployeeDTO entity)
{
return(await _employeeRepository.Add(entity));
}
public List <ValidationResult> Validate(EmployeeDTO employee)
{
List <ValidationResult> errors = new List <ValidationResult>();
if (string.IsNullOrWhiteSpace(employee.EmployeeName))
{
errors.Add(new ValidationResult("Введите имя сотрудника", new List <string>()
{
"EmployeeName"
}));
}
if (employee.EmployeeName.Length > 20 || employee.EmployeeName.Length < 2)
{
errors.Add(new ValidationResult("Недопустимая длина имени", new List <string>()
{
"EmployeeName"
}));
}
if (string.IsNullOrWhiteSpace(employee.EmployeeSurname))
{
errors.Add(new ValidationResult("Введите фамилию сотрудника", new List <string>()
{
"EmployeeSurname"
}));
}
if (employee.EmployeeSurname.Length > 20 || employee.EmployeeSurname.Length < 2)
{
errors.Add(new ValidationResult("Недопустимая длина фамилии", new List <string>()
{
"EmployeeSurname"
}));
}
if (string.IsNullOrWhiteSpace(employee.EmployeePatronymic))
{
errors.Add(new ValidationResult("Введите отчество сотрудника", new List <string>()
{
"EmployeePatronymic"
}));
}
if (employee.EmployeePatronymic.Length > 20 || employee.EmployeePatronymic.Length < 2)
{
errors.Add(new ValidationResult("Недопустимая длина отчества", new List <string>()
{
"EmployeePatronymic"
}));
}
if (string.IsNullOrWhiteSpace(employee.Email))
{
errors.Add(new ValidationResult("Введите e-mai сотрудника", new List <string>()
{
"Email"
}));
}
if (!(new EmailAddressAttribute()).IsValid(employee.Email))
{
errors.Add(new ValidationResult("Неверный e-mail", new List <string>()
{
"Email"
}));
}
if (employee.GitLink != null && (employee.GitLink.Length > 30 || employee.GitLink.Length < 2))
{
errors.Add(new ValidationResult("Недопустимая длина ссылки", new List <string>()
{
"GitLink"
}));
}
if (employee.RoleId == 0)
{
errors.Add(new ValidationResult("Не указан идентификатор роли", new List <string>()
{
"RoleId"
}));
}
if (employee.RoleId != 0 && (employee.RoleId > 3 || employee.RoleId < 1))
{
errors.Add(new ValidationResult("Роль не существует", new List <string>()
{
"RoleId"
}));
}
if (employee.PhoneNumber != null && !Regex.IsMatch(employee.PhoneNumber, @"^(\+375|80)(29|25|44|33)(\d{3})(\d{2})(\d{2})$"))
{
errors.Add(new ValidationResult("Неверно введен номер", new List <string>()
{
"PhoneNumber"
}));
}
return(errors);
}
public async Task <ResponsePackage <EmployeeDTO> > UpdateEmployeeRecord(EmployeeDTO user)
{
return(await new SendToServerService <EmployeeDTO, EmployeeDTO>().PostDataByJsonObjectAsync("Employee/UpdateEmployee", user));
}
public Employee()
{
InitializeComponent();
DTO = new EmployeeDTO();
enableDisableButton();
}
public void SaveEmployee(EmployeeDTO employee, DepartmentDTO department)
{
this.repository.Save(employee.MapToModel(department.MapToModel()));
}
public void AddEmployee(SqlCommand cmd, EmployeeDTO employee)
{
WasAddEmployeeCalled = true;
}
public void AddEmployeeDTO(EmployeeDTO EmployeeDTO)
{
EmployeeDTO.ID = Guid.NewGuid();
empList.Add(EmployeeDTO);
}
public override string TransformName(EmployeeDTO employee)
{
char[] charArray = employee.Name.ToCharArray();
Array.Reverse(charArray);
return(new string( charArray ));
}
void init()
{
EmployeeJobPositions = new EmployeeJobPositionsDTO();
Employee = new EmployeeDTO();
Period = new PeriodDTO();
}
public async Task <IEmployee> GetEmployee(int id)
{
EmployeeDTO employeeDTO = await _repository.GetEmployee(id);
return(EmployeeFactory.LoadEmployee(employeeDTO));
}
public IHttpActionResult GetEmployeeView(int id)
{
//провобала делать асинхронные, получается медленнее
try
{
UnitOfWork unitOfWork = new UnitOfWork(factory);
//Employee
//почему бы и нет?
Employee employee =
employee = unitOfWork.EmployeesRepository
.Get(d => d.Id == id, includeProperties: @"Address,Address.AddressLocality,Address.AddressPlace,Address.AddressRegion,Address.AddressVillage,Address.Country,
EmployeeOffices,EmployeeOffices.Department,EmployeeOffices.Office,EmployeeOffices.Profession,
EmployeePassports,EmployeePassports.Address,EmployeePassports.Address.AddressLocality,
EmployeePassports.Address.AddressPlace,EmployeePassports.Address.AddressRegion,EmployeePassports.Address.AddressVillage,EmployeePassports.Address.Country,
EmployeeMilitaryCards,
EmployeeLanguages,EmployeeLanguages.EmployeeLanguageType,EmployeeLanguages.Language,
EmployeeInternationalPassports,
EmployeeGuns,
EmployeeFoundationDocuments,EmployeeFoundationDocuments.FoundationDocument,
EmployeeEducations,EmployeeEducations.EducationStudyForm,
EmployeeDrivingLicenses,
EmployeeContacts,EmployeeContacts.ContactType,
EmployeeCars,
EmployeeInsurance")
.FirstOrDefault();
if (employee == null)
{
throw new NotFoundException();
}
////EmployeeProfilePicture
SqlParameter pEmployeeId = new SqlParameter
{
ParameterName = "@EmployeeId",
IsNullable = false,
Direction = ParameterDirection.Input,
DbType = DbType.Int32,
Value = id
};
employee.ProfilePicture = unitOfWork.SQLQuery <string>("exec GetProfilePicturePathByEmployeeId @EmployeeId ", pEmployeeId).FirstOrDefault();
//Error: SqlParameter уже содержится в другом SqlParameterCollection
SqlParameter pEmployeeId1 = new SqlParameter
{
ParameterName = "@EmployeeId",
IsNullable = false,
Direction = ParameterDirection.Input,
DbType = DbType.Int32,
Value = id
};
//AspNetUserName
employee.FullUserName = unitOfWork.SQLQuery <string>("exec GetFullAspNetUserNameByEmployeeId @EmployeeId ", pEmployeeId1).FirstOrDefault();
//employee.EmployeeOffices = unitOfWork.EmployeeOfficesRepository
// .Get(d => d.Deleted != true && d.EmployeeId == id, includeProperties: "Department,Office,Profession").ToList();
//employee.EmployeePassports = unitOfWork.EmployeePassportsRepository
//.Get(d => d.Deleted != true && d.EmployeeId == id, includeProperties: "Address,Address.AddressLocality,Address.AddressPlace,Address.AddressRegion,Address.AddressVillage,Address.Country").ToList() ;
// employee.EmployeeMilitaryCards = unitOfWork.EmployeeMilitaryCardsRepository.Get(d => d.Deleted != true && d.EmployeeId == id);
//employee.EmployeeLanguages = unitOfWork.EmployeeLanguagesRepository
// .Get(d => d.Deleted != true && d.EmployeeId == id, includeProperties: "EmployeeLanguageType,Language");
//employee.EmployeeInternationalPassports = unitOfWork.EmployeeInternationalPassportsRepository
// .Get(d => d.Deleted != true && d.EmployeeId == id);
//employee.EmployeeGuns = unitOfWork.EmployeeGunsRepository
//.Get(d => d.Deleted != true && d.EmployeeId == id);
//employee.EmployeeFoundationDocuments = unitOfWork.EmployeeFoundationDocumentsRepository
//.Get(d => d.Deleted != true && d.EmployeeId == id, includeProperties: "FoundationDocument");
//employee.EmployeeEducations = unitOfWork.EmployeeEducationsRepository
//.Get(d => d.Deleted != true && d.EmployeeId == id, includeProperties: "EducationStudyForm");
//employee.EmployeeDrivingLicenses = unitOfWork.EmployeeDrivingLicensesRepository
//.Get(d => d.Deleted != true && d.EmployeeId == id);
//employee.EmployeeContacts = unitOfWork.EmployeeContactsRepository
//.Get(d => d.Deleted != true && d.EmployeeId == id, includeProperties: "ContactType");
//employee.EmployeeCars = unitOfWork.EmployeeCarsRepository
//.Get(d => d.Deleted != true && d.EmployeeId == id);
EmployeeDTO dto = employee.ToDTOView();
return(Ok(dto));
}
catch (NotFoundException nfe)
{
return(NotFound());
}
catch (ConflictException ce)
{
return(Conflict());
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
public bool ValidateLogin(EmployeeDTO Employee)
{
return(employee.ValidateLogin(Employee));
}
public async Task <IActionResult> UpdateUser([FromBody] EmployeeDTO employee)
{
await _employeeManager.UpdateEmployeeById(employee);
return(Ok());
}
public IActionResult Post([FromBody] EmployeeDTO _employeeDTO)
{
var employeeModel = _mapper.Map <EmployeeModel>(_employeeDTO);
return(Ok(employeeModel));
}
public void AddEmployee(SqlCommand cmd, EmployeeDTO employee)
{
cmd.Parameters.AddWithValue("@OPNurseFirstName", employee.FirstName_);
cmd.Parameters.AddWithValue("@OPNurseLastName", employee.LastName_);
cmd.Parameters.AddWithValue("@OPNurseIDNumber", employee.EmployeeID_);
}
public async Task <IActionResult> UpdateAsync(EmployeeDTO employeeDTO)
{
var updated = await repository.UpdateAsync(employeeDTO);
return(Ok(updated));
}
public void GetLastEmployeesHistoryTest()
{
ParticipationHistoryService participationHistoryService = new ParticipationHistoryService(uow, new Map <ParticipationHistory, ParticipationHistoryDTO>());
EmployeeService employeeService = new EmployeeService(uow, new Map <Employee, EmployeeDTO>());
ProjectService projectService = new ProjectService(uow, new Map <Project, ProjectDTO>());
ProjectWorkService projectWorkService = new ProjectWorkService(uow, new Map <ProjectWork, ProjectWorkDTO>());
EmployeeDTO employee = new EmployeeDTO
{
EmployeeName = "Екатерина",
EmployeeSurname = "Антонович",
EmployeePatronymic = "Алексеевна",
RoleId = 3,
Email = "*****@*****.**",
};
var employeeOnWork = employeeService.CreateEmployee(employee);
var em = employeeService.GetEmployeeById(employeeOnWork.Id);
ProjectDTO project = new ProjectDTO
{
ProjectName = "проект 1",
ProjectDescription = "проект номер один",
ProjectStartDate = new DateTimeOffset(2021, 10, 6, 10, 15, 35, new TimeSpan(3, 0, 0)),
ProjectEndDate = new DateTimeOffset(2021, 11, 21, 10, 15, 35, new TimeSpan(3, 0, 0))
};
var proj = projectService.CreateProject(project);
var pr = projectService.GetProjectById(proj.Id);
ProjectWorkDTO projectWork = new ProjectWorkDTO
{
EmployeeId = em.Id,
ProjectId = pr.Id,
ProjectRoleId = 3
};
var pWork = projectWorkService.CreateProjectWork(projectWork);
var prw = projectWorkService.GetProjectWorkById(pWork.Id);
ParticipationHistoryDTO participationHistory1 = new ParticipationHistoryDTO
{
ProjectWorkId = prw.Id,
StartDate = new DateTimeOffset(2021, 10, 16, 10, 15, 35, new TimeSpan(3, 0, 0)),
EndDate = new DateTimeOffset(2021, 11, 04, 11, 15, 35, new TimeSpan(3, 0, 0))
};
var errors = phvalidator.Validate(participationHistory1);
var history1 = participationHistoryService.CreateHistory(participationHistory1);
var actual1 = participationHistoryService.GetHistoryById(history1.Id);
ParticipationHistoryDTO participationHistory2 = new ParticipationHistoryDTO
{
ProjectWorkId = prw.Id,
StartDate = new DateTimeOffset(2021, 11, 05, 10, 15, 35, new TimeSpan(3, 0, 0)),
EndDate = new DateTimeOffset(2021, 11, 21, 11, 15, 35, new TimeSpan(3, 0, 0))
};
var errors2 = phvalidator.Validate(participationHistory2);
var history2 = participationHistoryService.CreateHistory(participationHistory2);
var actual2 = participationHistoryService.GetHistoryById(history2.Id);
var actual = participationHistoryService.GetLastEmployeesHistory(prw.Id);
ParticipationHistoryDTO expected = new ParticipationHistoryDTO
{
Id = actual2.Id,
ProjectWorkId = prw.Id,
StartDate = new DateTimeOffset(2021, 11, 05, 10, 15, 35, new TimeSpan(3, 0, 0)),
EndDate = new DateTimeOffset(2021, 11, 21, 11, 15, 35, new TimeSpan(3, 0, 0))
};
Assert.IsTrue(errors.Count == 0 && errors2.Count == 0 && actual.Id == expected.Id && actual.ProjectWorkId == expected.ProjectWorkId &&
actual.StartDate == expected.StartDate && actual.EndDate == expected.EndDate);
participationHistoryService.DeleteHistoryById(actual1.Id);
participationHistoryService.DeleteHistoryById(actual2.Id);
projectWorkService.DeleteProjectWorkById(prw.Id);
employeeService.DeleteEmployeeById(em.Id);
projectService.DeleteProjectById(pr.Id);
}
public static void PrintEmployee(EmployeeDTO dto)
{
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine($"ID:{dto.ID} - First Name:{dto.FirstName} - Last Name:{dto.LastName} - Role: {(EmployeeRole)dto.Role}");
Console.ForegroundColor = ConsoleColor.White;
}
public void TransformDTOToEmployee()
{
var adapter = new EmployeeAdapter();
var employee = new EmployeeDTO()
{
EmployeeID = 1,
LoginID = "petter"
,ContactID = 12
,EmployeePayHistories = new List<EmployeePayHistoryDTO>()
{
new EmployeePayHistoryDTO()
{
EmployeeID = 1,
ModifiedDate = DateTime.Now
}
}
};
var dto = adapter.Transform<EmployeeDTO, Employee>(employee);
Assert.Equal(employee.EmployeeID, dto.EmployeeID);
Assert.Equal(employee.LoginID, dto.LoginID);
}
public EmployeeDTO save(EmployeeDTO employee)
{
return(mapper.Map <Employee, EmployeeDTO>(employeeRepository.save(mapper.Map <EmployeeDTO, Employee>(employee))));
}
