weaver-hrm-salary/src/com/engine/salary/wrapper/TaxAgentWrapper.java

package com.engine.salary.wrapper;

import com.cloudstore.eccom.pc.table.WeaTable;
import com.cloudstore.eccom.result.WeaResultMsg;
import com.engine.common.util.ServiceUtil;
import com.engine.core.impl.Service;
import com.engine.salary.entity.datacollection.DataCollectionEmployee;
import com.engine.salary.entity.hrm.HrmStatus;
import com.engine.salary.entity.taxagent.bo.TaxAgentBO;
import com.engine.salary.entity.taxagent.dto.TaxAgentEmployeeOptionDTO;
import com.engine.salary.entity.taxagent.dto.TaxAgentFormDTO;
import com.engine.salary.entity.taxagent.dto.TaxAgentManageRangeFormDTO;
import com.engine.salary.entity.taxagent.dto.TaxAgentManageRangeListDTO;
import com.engine.salary.entity.taxagent.param.*;
import com.engine.salary.entity.taxagent.po.TaxAgentAdminPO;
import com.engine.salary.entity.taxagent.po.TaxAgentPO;
import com.engine.salary.enums.UserStatusEnum;
import com.engine.salary.exception.SalaryRunTimeException;
import com.engine.salary.service.*;
import com.engine.salary.service.impl.*;
import com.engine.salary.util.SalaryI18nUtil;
import com.engine.salary.util.page.PageInfo;
import com.engine.salary.util.page.PageUtil;
import com.google.common.collect.Maps;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.math.NumberUtils;
import org.springframework.beans.BeanUtils;
import weaver.hrm.User;

import java.util.*;
import java.util.stream.Collectors;

/**
 * 个税扣缴义务人
 * <p>Copyright: Copyright (c) 2022</p>
 * <p>Company: 泛微软件</p>
 *
 * @author qiantao
 * @version 1.0
 **/
public class TaxAgentWrapper extends Service {

    public TaxAgentBaseService getTaxAgentBaseService(User user) {
        return ServiceUtil.getService(TaxAgentBaseServiceImpl.class, user);
    }

    public TaxAgentAdminService getTaxAgentAdminService(User user) {
        return ServiceUtil.getService(TaxAgentAdminServiceImpl.class, user);
    }

    public TaxAgentV2Service getTaxAgentService(User user) {
        return ServiceUtil.getService(TaxAgentV2ServiceImpl.class, user);
    }

    public SalaryEmployeeService getSalaryEmployeeService(User user) {
        return ServiceUtil.getService(SalaryEmployeeServiceImpl.class, user);
    }

    public TaxAgentManageRangeService getTaxAgentManageRangeService(User user) {
        return ServiceUtil.getService(TaxAgentManageRangeServiceImpl.class, user);
    }

//    private PaymentAgencyService paymentAgencyService;
//
//    private SIEmployeeStatusMapper siEmployeeStatusMapper;
//
//    private HrmCommonHrmStatusService hrmCommonHrmStatusService;
//
//    private HrmConfigSetCache hrmConfigSetCache;

    /**
     * 是否是薪酬模块总管理员
     *
     * @param currentEmployeeId
     * @return
     */
    public Boolean isChief(Long currentEmployeeId) {
        return getTaxAgentService(user).isChief(currentEmployeeId);
    }

    /**
     * 权限信息
     *
     * @param currentEmployeeId
     * @return
     */
    public Map<String, Boolean> permission(Long currentEmployeeId) {
        Map<String, Boolean> resultMap = Maps.newHashMap();
        Boolean isChief = isChief(currentEmployeeId);
        Boolean isDefaultOpen = getTaxAgentService(user).isDefaultOpen(currentEmployeeId);
        Boolean isAdminEnable = getTaxAgentService(user).isAdminEnable(currentEmployeeId);
        resultMap.put("isChief", isChief);
        resultMap.put("isDefaultOpen", isDefaultOpen);
        resultMap.put("isAdminEnable", isAdminEnable);
        return resultMap;
    }

