package doumeemes.service.ext.impl;
|
|
import com.baomidou.mybatisplus.core.conditions.Wrapper;
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
import com.github.pagehelper.PageHelper;
|
import com.github.pagehelper.PageInfo;
|
import doumeemes.core.constants.ResponseStatus;
|
import doumeemes.core.exception.BusinessException;
|
import doumeemes.core.model.LoginUserInfo;
|
import doumeemes.core.model.PageData;
|
import doumeemes.core.model.PageWrap;
|
import doumeemes.core.utils.Constants;
|
import doumeemes.core.utils.DateUtil;
|
import doumeemes.core.utils.dingding.DingDingSyncUtil;
|
import doumeemes.core.utils.dingding.bean.CompanyUserDTO;
|
import doumeemes.core.utils.redis.RedisUtil;
|
import doumeemes.dao.business.BackorderMapper;
|
import doumeemes.dao.business.model.*;
|
import doumeemes.dao.ext.*;
|
import doumeemes.dao.ext.dto.*;
|
import doumeemes.dao.ext.vo.CompanyExtListVO;
|
import doumeemes.dao.ext.vo.DepartmentExtListVO;
|
import doumeemes.dao.system.SystemDepartmentUserMapper;
|
import doumeemes.dao.system.SystemUserMapper;
|
import doumeemes.dao.system.model.SystemDepartmentUser;
|
import doumeemes.dao.system.model.SystemUser;
|
import doumeemes.service.ext.CompanyExtService;
|
import doumeemes.service.ext.DepartmentExtService;
|
import lombok.extern.slf4j.Slf4j;
|
import org.apache.commons.lang3.StringUtils;
|
import org.apache.shiro.SecurityUtils;
|
import org.springframework.beans.BeanUtils;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.data.redis.core.RedisTemplate;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.util.CollectionUtils;
|
|
import java.util.*;
|
import java.util.stream.Collectors;
|
|
/**
|
* 组织信息Service实现
|
* @author 江蹄蹄
|
* @date 2022/04/20 10:59
|
*/
|
@Slf4j
|
@Service
|
public class DepartmentExtServiceImpl implements DepartmentExtService {
|
|
@Autowired
|
private RedisTemplate<String, Object> redisTemplate;
|
|
@Autowired
|
private DepartmentExtMapper departmentExtMapper;
|
@Autowired
|
private SystemUserMapper systemUserMapper;
|
@Autowired
|
private CompanyPositionExtMapper companyPositionExtMapper;
|
@Autowired
|
private PlansExtMapper plansExtMapper;
|
@Autowired
|
private BackorderMapper backorderMapper;
|
@Autowired
|
private CompanyUserExtMapper companyUserExtMapper;
|
@Autowired
|
private WorkorderExtMapper workorderExtMapper;
|
@Autowired
|
private WorkorderCheckExtMapper workorderCheckExtMapper;
|
@Autowired
|
private WOutboundExtMapper wOutboundExtMapper;
|
@Autowired
|
private CompanyExtMapper companyExtMapper;
|
@Autowired
|
private CompanyExtService companyExtService;
|
@Autowired
|
private WTransferExtMapper wTransferExtMapper;
|
|
@Override
|
public PageData<DepartmentExtListVO> findPage(PageWrap<QueryDepartmentExtDTO> pageWrap) {
|
LoginUserInfo user = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
|
if(Constants.equalsInteger(user.getType(),Constants.USERTYPE.COM)){
|
//如果是企业级用户，只能看自己企业的部门数据
|
pageWrap.getModel().setType(Constants.DEPART_TYPE.com);
|
pageWrap.getModel().setRootId(user.getRootDepartment().getId());
|
}else{
|
pageWrap.getModel().setType(Constants.DEPART_TYPE.plat);
|
}
|
PageHelper.startPage(pageWrap.getPage(), pageWrap.getCapacity());
|
List<DepartmentExtListVO> result = departmentExtMapper.selectList(pageWrap.getModel());
|
return PageData.from(new PageInfo<>(result));
|
}
|
@Override
|
public DepartmentExtListVO treeComList(QueryDepartmentExtDTO pageWrap) {
|
LoginUserInfo user = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
|
if(Constants.equalsInteger(user.getType(),Constants.USERTYPE.COM)){
|
//如果是企业级用户，只能看自己企业的部门数据
|
DepartmentExtListVO treeList = RedisUtil.getObject(redisTemplate,Constants.RedisKeys.COM_DEPART_TREE_KEY+user.getCompany().getId(),DepartmentExtListVO.class);
|
return treeList;
|
}
|
return null;
|
}
|
|
@Override
|
public Integer create(Department department) {
|
// 用户信息
|
LoginUserInfo user = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
|
department.setCreateTime(DateUtil.getCurrentDate());
|
department.setDeleted(Constants.ZERO);
|
department.setCreateUser(user.getId());
|
department.setStatus(Constants.formatIntegerNum(department.getStatus()));
|
if(Constants.equalsInteger(user.getType(),Constants.USERTYPE.COM)){
|
//如果是企业级用户
|
if(department.getParentId() != null){
|
DepartmentExtListVO p = getModelById(user.getCompany().getId(),department.getParentId());
|
if(p==null){
|
throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(),"对不起，上级部门不存在");
|
}
|
if(p.getParentId()!= null && Constants.equalsInteger(department.getType(),Constants.DEPART_TYPE.com)){
|
throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(),"对不起，请选择正确的部门类型");
|
}
|
}else{
|
throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(),"对不起，请选择上级部门");
|
}
|
department.setCompanyId(user.getCompany().getId());
|
department.setRootId(user.getRootDepartment().getId());
|
}else {
|
department.setType(Constants.DEPART_TYPE.plat);
|
}
|
departmentExtMapper.insert(department);
|
if(Constants.equalsInteger(user.getType(),Constants.USERTYPE.COM)){
|
//更新缓存信息
|
loadComDepart(user.getCompany());
|
}
|
return department.getId();
|
}
|
|
@Override
|
public void deleteById(Integer id) {
|
LoginUserInfo user = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
|
if(Constants.equalsInteger(user.getType(),Constants.USERTYPE.COM)){
|
DepartmentExtListVO model =getModelById(user.getCompany().getId(),id) ;
|
if(model == null){
|
throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(), ResponseStatus.DATA_EMPTY.getMessage());
|
}
|
if(model.getParentId()==null){
|
//如果是根组织，不允许修改
|
throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(),"对不起，主组织不允许删除");
|
}
|
if(model.getChildren()!= null && model.getChildren().size()>0){
|
//如果有子部门，不允许修改
|
throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(),"对不起，子部门不为空，不能删除！");
|
}
|
CompanyUser cu = new CompanyUser();
|
cu.setDepartmentId(model.getId());
|
cu.setDeleted(Constants.ZERO);
|
if(companyUserExtMapper.selectCount(new QueryWrapper<>(cu))>0 ){
|
throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(),"对不起，部门下存在绑定员工，不能删除！");
|
}
|
}
|
|
Department department = new Department();
|
department.setId(id);
|
department.setDeleted(Constants.ONE);
|
departmentExtMapper.updateById(department);
|
if(Constants.equalsInteger(user.getType(),Constants.USERTYPE.COM)){
|
//更新缓存信息
|
loadComDepart(user.getCompany());
|
}
|
}
|
|
@Override
|
@Transactional
|
public void deleteByIdInBatch(List<Integer> ids) {
|
if (CollectionUtils.isEmpty(ids)) return;
|
LoginUserInfo user = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
|
for (Integer id : ids) {
|
if(Constants.equalsInteger(user.getType(),Constants.USERTYPE.COM) && getModelById(user.getCompany().getId(),id) ==null){
|
throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(), ResponseStatus.DATA_EMPTY.getMessage());
|
}
|
Department department = new Department();
|
department.setId(id);
|
department.setDeleted(Constants.ONE);
|
departmentExtMapper.updateById(department);
|
}
|
if(Constants.equalsInteger(user.getType(),Constants.USERTYPE.COM)){
|
//更新缓存信息
|
loadComDepart(user.getCompany());
|
}
|
}
|
|
@Override
|
public void updateById(Department department) {
|
// 用户信息
|
LoginUserInfo user = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
|
if(Constants.equalsInteger(user.getType(),Constants.USERTYPE.COM)){
|
DepartmentExtListVO model =getModelById(user.getCompany().getId(),department.getId()) ;
|
if(model == null){
|
throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(), ResponseStatus.DATA_EMPTY.getMessage());
|
}
|
if(model.getParentId()==null){
|
//如果是根组织，不允许修改
|
throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(),"对不起，主组织不允许修改");
|
}
|
if(department.getParentId()==null){
|
throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(),"对不起，请选择父级组织");
|
}
|
if(getModelById(user.getCompany().getId(),department.getParentId())==null){
|
throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(),"对不起，父级组织不存在");
|
}
|
}
|
department.setUpdateTime(DateUtil.getCurrentDate());
|
department.setUpdateUser(user.getId());
|
departmentExtMapper.updateById(department);
|
if(Constants.equalsInteger(user.getType(),Constants.USERTYPE.COM)){
|
//更新缓存信息
|
loadComDepart(user.getCompany());
|
}
|
}
|
|
@Override
|
@Transactional
|
public void updateByIdInBatch(List<Department> departments) {
|
if (CollectionUtils.isEmpty(departments)) return;
|
LoginUserInfo user = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
|
for (Department department: departments) {
|
if(Constants.equalsInteger(user.getType(),Constants.USERTYPE.COM) && getModelById(user.getCompany().getId(),department.getId()) ==null){
|
throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(), ResponseStatus.DATA_EMPTY.getMessage());
|
}
|
departmentExtMapper.updateById(department);
|
}
|
if(Constants.equalsInteger(user.getType(),Constants.USERTYPE.COM)){
|
//更新缓存信息
|
loadComDepart(user.getCompany());
|
}
|
}
|
|
@Override
|
public Department findById(Integer id) {
|
return departmentExtMapper.selectById(id);
|
}
|
|
@Override
|
public List<Department> findByIds(List<Integer> ids) {
|
if (CollectionUtils.isEmpty(ids)) {
|
return Collections.emptyList();
|
}
|
QueryWrapper<Department> queryWrapper = new QueryWrapper<>();
|
queryWrapper.lambda().in(Department::getId, ids).eq(Department::getDeleted, Boolean.FALSE);
|
return departmentExtMapper.selectList(queryWrapper);
|
}
|
|
@Override
|
public Department findOne(Department Department) {
|
Wrapper<Department> wrapper = new QueryWrapper<>(Department);
|
return departmentExtMapper.selectOne(wrapper);
|
}
|
|
@Override
|
public List<DepartmentExtListVO> findList(QueryDepartmentExtDTO dto) {
|
return departmentExtMapper.selectList(dto);
|
}
|
|
@Override
|
public long count(Department Department) {
|
Wrapper<Department> wrapper = new QueryWrapper<>(Department);
|
return departmentExtMapper.selectCount(wrapper);
|
}
|
@Override
|
public void changeCom(Integer id) {
|
LoginUserInfo user = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
|
if(Constants.equalsInteger(user.getType(),Constants.USERTYPE.COM)){
|
//如果是企业级用户，只能看自己企业的部门数据
|
List<Integer> pList = user.getDepartPermissionList();
|
boolean hasRole = false;
|
if(pList!=null && pList.size()>0){
|
for(Integer t : pList){
|
if(Constants.equalsInteger(t,id)){
|
hasRole = true;
|
break;
|
}
|
}
|
}else{
|
hasRole = true;
|
}
|
if(!hasRole){
|
throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(), "您没有权限切换到该部门");
|
}
|
//切换当前部门
|
DepartmentExtListVO d = getModelById(user.getCompany().getId(),id);
|
if(d==null || !Constants.equalsInteger(d.getType(),Constants.DEPART_TYPE.com)){
|
throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(), "对不起！只能切换到公司级部门！");
|
}
|
user.setCurComDepartment(d);
|
}
|
}
|
|
@Override
|
public List<Integer> findChildren(Integer departmentId) {
|
List<Integer> pool = new ArrayList<>();
|
this.fillChildren(pool, Arrays.asList(departmentId));
|
return pool;
|
}
|
|
@Override
|
public List<Integer> userDataPermissonList(DepartmentExtListVO depart ,boolean isleaf) {
|
List<Integer> pool = new ArrayList<>();
|
List<DepartmentExtListVO> departList = RedisUtil.getObject(redisTemplate,Constants.RedisKeys.COM_DEPART_LIST_KEY+depart.getCompanyId(),ArrayList.class);
|
pool.add(depart.getId());
|
this.fillDepartChildren(pool, Arrays.asList(depart.getId()),isleaf,departList);
|
return pool;
|
}
|
|
private void fillDepartChildren(List<Integer> pool, List<Integer> asList, boolean isleaf, List<DepartmentExtListVO> departList) {
|
List<DepartmentExtListVO> departments = getDepartListByParentIds(asList,departList);
|
List<Integer> ids = departments.stream().map(DepartmentExtListVO::getId).collect(Collectors.toList());
|
if(isleaf){
|
if (ids.size() > 0) {
|
pool.addAll(ids);
|
this.fillDepartChildren(pool, ids,isleaf,departList);
|
}
|
}else{
|
pool.addAll(ids);
|
}
|
|
}
|
|
private List<DepartmentExtListVO> getDepartListByParentIds(List<Integer> asList, List<DepartmentExtListVO> departList) {
|
List<DepartmentExtListVO> list = new ArrayList<>();
|
if(asList.size()>0){
|
for(Integer id : asList){
|
list.addAll(getDepartListByParentId(id,departList));
|
}
|
}
|
return list;
|
}
|
|
@Override
|
public DepartmentExtListVO getModelById(Integer comId,Integer id) {
|
List<DepartmentExtListVO> list = RedisUtil.getObject(redisTemplate,Constants.RedisKeys.COM_DEPART_LIST_KEY+comId,ArrayList.class);
|
if(list != null){
|
for(DepartmentExtListVO d : list){
|
if(Constants.equalsInteger(d.getId(),id)){
|
return d;
|
}
|
}
|
}
|
return null;
|
}
|
@Override
|
public DepartmentExtListVO getModelById(Integer comId,Integer id, List<DepartmentExtListVO> list ) {
|
if(list != null){
|
for(DepartmentExtListVO d : list){
|
if(Constants.equalsInteger(d.getId(),id)){
|
return d;
|
}
|
}
|
}
|
return null;
|
}
|
|
@Override
|
public DepartmentExtListVO getModelByName(Integer comId,String name) {
|
List<DepartmentExtListVO> list = RedisUtil.getObject(redisTemplate,Constants.RedisKeys.COM_DEPART_LIST_KEY+comId,ArrayList.class);
|
if(list != null){
|
for(DepartmentExtListVO d : list){
|
if(StringUtils.equals(name,d.getName())){
|
return d;
|
}
|
}
|
}
|
return null;
|
}
|
@Override
|
public DepartmentExtListVO getModelByComDepartAndName(Integer comId,Integer comDepartId,String name) {
|
List<DepartmentExtListVO> list = RedisUtil.getObject(redisTemplate,Constants.RedisKeys.COM_DEPART_LIST_KEY+comId,ArrayList.class);
|
if(list != null){
|
for(DepartmentExtListVO d : list){
|
if(StringUtils.equals(name,d.getName()) && Constants.equalsInteger(getComDepartId(d,list),comDepartId)){
|
return d;
|
}
|
}
|
}
|
return null;
|
}
|
@Override
|
public Integer getComDepartId(DepartmentExtListVO depart) {
|
//如果是根节点或者已经企业级部门
|
if(depart.getParentId() == null || Constants.equalsInteger(depart.getType(),Constants.DEPART_TYPE.com)){
|
return depart.getId();
|
}
|
//父级部门
|
DepartmentExtListVO d = getModelById(depart.getCompanyId(),depart.getParentId());
|
if(d == null){
|
return null;
|
}
|
if( Constants.equalsInteger(d.getType(),Constants.DEPART_TYPE.com)){
|
//如果父级是企业级部门，直接返回
|
return d.getId();
|
}else{
|
//如果父级不是企业级部门继续往上级查，直到查到父级几点
|
return getComDepartId(d);
|
}
|
}
|
@Override
|
public Integer getComDepartId(DepartmentExtListVO depart,List<DepartmentExtListVO> allDepartList) {
|
//如果是根节点或者已经企业级部门
|
if(depart.getParentId() == null || Constants.equalsInteger(depart.getType(),Constants.DEPART_TYPE.com)){
|
return depart.getId();
|
}
|
//父级部门
|
DepartmentExtListVO d = getModelById(depart.getCompanyId(),depart.getParentId(),allDepartList);
|
if(d == null){
|
return null;
|
}
|
if( Constants.equalsInteger(d.getType(),Constants.DEPART_TYPE.com)){
|
//如果父级是企业级部门，直接返回
|
return d.getId();
|
}else{
|
//如果父级不是企业级部门继续往上级查，直到查到父级几点
|
return getComDepartId(d,allDepartList);
|
}
|
}
|
@Override
|
public void loadComDepart(CompanyExtListVO com ) {
|
|
QueryDepartmentExtDTO d = new QueryDepartmentExtDTO();
|
d.setDeleted(Constants.ZERO);
|
d.setCompanyId(com.getId());
|
//查询全部企业部门信息
|
List<DepartmentExtListVO> allDepart = departmentExtMapper.selectList(d);
|
DepartmentExtListVO rootDepart = getDepartByComId(com.getId(),allDepart);
|
if(rootDepart!=null){
|
List<DepartmentExtListVO> pool = new ArrayList<>();
|
pool.add(rootDepart);
|
getCompnayDepartTree(pool, allDepart);
|
}
|
//加入redis缓存，以企业id为编码，缓存企业全部部门
|
RedisUtil.addObject(redisTemplate,Constants.RedisKeys.COM_DEPART_LIST_KEY+com.getId(),allDepart);
|
//加入redis缓存，以企业id为编码，缓存企业部门树形结构
|
RedisUtil.addObject(redisTemplate,Constants.RedisKeys.COM_INFO_KEY+com.getId(),com);
|
//加入redis缓存，存储企业信息
|
RedisUtil.addObject(redisTemplate,Constants.RedisKeys.COM_DEPART_TREE_KEY+com.getId(),rootDepart);
|
}
|
@Override
|
public void loadAllDepart() {
|
QueryCompanyExtDTO dto = new QueryCompanyExtDTO();
|
dto.setDeleted(Constants.ZERO);
|
//查询全部企业信息
|
List<CompanyExtListVO> list = companyExtMapper.selectList(dto);
|
if(list != null && list.size()>0){
|
QueryDepartmentExtDTO d = new QueryDepartmentExtDTO();
|
d.setDeleted(Constants.ZERO);
|
//查询全部企业部门信息
|
List<DepartmentExtListVO> departList = departmentExtMapper.selectList(d);
|
for(CompanyExtListVO com : list){
|
//当前企业的全部部门信息
|
List<DepartmentExtListVO> allDepart = getAllDepartByComId(com.getId(),departList);
|
DepartmentExtListVO rootDepart = getDepartByComId(com.getId(),allDepart);
|
if(rootDepart!=null){
|
List<DepartmentExtListVO> pool = new ArrayList<>();
|
pool.add(rootDepart);
|
getCompnayDepartTree(pool, allDepart);
|
}
|
//加入redis缓存，以企业id为编码，缓存企业全部部门
|
RedisUtil.addObject(redisTemplate,Constants.RedisKeys.COM_DEPART_LIST_KEY+com.getId(),allDepart);
|
|
QueryWOutboundExtDTO w = new QueryWOutboundExtDTO();
|
w.setRootDepartId(rootDepart.getId());
|
if(RedisUtil.getObject(redisTemplate,Constants.RedisKeys.COM_OUTBOUND_IN_KEY+com.getId(),Integer.class) == null){
|
w.setType(Constants.WOUTBOUND_TYPE.in);
|
//加入redis缓存，以企业id为编码，缓存企业入库单总数量
|
RedisUtil.addObject(redisTemplate,Constants.RedisKeys.COM_OUTBOUND_IN_KEY+com.getId(),wOutboundExtMapper.selectCountToday(w));
|
}
|
if(RedisUtil.getObject(redisTemplate,Constants.RedisKeys.COM_OUTBOUND_OUT_KEY+com.getId(),Integer.class) == null){
|
w.setType(Constants.WOUTBOUND_TYPE.out);
|
//加入redis缓存，以企业id为编码，缓存企业出库单总数量
|
RedisUtil.addObject(redisTemplate,Constants.RedisKeys.COM_OUTBOUND_OUT_KEY+com.getId(),wOutboundExtMapper.selectCountToday(w));
|
}
|
if(RedisUtil.getObject(redisTemplate,Constants.RedisKeys.COM_BACKORDER_CODE_KEY+com.getId(),Integer.class) == null){
|
Backorder backorder = new Backorder();
|
backorder.setRootDepartId(rootDepart.getId());
|
//加入redis缓存，以企业id为编码，缓存企业今天返工总数量
|
RedisUtil.addObject(redisTemplate,Constants.RedisKeys.COM_BACKORDER_CODE_KEY+com.getId(),backorderMapper.selectCount( new LambdaQueryWrapper<>(backorder).apply(" to_days(CREATE_TIME)=to_days(now())")));
|
}
|
QueryPlansExtDTO p = new QueryPlansExtDTO();
|
p.setRootDepartId(rootDepart.getId());
|
if(RedisUtil.getObject(redisTemplate,Constants.RedisKeys.COM_PLANS_CODE_KEY+com.getId(),Integer.class) == null){
|
//加入redis缓存，以企业id为编码，缓存企业今天计划总数量
|
RedisUtil.addObject(redisTemplate,Constants.RedisKeys.COM_PLANS_CODE_KEY+com.getId(),plansExtMapper.selectCountToday(p));
|
}
|
if(RedisUtil.getObject(redisTemplate,Constants.RedisKeys.COM_PLAN_BATCH_KEY+com.getId(),Integer.class) == null){
|
p.setType(Constants.PLAN_TYPE.back);
|
//加入redis缓存，以企业id为编码，缓存企业今天返工计划总数量
|
RedisUtil.addObject(redisTemplate,Constants.RedisKeys.COM_PLAN_BATCH_KEY+com.getId(),plansExtMapper.selectCountToday(p));
|
}
|
if(RedisUtil.getObject(redisTemplate,Constants.RedisKeys.COM_CHECK_CODE_KEY+com.getId(),Integer.class) == null){
|
QueryWorkorderCheckExtDTO cp = new QueryWorkorderCheckExtDTO();
|
p.setRootDepartId(rootDepart.getId());
|
//加入redis缓存，以企业id为编码，缓存企业今天检验总数量
|
RedisUtil.addObject(redisTemplate,Constants.RedisKeys.COM_CHECK_CODE_KEY+com.getId(),workorderCheckExtMapper.selectCountToday(cp));
|
}
|
if(RedisUtil.getObject(redisTemplate,Constants.RedisKeys.COM_WORKORDER_CODE_KEY+com.getId(),Integer.class) == null){
|
QueryWorkorderExtDTO o = new QueryWorkorderExtDTO();
|
o.setRootDepartId(rootDepart.getId());
|
//加入redis缓存，以企业id为编码，缓存企业今天工单总数量
|
RedisUtil.addObject(redisTemplate,Constants.RedisKeys.COM_WORKORDER_CODE_KEY+com.getId(),workorderExtMapper.selectCountToday(o));
|
//加入redis缓存，以企业id为编码，缓存企业部门树形结构
|
}
|
if(RedisUtil.getObject(redisTemplate,Constants.RedisKeys.COM_TRANSFER_KEY+com.getId(),Integer.class) == null){
|
QueryWTransferExtDTO o = new QueryWTransferExtDTO();
|
o.setRootDepartId(rootDepart.getId());
|
//加入redis缓存，以企业id为编码，缓存企业今天工单总数量
|
RedisUtil.addObject(redisTemplate,Constants.RedisKeys.COM_TRANSFER_KEY+com.getId(),wTransferExtMapper.selectCountToday(o));
|
//加入redis缓存，以企业id为编码，缓存企业部门树形结构
|
}
|
RedisUtil.addObject(redisTemplate,Constants.RedisKeys.COM_INFO_KEY+com.getId(),com);
|
//加入redis缓存，存储企业信息
|
RedisUtil.addObject(redisTemplate,Constants.RedisKeys.COM_DEPART_TREE_KEY+com.getId(),rootDepart);
|
}
|
// Integer comId = getComDepartId(departList.get(departList.size()-2));
|
// System.out.println(comId+"========================");
|
}
|
}
|
@Override
|
public void initCompnayCodes(){
|
QueryCompanyExtDTO dto = new QueryCompanyExtDTO();
|
dto.setDeleted(Constants.ZERO);
|
//查询全部企业信息
|
List<CompanyExtListVO> list = companyExtMapper.selectList(dto);
|
if(list != null && list.size()>0){
|
for(CompanyExtListVO com : list){
|
//加入redis缓存，以企业id为编码，缓存企业入库单总数量
|
RedisUtil.addObject(redisTemplate,Constants.RedisKeys.COM_OUTBOUND_IN_KEY+com.getId(),0);
|
//加入redis缓存，以企业id为编码，缓存企业出库单总数量
|
RedisUtil.addObject(redisTemplate,Constants.RedisKeys.COM_OUTBOUND_OUT_KEY+com.getId(),0);
|
//加入redis缓存，以企业id为编码，缓存企业今天计划总数量
|
RedisUtil.addObject(redisTemplate,Constants.RedisKeys.COM_PLANS_CODE_KEY+com.getId(),0);
|
//加入redis缓存，以企业id为编码，缓存企业今天工单总数量
|
RedisUtil.addObject(redisTemplate,Constants.RedisKeys.COM_WORKORDER_CODE_KEY+com.getId(),0);
|
//加入redis缓存，以企业id为编码，缓存企业今天检验总数量
|
RedisUtil.addObject(redisTemplate,Constants.RedisKeys.COM_CHECK_CODE_KEY+com.getId(),0);
|
//加入redis缓存，以企业id为编码，缓存企业转库单总数量
|
RedisUtil.addObject(redisTemplate,Constants.RedisKeys.COM_TRANSFER_KEY+com.getId(),0);
|
//加入redis缓存，以企业id为编码，缓存企业返修申请单总数量
|
RedisUtil.addObject(redisTemplate,Constants.RedisKeys.COM_BACKORDER_CODE_KEY+com.getId(),0);
|
//加入redis缓存，以企业id为编码，缓存企业计划批次单总数量
|
RedisUtil.addObject(redisTemplate,Constants.RedisKeys.COM_PLAN_BATCH_KEY+com.getId(),0);
|
//加入redis缓存，以企业id为编码，缓存企业计划批次单总数量
|
RedisUtil.addObject(redisTemplate,Constants.RedisKeys.COM_DEVIECE_CHECK_KEY+com.getId(),0);
|
//加入redis缓存，以企业id为编码，缓存企业计划批次单总数量
|
RedisUtil.addObject(redisTemplate,Constants.RedisKeys.COM_WORK_PLAN_KEY+com.getId(),0);
|
//加入redis缓存，以企业id为编码，缓存企业计划批次单总数量
|
RedisUtil.addObject(redisTemplate,Constants.RedisKeys.COM_CATEGORY_CHECK_KEY+com.getId(),0);
|
//加入redis缓存，以企业id为编码，缓存企业计划批次单总数量
|
RedisUtil.addObject(redisTemplate,Constants.RedisKeys.COM_PROCEDURES_CHECK_KEY+com.getId(),0);
|
//加入redis缓存，以企业id为编码，缓存企业计划批次单总数量
|
RedisUtil.addObject(redisTemplate,Constants.RedisKeys.COM_ROUTE_CHECK_KEY+com.getId(),0);
|
//加入redis缓存，以企业id为编码，缓存企业计划批次单总数量
|
RedisUtil.addObject(redisTemplate,Constants.RedisKeys.COM_WAREHOUSE_CHECK_KEY+com.getId(),0);
|
//加入redis缓存，以企业id为编码，缓存企业计划批次单总数量
|
RedisUtil.addObject(redisTemplate,Constants.RedisKeys.COM_LOCATION_CHECK_KEY+com.getId(),0);
|
//加入redis缓存，以企业id为编码，缓存企业计划批次单总数量
|
RedisUtil.addObject(redisTemplate,Constants.RedisKeys.COM_MATERIAL_CHECK_KEY+com.getId(),0);
|
}
|
}
|
}
|
@Override
|
public void initCompnayCodesByCom(Company com){
|
if(com != null){
|
//加入redis缓存，以企业id为编码，缓存企业入库单总数量
|
RedisUtil.addObject(redisTemplate,Constants.RedisKeys.COM_OUTBOUND_IN_KEY+com.getId(),0);
|
//加入redis缓存，以企业id为编码，缓存企业出库单总数量
|
RedisUtil.addObject(redisTemplate,Constants.RedisKeys.COM_OUTBOUND_OUT_KEY+com.getId(),0);
|
//加入redis缓存，以企业id为编码，缓存企业今天计划总数量
|
RedisUtil.addObject(redisTemplate,Constants.RedisKeys.COM_PLANS_CODE_KEY+com.getId(),0);
|
//加入redis缓存，以企业id为编码，缓存企业今天工单总数量
|
RedisUtil.addObject(redisTemplate,Constants.RedisKeys.COM_WORKORDER_CODE_KEY+com.getId(),0);
|
//加入redis缓存，以企业id为编码，缓存企业今天检验总数量
|
RedisUtil.addObject(redisTemplate,Constants.RedisKeys.COM_CHECK_CODE_KEY+com.getId(),0);
|
//加入redis缓存，以企业id为编码，缓存企业转库单总数量
|
RedisUtil.addObject(redisTemplate,Constants.RedisKeys.COM_TRANSFER_KEY+com.getId(),0);
|
//加入redis缓存，以企业id为编码，缓存企业返修申请单总数量
|
RedisUtil.addObject(redisTemplate,Constants.RedisKeys.COM_BACKORDER_CODE_KEY+com.getId(),0);
|
//加入redis缓存，以企业id为编码，缓存企业计划批次单总数量
|
RedisUtil.addObject(redisTemplate,Constants.RedisKeys.COM_PLAN_BATCH_KEY+com.getId(),0);
|
}
|
}
|
|
/**
|
* 根据企业编码获取企业根组织
|
* @param id
|
* @param departList
|
* @return
|
*/
|
private DepartmentExtListVO getDepartByComId(Integer id, List<DepartmentExtListVO> departList) {
|
if(departList!= null){
|
for(DepartmentExtListVO d :departList){
|
if(Constants.equalsInteger(id,d.getCompanyId())&&d.getParentId() == null){
|
return d;
|
}
|
}
|
}
|
return null;
|
}
|
/**
|
* 根据企业编码获取企业根组织
|
* @param id
|
* @param departList
|
* @return
|
*/
|
private List<DepartmentExtListVO> getAllDepartByComId(Integer id, List<DepartmentExtListVO> departList) {
|
List<DepartmentExtListVO> list = null;
|
if(departList!= null){
|
for(DepartmentExtListVO d :departList){
|
if(Constants.equalsInteger(id,d.getCompanyId())){
|
if(list == null){
|
list = new ArrayList<>();
|
}
|
list.add(d);
|
}
|
}
|
}
|
return list;
|
}
|
|
/**
|
* 获取子部门集合
|
* @author Eva.Caesar Liu
|
* @date 2022/04/18 18:12
|
*/
|
private void getCompnayDepartTree(List<DepartmentExtListVO> pool, List<DepartmentExtListVO> departList) {
|
if(pool!=null && pool.size()>0){
|
for(DepartmentExtListVO d : pool){
|
List<DepartmentExtListVO> departments = getDepartListByParentId(d.getId(),departList);
|
getCompnayDepartTree(departments,departList);
|
d.setChildren(departments);
|
}
|
}
|
}
|
|
private List<DepartmentExtListVO> getDepartListByParentId(Integer pId, List<DepartmentExtListVO> departList) {
|
List<DepartmentExtListVO> list = new ArrayList<>();
|
if(departList!= null){
|
for(DepartmentExtListVO d :departList){
|
if(Constants.equalsInteger(d.getParentId(),pId)){
|
|
list.add(d);
|
}
|
}
|
}
|
return list;
|
}
|
|
/**
|
* 获取子部门ID
|
* @author Eva.Caesar Liu
|
* @date 2022/04/18 18:12
|
*/
|
private void fillChildren(List<Integer> pool, List<Integer> parentIds) {
|
QueryWrapper<Department> queryWrapper = new QueryWrapper<>();
|
queryWrapper.lambda()
|
.eq(Department::getDeleted, Constants.ZERO)
|
.in(Department::getParentId, parentIds);
|
List<Department> departments = departmentExtMapper.selectList(queryWrapper);
|
List<Integer> ids = departments.stream().map(Department::getId).collect(Collectors.toList());
|
if (ids.size() > 0) {
|
pool.addAll(ids);
|
this.fillChildren(pool, ids);
|
}
|
}
|
|
private static DepartmentExtListVO departmentExtListVO;
|
@Override
|
public List<DepartmentExtListVO> getDepartmentListByConditon(QueryDepartmentExtDTO pageWrap) {
|
departmentExtListVO=null;
|
LoginUserInfo user = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
|
if(Constants.equalsInteger(user.getType(),Constants.USERTYPE.COM)){
|
//如果是企业级用户，只能看自己企业的部门数据
|
//数据权限
|
if(!Constants.equalsInteger(pageWrap.getType(),Constants.DEPART_TYPE.com)){
|
//如果查询非公司级部门，只能查询当前用户切换的公司级下属部门
|
pageWrap.setComDepartId(user.getCurComDepartment().getId());
|
}
|
List<Integer> dataPermission = user.getDepartPermissionList();
|
if(dataPermission!=null && dataPermission.size()==0) {
|
if(pageWrap.getType()!=null && Constants.equalsInteger(pageWrap.getType(),Constants.DEPART_TYPE.com)){
|
//只能看自己的公司级
|
List<DepartmentExtListVO> list =new ArrayList<>();
|
list.add(user.getComDepartment());
|
return list;
|
} else if(pageWrap.getType()!=null && Constants.equalsInteger(pageWrap.getType(),user.getDepartment().getType())){
|
//只能看自己的部门
|
List<DepartmentExtListVO> list =new ArrayList<>();
|
list.add(user.getDepartment());
|
return list;
|
}
|
return null;
|
}
|
//否则走数据权限
|
//查询全部企业部门信息
|
List<DepartmentExtListVO> list = RedisUtil.getObject(redisTemplate,Constants.RedisKeys.COM_DEPART_LIST_KEY+user.getCompany().getId(),ArrayList.class);
|
List<DepartmentExtListVO> allDepart = new ArrayList<>();
|
if(list != null && list.size()>0){
|
for(DepartmentExtListVO d : list){
|
if(pageWrap.getType()!=null && !Constants.equalsInteger(pageWrap.getType(),d.getType())){
|
continue;
|
}
|
if(pageWrap.getName()!=null && !StringUtils.equals(pageWrap.getName(),d.getName())){
|
continue;
|
}
|
if(pageWrap.getComDepartId()!=null && !Constants.equalsInteger(getComDepartId(d,list),pageWrap.getComDepartId())){
|
continue;
|
}
|
if(dataPermission == null || (dataPermission!=null && inPerissionList(dataPermission,d.getId()))) {
|
allDepart.add(d);
|
}
|
}
|
}
|
|
|
//获取当前用户所在的公司级或者工厂型组织
|
this.getpartentList(list,user.getDepartment().getId(),pageWrap.getType());
|
|
Boolean mark=false;
|
|
if(departmentExtListVO!=null){
|
if(allDepart.size()>0){
|
for(int p=0;p<allDepart.size();p++){
|
DepartmentExtListVO depv=allDepart.get(p);
|
|
if(Constants.equalsInteger(depv.getId(),departmentExtListVO.getId())){
|
mark=true;
|
}
|
}
|
}else{
|
// allDepart.add(pool);
|
}
|
if(!mark){
|
allDepart.add(departmentExtListVO);
|
}
|
|
}
|
|
return allDepart;
|
}
|
return null;
|
}
|
|
private boolean inPerissionList(List<Integer> dataPermission, Integer id) {
|
if(dataPermission!=null){
|
for(Integer tid : dataPermission){
|
if(Constants.equalsInteger(tid,id)){
|
return true;
|
}
|
}
|
}else{
|
//为null表示拥有全部数据权限
|
return true;
|
}
|
return false;
|
}
|
|
|
|
/**
|
* 获取当前用户所在的的工厂型或公司型组织
|
* @author Eva.Caesar Liu
|
* @date 2022/04/18 18:12
|
*/
|
private void getpartentList( List<DepartmentExtListVO> list ,Integer departmentid,Integer type) {
|
for(int i=0;i<list.size();i++){
|
DepartmentExtListVO del=list.get(i);
|
if(Constants.equalsInteger(del.getId(),departmentid)){
|
if(Constants.equalsInteger(del.getType(),type)){
|
departmentExtListVO=del;
|
}else{
|
this.getpartentList( list ,del.getParentId() ,type);
|
}
|
}
|
}
|
}
|
|
|
/**
|
* 手动同步钉钉数据
|
*/
|
@Override
|
public void syncDingDingDepartment(){
|
LoginUserInfo user = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
|
//读取对应部门信息
|
List<Department> departmentList = DingDingSyncUtil.getDingDingDepartListInfo
|
(user.getCompanyUser(),null);
|
if(departmentList.size()>Constants.ZERO){
|
for (Department department:departmentList ) {
|
this.dealDepartmentData(department,user);
|
}
|
}
|
}
|
|
public void dealDepartmentData(Department department,LoginUserInfo user){
|
//初始化此部门下所有用户集合
|
List<CompanyUser> companyUserList = new ArrayList<>();
|
Company company = companyExtMapper.selectById(user.getCompany().getId());
|
//同步初始下标
|
Long cursor = 0L;
|
//是否存在下一页
|
Boolean hasMore = true;
|
while(hasMore){
|
//同步部门下所有用户信息
|
CompanyUserDTO companyUserDTO = DingDingSyncUtil.getDingDingDepartUserListInfo(company,department,cursor);
|
if(companyUserDTO.getCompanyUserList().size()>Constants.ZERO){
|
companyUserList.addAll(companyUserDTO.getCompanyUserList());
|
}
|
cursor = companyUserDTO.getNextCursor();
|
hasMore = companyUserDTO.getHasMore();
|
}
|
//查询部门是否已存在
|
if(departmentExtMapper.selectCount(new QueryWrapper<Department>().eq("NAME",department.getName())
|
.eq("COMPANY_ID",department.getCompanyId())
|
.eq("DELETED",Constants.ZERO)
|
)<Constants.ZERO){
|
departmentExtMapper.insert(department);
|
}
|
else{
|
department = departmentExtMapper.selectOne(new QueryWrapper<Department>()
|
.eq("NAME",department.getName())
|
.eq("COMPANY_ID",department.getCompanyId())
|
.eq("DELETED",Constants.ZERO)
|
.last("limit 1"));
|
}
|
//循环处理部门用户数据
|
if(companyUserList.size()>Constants.ZERO){
|
for (CompanyUser companyUser:companyUserList) {
|
//查询手机号是否存在用户
|
SystemUser systemUser = systemUserMapper.selectOne(new QueryWrapper<SystemUser>()
|
.eq("MOBILE",companyUser.getPhone())
|
.eq("DELETED",Constants.ZERO)
|
.last(" limit 1 ")
|
);
|
if(Objects.isNull(systemUser)){
|
systemUser = new SystemUser();
|
systemUser.setCreateUser(user.getId());
|
systemUser.setCreateTime(new Date());
|
systemUser.setUsername(companyUser.getPhone());
|
systemUser.setRealname(companyUser.getName());
|
systemUser.setType(Constants.ONE);
|
systemUserMapper.insert(systemUser);
|
}
|
if(StringUtils.isNotBlank(companyUser.getPosition())){
|
//查询岗位是否已存在
|
CompanyPosition companyPosition = companyPositionExtMapper.selectOne(new QueryWrapper<CompanyPosition>()
|
.eq("COMPANY_ID",company.getId())
|
.eq("NAME",companyUser.getPosition())
|
.eq("DELETED",Constants.ZERO)
|
.eq("STATUS",Constants.ZERO)
|
.last(" limit 1 ")
|
);
|
if(Objects.isNull(companyPosition)){
|
companyPosition = new CompanyPosition();
|
companyPosition.setDeleted(Constants.ZERO);
|
companyPosition.setStatus(Constants.ZERO);
|
companyPosition.setCreateTime(new Date());
|
companyPosition.setCreateUser(user.getId());
|
companyPosition.setName(companyUser.getPosition());
|
companyPosition.setCompanyId(company.getId());
|
companyPositionExtMapper.insert(companyPosition);
|
}
|
companyUser.setPositionId(companyPosition.getId());
|
}
|
|
|
//查询 companyUser是否已存在
|
if(companyUserExtMapper.selectCount(new QueryWrapper<CompanyUser>()
|
.eq("DEPARTMENT_ID",companyUser.getDepartmentId())
|
.eq("USER_ID",systemUser.getId())
|
.eq("STATUS",Constants.ZERO)
|
.eq("PHONE",companyUser.getPhone())
|
)<=Constants.ZERO){
|
|
companyUser.setDepartmentId(department.getId());
|
companyUser.setUserId(systemUser.getId());
|
companyUserExtMapper.insert(companyUser);
|
}
|
}
|
}
|
}
|
|
|
/**
|
* 订阅部门信息
|
* @param departmentId
|
* @param companyId
|
* @param optType add = 新增 edit = 修改 delete = 删除
|
*/
|
@Override
|
public Department syncDepartment(Long departmentId,Integer companyId,String optType){
|
Company company = companyExtMapper.selectById(companyId);
|
String accessToken = companyExtService.getDingdingToken(companyId);
|
Department department = DingDingSyncUtil.getDingDingDepartInfo(company,departmentId,accessToken);
|
//公司级企业信息
|
Department comDepartment = departmentExtMapper.selectOne(new QueryWrapper<Department>()
|
.eq("TYPE",Constants.DEPART_TYPE.com)
|
.eq("COMPANY_ID",companyId)
|
.eq("DELETED",Constants.ZERO).last("limit 1"));
|
if(Objects.isNull(comDepartment)){
|
department.setRootId(comDepartment.getRootId());
|
department.setValidTime(comDepartment.getValidTime());
|
}
|
//查询部门父级是否存在
|
if(!Objects.isNull(department.getParentId())){
|
Department parentDepartment = departmentExtMapper.selectOne(new QueryWrapper<Department>()
|
.eq("DD_DEPT_ID",department.getParentId()).last("limit 1"));
|
if(!Objects.isNull(parentDepartment)){
|
department.setParentId(parentDepartment.getId());
|
}
|
}else{
|
//若无父级部门，则默认归属公司部门 type = 0
|
if(!Objects.isNull(comDepartment)){
|
department.setParentId(comDepartment.getId());
|
}else{
|
department.setParentId(null);
|
}
|
}
|
if(optType.equals("add")){
|
if(departmentExtMapper.selectCount(new QueryWrapper<Department>()
|
.eq("NAME",department.getName())
|
.eq("COMPANY_ID",department.getCompanyId())
|
.eq("DELETED",Constants.ZERO)
|
)<=Constants.ZERO){
|
departmentExtMapper.insert(department);
|
}else{
|
Department dbDepartment = departmentExtMapper.selectOne(new QueryWrapper<Department>()
|
.eq("NAME",department.getName())
|
.eq("COMPANY_ID",department.getCompanyId())
|
.eq("DELETED",Constants.ZERO));
|
dbDepartment.setDdDeptId(department.getDdDeptId());
|
dbDepartment.setUpdateTime(new Date());
|
departmentExtMapper.updateById(dbDepartment);
|
}
|
}else if(optType.equals("edit")){
|
Department dbDepartment = departmentExtMapper.selectOne(new QueryWrapper<Department>().eq("DD_DEPT_ID",departmentId));
|
if(!Objects.isNull(dbDepartment)){
|
dbDepartment.setName(department.getName());
|
dbDepartment.setParentId(department.getParentId());
|
dbDepartment.setUpdateTime(new Date());
|
departmentExtMapper.updateById(dbDepartment);
|
}
|
}else if(optType.equals("delete")){
|
Department dbDepartment = departmentExtMapper.selectOne(new QueryWrapper<Department>().eq("DD_DEPT_ID",departmentId));
|
if(!Objects.isNull(dbDepartment)){
|
dbDepartment.setDeleted(Constants.ONE);
|
dbDepartment.setUpdateTime(new Date());
|
departmentExtMapper.updateById(dbDepartment);
|
}
|
}
|
return department;
|
}
|
|
@Override
|
public void syncDelDepartment(Long departmentId){
|
log.debug("钉钉部门信息同步删除业务=>同步钉钉部门主键【"+departmentId+"】");
|
Department dbDepartment = departmentExtMapper.selectOne(new QueryWrapper<Department>().eq("DD_DEPT_ID",departmentId));
|
if(!Objects.isNull(dbDepartment)){
|
dbDepartment.setDeleted(Constants.ONE);
|
dbDepartment.setUpdateTime(new Date());
|
departmentExtMapper.updateById(dbDepartment);
|
}
|
}
|
|
}
|
