package cn.iocoder.yudao.module.hrm.service.employee;
|
|
import cn.hutool.core.collection.CollUtil;
|
import cn.hutool.core.util.StrUtil;
|
import cn.hutool.json.JSONUtil;
|
import cn.iocoder.yudao.framework.common.exception.ServiceException;
|
import cn.iocoder.yudao.framework.common.pojo.PageResult;
|
import cn.iocoder.yudao.framework.common.util.object.BeanUtils;
|
import cn.iocoder.yudao.framework.operatelog.core.util.OperateLogUtils;
|
import cn.iocoder.yudao.module.hrm.controller.admin.employee.vo.HrmEmployeeEducationSaveReqVO;
|
import cn.iocoder.yudao.module.hrm.controller.admin.employee.vo.HrmEmployeeEmergencyContactSaveReqVO;
|
import cn.iocoder.yudao.module.hrm.controller.admin.employee.vo.HrmEmployeeImportExcelVO;
|
import cn.iocoder.yudao.module.hrm.controller.admin.employee.vo.HrmEmployeeImportReqVO;
|
import cn.iocoder.yudao.module.hrm.controller.admin.employee.vo.HrmEmployeeImportRespVO;
|
import cn.iocoder.yudao.module.hrm.controller.admin.employee.vo.HrmEmployeePageReqVO;
|
import cn.iocoder.yudao.module.hrm.controller.admin.employee.vo.HrmEmployeeRespVO;
|
import cn.iocoder.yudao.module.hrm.controller.admin.employee.vo.HrmEmployeeSaveReqVO;
|
import cn.iocoder.yudao.module.hrm.controller.admin.employee.vo.HrmEmployeeSimpleRespVO;
|
import cn.iocoder.yudao.module.hrm.controller.admin.employee.vo.HrmEmployeeStatisticsRespVO;
|
import cn.iocoder.yudao.module.hrm.controller.admin.employee.vo.HrmEmployeeWorkHistorySaveReqVO;
|
import cn.iocoder.yudao.module.hrm.dal.dataobject.employee.HrmEmployeeContractDO;
|
import cn.iocoder.yudao.module.hrm.dal.dataobject.employee.HrmEmployeeDO;
|
import cn.iocoder.yudao.module.hrm.dal.dataobject.employee.HrmEmployeeEducationDO;
|
import cn.iocoder.yudao.module.hrm.dal.dataobject.employee.HrmEmployeeEmergencyContactDO;
|
import cn.iocoder.yudao.module.hrm.dal.dataobject.employee.HrmEmployeeWorkHistoryDO;
|
import cn.iocoder.yudao.module.hrm.dal.mysql.employee.HrmEmployeeContractMapper;
|
import cn.iocoder.yudao.module.hrm.dal.mysql.employee.HrmEmployeeEducationMapper;
|
import cn.iocoder.yudao.module.hrm.dal.mysql.employee.HrmEmployeeEmergencyContactMapper;
|
import cn.iocoder.yudao.module.hrm.dal.mysql.employee.HrmEmployeeMapper;
|
import cn.iocoder.yudao.module.hrm.dal.mysql.employee.HrmEmployeeWorkHistoryMapper;
|
import cn.iocoder.yudao.module.hrm.dal.redis.HrmNoRedisDAO;
|
import cn.iocoder.yudao.module.system.api.dept.DeptApi;
|
import cn.iocoder.yudao.module.system.api.dept.PostApi;
|
import cn.iocoder.yudao.module.system.api.dept.dto.DeptRespDTO;
|
import cn.iocoder.yudao.module.system.api.dept.dto.PostRespDTO;
|
import cn.iocoder.yudao.module.system.api.permission.RoleApi;
|
import cn.iocoder.yudao.module.system.api.permission.dto.RoleRespDTO;
|
import cn.iocoder.yudao.module.system.api.user.AdminUserApi;
|
import cn.iocoder.yudao.module.system.api.user.dto.AdminUserCreateReqDTO;
|
import cn.iocoder.yudao.module.system.api.user.dto.AdminUserUpdateReqDTO;
|
import com.mzt.logapi.starter.annotation.LogRecord;
|
import jakarta.annotation.Resource;
|
import org.springframework.context.annotation.Lazy;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.validation.annotation.Validated;
|
|
import java.time.LocalDate;
|
import java.time.YearMonth;
|
import java.time.temporal.ChronoUnit;
|
import java.util.ArrayList;
|
import java.util.Collection;
|
import java.util.Collections;
|
import java.util.Comparator;
|
import java.util.HashSet;
|
import java.util.LinkedHashMap;
|
import java.util.LinkedHashSet;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Objects;
|
import java.util.Set;
|
import java.util.stream.Collectors;
|
|
import static cn.iocoder.yudao.framework.common.exception.util.ServiceExceptionUtil.exception;
|
import static cn.iocoder.yudao.framework.common.util.collection.CollectionUtils.filterList;
|
import static cn.iocoder.yudao.module.hrm.enums.ErrorCodeConstants.*;
|
import static cn.iocoder.yudao.module.hrm.enums.LogRecordConstants.*;
|
|
/**
|
* 员工信息 Service 实现类
|
*
|
* @author 超级管理员
|
*/
|
@Service
|
@Validated
|
public class HrmEmployeeServiceImpl implements HrmEmployeeService {
|
|
/** 员工状态：离职 */
|
private static final Integer EMPLOYEE_STATUS_RESIGNED = 3;
|
|
@Resource
|
private HrmEmployeeMapper employeeMapper;
|
@Resource
|
private HrmEmployeeEducationMapper educationMapper;
|
@Resource
|
private HrmEmployeeContractMapper contractMapper;
|
@Resource
|
private HrmEmployeeWorkHistoryMapper workHistoryMapper;
|
@Resource
|
private HrmEmployeeEmergencyContactMapper emergencyContactMapper;
|
@Resource
|
private HrmNoRedisDAO noRedisDAO;
|
@Resource
|
private DeptApi deptApi;
|
@Resource
|
private PostApi postApi;
|
@Resource
|
private AdminUserApi adminUserApi;
|
@Resource
|
private RoleApi roleApi;
|
@Resource
|
@Lazy // 自注入需延迟加载，否则 bean 被代理包装后注入原始版本导致启动失败
|
private HrmEmployeeService self;
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public Long createEmployee(HrmEmployeeSaveReqVO createReqVO) {
|
// 1. 校验部门
|
deptApi.validateDeptList(Collections.singleton(createReqVO.getDeptId()));
|
// 2. 校验岗位
|
postApi.validPostList(createReqVO.getPostIds());
|
// 3. 校验手机号是否已存在
|
if (employeeMapper.selectByPhone(createReqVO.getPhone()) != null) {
|
throw exception(EMPLOYEE_PHONE_EXISTS);
|
}
|
// 4. 同步创建系统用户
|
AdminUserCreateReqDTO userCreateReqDTO = new AdminUserCreateReqDTO();
|
userCreateReqDTO.setUsername(createReqVO.getPhone());
|
userCreateReqDTO.setNickname(createReqVO.getName());
|
userCreateReqDTO.setDeptId(createReqVO.getDeptId());
|
userCreateReqDTO.setPostIds(new LinkedHashSet<>(createReqVO.getPostIds()));
|
userCreateReqDTO.setMobile(createReqVO.getPhone());
|
userCreateReqDTO.setPassword(createReqVO.getPhone());
|
userCreateReqDTO.setSex(createReqVO.getGender());
|
userCreateReqDTO.setEmail(createReqVO.getEmail());
|
userCreateReqDTO.setRemark(createReqVO.getRemark());
|
// 设置角色
|
if (CollUtil.isNotEmpty(createReqVO.getRoleIds())) {
|
userCreateReqDTO.setRoleIds(createReqVO.getRoleIds().stream().collect(Collectors.toSet()));
|
}
|
Long userId = adminUserApi.createUser(userCreateReqDTO);
|
// 5. 生成员工编号
|
String employeeNo = generateUniqueEmployeeNo();
|
// 6. 插入员工记录
|
HrmEmployeeDO employee = BeanUtils.toBean(createReqVO, HrmEmployeeDO.class);
|
employee.setEmployeeNo(employeeNo);
|
employee.setUserId(userId); // 关联系统用户ID
|
// roleIds 存储为 JSON
|
if (CollUtil.isNotEmpty(createReqVO.getRoleIds())) {
|
employee.setRoleIds(JSONUtil.toJsonStr(createReqVO.getRoleIds()));
|
}
|
// postIds 存储为 JSON
|
if (CollUtil.isNotEmpty(createReqVO.getPostIds())) {
|
employee.setPostIds(JSONUtil.toJsonStr(createReqVO.getPostIds()));
|
}
|
employeeMapper.insert(employee);
|
Long employeeId = employee.getId();
|
// 7. 同步添加教育经历
|
if (CollUtil.isNotEmpty(createReqVO.getEducations())) {
|
createReqVO.getEducations().forEach(educationVO -> {
|
HrmEmployeeEducationDO education = BeanUtils.toBean(educationVO, HrmEmployeeEducationDO.class);
|
education.setEmployeeId(employeeId);
|
educationMapper.insert(education);
|
});
|
}
|
// 8. 同步添加工作经历
|
if (CollUtil.isNotEmpty(createReqVO.getWorkHistories())) {
|
createReqVO.getWorkHistories().forEach(workHistoryVO -> {
|
HrmEmployeeWorkHistoryDO workHistory = BeanUtils.toBean(workHistoryVO, HrmEmployeeWorkHistoryDO.class);
|
workHistory.setEmployeeId(employeeId);
|
workHistoryMapper.insert(workHistory);
|
});
|
}
|
// 9. 同步添加紧急联系人
|
if (CollUtil.isNotEmpty(createReqVO.getEmergencyContacts())) {
|
createReqVO.getEmergencyContacts().forEach(emergencyContactVO -> {
|
HrmEmployeeEmergencyContactDO emergencyContact = BeanUtils.toBean(emergencyContactVO, HrmEmployeeEmergencyContactDO.class);
|
emergencyContact.setEmployeeId(employeeId);
|
emergencyContactMapper.insert(emergencyContact);
|
});
|
}
|
return employeeId;
|
}
|
|
private String generateUniqueEmployeeNo() {
|
String employeeNo = noRedisDAO.generateEmployeeNo();
|
if (employeeMapper.selectByEmployeeNo(employeeNo) != null) {
|
return generateUniqueEmployeeNo();
|
}
|
return employeeNo;
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public void updateEmployee(HrmEmployeeSaveReqVO updateReqVO) {
|
// 校验存在
|
HrmEmployeeDO employee = validateEmployeeExists(updateReqVO.getId());
|
// 校验部门
|
deptApi.validateDeptList(Collections.singleton(updateReqVO.getDeptId()));
|
// 校验岗位
|
postApi.validPostList(updateReqVO.getPostIds());
|
// 校验手机号是否已存在（如果手机号有变更）
|
if (!Objects.equals(employee.getPhone(), updateReqVO.getPhone())
|
&& employeeMapper.selectByPhone(updateReqVO.getPhone()) != null) {
|
throw exception(EMPLOYEE_PHONE_EXISTS);
|
}
|
// 更新员工主表
|
HrmEmployeeDO updateObj = BeanUtils.toBean(updateReqVO, HrmEmployeeDO.class);
|
// roleIds 存储为 JSON
|
if (CollUtil.isNotEmpty(updateReqVO.getRoleIds())) {
|
updateObj.setRoleIds(JSONUtil.toJsonStr(updateReqVO.getRoleIds()));
|
}
|
// postIds 存储为 JSON
|
if (CollUtil.isNotEmpty(updateReqVO.getPostIds())) {
|
updateObj.setPostIds(JSONUtil.toJsonStr(updateReqVO.getPostIds()));
|
}
|
employeeMapper.updateById(updateObj);
|
// 同步更新关联系统用户（岗位/部门/昵称/角色/邮箱/备注），保持与用户管理一致
|
if (employee.getUserId() != null) {
|
AdminUserUpdateReqDTO userUpdateReqDTO = new AdminUserUpdateReqDTO();
|
userUpdateReqDTO.setId(employee.getUserId());
|
userUpdateReqDTO.setNickname(updateReqVO.getName());
|
userUpdateReqDTO.setDeptId(updateReqVO.getDeptId());
|
userUpdateReqDTO.setPostIds(new LinkedHashSet<>(updateReqVO.getPostIds()));
|
userUpdateReqDTO.setRoleIds(CollUtil.isEmpty(updateReqVO.getRoleIds()) ? null
|
: new LinkedHashSet<>(updateReqVO.getRoleIds()));
|
userUpdateReqDTO.setEmail(updateReqVO.getEmail());
|
userUpdateReqDTO.setRemark(updateReqVO.getRemark());
|
adminUserApi.updateUser(userUpdateReqDTO);
|
}
|
Long employeeId = updateReqVO.getId();
|
|
// 同步教育经历
|
syncEducationList(employeeId, updateReqVO.getEducations());
|
// 同步工作经历
|
syncWorkHistoryList(employeeId, updateReqVO.getWorkHistories());
|
// 同步紧急联系人
|
syncEmergencyContactList(employeeId, updateReqVO.getEmergencyContacts());
|
}
|
|
private void syncEducationList(Long employeeId, List<HrmEmployeeEducationSaveReqVO> newList) {
|
educationMapper.deleteByEmployeeId(employeeId);
|
if (CollUtil.isNotEmpty(newList)) {
|
newList.forEach(vo -> {
|
HrmEmployeeEducationDO education = BeanUtils.toBean(vo, HrmEmployeeEducationDO.class);
|
education.setId(null);
|
education.setEmployeeId(employeeId);
|
educationMapper.insert(education);
|
});
|
}
|
}
|
|
private void syncWorkHistoryList(Long employeeId, List<HrmEmployeeWorkHistorySaveReqVO> newList) {
|
workHistoryMapper.deleteByEmployeeId(employeeId);
|
if (CollUtil.isNotEmpty(newList)) {
|
newList.forEach(vo -> {
|
HrmEmployeeWorkHistoryDO workHistory = BeanUtils.toBean(vo, HrmEmployeeWorkHistoryDO.class);
|
workHistory.setId(null);
|
workHistory.setEmployeeId(employeeId);
|
workHistoryMapper.insert(workHistory);
|
});
|
}
|
}
|
|
private void syncEmergencyContactList(Long employeeId, List<HrmEmployeeEmergencyContactSaveReqVO> newList) {
|
emergencyContactMapper.deleteByEmployeeId(employeeId);
|
if (CollUtil.isNotEmpty(newList)) {
|
newList.forEach(vo -> {
|
HrmEmployeeEmergencyContactDO emergencyContact = BeanUtils.toBean(vo, HrmEmployeeEmergencyContactDO.class);
|
emergencyContact.setId(null);
|
emergencyContact.setEmployeeId(employeeId);
|
emergencyContactMapper.insert(emergencyContact);
|
});
|
}
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public void deleteEmployee(Long id) {
|
// 校验存在
|
validateEmployeeExists(id);
|
// 级联删除子表
|
educationMapper.deleteByEmployeeId(id);
|
workHistoryMapper.deleteByEmployeeId(id);
|
emergencyContactMapper.deleteByEmployeeId(id);
|
// 删除员工
|
employeeMapper.deleteById(id);
|
}
|
|
private HrmEmployeeDO validateEmployeeExists(Long id) {
|
HrmEmployeeDO employee = employeeMapper.selectById(id);
|
if (employee == null) {
|
throw exception(EMPLOYEE_NOT_EXISTS);
|
}
|
return employee;
|
}
|
|
@Override
|
public HrmEmployeeDO getEmployee(Long id) {
|
return employeeMapper.selectById(id);
|
}
|
|
@Override
|
public HrmEmployeeRespVO getEmployeeDetail(Long id) {
|
HrmEmployeeDO employee = getEmployee(id);
|
if (employee == null) {
|
return null;
|
}
|
HrmEmployeeRespVO respVO = BeanUtils.toBean(employee, HrmEmployeeRespVO.class);
|
// 解析 roleIds JSON
|
if (StrUtil.isNotBlank(employee.getRoleIds())) {
|
respVO.setRoleIds(JSONUtil.toList(employee.getRoleIds(), Long.class));
|
}
|
// 填充部门名称
|
if (employee.getDeptId() != null) {
|
DeptRespDTO dept = deptApi.getDept(employee.getDeptId());
|
if (dept != null) {
|
respVO.setDeptName(dept.getName());
|
}
|
}
|
// 填充岗位信息
|
if (StrUtil.isNotBlank(employee.getPostIds())) {
|
List<Long> postIds = JSONUtil.toList(employee.getPostIds(), Long.class);
|
respVO.setPostIds(postIds);
|
if (CollUtil.isNotEmpty(postIds)) {
|
Map<Long, PostRespDTO> postMap = postApi.getPostMap(postIds);
|
respVO.setPostNames(postIds.stream()
|
.filter(postMap::containsKey)
|
.map(postId -> postMap.get(postId).getName())
|
.collect(Collectors.joining(",")));
|
}
|
}
|
// 填充角色名称
|
if (CollUtil.isNotEmpty(respVO.getRoleIds())) {
|
List<RoleRespDTO> roles = roleApi.getRoleList(respVO.getRoleIds());
|
if (CollUtil.isNotEmpty(roles)) {
|
respVO.setRoleNames(roles.stream().map(RoleRespDTO::getName).collect(Collectors.joining(",")));
|
}
|
}
|
return respVO;
|
}
|
|
@Override
|
public HrmEmployeeDO validateEmployee(Long id) {
|
HrmEmployeeDO employee = employeeMapper.selectById(id);
|
if (employee == null) {
|
throw exception(EMPLOYEE_NOT_EXISTS);
|
}
|
return employee;
|
}
|
|
@Override
|
public PageResult<HrmEmployeeDO> getEmployeePage(HrmEmployeePageReqVO pageReqVO) {
|
if (pageReqVO.getDeptId() != null) {
|
// 选中部门时，连带查询其所有子部门的员工（含自身）
|
List<DeptRespDTO> childDepts = deptApi.getChildDeptList(pageReqVO.getDeptId());
|
Set<Long> deptIds = new LinkedHashSet<>();
|
deptIds.add(pageReqVO.getDeptId());
|
if (CollUtil.isNotEmpty(childDepts)) {
|
childDepts.forEach(dept -> deptIds.add(dept.getId()));
|
}
|
return employeeMapper.selectPageByDeptIds(pageReqVO, deptIds);
|
}
|
return employeeMapper.selectPage(pageReqVO);
|
}
|
|
@Override
|
public List<HrmEmployeeDO> getEmployeeList(Collection<Long> ids) {
|
return employeeMapper.selectByIds(ids);
|
}
|
|
@Override
|
public List<HrmEmployeeSimpleRespVO> getEmployeeSimpleList(Integer employeeStatus) {
|
List<HrmEmployeeDO> list = employeeMapper.selectListByStatus(employeeStatus);
|
// 填充部门名称
|
Set<Long> deptIds = list.stream()
|
.map(HrmEmployeeDO::getDeptId)
|
.filter(Objects::nonNull)
|
.collect(Collectors.toSet());
|
Map<Long, DeptRespDTO> deptMap = deptApi.getDeptMap(deptIds);
|
return list.stream().map(emp -> {
|
HrmEmployeeSimpleRespVO vo = new HrmEmployeeSimpleRespVO();
|
vo.setId(emp.getId());
|
vo.setEmployeeNo(emp.getEmployeeNo());
|
vo.setName(emp.getName());
|
vo.setEmployeeStatus(emp.getEmployeeStatus());
|
if (emp.getDeptId() != null && deptMap.containsKey(emp.getDeptId())) {
|
vo.setDeptName(deptMap.get(emp.getDeptId()).getName());
|
}
|
return vo;
|
}).collect(Collectors.toList());
|
}
|
|
@Override
|
public HrmEmployeeDO getEmployeeByUserId(Long userId) {
|
return employeeMapper.selectByUserId(userId);
|
}
|
|
@Override
|
public boolean updateEmployeeStatusToResignedByUserId(Long userId, LocalDate leaveDate) {
|
if (userId == null) {
|
return false;
|
}
|
return employeeMapper.updateEmployeeStatusByUserId(userId, EMPLOYEE_STATUS_RESIGNED, leaveDate) > 0;
|
}
|
|
@Override
|
public HrmEmployeeDO getEmployeeByName(String name) {
|
return employeeMapper.selectByName(name);
|
}
|
|
@Override
|
public List<HrmEmployeeDO> getEmployeeListByName(String name) {
|
return employeeMapper.selectListByName(name);
|
}
|
|
@Override
|
@LogRecord(type = HRM_EMPLOYEE_TYPE, subType = HRM_EMPLOYEE_IMPORT_SUB_TYPE, bizNo = "0",
|
success = HRM_EMPLOYEE_IMPORT_SUCCESS)
|
public HrmEmployeeImportRespVO importEmployeeList(List<HrmEmployeeImportExcelVO> importEmployees,
|
HrmEmployeeImportReqVO importReqVO) {
|
// 1. 校验非空
|
importEmployees = filterList(importEmployees, item -> Objects.nonNull(item.getName()));
|
if (CollUtil.isEmpty(importEmployees)) {
|
throw exception(EMPLOYEE_IMPORT_LIST_IS_EMPTY);
|
}
|
// 2. 预加载部门/岗位/角色 名称 -> 实体 映射
|
Map<String, DeptRespDTO> deptMap = deptApi.getDeptList().stream()
|
.collect(Collectors.toMap(DeptRespDTO::getName, dept -> dept, (v1, v2) -> v1));
|
Map<String, PostRespDTO> postMap = postApi.getPostList().stream()
|
.collect(Collectors.toMap(PostRespDTO::getName, post -> post, (v1, v2) -> v1));
|
Map<String, RoleRespDTO> roleMap = roleApi.getRoleList().stream()
|
.collect(Collectors.toMap(RoleRespDTO::getName, role -> role, (v1, v2) -> v1));
|
// 3. 逐条处理
|
HrmEmployeeImportRespVO respVO = HrmEmployeeImportRespVO.builder()
|
.createNames(new ArrayList<>())
|
.updateNames(new ArrayList<>())
|
.failureNames(new LinkedHashMap<>())
|
.build();
|
for (HrmEmployeeImportExcelVO importEmployee : importEmployees) {
|
String name = importEmployee.getName();
|
try {
|
// 3.1 名称转 ID
|
Long deptId = parseDeptId(importEmployee.getDeptName(), deptMap);
|
Set<Long> postIds = parsePostIds(importEmployee.getPostName(), postMap);
|
Set<Long> roleIds = parseRoleIds(importEmployee.getRoleNames(), roleMap);
|
// 3.2 构建保存请求
|
HrmEmployeeSaveReqVO saveReqVO = buildImportSaveReqVO(importEmployee, deptId, postIds, roleIds);
|
// 3.3 判断存在性：按手机号
|
HrmEmployeeDO existEmployee = employeeMapper.selectByPhone(importEmployee.getPhone());
|
if (existEmployee == null) {
|
self.createEmployee(saveReqVO);
|
respVO.getCreateNames().add(name);
|
} else {
|
if (!Boolean.TRUE.equals(importReqVO.getUpdateSupport())) {
|
respVO.getFailureNames().put(name, EMPLOYEE_PHONE_EXISTS.getMsg());
|
continue;
|
}
|
saveReqVO.setId(existEmployee.getId());
|
self.updateEmployee(saveReqVO);
|
respVO.getUpdateNames().add(name);
|
}
|
} catch (ServiceException ex) {
|
respVO.getFailureNames().put(name, ex.getMessage());
|
} catch (Exception ex) {
|
respVO.getFailureNames().put(name, ex.getMessage());
|
}
|
}
|
// 记录导入结果汇总，供 @LogRecord 的 success 文案引用
|
OperateLogUtils.putImportSummary(respVO.getCreateNames(), respVO.getUpdateNames(),
|
respVO.getFailureNames());
|
return respVO;
|
}
|
|
private HrmEmployeeSaveReqVO buildImportSaveReqVO(HrmEmployeeImportExcelVO importEmployee,
|
Long deptId, Set<Long> postIds, Set<Long> roleIds) {
|
if (StrUtil.isBlank(importEmployee.getName())) {
|
throw exception(EMPLOYEE_IMPORT_FIELD_REQUIRED, "员工姓名");
|
}
|
if (StrUtil.isBlank(importEmployee.getPhone())) {
|
throw exception(EMPLOYEE_IMPORT_FIELD_REQUIRED, "手机号");
|
}
|
if (importEmployee.getHireDate() == null) {
|
throw exception(EMPLOYEE_IMPORT_FIELD_REQUIRED, "入职日期");
|
}
|
HrmEmployeeSaveReqVO reqVO = new HrmEmployeeSaveReqVO();
|
reqVO.setName(importEmployee.getName());
|
reqVO.setGender(importEmployee.getGender() != null ? importEmployee.getGender() : 1); // 默认男
|
reqVO.setPhone(importEmployee.getPhone());
|
reqVO.setDeptId(deptId);
|
reqVO.setPostIds(CollUtil.isEmpty(postIds) ? null : new ArrayList<>(postIds));
|
reqVO.setRoleIds(CollUtil.isEmpty(roleIds) ? null : new ArrayList<>(roleIds));
|
reqVO.setHireDate(importEmployee.getHireDate());
|
reqVO.setEmployeeStatus(importEmployee.getEmployeeStatus() != null
|
? importEmployee.getEmployeeStatus() : 1); // 默认在职
|
reqVO.setEmail(importEmployee.getEmail());
|
reqVO.setBirthday(importEmployee.getBirthday());
|
reqVO.setIdCard(importEmployee.getIdCard());
|
reqVO.setNation(importEmployee.getNation());
|
reqVO.setMarriageStatus(importEmployee.getMarriageStatus());
|
reqVO.setAge(importEmployee.getAge());
|
reqVO.setEducation(importEmployee.getEducation());
|
reqVO.setPoliticalStatus(importEmployee.getPoliticalStatus());
|
reqVO.setRemark(importEmployee.getRemark());
|
return reqVO;
|
}
|
|
private Long parseDeptId(String deptName, Map<String, DeptRespDTO> deptMap) {
|
if (StrUtil.isBlank(deptName)) {
|
throw exception(EMPLOYEE_IMPORT_FIELD_REQUIRED, "部门名称");
|
}
|
DeptRespDTO dept = deptMap.get(deptName.trim());
|
if (dept == null) {
|
throw exception(EMPLOYEE_DEPT_NAME_NOT_EXISTS, deptName.trim());
|
}
|
return dept.getId();
|
}
|
|
private Set<Long> parsePostIds(String postNames, Map<String, PostRespDTO> postMap) {
|
if (StrUtil.isBlank(postNames)) {
|
throw exception(EMPLOYEE_IMPORT_FIELD_REQUIRED, "岗位名称");
|
}
|
Set<Long> postIds = new LinkedHashSet<>();
|
for (String postName : postNames.split("[,，]")) {
|
String trimmed = postName.trim();
|
if (StrUtil.isBlank(trimmed)) {
|
continue;
|
}
|
PostRespDTO post = postMap.get(trimmed);
|
if (post == null) {
|
throw exception(EMPLOYEE_POST_NAME_NOT_EXISTS, trimmed);
|
}
|
postIds.add(post.getId());
|
}
|
if (CollUtil.isEmpty(postIds)) {
|
throw exception(EMPLOYEE_IMPORT_FIELD_REQUIRED, "岗位名称");
|
}
|
return postIds;
|
}
|
|
private Set<Long> parseRoleIds(String roleNames, Map<String, RoleRespDTO> roleMap) {
|
if (StrUtil.isBlank(roleNames)) {
|
return Collections.emptySet();
|
}
|
Set<Long> roleIds = new LinkedHashSet<>();
|
for (String roleName : roleNames.split("[,，]")) {
|
String trimmed = roleName.trim();
|
if (StrUtil.isBlank(trimmed)) {
|
continue;
|
}
|
RoleRespDTO role = roleMap.get(trimmed);
|
if (role == null) {
|
throw exception(EMPLOYEE_ROLE_NAME_NOT_EXISTS, trimmed);
|
}
|
roleIds.add(role.getId());
|
}
|
return roleIds;
|
}
|
|
// ==================== 人力统计 ====================
|
|
/** 员工状态：在职 */
|
private static final Integer EMPLOYEE_STATUS_ACTIVE = 1;
|
/** 员工状态：试用 */
|
private static final Integer EMPLOYEE_STATUS_PROBATION = 2;
|
|
/** 工龄区间名称，与下限（含）一一对应，最后一档无上限 */
|
private static final String[] TENURE_BUCKET_NAMES = {"1年以内", "1-3年", "3-5年", "5-10年", "10年以上"};
|
private static final double[] TENURE_BUCKET_MIN = {0, 1, 3, 5, 10};
|
|
/** 年龄区间名称，与下限（含）一一对应，最后一档无上限 */
|
private static final String[] AGE_BUCKET_NAMES = {"25岁以下", "25-30岁", "30-35岁", "35-40岁", "40-50岁", "50岁以上"};
|
private static final int[] AGE_BUCKET_MIN = {0, 25, 30, 35, 40, 50};
|
|
@Override
|
public HrmEmployeeStatisticsRespVO getTenureStatistics() {
|
List<HrmEmployeeDO> allEmployees = employeeMapper.selectList();
|
LocalDate today = LocalDate.now();
|
int currentYear = today.getYear();
|
|
List<HrmEmployeeDO> activeEmployees = allEmployees.stream()
|
.filter(e -> Objects.equals(e.getEmployeeStatus(), EMPLOYEE_STATUS_ACTIVE)
|
|| Objects.equals(e.getEmployeeStatus(), EMPLOYEE_STATUS_PROBATION))
|
.collect(Collectors.toList());
|
|
HrmEmployeeStatisticsRespVO respVO = new HrmEmployeeStatisticsRespVO();
|
respVO.setTotalCount(activeEmployees.size());
|
respVO.setActiveCount((int) activeEmployees.stream()
|
.filter(e -> Objects.equals(e.getEmployeeStatus(), EMPLOYEE_STATUS_ACTIVE)).count());
|
respVO.setProbationCount((int) activeEmployees.stream()
|
.filter(e -> Objects.equals(e.getEmployeeStatus(), EMPLOYEE_STATUS_PROBATION)).count());
|
respVO.setResignedCount((int) allEmployees.stream()
|
.filter(e -> Objects.equals(e.getEmployeeStatus(), EMPLOYEE_STATUS_RESIGNED)).count());
|
// 本年入职：在岗员工中入职日期落在今年
|
respVO.setThisYearHireCount((int) activeEmployees.stream()
|
.filter(e -> e.getHireDate() != null && e.getHireDate().getYear() == currentYear).count());
|
// 本年离职：离职员工中离职日期落在今年
|
respVO.setThisYearResignCount((int) allEmployees.stream()
|
.filter(e -> Objects.equals(e.getEmployeeStatus(), EMPLOYEE_STATUS_RESIGNED))
|
.filter(e -> e.getLeaveDate() != null && e.getLeaveDate().getYear() == currentYear).count());
|
|
// 1. 平均工龄、平均年龄
|
List<Double> tenureList = activeEmployees.stream()
|
.map(e -> calculateTenureYears(e, today))
|
.filter(Objects::nonNull)
|
.collect(Collectors.toList());
|
respVO.setAverageTenureYears(averageOf(tenureList));
|
List<Integer> ageList = activeEmployees.stream()
|
.map(e -> resolveAge(e, today))
|
.filter(Objects::nonNull)
|
.collect(Collectors.toList());
|
respVO.setAverageAge(averageOfInt(ageList));
|
|
// 2. 工龄分布
|
int[] tenureCounts = new int[TENURE_BUCKET_NAMES.length];
|
for (Double tenure : tenureList) {
|
tenureCounts[resolveTenureBucket(tenure)]++;
|
}
|
List<HrmEmployeeStatisticsRespVO.ItemVO> tenureDistribution = new ArrayList<>();
|
for (int i = 0; i < TENURE_BUCKET_NAMES.length; i++) {
|
tenureDistribution.add(new HrmEmployeeStatisticsRespVO.ItemVO(TENURE_BUCKET_NAMES[i], tenureCounts[i]));
|
}
|
respVO.setTenureDistribution(tenureDistribution);
|
|
// 3. 年龄分布
|
int[] ageCounts = new int[AGE_BUCKET_NAMES.length];
|
for (Integer age : ageList) {
|
ageCounts[resolveAgeBucket(age)]++;
|
}
|
List<HrmEmployeeStatisticsRespVO.ItemVO> ageDistribution = new ArrayList<>();
|
for (int i = 0; i < AGE_BUCKET_NAMES.length; i++) {
|
ageDistribution.add(new HrmEmployeeStatisticsRespVO.ItemVO(AGE_BUCKET_NAMES[i], ageCounts[i]));
|
}
|
respVO.setAgeDistribution(ageDistribution);
|
|
// 4. 学历分布（未填写的归入“未填写”）
|
Map<String, Integer> educationMap = new LinkedHashMap<>();
|
activeEmployees.stream()
|
.map(e -> StrUtil.blankToDefault(StrUtil.trim(e.getEducation()), "未填写"))
|
.forEach(name -> educationMap.merge(name, 1, Integer::sum));
|
respVO.setEducationDistribution(toItemListSorted(educationMap));
|
|
// 5. 性别分布（1 男 / 2 女 / 其它 未知）
|
Map<String, Integer> genderMap = new LinkedHashMap<>();
|
activeEmployees.forEach(e -> {
|
String name = Objects.equals(e.getGender(), 1) ? "男" : Objects.equals(e.getGender(), 2) ? "女" : "未知";
|
genderMap.merge(name, 1, Integer::sum);
|
});
|
respVO.setGenderDistribution(toItemListSorted(genderMap));
|
|
// 6. 部门工龄统计
|
Set<Long> deptIds = activeEmployees.stream()
|
.map(HrmEmployeeDO::getDeptId)
|
.filter(Objects::nonNull)
|
.collect(Collectors.toSet());
|
Map<Long, DeptRespDTO> deptMap = CollUtil.isEmpty(deptIds) ? Collections.emptyMap() : deptApi.getDeptMap(deptIds);
|
Map<Long, List<Double>> deptTenureMap = new LinkedHashMap<>();
|
Map<Long, String> deptNameMap = new LinkedHashMap<>();
|
for (HrmEmployeeDO employee : activeEmployees) {
|
Double tenure = calculateTenureYears(employee, today);
|
if (employee.getDeptId() == null) {
|
deptTenureMap.computeIfAbsent(0L, k -> new ArrayList<>()).add(tenure == null ? 0D : tenure);
|
deptNameMap.putIfAbsent(0L, "未分配部门");
|
continue;
|
}
|
deptTenureMap.computeIfAbsent(employee.getDeptId(), k -> new ArrayList<>())
|
.add(tenure == null ? 0D : tenure);
|
DeptRespDTO dept = deptMap.get(employee.getDeptId());
|
deptNameMap.put(employee.getDeptId(), dept != null ? dept.getName() : "部门ID=" + employee.getDeptId());
|
}
|
List<HrmEmployeeStatisticsRespVO.DeptTenureVO> deptTenureList = new ArrayList<>();
|
deptTenureMap.forEach((deptId, tenures) -> {
|
HrmEmployeeStatisticsRespVO.DeptTenureVO deptVO = new HrmEmployeeStatisticsRespVO.DeptTenureVO();
|
deptVO.setDeptId(deptId == 0L ? null : deptId);
|
deptVO.setDeptName(deptNameMap.get(deptId));
|
deptVO.setCount(tenures.size());
|
deptVO.setAverageTenureYears(averageOf(tenures));
|
deptTenureList.add(deptVO);
|
});
|
deptTenureList.sort(Comparator.comparing(HrmEmployeeStatisticsRespVO.DeptTenureVO::getAverageTenureYears,
|
Comparator.nullsLast(Comparator.reverseOrder())));
|
respVO.setDeptTenureList(deptTenureList);
|
|
// 6.1 部门人数分布（与部门工龄同一份分组，直接复用）
|
Map<String, Integer> deptCountMap = new LinkedHashMap<>();
|
deptTenureMap.forEach((deptId, tenures) -> deptCountMap.put(deptNameMap.get(deptId), tenures.size()));
|
respVO.setDeptDistribution(toItemListSorted(deptCountMap));
|
|
// 7. 工龄排行（前 10 名）
|
respVO.setTopTenureEmployees(activeEmployees.stream()
|
.filter(e -> e.getHireDate() != null)
|
.sorted(Comparator.comparing(HrmEmployeeDO::getHireDate))
|
.limit(10)
|
.map(e -> {
|
HrmEmployeeStatisticsRespVO.TenureEmployeeVO employeeVO = new HrmEmployeeStatisticsRespVO.TenureEmployeeVO();
|
employeeVO.setId(e.getId());
|
employeeVO.setName(e.getName());
|
DeptRespDTO dept = e.getDeptId() == null ? null : deptMap.get(e.getDeptId());
|
employeeVO.setDeptName(dept != null ? dept.getName() : (e.getDeptId() == null ? "未分配部门" : "部门ID=" + e.getDeptId()));
|
employeeVO.setHireDate(e.getHireDate());
|
employeeVO.setTenureYears(calculateTenureYears(e, today));
|
return employeeVO;
|
})
|
.collect(Collectors.toList()));
|
|
// 8. 人员状态构成（在职 / 试用 / 离职，其余状态归入“其它”）
|
int activeStatusCount = (int) activeEmployees.stream()
|
.filter(e -> Objects.equals(e.getEmployeeStatus(), EMPLOYEE_STATUS_ACTIVE)).count();
|
int probationStatusCount = (int) activeEmployees.stream()
|
.filter(e -> Objects.equals(e.getEmployeeStatus(), EMPLOYEE_STATUS_PROBATION)).count();
|
int resignedStatusCount = (int) allEmployees.stream()
|
.filter(e -> Objects.equals(e.getEmployeeStatus(), EMPLOYEE_STATUS_RESIGNED)).count();
|
List<HrmEmployeeStatisticsRespVO.ItemVO> statusDistribution = new ArrayList<>();
|
statusDistribution.add(new HrmEmployeeStatisticsRespVO.ItemVO("在职", activeStatusCount));
|
statusDistribution.add(new HrmEmployeeStatisticsRespVO.ItemVO("试用", probationStatusCount));
|
statusDistribution.add(new HrmEmployeeStatisticsRespVO.ItemVO("离职", resignedStatusCount));
|
int otherStatusCount = allEmployees.size() - activeStatusCount - probationStatusCount - resignedStatusCount;
|
if (otherStatusCount > 0) {
|
statusDistribution.add(new HrmEmployeeStatisticsRespVO.ItemVO("其它", otherStatusCount));
|
}
|
respVO.setStatusDistribution(statusDistribution);
|
|
// 9. 岗位分布（postIds 为 JSON 数组，可一人多岗；无岗位归入“未分配岗位”）
|
Set<Long> postIds = new HashSet<>();
|
for (HrmEmployeeDO employee : activeEmployees) {
|
if (StrUtil.isNotBlank(employee.getPostIds())) {
|
postIds.addAll(JSONUtil.toList(employee.getPostIds(), Long.class));
|
}
|
}
|
Map<Long, PostRespDTO> postMap = CollUtil.isEmpty(postIds) ? Collections.emptyMap() : postApi.getPostMap(postIds);
|
Map<String, Integer> postCountMap = new LinkedHashMap<>();
|
for (HrmEmployeeDO employee : activeEmployees) {
|
List<Long> employeePostIds = StrUtil.isNotBlank(employee.getPostIds())
|
? JSONUtil.toList(employee.getPostIds(), Long.class) : Collections.emptyList();
|
if (CollUtil.isEmpty(employeePostIds)) {
|
postCountMap.merge("未分配岗位", 1, Integer::sum);
|
continue;
|
}
|
for (Long postId : employeePostIds) {
|
PostRespDTO post = postMap.get(postId);
|
postCountMap.merge(post != null ? post.getName() : "岗位ID=" + postId, 1, Integer::sum);
|
}
|
}
|
respVO.setPostDistribution(toItemListSorted(postCountMap));
|
|
// 10. 婚姻状况、政治面貌分布（档案自由文本，空值归入“未填写”）
|
Map<String, Integer> marriageMap = new LinkedHashMap<>();
|
Map<String, Integer> politicalMap = new LinkedHashMap<>();
|
for (HrmEmployeeDO employee : activeEmployees) {
|
marriageMap.merge(StrUtil.blankToDefault(StrUtil.trim(employee.getMarriageStatus()), "未填写"), 1, Integer::sum);
|
politicalMap.merge(StrUtil.blankToDefault(StrUtil.trim(employee.getPoliticalStatus()), "未填写"), 1, Integer::sum);
|
}
|
respVO.setMarriageDistribution(toItemListSorted(marriageMap));
|
respVO.setPoliticalDistribution(toItemListSorted(politicalMap));
|
|
// 11. 近 12 个月入职 / 离职趋势（含本月）
|
Map<YearMonth, Integer> hireMonthMap = new LinkedHashMap<>();
|
Map<YearMonth, Integer> resignMonthMap = new LinkedHashMap<>();
|
allEmployees.forEach(e -> {
|
if (e.getHireDate() != null) {
|
hireMonthMap.merge(YearMonth.from(e.getHireDate()), 1, Integer::sum);
|
}
|
if (e.getLeaveDate() != null) {
|
resignMonthMap.merge(YearMonth.from(e.getLeaveDate()), 1, Integer::sum);
|
}
|
});
|
List<HrmEmployeeStatisticsRespVO.TrendVO> trendList = new ArrayList<>();
|
YearMonth startMonth = YearMonth.from(today).minusMonths(11);
|
for (int i = 0; i < 12; i++) {
|
YearMonth month = startMonth.plusMonths(i);
|
HrmEmployeeStatisticsRespVO.TrendVO trendVO = new HrmEmployeeStatisticsRespVO.TrendVO();
|
trendVO.setMonth(month.toString());
|
trendVO.setHireCount(hireMonthMap.getOrDefault(month, 0));
|
trendVO.setResignCount(resignMonthMap.getOrDefault(month, 0));
|
trendList.add(trendVO);
|
}
|
respVO.setHireResignTrend(trendList);
|
|
// 12. 合同到期预警（只看在岗员工的当前生效合同）
|
Set<Long> activeEmployeeIds = activeEmployees.stream()
|
.map(HrmEmployeeDO::getId)
|
.collect(Collectors.toSet());
|
Map<Long, HrmEmployeeContractDO> currentContractMap = contractMapper.selectList().stream()
|
.filter(c -> Boolean.TRUE.equals(c.getIsCurrent()))
|
.filter(c -> c.getTerminateStatus() == null || c.getTerminateStatus() == 0)
|
.filter(c -> activeEmployeeIds.contains(c.getEmployeeId()))
|
.collect(Collectors.toMap(HrmEmployeeContractDO::getEmployeeId, c -> c, (a, b) -> a));
|
int expiredCount = 0;
|
int expireIn30Count = 0;
|
int expireIn90Count = 0;
|
int expireOver90Count = 0;
|
int unlimitedCount = 0;
|
for (HrmEmployeeContractDO contract : currentContractMap.values()) {
|
if (contract.getEndDate() == null) {
|
unlimitedCount++;
|
continue;
|
}
|
long days = ChronoUnit.DAYS.between(today, contract.getEndDate());
|
if (days < 0) {
|
expiredCount++;
|
} else if (days <= 30) {
|
expireIn30Count++;
|
} else if (days <= 90) {
|
expireIn90Count++;
|
} else {
|
expireOver90Count++;
|
}
|
}
|
List<HrmEmployeeStatisticsRespVO.ItemVO> contractWarning = new ArrayList<>();
|
contractWarning.add(new HrmEmployeeStatisticsRespVO.ItemVO("已到期", expiredCount));
|
contractWarning.add(new HrmEmployeeStatisticsRespVO.ItemVO("30天内到期", expireIn30Count));
|
contractWarning.add(new HrmEmployeeStatisticsRespVO.ItemVO("31-90天到期", expireIn90Count));
|
contractWarning.add(new HrmEmployeeStatisticsRespVO.ItemVO("90天以上", expireOver90Count));
|
contractWarning.add(new HrmEmployeeStatisticsRespVO.ItemVO("无固定期限", unlimitedCount));
|
respVO.setContractWarning(contractWarning);
|
respVO.setNoContractCount(Math.max(0, activeEmployeeIds.size() - currentContractMap.size()));
|
|
return respVO;
|
}
|
|
/**
|
* 计算工龄（年，保留 1 位小数）；离职员工按离职日期计算，无入职日期返回 null
|
*/
|
private Double calculateTenureYears(HrmEmployeeDO employee, LocalDate today) {
|
if (employee.getHireDate() == null) {
|
return null;
|
}
|
LocalDate endDate = employee.getLeaveDate() != null ? employee.getLeaveDate() : today;
|
if (endDate.isBefore(employee.getHireDate())) {
|
return 0D;
|
}
|
double years = ChronoUnit.DAYS.between(employee.getHireDate(), endDate) / 365.25D;
|
return Math.round(years * 10D) / 10D;
|
}
|
|
/**
|
* 解析年龄：优先取档案年龄，缺失时用出生日期推算
|
*/
|
private Integer resolveAge(HrmEmployeeDO employee, LocalDate today) {
|
if (employee.getAge() != null && employee.getAge() > 0) {
|
return employee.getAge();
|
}
|
if (employee.getBirthday() == null) {
|
return null;
|
}
|
return (int) ChronoUnit.YEARS.between(employee.getBirthday(), today);
|
}
|
|
private int resolveTenureBucket(double tenure) {
|
for (int i = TENURE_BUCKET_MIN.length - 1; i >= 0; i--) {
|
if (tenure >= TENURE_BUCKET_MIN[i]) {
|
return i;
|
}
|
}
|
return 0;
|
}
|
|
private int resolveAgeBucket(int age) {
|
for (int i = AGE_BUCKET_MIN.length - 1; i >= 0; i--) {
|
if (age >= AGE_BUCKET_MIN[i]) {
|
return i;
|
}
|
}
|
return 0;
|
}
|
|
private List<HrmEmployeeStatisticsRespVO.ItemVO> toItemListSorted(Map<String, Integer> countMap) {
|
return countMap.entrySet().stream()
|
.sorted(Map.Entry.<String, Integer>comparingByValue().reversed())
|
.map(entry -> new HrmEmployeeStatisticsRespVO.ItemVO(entry.getKey(), entry.getValue()))
|
.collect(Collectors.toList());
|
}
|
|
private Double averageOf(List<Double> values) {
|
if (CollUtil.isEmpty(values)) {
|
return 0D;
|
}
|
double sum = values.stream().mapToDouble(Double::doubleValue).sum();
|
return Math.round(sum / values.size() * 10D) / 10D;
|
}
|
|
private Double averageOfInt(List<Integer> values) {
|
if (CollUtil.isEmpty(values)) {
|
return 0D;
|
}
|
double sum = values.stream().mapToInt(Integer::intValue).sum();
|
return Math.round(sum / values.size() * 10D) / 10D;
|
}
|
|
}
|
