package com.qianwen.smartman.modules.cps.service.impl;
|
|
import cn.hutool.core.util.StrUtil;
|
import com.alibaba.excel.write.merge.AbstractMergeStrategy;
|
import com.baomidou.mybatisplus.core.conditions.Wrapper;
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
|
import com.baomidou.mybatisplus.core.metadata.IPage;
|
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
|
import com.baomidou.mybatisplus.core.toolkit.support.SFunction;
|
import com.google.common.collect.Lists;
|
import java.lang.invoke.SerializedLambda;
|
import java.util.ArrayList;
|
import java.util.Arrays;
|
import java.util.HashMap;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Objects;
|
import java.util.function.Function;
|
import java.util.stream.Collectors;
|
import org.slf4j.Logger;
|
import org.slf4j.LoggerFactory;
|
import com.qianwen.smartman.common.cache.DictCache;
|
import com.qianwen.smartman.common.cache.RegionCache;
|
import com.qianwen.smartman.common.cache.SysCache;
|
import com.qianwen.smartman.common.constant.CommonConstant;
|
import com.qianwen.smartman.common.constant.CommonGroupConstant;
|
import com.qianwen.smartman.common.constant.DateConstant;
|
import com.qianwen.smartman.common.constant.ExcelConstant;
|
import com.qianwen.smartman.common.enums.CommonGroupTypeEnum;
|
import com.qianwen.smartman.common.enums.DictEnum;
|
import com.qianwen.smartman.common.enums.StatusType;
|
import com.qianwen.smartman.common.utils.ExtraLambdaQueryWrapper;
|
import com.qianwen.smartman.common.utils.Lambda;
|
import com.qianwen.smartman.common.utils.MessageUtils;
|
import com.qianwen.smartman.common.utils.TreeUtils;
|
import com.qianwen.smartman.common.utils.ValidatorUtils;
|
import com.qianwen.core.excel.util.ExcelUtil;
|
import com.qianwen.core.log.exception.ServiceException;
|
import com.qianwen.core.mp.base.BaseServiceImpl;
|
import com.qianwen.core.oss.model.BladeFile;
|
import com.qianwen.core.secure.utils.AuthUtil;
|
import com.qianwen.core.tool.utils.DateUtil;
|
import com.qianwen.core.tool.utils.Func;
|
import com.qianwen.smartman.modules.cps.convert.EmployeeConvert;
|
import com.qianwen.smartman.modules.cps.dto.EmployeeDTO;
|
import com.qianwen.smartman.modules.cps.dto.EmployeeNameDTO;
|
import com.qianwen.smartman.modules.cps.entity.CommonGroup;
|
import com.qianwen.smartman.modules.cps.entity.CommonGroupOfItem;
|
import com.qianwen.smartman.modules.cps.entity.Employee;
|
import com.qianwen.smartman.modules.cps.entity.EmployeePost;
|
import com.qianwen.smartman.modules.cps.excel.EmployeeImport;
|
import com.qianwen.smartman.modules.cps.mapper.EmployeeMapper;
|
import com.qianwen.smartman.modules.cps.service.ICommonGroupOfItemService;
|
import com.qianwen.smartman.modules.cps.service.ICommonGroupService;
|
import com.qianwen.smartman.modules.cps.service.IEmployeePostService;
|
import com.qianwen.smartman.modules.cps.service.IEmployeeService;
|
import com.qianwen.smartman.modules.cps.vo.CommonGroupTypeVO;
|
import com.qianwen.smartman.modules.cps.vo.EmployeeSelectVO;
|
import com.qianwen.smartman.modules.cps.vo.EmployeeSubmitVO;
|
import com.qianwen.smartman.modules.cps.vo.EmployeeUpdatePartVO;
|
import com.qianwen.smartman.modules.cps.vo.EmployeeVO;
|
import com.qianwen.smartman.modules.cps.vo.GroupTreeVO;
|
import com.qianwen.smartman.modules.cps.vo.HierarchyVO;
|
import com.qianwen.smartman.modules.notify.dto.NotifyUserDTO;
|
import com.qianwen.smartman.modules.resource.builder.oss.OssBuilder;
|
import com.qianwen.smartman.modules.system.entity.Post;
|
import com.qianwen.smartman.modules.system.service.ICodeGeneratorService;
|
import com.qianwen.smartman.modules.system.service.IPostService;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.web.multipart.MultipartFile;
|
|
@Service
|
/* loaded from: blade-api.jar:BOOT-INF/classes/org/springblade/modules/cps/service/impl/EmployeeServiceImpl.class */
|
public class EmployeeServiceImpl extends BaseServiceImpl<EmployeeMapper, Employee> implements IEmployeeService {
|
private static final Logger log = LoggerFactory.getLogger(EmployeeServiceImpl.class);
|
private final ICommonGroupService commonGroupService;
|
private final ICommonGroupOfItemService commonGroupOfItemService;
|
private final IEmployeePostService employeePostService;
|
private final OssBuilder ossBuilder;
|
private final ICodeGeneratorService codeGeneratorService;
|
private final IPostService postService;
|
|
|
public EmployeeServiceImpl(final ICommonGroupService commonGroupService, final ICommonGroupOfItemService commonGroupOfItemService, final IEmployeePostService employeePostService, final OssBuilder ossBuilder, final ICodeGeneratorService codeGeneratorService, final IPostService postService) {
|
this.commonGroupService = commonGroupService;
|
this.commonGroupOfItemService = commonGroupOfItemService;
|
this.employeePostService = employeePostService;
|
this.ossBuilder = ossBuilder;
|
this.codeGeneratorService = codeGeneratorService;
|
this.postService = postService;
|
}
|
|
@Override // org.springblade.modules.cps.service.IEmployeeService
|
@Transactional(rollbackFor = {Exception.class})
|
public EmployeeVO submit(EmployeeSubmitVO employeeSubmitVO) {
|
if (Func.isEmpty(employeeSubmitVO.getOrganizationId())) {
|
Long rootNodeId = this.commonGroupService.getRootNodeId(CommonGroupTypeEnum.ORGANIZATION.getName(), CommonGroupConstant.DEFAULT_CATEGORY);
|
employeeSubmitVO.setOrganizationId(rootNodeId + "");
|
}
|
Boolean update = Func.isEmpty(employeeSubmitVO.getId()) ? Boolean.FALSE : Boolean.TRUE;
|
checkEmployee(update, employeeSubmitVO);
|
checkUnable(employeeSubmitVO);
|
validMobile(employeeSubmitVO, update, Boolean.TRUE);
|
Employee employee = EmployeeConvert.INSTANCE.convert(employeeSubmitVO);
|
saveOrUpdate(employee);
|
submitEmployeeOrganization(update, employee.getId(), employeeSubmitVO.getOrganizationId());
|
submitEmployeePost(update, employee.getId(), employeeSubmitVO.getPostId());
|
return EmployeeConvert.INSTANCE.convert(employee);
|
}
|
|
private void validMobile(EmployeeSubmitVO employeeSubmitVO, Boolean isUpdate, Boolean isMobile) {
|
SFunction<Employee, String> column = isMobile.booleanValue() ? (v0) -> {
|
return v0.getTel();
|
} : (v0) -> {
|
return v0.getEmail();
|
};
|
String conditionValue = isMobile.booleanValue() ? employeeSubmitVO.getTel() : employeeSubmitVO.getEmail();
|
|
LambdaQueryWrapper<Employee> wrapper = Wrappers.<Employee>lambdaQuery().eq(column, conditionValue).ne(isUpdate.booleanValue(), Employee::getId, employeeSubmitVO.getId());
|
|
Employee employee = (Employee) getOne(wrapper, false);
|
if (!Objects.isNull(employee)) {
|
String message = MessageUtils.message("cps.employee.mobile.already.exists", new Object[0]);
|
Object[] objArr = new Object[2];
|
objArr[0] = isMobile.booleanValue() ? employeeSubmitVO.getTel() : employeeSubmitVO.getEmail();
|
objArr[1] = employee.getName();
|
throw new ServiceException(StrUtil.format(message, objArr));
|
}
|
}
|
|
private void checkUnable(EmployeeSubmitVO employeeSubmitVO) {
|
Employee employee = (Employee)getOne(Lambda.<Employee>create()
|
.eq(Employee::getJobNumber, employeeSubmitVO.getJobNumber())
|
.ne(Func.isNotEmpty(employeeSubmitVO.getId()), Employee::getId, employeeSubmitVO.getId())
|
.eq(Employee::getStatus, CommonConstant.DEACTIVATE)
|
.limit());/*
|
Employee employee = (Employee) getOne(((ExtraLambdaQueryWrapper) ((ExtraLambdaQueryWrapper) Lambda.create().eq((v0) -> {
|
return v0.getJobNumber();
|
}, employeeSubmitVO.getJobNumber())).ne(Func.isNotEmpty(employeeSubmitVO.getId()), (v0) -> {
|
return v0.getId();
|
}, employeeSubmitVO.getId()).eq((v0) -> {
|
return v0.getStatus();
|
}, CommonConstant.DEACTIVATE)).limit());*/
|
if (employee != null) {
|
throw new ServiceException(MessageUtils.message("cps.employee.name.exist.same.stop", new Object[0]));
|
}
|
}
|
|
private void checkEmployee(Boolean update, EmployeeSubmitVO employeeSubmitVO) {
|
if (Func.isNotEmpty(employeeSubmitVO.getJobNumber())) {
|
Employee employee = getOne(Lambda.<Employee>create()
|
.eq(Employee::getJobNumber, employeeSubmitVO.getJobNumber())
|
.ne(update.booleanValue(), Employee::getId, employeeSubmitVO.getId())
|
.eq(Employee::getStatus, CommonConstant.ENABLE)
|
.limit());
|
/*
|
Employee employee = (Employee) getOne(((ExtraLambdaQueryWrapper) ((ExtraLambdaQueryWrapper) Lambda.create().eq((v0) -> {
|
return v0.getJobNumber();
|
}, employeeSubmitVO.getJobNumber())).ne(update.booleanValue(), (v0) -> {
|
return v0.getId();
|
}, employeeSubmitVO.getId()).eq((v0) -> {
|
return v0.getStatus();
|
}, CommonConstant.ENABLE)).limit());
|
*/
|
if (Func.isNotEmpty(employee)) {
|
throw new ServiceException(MessageUtils.message("cps.employee.job.number.already.exists", new Object[0]));
|
}
|
}
|
}
|
|
private void validCode(String code, Long id) {
|
Employee employee = getOne(Lambda.<Employee>create()
|
.eq(Employee::getCode, code)
|
.ne(Func.isNotEmpty(id), Employee::getId, id)
|
.eq(Employee::getStatus, CommonConstant.ENABLE)
|
.limit());
|
/*
|
Employee employee = (Employee) getOne(((ExtraLambdaQueryWrapper) ((ExtraLambdaQueryWrapper) Lambda.create().eq((v0) -> {
|
return v0.getCode();
|
}, code)).ne(Func.isNotEmpty(id), (v0) -> {
|
return v0.getId();
|
}, id).eq((v0) -> {
|
return v0.getStatus();
|
}, CommonConstant.ENABLE)).limit());*/
|
if (Func.isNotEmpty(employee)) {
|
throw new ServiceException(MessageUtils.message("cps.employee.code.already.exists", new Object[0]));
|
}
|
}
|
|
@Override // org.springblade.modules.cps.service.IEmployeeService
|
public IPage<EmployeeDTO> selectEmployeePage(IPage<EmployeeDTO> page, EmployeeSelectVO employeeSelectVO) {
|
List<Long> organizationIdList = this.commonGroupService.getCommonGroupChildIds(employeeSelectVO.getOrganizationCode(), CommonGroupTypeEnum.ORGANIZATION.getName(), CommonGroupConstant.DEFAULT_CATEGORY);
|
return page.setRecords(((EmployeeMapper) this.baseMapper).selectEmployeePage(page, employeeSelectVO, organizationIdList));
|
}
|
|
@Override // org.springblade.modules.cps.service.IEmployeeService
|
@Transactional(rollbackFor = {Exception.class})
|
public BladeFile importEmployee(List<EmployeeImport> data, String organizationCode) {
|
if (Func.isEmpty(data)) {
|
throw new ServiceException(MessageUtils.message("excel.import.data.can.not.be.null", new Object[0]));
|
}
|
if (data.size() > 200) {
|
throw new ServiceException(MessageUtils.message("excel.import.size.failed", new Object[0]));
|
}
|
HashMap<String, Long> commonGroupNameMap = this.commonGroupService.getCommonGroupNameMap(organizationCode, CommonGroupTypeEnum.ORGANIZATION.getName(), CommonGroupConstant.DEFAULT_CATEGORY);
|
HashMap<String, Long> commonGroupNameStatusMap = this.commonGroupService.getCommonGroupNameMap(organizationCode, CommonGroupTypeEnum.ORGANIZATION.getName(), CommonGroupConstant.DEFAULT_CATEGORY, CommonConstant.ENABLE);
|
HashMap<String, Object> jobNumberMap = new HashMap<>(16);
|
HashMap<String, Object> telMap = new HashMap<>(16);
|
|
List<Employee> employeeList = list(Wrappers.<Employee>lambdaQuery().eq(Employee::getStatus, CommonConstant.ENABLE));
|
/*
|
List<Employee> employeeList = list((Wrapper) Wrappers.lambdaQuery().eq((v0) -> {
|
return v0.getStatus();
|
}, CommonConstant.ENABLE));*/
|
if (Func.isNotEmpty(employeeList)) {
|
employeeList.forEach(x -> {
|
jobNumberMap.put(x.getJobNumber(), null);
|
telMap.put(x.getTel(), null);
|
});
|
}
|
Boolean flag = Boolean.TRUE;
|
for (EmployeeImport datum : data) {
|
checkImportEmployee(datum, commonGroupNameMap, jobNumberMap, telMap, commonGroupNameStatusMap);
|
if (Func.isNotEmpty(datum.getFailReason())) {
|
flag = Boolean.FALSE;
|
}
|
}
|
if (!flag.booleanValue()) {
|
MultipartFile multipartFile = ExcelUtil.exportFillTemplateToMultipartFile(ExcelConstant.DIRECTORY + "employeeFailTemplate" + ExcelConstant.SUFFIX, MessageUtils.message("excel.import.failed.report.name", new Object[0]) + ExcelConstant.SUFFIX, "员工信息表", (List) data.stream().filter(x2 -> {
|
return Func.isNotEmpty(x2.getFailReason());
|
}).collect(Collectors.toList()), (Object) null, (AbstractMergeStrategy) null);
|
BladeFile bladeFile = this.ossBuilder.tempTemplate().putFile(multipartFile.getOriginalFilename(), multipartFile);
|
return bladeFile;
|
}
|
data.forEach(x3 -> {
|
Employee employee = EmployeeConvert.INSTANCE.convert(x3);
|
saveImportEmployee(employee);
|
});
|
return null;
|
}
|
|
@Override // org.springblade.modules.cps.service.IEmployeeService
|
@Transactional(rollbackFor = {Exception.class})
|
public Boolean changeOrganization(List<Long> employeeIds, Long organizationId) {
|
if (Func.isEmpty(organizationId)) {
|
organizationId = this.commonGroupService.getRootNodeId(CommonGroupTypeEnum.ORGANIZATION.getName(), CommonGroupConstant.DEFAULT_CATEGORY);
|
}
|
List<Employee> employeeList = new ArrayList<>();
|
List<CommonGroupOfItem> commonGroupOfItemList = new ArrayList<>();
|
for (Long employeeId : employeeIds) {
|
Employee employee = new Employee();
|
employee.setId(employeeId);
|
employee.setOrganizationId(organizationId.toString());
|
employeeList.add(employee);
|
CommonGroupOfItem commonGroupOfItem = new CommonGroupOfItem(organizationId, employeeId, CommonGroupTypeEnum.ORGANIZATION.getName(), CommonGroupConstant.DEFAULT_CATEGORY);
|
commonGroupOfItemList.add(commonGroupOfItem);
|
}
|
updateBatchById(employeeList);
|
|
this.commonGroupOfItemService.remove(Wrappers.<CommonGroupOfItem>query().lambda()
|
.in(CommonGroupOfItem::getItemId, employeeIds));
|
|
/*
|
this.commonGroupOfItemService.remove((Wrapper) Wrappers.query().lambda().in((v0) -> {
|
return v0.getItemId();
|
}, employeeIds));*/
|
this.commonGroupOfItemService.saveBatch(commonGroupOfItemList);
|
return Boolean.TRUE;
|
}
|
|
@Override // org.springblade.modules.cps.service.IEmployeeService
|
public Boolean changeUserId(Long employeeId, Long oldEmployeeId, Long userId) {
|
update(Wrappers.<Employee>lambdaUpdate().set(Employee::getUserId, null).eq(Employee::getId, oldEmployeeId));
|
/*
|
update((Wrapper) ((LambdaUpdateWrapper) Wrappers.lambdaUpdate().set((v0) -> {
|
return v0.getUserId();
|
}, (Object) null)).eq((v0) -> {
|
return v0.getId();
|
}, oldEmployeeId));*/
|
if (Func.isNotEmpty(employeeId)) {
|
return Boolean.valueOf(update(Wrappers.<Employee>lambdaUpdate().set(Employee::getUserId, userId).eq(Employee::getId, employeeId)));
|
/*
|
return Boolean.valueOf(update((Wrapper) ((LambdaUpdateWrapper) Wrappers.lambdaUpdate().set((v0) -> {
|
return v0.getUserId();
|
}, userId)).eq((v0) -> {
|
return v0.getId();
|
}, employeeId)));*/
|
}
|
return true;
|
}
|
|
@Override // org.springblade.modules.cps.service.IEmployeeService
|
public Boolean updateUserIdIsNull(List<String> userIdList) {
|
|
return Boolean.valueOf(update(Wrappers.<Employee>lambdaUpdate().set(Employee::getUserId, null).in(Employee::getUserId, userIdList)));
|
/*
|
return Boolean.valueOf(update((Wrapper) ((LambdaUpdateWrapper) Wrappers.lambdaUpdate().set((v0) -> {
|
return v0.getUserId();
|
}, (Object) null)).in((v0) -> {
|
return v0.getUserId();
|
}, userIdList)));*/
|
}
|
|
@Override // org.springblade.modules.cps.service.IEmployeeService
|
public Boolean checkUserIsBindEmployee(String userIds) {
|
long count = count(Wrappers.<Employee>query().lambda()
|
.in(Employee::getUserId, Func.toLongList(userIds)));
|
/*
|
long count = count((Wrapper) Wrappers.query().lambda().in((v0) -> {
|
return v0.getUserId();
|
}, Func.toLongList(userIds)));
|
*/
|
return Boolean.valueOf(count > 0);
|
}
|
|
@Override // org.springblade.modules.cps.service.IEmployeeService
|
public List<GroupTreeVO> getUnbindEmployeeList(String employeeId) {
|
CommonGroupTypeVO commonGroupType = new CommonGroupTypeVO().setGroupType(CommonGroupTypeEnum.ORGANIZATION.getName()).setGroupCategory(CommonGroupConstant.DEFAULT_CATEGORY);
|
List<GroupTreeVO> list = ((EmployeeMapper) this.baseMapper).getUnbindEmployeeList(employeeId);
|
return TreeUtils.allGroupTree(commonGroupType, list);
|
}
|
|
@Override // org.springblade.modules.cps.service.IEmployeeService
|
public Employee getByUserId(Long userId) {
|
return (Employee)getOne(Wrappers.<Employee>query().lambda()
|
.eq(Employee::getUserId, userId));
|
/*
|
return (Employee) getOne((Wrapper) Wrappers.query().lambda().eq((v0) -> {
|
return v0.getUserId();
|
}, userId));*/
|
}
|
|
private void checkImportEmployee(EmployeeImport employeeImport, HashMap<String, Long> commonGroupNameMap, HashMap<String, Object> jobNumberMap, HashMap<String, Object> telMap, HashMap<String, Long> commonGroupNameStatusMap) {
|
Map<String, Employee> stopEmployeeMap = null;
|
|
List<Employee> list = list(Wrappers.<Employee>lambdaQuery().eq(Employee::getStatus, CommonConstant.DEACTIVATE));
|
/*
|
List<Employee> list = list((Wrapper) Wrappers.lambdaQuery().eq((v0) -> {
|
return v0.getStatus();
|
}, CommonConstant.DEACTIVATE));*/
|
if (Func.isNotEmpty(list)) {
|
stopEmployeeMap = list.stream().collect(Collectors.toMap((v0) -> {
|
return v0.getJobNumber();
|
}, Function.identity(), (k1, k2) -> {
|
return k1;
|
}));
|
}
|
if (Func.isEmpty(employeeImport.getJobNumber())) {
|
employeeImport.setFailReason(MessageUtils.message("cps.employee.job.number.can.not.be.null", new Object[0]));
|
return;
|
}
|
if (Func.isNotEmpty(employeeImport.getJobNumber()) && stopEmployeeMap != null) {
|
Employee employee = stopEmployeeMap.get(employeeImport.getJobNumber());
|
if (employee != null) {
|
employeeImport.setFailReason(MessageUtils.message("cps.employee.name.exist.same.stop", new Object[0]));
|
return;
|
}
|
}
|
if (ValidatorUtils.checkContextLength(employeeImport.getName())) {
|
employeeImport.setFailReason(MessageUtils.message("cps.employee.column.name.can.not.exceed", new Object[0]));
|
} else if (jobNumberMap.containsKey(employeeImport.getJobNumber())) {
|
employeeImport.setFailReason(MessageUtils.message("cps.employee.job.number.already.exists", new Object[0]));
|
} else {
|
jobNumberMap.put(employeeImport.getJobNumber(), null);
|
if (Func.isNotEmpty(employeeImport.getEmail()) && !ValidatorUtils.isEmail(employeeImport.getEmail())) {
|
employeeImport.setFailReason(MessageUtils.message("cps.employee.email.not.valid", new Object[0]));
|
} else if (Func.isEmpty(employeeImport.getTel())) {
|
employeeImport.setFailReason(MessageUtils.message("cps.employee.tel.number.can.not.be.null", new Object[0]));
|
} else if (!ValidatorUtils.isMobile(employeeImport.getTel())) {
|
employeeImport.setFailReason(MessageUtils.message("cps.employee.tel.number.not.valid", new Object[0]));
|
} else if (telMap.containsKey(employeeImport.getTel())) {
|
employeeImport.setFailReason(MessageUtils.message("cps.employee.tel.number.already.exists", new Object[0]));
|
} else {
|
telMap.put(employeeImport.getTel(), null);
|
if (Func.isEmpty(employeeImport.getStatusName())) {
|
employeeImport.setFailReason(MessageUtils.message("cps.employee.status.can.not.be.null", new Object[0]));
|
return;
|
}
|
String status = DictCache.getKey(DictEnum.EMPLOYEE_STATUS, employeeImport.getStatusName());
|
if (Func.isEmpty(status)) {
|
employeeImport.setFailReason(MessageUtils.message("cps.employee.status.is.not.exist", new Object[0]));
|
return;
|
}
|
employeeImport.setStatus(Integer.valueOf(Integer.parseInt(status)));
|
if (Func.isNotEmpty(employeeImport.getPostName())) {
|
Post post = this.postService.getOne(Lambda.<Post>create()
|
.eq(Post::getPostName, employeeImport.getPostName())
|
.eq(Post::getStatus, CommonConstant.DEACTIVATE)
|
.limit());
|
/*
|
Post post = (Post) this.postService.getOne(((ExtraLambdaQueryWrapper) ((ExtraLambdaQueryWrapper) Lambda.create().eq((v0) -> {
|
return v0.getPostName();
|
}, employeeImport.getPostName())).eq((v0) -> {
|
return v0.getStatus();
|
}, CommonConstant.DEACTIVATE)).limit());*/
|
if (post != null) {
|
employeeImport.setFailReason(MessageUtils.message("cps.post.name.already.exist.stop.status", new Object[0]));
|
return;
|
}
|
String postIds = SysCache.getPostIds(AuthUtil.getTenantId(), employeeImport.getPostName());
|
if (Func.isEmpty(postIds)) {
|
employeeImport.setFailReason(MessageUtils.message("cps.employee.post.is.not.exist", new Object[0]));
|
return;
|
}
|
employeeImport.setPostId(postIds);
|
}
|
if (Func.isNotEmpty(employeeImport.getOrganizationName())) {
|
String[] splitNames = employeeImport.getOrganizationName().split("-");
|
for (String name : splitNames) {
|
if (ValidatorUtils.checkContextLength(name)) {
|
employeeImport.setFailReason(MessageUtils.message("cps.employee.column.organization.can.not.exceed", new Object[0]));
|
return;
|
}
|
}
|
if (!commonGroupNameMap.containsKey(employeeImport.getOrganizationName())) {
|
employeeImport.setFailReason(MessageUtils.message("cps.employee.organization.is.not.exist", new Object[0]));
|
return;
|
} else if (!commonGroupNameStatusMap.containsKey(employeeImport.getOrganizationName())) {
|
employeeImport.setFailReason(MessageUtils.message("cps.organization.already.exist.stop.status", new Object[0]));
|
return;
|
} else {
|
employeeImport.setOrganizationId(commonGroupNameMap.get(employeeImport.getOrganizationName()).toString());
|
}
|
} else {
|
Long rootNodeId = this.commonGroupService.getRootNodeId(CommonGroupTypeEnum.ORGANIZATION.getName(), CommonGroupConstant.DEFAULT_CATEGORY);
|
employeeImport.setOrganizationId(rootNodeId + "");
|
}
|
if (Func.isNotEmpty(employeeImport.getStrHireDate())) {
|
try {
|
employeeImport.setHireDate(DateUtil.parse(employeeImport.getStrHireDate(), DateConstant.PATTERN_DATE));
|
} catch (Exception e) {
|
employeeImport.setFailReason(MessageUtils.message("cps.employee.hire.date.not.valid", new Object[0]));
|
return;
|
}
|
}
|
if (Func.isEmpty(employeeImport.getPinCode())) {
|
employeeImport.setFailReason(MessageUtils.message("cps.employee.pin.can.not.be.null", new Object[0]));
|
return;
|
}
|
int length = employeeImport.getPinCode().length();
|
if (!ValidatorUtils.isNumber(employeeImport.getPinCode()) || length < 4 || length > 6) {
|
employeeImport.setFailReason(MessageUtils.message("cps.employee.pin.not.valid", new Object[0]));
|
} else {
|
employeeImport.setPinCode(employeeImport.getPinCode());
|
}
|
}
|
}
|
}
|
|
private void saveImportEmployee(Employee employee) {
|
saveOrUpdate(employee);
|
submitEmployeeOrganization(Boolean.FALSE, employee.getId(), employee.getOrganizationId());
|
submitEmployeePost(Boolean.FALSE, employee.getId(), employee.getPostId());
|
}
|
|
private void submitEmployeeOrganization(Boolean update, Long employeeId, String organizationId) {
|
if (update.booleanValue()) {
|
this.commonGroupOfItemService.remove(Wrappers.<CommonGroupOfItem>lambdaQuery().eq(CommonGroupOfItem::getItemId, employeeId));
|
/*
|
this.commonGroupOfItemService.remove((Wrapper) Wrappers.lambdaQuery().eq((v0) -> {
|
return v0.getItemId();
|
}, employeeId));
|
*/
|
}
|
if (Func.isNotEmpty(organizationId)) {
|
List<Long> organizationIdList = Func.toLongList(organizationId);
|
List<CommonGroupOfItem> commonGroupOfItemList = new ArrayList<>();
|
organizationIdList.forEach(x -> {
|
CommonGroupOfItem commonGroupOfItem = new CommonGroupOfItem(x, employeeId, CommonGroupTypeEnum.ORGANIZATION.getName(), CommonGroupConstant.DEFAULT_CATEGORY);
|
commonGroupOfItemList.add(commonGroupOfItem);
|
});
|
this.commonGroupOfItemService.saveBatch(commonGroupOfItemList);
|
}
|
}
|
|
private void submitEmployeePost(Boolean update, Long employeeId, String postId) {
|
if (update.booleanValue()) {
|
this.employeePostService.remove(Wrappers.<EmployeePost>lambdaQuery().eq(EmployeePost::getEmployeeId, employeeId));
|
/*
|
this.employeePostService.remove((Wrapper) Wrappers.lambdaQuery().eq((v0) -> {
|
return v0.getEmployeeId();
|
}, employeeId));*/
|
}
|
if (Func.isNotEmpty(postId)) {
|
List<Long> postIdList = Func.toLongList(postId);
|
List<EmployeePost> employeePostList = new ArrayList<>();
|
postIdList.forEach(x -> {
|
EmployeePost employeePost = new EmployeePost();
|
employeePost.setEmployeeId(employeeId);
|
employeePost.setPostId(x);
|
employeePostList.add(employeePost);
|
});
|
this.employeePostService.saveBatch(employeePostList);
|
}
|
}
|
|
@Override // org.springblade.modules.cps.service.IEmployeeService
|
public List<NotifyUserDTO> getNotifySubscriberList(List<String> userIds) {
|
return (List<NotifyUserDTO>)list(Wrappers.<Employee>lambdaQuery().in(Employee::getId, userIds)
|
.select(Employee::getId, Employee::getTel, Employee::getEmail )).stream()
|
.map(user -> new NotifyUserDTO(user.getId(), user.getEmail(), user.getTel(), null))
|
.collect(Collectors.toList());
|
/*
|
return (List) list(((LambdaQueryWrapper) Wrappers.lambdaQuery().in((v0) -> {
|
return v0.getId();
|
}, userIds)).select(new SFunction[]{(v0) -> {
|
return v0.getId();
|
}, (v0) -> {
|
return v0.getTel();
|
}, (v0) -> {
|
return v0.getEmail();
|
}})).stream().map(user -> {
|
return new NotifyUserDTO(user.getId(), user.getEmail(), user.getTel(), null);
|
}).collect(Collectors.toList());*/
|
}
|
|
@Override // org.springblade.modules.cps.service.IEmployeeService
|
public Boolean removeEmployee(List<Long> ids, Integer type) {
|
if (StatusType.REMOVE.getType().equals(type)) {
|
return Boolean.valueOf(removeByIds(ids));
|
}
|
return Boolean.valueOf(changeStatus(ids, CommonConstant.DEACTIVATE));
|
}
|
|
@Override // org.springblade.modules.cps.service.IEmployeeService
|
public List<EmployeeDTO> selectEmployeeList(EmployeeSelectVO employeeSelectVO) {
|
List<Long> organizationIdList = this.commonGroupService.getCommonGroupChildIds(employeeSelectVO.getOrganizationCode(), CommonGroupTypeEnum.ORGANIZATION.getName(), CommonGroupConstant.DEFAULT_CATEGORY);
|
return ((EmployeeMapper) this.baseMapper).selectEmployeeList(employeeSelectVO, organizationIdList);
|
}
|
|
@Override // org.springblade.modules.cps.service.IEmployeeService
|
public List<Employee> listByOrgIds(List<Long> orgIds) {
|
if (Func.isNotEmpty(orgIds)) {
|
List<CommonGroupOfItem> list = this.commonGroupOfItemService.list(Wrappers.<CommonGroupOfItem>lambdaQuery().in(CommonGroupOfItem::getGroupId, orgIds).eq(CommonGroupOfItem::getGroupType, CommonGroupTypeEnum.ORGANIZATION.getName())
|
.eq(CommonGroupOfItem::getGroupCategory, CommonGroupConstant.DEFAULT_CATEGORY));
|
/*
|
List<CommonGroupOfItem> list = this.commonGroupOfItemService.list((Wrapper) ((LambdaQueryWrapper) ((LambdaQueryWrapper) Wrappers.lambdaQuery().in((v0) -> {
|
return v0.getGroupId();
|
}, orgIds)).eq((v0) -> {
|
return v0.getGroupType();
|
}, CommonGroupTypeEnum.ORGANIZATION.getName())).eq((v0) -> {
|
return v0.getGroupCategory();
|
}, CommonGroupConstant.DEFAULT_CATEGORY));*/
|
List<Long> empIds = list.stream().map((v0) -> {
|
return v0.getItemId();
|
}).collect(Collectors.toList());
|
return listByIds(empIds);
|
}
|
return new ArrayList();
|
}
|
|
@Override // org.springblade.modules.cps.service.IEmployeeService
|
public List<GroupTreeVO> tree() {
|
List<GroupTreeVO> treeList = Lists.newArrayList();
|
CommonGroupTypeVO commonGroupType = new CommonGroupTypeVO().setGroupType(CommonGroupTypeEnum.ORGANIZATION.getName()).setGroupCategory(CommonGroupConstant.DEFAULT_CATEGORY);
|
List<Employee> list = list(Wrappers.<Employee>lambdaQuery().eq(Employee::getStatus, CommonConstant.ENABLE)
|
.orderByDesc(Arrays.asList(Employee::getCreateTime, Employee::getId) ));
|
/*
|
List<Employee> list = list((Wrapper) ((LambdaQueryWrapper) Wrappers.lambdaQuery().eq((v0) -> {
|
return v0.getStatus();
|
}, CommonConstant.ENABLE)).orderByDesc((v0) -> {
|
return v0.getCreateTime();
|
}, new SFunction[]{(v0) -> {
|
return v0.getId();
|
}}));*/
|
list.forEach(x -> {
|
GroupTreeVO groupTree = EmployeeConvert.INSTANCE.convertToTree(x);
|
groupTree.setParentId(Long.valueOf(Func.toLong(x.getOrganizationId())));
|
groupTree.setIsGroup(Boolean.FALSE);
|
groupTree.setAvatar(x.getAvatar());
|
treeList.add(groupTree);
|
});
|
return TreeUtils.allGroupTree(commonGroupType, treeList);
|
}
|
|
@Override // org.springblade.modules.cps.service.IEmployeeService
|
public Boolean updatePart(EmployeeUpdatePartVO employeeUpdatePartVO) {
|
if (Func.isNotEmpty(employeeUpdatePartVO.getPinCode())) {
|
Employee employee = (Employee) getById(employeeUpdatePartVO.getId());
|
if (!employeeUpdatePartVO.getPinCode().equals(employee.getPinCode())) {
|
throw new ServiceException(MessageUtils.message("cps.employee.ori.pin.error", new Object[0]));
|
}
|
return Boolean.valueOf(update(Wrappers.<Employee>lambdaUpdate().set(Employee::getPinCode, employeeUpdatePartVO.getNewPinCode()).eq(Employee::getId, employeeUpdatePartVO.getId())));
|
/*
|
return Boolean.valueOf(update((Wrapper) ((LambdaUpdateWrapper) Wrappers.lambdaUpdate().set((v0) -> {
|
return v0.getPinCode();
|
}, employeeUpdatePartVO.getNewPinCode())).eq((v0) -> {
|
return v0.getId();
|
}, employeeUpdatePartVO.getId())));*/
|
} else if (Func.isNotEmpty(employeeUpdatePartVO.getJobNumber())) {
|
EmployeeSubmitVO employeeSubmitVO = new EmployeeSubmitVO();
|
employeeSubmitVO.setId(employeeUpdatePartVO.getId());
|
employeeSubmitVO.setJobNumber(employeeUpdatePartVO.getJobNumber());
|
checkEmployee(true, employeeSubmitVO);
|
checkUnable(employeeSubmitVO);
|
|
return Boolean.valueOf(update(Wrappers.<Employee>lambdaUpdate().set(Employee::getJobNumber, employeeUpdatePartVO.getJobNumber()).eq(Employee::getId, employeeUpdatePartVO.getId())));
|
/*
|
return Boolean.valueOf(update((Wrapper) ((LambdaUpdateWrapper) Wrappers.lambdaUpdate().set((v0) -> {
|
return v0.getJobNumber();
|
}, employeeUpdatePartVO.getJobNumber())).eq((v0) -> {
|
return v0.getId();
|
}, employeeUpdatePartVO.getId())));
|
*/
|
} else {
|
return false;
|
}
|
}
|
|
@Override // org.springblade.modules.cps.service.IEmployeeService
|
public EmployeeNameDTO getEmployeeNameMap() {
|
HashMap<String, Long> employeeNameMap = new HashMap<>(16);
|
HashMap<String, Long> repeatEmployeeNameMap = new HashMap<>(16);
|
|
List<Employee> list = list(Wrappers.<Employee>lambdaQuery().eq(Employee::getStatus, CommonConstant.ENABLE));
|
/*
|
List<Employee> list = list((Wrapper) Wrappers.lambdaQuery().eq((v0) -> {
|
return v0.getStatus();
|
}, CommonConstant.ENABLE));*/
|
list.forEach(x -> {
|
if (employeeNameMap.containsKey(x.getName())) {
|
repeatEmployeeNameMap.put(x.getName(), null);
|
}
|
employeeNameMap.putIfAbsent(x.getName(), x.getId());
|
});
|
EmployeeNameDTO result = new EmployeeNameDTO().setEmployeeNameMap(employeeNameMap).setRepeatEmployeeNameMap(repeatEmployeeNameMap);
|
return result;
|
}
|
|
@Override // org.springblade.modules.cps.service.IEmployeeService
|
public EmployeeVO currentEmployee(Long userId) {
|
Employee one = (Employee)getOne(Wrappers.<Employee>lambdaQuery().like(Employee::getUserId, userId));
|
/*
|
Employee one = (Employee) getOne((Wrapper) Wrappers.lambdaQuery().like((v0) -> {
|
return v0.getUserId();
|
}, userId));*/
|
return EmployeeConvert.INSTANCE.convert(one);
|
}
|
|
@Override // org.springblade.modules.cps.service.IEmployeeService
|
public HierarchyVO getEmployeeHierarchy(Long employeeId) {
|
HierarchyVO hierarchy = new HierarchyVO();
|
Employee employee = (Employee) getById(employeeId);
|
if (Func.isEmpty(employee)) {
|
return hierarchy;
|
}
|
List<Long> idList = Lists.newArrayList();
|
StringBuilder sb = new StringBuilder();
|
String organizationId = employee.getOrganizationId();
|
CommonGroup currentNode = (CommonGroup) this.commonGroupService.getById(organizationId);
|
List<String> codeList = getCodeHierarchyList(currentNode.getCode());
|
if (Func.isNotEmpty(codeList)) {
|
List<CommonGroup> list = this.commonGroupService.list(Wrappers.<CommonGroup>lambdaQuery().eq(CommonGroup::getGroupType, CommonGroupTypeEnum.ORGANIZATION.getName())
|
.eq(CommonGroup::getGroupCategory, CommonGroupConstant.DEFAULT_CATEGORY)
|
.in(CommonGroup::getCode, codeList)
|
.last("order by length(code)"));
|
/*
|
List<CommonGroup> list = this.commonGroupService.list((Wrapper) ((LambdaQueryWrapper) ((LambdaQueryWrapper) ((LambdaQueryWrapper) Wrappers.lambdaQuery().eq((v0) -> {
|
return v0.getGroupType();
|
}, CommonGroupTypeEnum.ORGANIZATION.getName())).eq((v0) -> {
|
return v0.getGroupCategory();
|
}, CommonGroupConstant.DEFAULT_CATEGORY)).in((v0) -> {
|
return v0.getCode();
|
}, codeList)).last("order by length(code)"));*/
|
list.forEach(x -> {
|
idList.add(x.getId());
|
sb.append(x.getName() + "/");
|
});
|
}
|
idList.add(currentNode.getId());
|
sb.append(currentNode.getName() + "/");
|
idList.add(employee.getId());
|
sb.append(employee.getName());
|
return hierarchy.setIdList(idList).setName(sb.toString());
|
}
|
|
private List<String> getCodeHierarchyList(String code) {
|
List<String> codeList = new ArrayList<>();
|
String[] codes = code.split("\\.");
|
for (int i = 0; i < codes.length - 1; i++) {
|
codeList.add(code.substring(0, 5 * (i + 1)));
|
}
|
return codeList;
|
}
|
}
|