    /**
     * 个税口角义务人列表
     *
     * @param queryParam
     * @return
     */
    public Map<String, Object> list(TaxAgentQueryParam queryParam) {
        // 是否是总管理员
        Boolean isChief = getTaxAgentService(user).isChief((long) user.getUID());
        // 是否开启分权
        boolean isOpenDevolution = getTaxAgentBaseService(user).isOpenDevolution();

//        List<PaymentAgencyPO> paymentAgencyPOS = paymentAgencyService.listAll(currentTenantKey);

        PageInfo<TaxAgentPO> page = null;
        if (isChief) {
            page = getTaxAgentService(user).listPage(queryParam);
        } else {
            // 分权情况下，根据自己作为管理员过滤列表
            if (isOpenDevolution) {
                List<TaxAgentPO> list = getTaxAgentService(user).list(queryParam);
                // 1.判断自己是否是管理员， 如果是管理员，就是能够操作所属个税扣缴义务人下的所有人的数据
                List<TaxAgentAdminPO> taxAgentAdminList = getTaxAgentAdminService(user).listByTaxAgentIdsAndEmployeeId(list.stream().map(TaxAgentPO::getId).collect(Collectors.toList()), (long) user.getUID());
                // 是管理员的列表
                List<Long> adminTaxAgentIds = taxAgentAdminList.stream().map(TaxAgentAdminPO::getTaxAgentId).collect(Collectors.toList());
                list = list.stream().filter(f -> adminTaxAgentIds.contains(f.getId())).collect(Collectors.toList());
                // 分页参数
                // 填充总数和当页数据
                PageInfo<TaxAgentPO> dtoPage = PageUtil.buildPage(queryParam.getCurrent(), queryParam.getPageSize());
                dtoPage.setTotal(list.size());
                dtoPage.setList(PageUtil.subList(dtoPage.getPageNum(), dtoPage.getSize(), list));
                page = dtoPage;
            }
        }

        PageInfo<Map<String, Object>> listPage = new PageInfo<>();

        String setLabel = SalaryI18nUtil.getI18nLabel(94614, "设置");
        if (isOpenDevolution) {
            List<TaxAgentPO> list = page.getList();
            List<Long> taxAgentIds = list.stream().map(TaxAgentPO::getId).collect(Collectors.toList());
            List<TaxAgentAdminPO> taxAgentAdmins = getTaxAgentAdminService(user).listByTaxAgentIds(taxAgentIds);
            List<DataCollectionEmployee> adminList = getSalaryEmployeeService(user).listByIds(taxAgentAdmins.stream().map(TaxAgentAdminPO::getEmployeeId).distinct().collect(Collectors.toList()));
            listPage.setList(TaxAgentBO.convertToTableListDTO(page.getList(), null, taxAgentAdmins, adminList, setLabel));
        } else {
            listPage.setList(TaxAgentBO.convertToTableListDTO(page.getList(), null, setLabel));
        }

        //构造表格
        WeaTable weaTable = new WeaTable();
        TaxAgentBO.buildTaxAgentTable(weaTable, isOpenDevolution);
        if (isChief) {
            // 在外展示操作按钮
//            weaTable.getOperates().get(0).setOuter(Boolean.TRUE);
        } else {
            // 去掉增删改权限
            weaTable.getOperates().getOperate().clear();
//            weaTable.getCheckBoxPermission().clear();
        }

        WeaResultMsg result = new WeaResultMsg(false);
        result.putAll(weaTable.makeDataResult());
        result.success();

        Map<String, Object> datas = new HashMap<>();
        datas.put("pageInfo", listPage);
        datas.put("dataKey", result.getResultMap());

        return datas;

    }

