/// <summary>
/// 新增
/// </summary>
/// <param name="employeeRequestDto"></param>
/// <returns></returns>
public async Task <bool> CreateAsync(EmployeeRequestDto employeeRequestDto)
{
var employee = employeeRequestDto.MapToCreateEntity <EmployeeRequestDto, Employee>();
await EmployeeValidatorsFilter.DoValidationAsync(_employeeRespository, employee, ValidatorTypeConstants.Create);
return(await _employeeRespository.InsertAsync(employee));
}
private async Task CreateOrRemoveRelationRoleEmployee(EmployeeRequestDto employeeRequestDto)
{
var empRole = await _relationEmployeeRoleAppService.GetRoleIdsByEmployeeIds(new List <string>() { employeeRequestDto.Id });
var dbRoleIds = empRole.Select(r => r.RoleId).ToList();
var addRoleIds = employeeRequestDto.RoleIds.Except(dbRoleIds);
var removeRoleIds = dbRoleIds.Except(employeeRequestDto.RoleIds);
var addRelationRoleEmp = addRoleIds.Select(o => new RelationEmployeeRoleRequestDto
{
Id = Guid.NewGuid().ToString(),
RoleId = o,
EmployeeId = employeeRequestDto.Id,
CreateUserId = employeeRequestDto.CreateUserId,
CreateUserName = employeeRequestDto.CreateUserName
});
await _relationEmployeeRoleAppService.BatchCreateAsync(addRelationRoleEmp.ToList());
var removeRelationRoleEmp = new RelationEmployeeRoleRemoveDto
{
EmployeeId = employeeRequestDto.Id,
RoleIds = removeRoleIds.ToList(),
ModifyUserId = employeeRequestDto.ModifyUserId,
ModifyUserName = employeeRequestDto.ModifyUserName,
ModifyDate = DateTime.Now
};
await _relationEmployeeRoleAppService.RemoveByEmployeeIdAndRoleIds(removeRelationRoleEmp);
}
/// <summary>
/// 新增
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public async Task <JsonResponse> Create(EmployeeRequestDto input)
{
input.InitCreateRequest();
var resJson = await _employeeDomainService.SaveEmployee(input);
return(resJson);
}
// <summary>
/// 保存成员
/// </summary>
/// <param name="employeeRequestDto"></param>
/// <returns></returns>
public async Task <JsonResponse> SaveEmployee(EmployeeRequestDto employeeRequestDto)
{
var resJson = await _applicationEnginee.TryTransactionAsync(async() =>
{
await CreateOrModifyEmployee(employeeRequestDto);
await CreateOrRemoveRelationOrganizationEmployee(employeeRequestDto);
await CreateOrRemoveRelationRoleEmployee(employeeRequestDto);
});
return(resJson);
}
/// <summary>
/// 修改
/// </summary>
/// <param name="employeeRequestDto"></param>
/// <returns></returns>
public async Task <bool> ModifyAsync(EmployeeRequestDto employeeRequestDto)
{
var employee = await _employeeRespository.FirstOrDefaultAsync(e => e.Id == employeeRequestDto.Id);
employeeRequestDto.Password = employee.Password;
employeeRequestDto.Salt = employee.Salt;
var entity = employeeRequestDto.MapToModifyEntity <EmployeeRequestDto, Employee>(employee);
await EmployeeValidatorsFilter.DoValidationAsync(_employeeRespository, entity, ValidatorTypeConstants.Modify);
return(await _employeeRespository.UpdateAsync(entity));
}
private async Task CreateOrModifyEmployee(EmployeeRequestDto employeeRequestDto)
{
if (employeeRequestDto.OperationStatus == OperationModel.Create)
{
employeeRequestDto.Salt = Utils.Number(8);
employeeRequestDto.Password = AESCryption.EncryptText(employeeRequestDto.Password, employeeRequestDto.Salt);
await _employeeAppService.CreateAsync(employeeRequestDto);
}
else if (employeeRequestDto.OperationStatus == OperationModel.Modify)
{
await _employeeAppService.ModifyAsync(employeeRequestDto);
}
}
/// <summary>
/// 登录
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public async Task <LoginUser> Authentication(EmployeeRequestDto input)
{
return(await _employeeDomainService.Login(input));
// return await Task.FromResult(new LoginUser()
// {
// IsSucceed = true,
// UserId = Guid.NewGuid().ToString(),
// Name = "admin",
// RoleType = RoleType.AdministratorRole
// });
//// return await _usersAppService.Login(input);
}
public async Task <Employee> CreateEmployeeAsync(EmployeeRequestDto employee)
{
var entry = await _dbContext.Employees.AddAsync(new Employee
{
FullName = employee.FullName,
PassportSeries = employee.PassportSeries,
PassportNumber = employee.PassportNumber,
OtherInfo = employee.OtherInfo,
LengthOfWork = employee.LengthOfWork,
PreviousWorkPlace = employee.PreviousWorkPlace,
DepartmentId = employee.DepartmentId,
PositionId = employee.PositionId
});
await _dbContext.SaveChangesAsync();
return(entry.Entity);
}
public async Task <Employee> UpdateEmployeeAsync(long id, EmployeeRequestDto employee)
{
if (employee.DepartmentId < 1 || employee.PositionId < 1)
{
throw new ArgumentException("invalid ids");
}
var entity = await _dbContext.Employees.SingleOrDefaultAsync(e => e.Id == id);
entity.FullName = employee.FullName;
entity.PassportSeries = employee.PassportSeries;
entity.PassportNumber = employee.PassportNumber;
entity.OtherInfo = employee.OtherInfo;
entity.LengthOfWork = employee.LengthOfWork;
entity.PreviousWorkPlace = employee.PreviousWorkPlace;
entity.DepartmentId = employee.DepartmentId;
entity.PositionId = employee.PositionId;
await _dbContext.SaveChangesAsync();
return(entity);
}
/// <summary>
/// 用户登录
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public async Task <LoginUser> Login(EmployeeRequestDto input)
{
var userAccount = await _employeeAppService.EmployeeLogin(input.UserId);
if (userAccount == null)
{
var _loginUser = new LoginUser()
{
IsSucceed = false, Message = "用户名不存在!"
};
return(await Task.FromResult(_loginUser));
}
var encryptPassword = AESCryption.EncryptText(input.Password, userAccount.Salt);
if (!string.Equals(encryptPassword, userAccount.Password))
{
var _loginUser = new LoginUser()
{
IsSucceed = false, Message = "密码错误!"
};
return(await Task.FromResult(_loginUser));
}
//var menuIds = await GetEmployeeMenuAsync(userAccount.Id);
var elements = await GetEmployeeModuleElementAsync(userAccount.Id);
var elementIds = elements.Select(e => e.Id).ToList();
var elementDtos = await _moduleElementAppService.GetElementByIds(elementIds);
var routePaths = elementDtos.Select(r => r.RoutePath).ToList();
return(await Task.FromResult(new LoginUser()
{
RoutePaths = routePaths,
IsSucceed = true,
Name = userAccount.Name,
Account = userAccount.UserId,
ExpireDateTime = DateTime.Now.AddHours(8),
UserId = userAccount.Id,
}));
}
public async Task <EmployeeResponseDto> CreateEmployee(EmployeeRequestDto employee)
{
var result = await _employeeService.CreateEmployeeAsync(employee);
return(_mapper.Map <EmployeeResponseDto>(result));
}
public async Task <EmployeeResponseDto> UpdateEmployee(long id, EmployeeRequestDto employee)
{
var result = await _employeeService.UpdateEmployeeAsync(id, employee);
return(_mapper.Map <EmployeeResponseDto>(result));
}
