public async Task <IActionResult> GetEmployee(long id, [FromQuery] EmployeeParams employeeParams)
{
var employee = await _service.GetByIdAsync(id);
if (employeeParams.OperationStatus[employeeParams.GetOperationIndex] == employeeParams.Mode)
{
var employeeDto = _mapper.Map <EmployeeDetailDto>(employee);
return(Ok(employeeDto));
}
else
{
EmployeeEditDto employeeEditDto;
if (employeeParams.OperationStatus[employeeParams.CreateOperationIndex] == employeeParams.Mode)
{
employeeEditDto = new EmployeeEditDto();
}
else
{
employeeEditDto = _mapper.Map <EmployeeEditDto>(employee);
}
await _dataBuildHelper.GetAdditionalData(employeeEditDto);
return(Ok(employeeEditDto));
}
}
protected virtual async Task <EmployeeEditDto> CreateEmployeeAsync(EmployeeEditDto input)
{
//TODO:新增前的逻辑判断，是否允许新增
var entity = ObjectMapper.Map <Employee>(input);
entity = await _employeeRepository.InsertAsync(entity);
return(entity.MapTo <EmployeeEditDto>());
}
/// <summary>
/// 编辑Employee
/// </summary>
//[AbpAuthorize(EmployeeAppPermissions.Employee_EditEmployee)]
protected virtual async Task UpdateEmployeeAsync(EmployeeEditDto input)
{
//TODO:更新前的逻辑判断，是否允许更新
var entity = await _employeeRepository.GetAsync(input.Id.Value);
input.MapTo(entity);
// ObjectMapper.Map(input, entity);
await _employeeRepository.UpdateAsync(entity);
}
/// <summary>
/// 添加或者修改Employee的方法
/// </summary>
/// <param name="input">员工信息实体</param>
/// <returns></returns>
public async Task CreateOrUpdateEmployeeDto(EmployeeEditDto input)
{
if (input.Id.HasValue)
{
await UpdateEmployeeAsync(input);
}
else
{
await CreateEmployeeAsync(input);
}
}
public async Task GetAdditionalData(EmployeeEditDto employeeEditDto)
{
var employees = (await _employeeService.Query(e => e.Active)).ToList();
List <SelectEntity> selectEmployees = GetData <Employee>(employees);
employeeEditDto.Superiors = selectEmployees;
var organizations = _organizationRepo.DbSet.Select(o => o).ToList();
List <SelectEntity> selectOrganizazions = GetData <OrganizationUnit>(organizations);
employeeEditDto.OrganizationUnits = selectOrganizazions;
}
public Employee ConvertEmployee(EmployeeEditDto employee, int id)
{
var convertedEmployee = new Employee
{
FirstName = employee.FirstName,
LastName = employee.LastName,
DepartmentId = employee.DepartmentId,
EmployeeId = id,
ComputerId = employee.ComputerId
};
return(convertedEmployee);
}
public ViewResult Edit(int id)
{
Employee employee = _employeeRepository.GetEmployee(id);
EmployeeEditDto employeeEditDto = new EmployeeEditDto
{
Id = employee.Id,
Name = employee.Name,
Email = employee.Email,
Departament = employee.Departament,
ExistingPhotoPath = employee.PhotoPath
};
return(View(employeeEditDto));
}
public async Task <IActionResult> CreateEmployee(EmployeeEditDto employeeEditDto)
{
employeeEditDto.Active = true;
var employee = _mapper.Map <Employee>(employeeEditDto);
var addedEmployee = await _service.AddAsync(employee);
if (addedEmployee != null)
{
return(StatusCode(201));
}
else
{
return(BadRequest());
}
}
public async Task <bool> EditAsync(EmployeeEditDto employeeToEdit)
{
var employee = await this.context.Users.FirstOrDefaultAsync(a => a.Id == employeeToEdit.Id);
if (employee == null)
{
throw new NullReferenceException(string.Format(ErrorMessages.EmployeeIdNullReference, employeeToEdit.Id));
}
employee.UserName = employeeToEdit.Username;
employee.NormalizedUserName = employeeToEdit.Username.ToUpper();
employee.Email = employeeToEdit.Email;
employee.NormalizedEmail = employeeToEdit.Email.ToUpper();
employee.FirstName = employeeToEdit.FirstName;
employee.MiddleName = employeeToEdit.MiddleName;
employee.LastName = employeeToEdit.LastName;
employee.FullName = employeeToEdit.FullName;
employee.DateOfBirth = DateTime.ParseExact(employeeToEdit.DateOfBirth, Constants.DATETIME_FORMAT, CultureInfo.InvariantCulture);
employee.PersonalPhoneNumber = employeeToEdit.PersonalPhoneNumber;
if (employeeToEdit.ProfilePicture != null)
{
employee.ProfilePicture = employeeToEdit.ProfilePicture;
}
employee.Position = employeeToEdit.Position;
if (employee.DepartmentId != employeeToEdit.DepartmentId)
{
await this.ChangeRolesAsync(employee, employeeToEdit.DepartmentId);
employee.DepartmentId = employeeToEdit.DepartmentId;
}
employee.PhoneNumber = employeeToEdit.PhoneNumber;
employee.AppointedOn = DateTime.ParseExact(employeeToEdit.AppointedOn, Constants.DATETIME_FORMAT, CultureInfo.InvariantCulture);
if (employee.AccessLevel != employeeToEdit.AccessLevel)
{
await this.ChangeAccessLevelClaimAsync(employee, employeeToEdit.AccessLevel);
}
this.context.Users.Update(employee);
var result = await this.context.SaveChangesAsync();
return(result > 0);
}
/// <summary>
/// 更新员工区县信息
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public async Task <EmployeeListDto> EditEmployeeAreaInfoAsync(EmployeeEditDto input)
{
var entity = await _employeeRepository.GetAsync(input.Id);
if (entity.AreaCode != input.AreaCode && entity.Area != input.Area)
{
entity.Area = input.Area;
entity.AreaCode = input.AreaCode;
var result = await _employeeRepository.UpdateAsync(entity);
return(result.MapTo <EmployeeListDto>());
}
else
{
return(entity.MapTo <EmployeeListDto>());
}
}
public async Task <GetEmployeeForEditOutput> GetEmployeeForEdit(NullableIdDto input)
{
EmployeeEditDto dto;
if (input.Id.HasValue) //Editing existing role?
{
var emp = await _empRepository.FirstOrDefaultAsync(input.Id.Value);
//taskEditDto = ObjectMapper.Map<TaskEditDto>(task);
dto = ObjectMapper.Map <EmployeeEditDto>(emp);
}
else
{
dto = new EmployeeEditDto();
}
return(new GetEmployeeForEditOutput
{
Employee = dto
});
}
/// <summary>
/// 导出Employee为excel表
/// </summary>
/// <returns></returns>
//public async Task<FileDto> GetEmployeesToExcel(){
//var users = await UserManager.Users.ToListAsync();
//var userListDtos = ObjectMapper.Map<List<UserListDto>>(users);
//await FillRoleNames(userListDtos);
//return _userListExcelExporter.ExportToFile(userListDtos);
//}
/// <summary>
/// MPA版本才会用到的方法
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public async Task <GetEmployeeForEditOutput> GetEmployeeForEdit(NullableIdDto <Guid> input)
{
var output = new GetEmployeeForEditOutput();
EmployeeEditDto employeeEditDto;
if (input.Id.HasValue)
{
var entity = await _employeeRepository.GetAsync(input.Id.Value);
employeeEditDto = entity.MapTo <EmployeeEditDto>();
//employeeEditDto = ObjectMapper.Map<List <employeeEditDto>>(entity);
}
else
{
employeeEditDto = new EmployeeEditDto();
}
output.Employee = employeeEditDto;
return(output);
}
public HttpResponseMessage EditEmployee(int id, EmployeeEditDto employee)
{
var repo = new EmployeeRepository();
var employeeEdit = new EmployeeModifier();
var changeEmployee = repo.ConvertEmployee(employee, id);
var makeEditsToEmployee = employeeEdit.EditEmployee(changeEmployee);
switch (makeEditsToEmployee)
{
case Models.StatusCode.NotFound:
return(Request.CreateErrorResponse(HttpStatusCode.NotFound, "That user does not exist."));
case Models.StatusCode.Success:
return(Request.CreateResponse(HttpStatusCode.OK));
case Models.StatusCode.Unsuccessful:
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, "Something went wrong updating this employee, please try again later."));
default:
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, "Something went wrong updating this employee, please try again later."));
}
}
public async Task <ActionResult <EmployeeDto> > UpdateEmployeeForCompany(Guid companyId, Guid employeeId,
EmployeeEditDto employee)
{
if (!await _companyRepository.CompanyExistsAsync(companyId))
{
return(NotFound());
}
var employeeEntity = await _companyRepository.GetEmployeeAsync(companyId, employeeId);
if (employeeEntity == null)
{
var employeeToAddEntity = _mapper.Map <Employee>(employee);
employeeToAddEntity.Id = employeeId;
employeeToAddEntity.CompanyId = companyId;
_companyRepository.AddEmployee(companyId, employeeToAddEntity);
await _companyRepository.SaveAsync();
var returnDto = _mapper.Map <EmployeeDto>(employeeToAddEntity);
return(CreatedAtRoute(nameof(GetEmployeeForCompany), new
{
companyId = companyId,
employeeId = returnDto.Id
}, returnDto));
}
_mapper.Map(employee, employeeEntity);
_companyRepository.UpdateEmployee(employeeEntity);
await _companyRepository.SaveAsync();
return(NoContent());
}