    public List<Map<String, Object>> paymentAgencyList(TaxAgentQueryParam queryParam) {
//        List<TaxAgentPO> taxAgentPOS = getTaxAgentService(user).listByIds(queryParam.getIds());
//        List<PaymentAgencyPO> paymentAgencyPOS = paymentAgencyService.listAll(currentTenantKey);
//        SalaryAssert.notEmpty(taxAgentPOS, "taxagent data is not exist");
//        TaxAgentPO taxAgentPO = taxAgentPOS.get(0);
//        return TaxAgentBO.buildPaymentAgency(taxAgentPO.getPaymentAgency(), paymentAgencyPOS);
        return null;
    }

    public String paymentAgencySave(TaxAgentSaveParam param) {
//        List<TaxAgentPO> taxAgentPOS = getTaxAgentService(user).listByIds(Collections.singletonList(param.getId()));
//        SalaryAssert.notEmpty(taxAgentPOS, "data is not exist");
//        TaxAgentPO taxAgentPO = taxAgentPOS.get(0);
//        List<String> errorList = new ArrayList<>();
//        List<String> resultList = new ArrayList<>();
//        if (StringUtils.isNotBlank(taxAgentPO.getPaymentAgency())) {
//            List<String> originList = new ArrayList<>(Arrays.asList(taxAgentPO.getPaymentAgency().split(",")));
//            List<String> list = new ArrayList<>(Arrays.asList(param.getPaymentAgency().split(",")));
//            originList.removeAll(list);
//            if (CollectionUtils.isNotEmpty(originList)) {
//                originList.stream().forEach(e -> {
//                    List<InsuranceEmployeeStatusPO> employeeStatusPOS = new LambdaQueryChainWrapper<>(siEmployeeStatusMapper)
//                            .eq(InsuranceEmployeeStatusPO::getTenantKey)
//                            .eq(InsuranceEmployeeStatusPO::getPaymentAgency, Long.valueOf(e))
//                            .eq(InsuranceEmployeeStatusPO::getPaymentOrganization, param.getId())
//                            .list();
//                    if (CollectionUtils.isNotEmpty(employeeStatusPOS)) {
//                        errorList.add(e);
//                    }
//                });
//            }
//            if (CollectionUtils.isNotEmpty(errorList)) {
//                List<PaymentAgencyPO> paymentAgencyPOS = paymentAgencyService.listAll(currentTenantKey);
//                errorList.forEach(e -> {
//                    Optional<PaymentAgencyPO> optionalPaymentAgencyPO = paymentAgencyPOS.stream().filter(po -> Objects.equals(e, String.valueOf(po.getId()))).findFirst();
//                    optionalPaymentAgencyPO.ifPresent(paymentAgencyPO -> resultList.add(paymentAgencyPO.getAgencyName()));
//                });
//            }
//        }
//        if (CollectionUtils.isNotEmpty(resultList)) {
//            return SalaryI18nUtil.getI18nLabel(currentTenantKey, currentEmploueeId, 115128, "有员工在") + String.join(",", resultList) + SalaryI18nUtil.getI18nLabel(currentTenantKey,
//                    currentEmploueeId, 115129, "缴纳社保福利，不可取消关联");
//        } else {
//            taxAgentPO.setPaymentAgency(param.getPaymentAgency());
//            getTaxAgentService(user).paymentAgencyUpdate(taxAgentPO, currentEmploueeId);
//        }
        return "";
    }

    /**
     * 获取个税扣缴义务人表单
     *
     * @param id
     * @return
     */
    public TaxAgentFormDTO getFrom(Long id) {
        TaxAgentFormDTO taxAgentFromDTO = new TaxAgentFormDTO();
        if (id != null) {
            TaxAgentPO taxAgent = getTaxAgentService(user).getById(id);
            if (taxAgent == null) {
                throw new SalaryRunTimeException(String.format(SalaryI18nUtil.getI18nLabel(100543, "个税扣缴人不存在") + "[id:%s]", id));
            }
            BeanUtils.copyProperties(taxAgent, taxAgentFromDTO);
        }
        // 是否开启分权
        boolean isOpenDevolution = getTaxAgentBaseService(user).isOpenDevolution();
        if (isOpenDevolution) {
            List<TaxAgentAdminPO> admins = getTaxAgentAdminService(user).listByTaxAgentIds(Collections.singletonList(id));
            // 目前是一个
            TaxAgentEmployeeOptionDTO taxAgentEmployee = new TaxAgentEmployeeOptionDTO();
            taxAgentEmployee.setId(CollectionUtils.isEmpty(admins) ? null : admins.get(0).getEmployeeId());
            if (taxAgentEmployee.getId() != null) {
                DataCollectionEmployee employee = getSalaryEmployeeService(user).getEmployeeById(taxAgentEmployee.getId());
                taxAgentEmployee.setContent(employee == null ? "" : employee.getUsername());
            }
            taxAgentFromDTO.setAdminUser(Collections.singletonList(taxAgentEmployee));
        } else {
            taxAgentFromDTO.setAdminUser(null);
        }

        return taxAgentFromDTO;
    }

    /**
     * 保存个税扣缴义务人
     *
     * @param saveParam
     * @return
     */
    public String save(TaxAgentSaveParam saveParam) {
        return getTaxAgentService(user).save(saveParam);
    }

    /**
     * 编辑个税扣缴义务人
     *
     * @param saveParam
     * @return
     */
    public String update(TaxAgentSaveParam saveParam) {
        return getTaxAgentService(user).update(saveParam);
    }

    /**
     * 更换管理员校验
     *
     * @param checkParam
     * @return
     */
    public Boolean adminChangeCheck(TaxAgentAdminChangeCheckParam checkParam) {
        return getTaxAgentService(user).adminChangeCheck(checkParam);
    }

    /**
     * 删除个税扣缴义务人
     *
     * @param ids
     * @return
     */
    public String delete(Collection<Long> ids) {
        return getTaxAgentService(user).delete(ids);
    }

    /**
     * 个税扣缴义务人下拉列表
     *
     * @return
     */
    public List<Map<String, Object>> selectList() {
        return getTaxAgentService(user).selectList();
    }

    /**
     * 范围列表
     *
     * @param queryParam
     * @return
     */
    public PageInfo<TaxAgentManageRangeListDTO> listRangeInclude(TaxAgentRangeQueryParam queryParam) {
        PageInfo<TaxAgentManageRangeListDTO> listPage = getTaxAgentManageRangeService(user).listPageByParamAndIncludeType(queryParam, NumberUtils.INTEGER_ONE);
        return listPage;
    }

    /**
     * 范围排除列表
     *
     * @param queryParam
     * @return
     */
    public PageInfo<TaxAgentManageRangeListDTO> listRangeExclude(TaxAgentRangeQueryParam queryParam) {
        PageInfo<TaxAgentManageRangeListDTO> listPage = getTaxAgentManageRangeService(user).listPageByParamAndIncludeType(queryParam, NumberUtils.INTEGER_ZERO);
        return listPage;
    }

    /**
     * 获取管理范围表单
     *
     * @return
     */
    public TaxAgentManageRangeFormDTO getRangeFrom() {
        // 查询人员状态
        List<HrmStatus> hrmStatusList = UserStatusEnum.getHrmStatusList();

        return TaxAgentManageRangeFormDTO.builder().employeeStatus(hrmStatusList).build();
    }

    /**
     * 保存管理范围
     *
     * @param saveParam
     * @return
     */
    public String saveRange(TaxAgentRangeSaveParam saveParam) {
        getTaxAgentManageRangeService(user).save(saveParam);
        return StringUtils.EMPTY;
    }

    /**
     * 删除管理范围
     *
     * @param ids
     * @return
     */
    public String deleteRange(Collection<Long> ids) {
        getTaxAgentManageRangeService(user).deleteByIds(ids);
        return StringUtils.EMPTY;
    }
}