KPI / fw-morax

package cn.fw.morax.service.biz.salary;

import cn.fw.common.exception.BusinessException;
import cn.fw.ehr.sdk.api.enums.StaffShopTypeEnum;
import cn.fw.morax.common.utils.DateUtil;
import cn.fw.morax.common.utils.PublicUtil;
import cn.fw.morax.domain.db.PayrollRecord;
import cn.fw.morax.domain.db.salary.SalaryExtraProject;
import cn.fw.morax.domain.db.salary.SalaryGroupUser;
import cn.fw.morax.domain.db.salary.SalaryPool;
import cn.fw.morax.domain.db.salary.SalaryProject;
import cn.fw.morax.domain.dto.salary.SalaryExtraDTO;
import cn.fw.morax.domain.enums.ExtraSalaryTypeEnum;
import cn.fw.morax.domain.enums.SalaryPayrollStatusEnum;
import cn.fw.morax.rpc.ehr.EhrRpcService;
import cn.fw.morax.rpc.ehr.dto.StaffBaseInfoDTO;
import cn.fw.morax.rpc.ehr.dto.StaffShopInfoDTO;
import cn.fw.morax.rpc.oop.OopRpcService;
import cn.fw.morax.rpc.oop.dto.ShopDTO;
import cn.fw.morax.sdk.dto.salary.GeneralSalaryProjectReq;
import cn.fw.morax.sdk.dto.salary.SalaryGroupUserQuery;
import cn.fw.morax.sdk.dto.salary.SalaryGroupUserResult;
import cn.fw.morax.sdk.dto.salary.SalaryRewardReq;
import cn.fw.morax.service.data.PayrollRecordService;
import cn.fw.morax.service.data.salary.*;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import lombok.Getter;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.redis.core.BoundListOperations;
import org.springframework.data.redis.core.ListOperations;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;

import java.text.SimpleDateFormat;
import java.time.YearMonth;
import java.util.*;
import java.util.stream.Collectors;

import static cn.fw.common.businessvalidator.Validator.BV;

/**
 * @author : kurisu
 * @version : 1.0
 * @className : SalaryReportService
 * @description : 薪酬数据上报
 * @date : 2022-04-22 10:28
 */

@RequiredArgsConstructor
@Slf4j
@Service
public class SalaryReportService {

    private final SalaryExtraProjectService salaryExtraProjectService;
    private final SalaryGroupUserService salaryGroupUserService;
    private final SalaryPoolService salaryPoolService;
    private final OopRpcService oopRpcService;
    private final EhrRpcService ehrRpcService;
    private final PayrollRecordService payrollRecordService;
    private final SalaryProjectService salaryProjectService;
    private final SalaryGroupService salaryGroupService;
    private final SalaryPoolCommonService salaryPoolCommonService;
    private final StringRedisTemplate stringRedisTemplate;
    private final PlatformTransactionManager platformTransactionManager;
    private final TransactionDefinition transactionDefinition;
    @Value("${spring.cache.custom.global-prefix}:extra-salary")
    @Getter
    private String extraSalaryKey;


    /**
     * 额外薪资数据保存失败的重试
     */
    public void retrySaveReward() {
        ListOperations<String, String> listOps = stringRedisTemplate.opsForList();
        String str;
        List<String> failList = new ArrayList<>();
        while ((str = listOps.leftPop(getExtraSalaryKey())) != null) {
            try {
                SalaryExtraDTO dto = JSONObject.parseObject(str, SalaryExtraDTO.class);
                if (Objects.isNull(dto)) {
                    continue;
                }
                saveExtraProjectTX(dto);
            } catch (Exception e) {
                failList.add(str);
                log.error("薪酬额外薪资数据保存失败", e);
            }
        }

        if (!CollectionUtils.isEmpty(failList)) {
            listOps.rightPushAll(getExtraSalaryKey(), failList);
        }
    }


    /**
     * 奖惩项薪资上报
     *
     * @param req
     */
    public void salaryRewardReport(SalaryRewardReq req) {
        SalaryExtraDTO extraDTO = transferExtraProject(req);
        try {
            saveExtraProjectTX(extraDTO);
        } catch (Exception e) {
            cacheFailProject(extraDTO, getExtraSalaryKey());
            log.error("奖惩项薪资上报数据处理失败", e);
        }
    }

    /**
     * 社保项上报
     *
     * @param req
     */
    public void socialSecurityProject(GeneralSalaryProjectReq req) {
        SalaryExtraDTO extraDTO = transferExtraProject(req, ExtraSalaryTypeEnum.NECESSARY);
        try {
            saveExtraProjectTX(extraDTO);
        } catch (Exception e) {
            cacheFailProject(extraDTO, getExtraSalaryKey());
            log.error("社保项上报数据处理失败", e);
        }
    }

    /**
     * 个税上报
     *
     * @param req
     */
    public void personTaxProject(GeneralSalaryProjectReq req) {
        SalaryExtraDTO extraDTO = transferExtraProject(req, ExtraSalaryTypeEnum.PERSON_TAX);
        try {
            saveExtraProjectTX(extraDTO);
        } catch (Exception e) {
            cacheFailProject(extraDTO, getExtraSalaryKey());
            log.error("社保项上报数据处理失败", e);
        }
    }

    /**
     * 补贴项上报
     *
     * @param req
     */
    public void subsidyProject(GeneralSalaryProjectReq req) {
        SalaryExtraDTO extraDTO = transferExtraProject(req, ExtraSalaryTypeEnum.SUBSIDY);
        try {
            saveExtraProjectTX(extraDTO);
        } catch (Exception e) {
            cacheFailProject(extraDTO, getExtraSalaryKey());
            log.error("补贴项薪资上报数据处理失败", e);
        }
    }

    /**
     * 事务保存额外薪酬项
     *
     * @param extraDTO
     */
    public void saveExtraProjectTX(SalaryExtraDTO extraDTO) {
        TransactionStatus transactionStatus = platformTransactionManager.getTransaction(transactionDefinition);
        try {
            saveExtraProject(extraDTO);
            platformTransactionManager.commit(transactionStatus);
        } catch (Exception e) {
            platformTransactionManager.rollback(transactionStatus);
            throw e;
        }
    }

    /**
     * 保存额外薪酬项
     *
     * @param extraDTO
     */
    public void saveExtraProject(SalaryExtraDTO extraDTO) {
        Optional<SalaryPool> optional = queryPoolByUser(extraDTO.getUserId(), extraDTO.getPostId(), extraDTO.getShopId(), extraDTO.getDataDate());
        Long fundShopId;
        Long shopId;
        Long groupId;
        String userName;

        if (optional.isPresent()) {
            SalaryPool salaryPool = optional.get();
            fundShopId = PublicUtil.isNotEmpty(salaryPool.getFundShopId()) ? salaryPool.getFundShopId() : salaryPool.getShopId();
            groupId = salaryPool.getGroupId();
            shopId = salaryPool.getShopId();
            userName = salaryPool.getUserName();
        } else {
            StaffBaseInfoDTO staff = ehrRpcService.queryStaffBaseInfo(extraDTO.getUserId());
            if (PublicUtil.isEmpty(staff)) {
                log.error("保存额外薪酬项，人员信息未找到：{}", JSON.toJSONString(extraDTO));
                throw new BusinessException("人员信息未找到");
            }
            if (PublicUtil.isEmpty(staff.getStaffShopList())) {
                log.error("保存额外薪酬项，员工门店列表为空：{}", JSON.toJSONString(extraDTO));
                throw new BusinessException("员工门店列表为空");
            }
            Optional<StaffShopInfoDTO> fundShop = staff.getStaffShopList().stream()
                    .filter(shop -> StaffShopTypeEnum.FUND_SHOP.getValue().equals(shop.getType()))
                    .findFirst();
            fundShopId = fundShop.isPresent() ? fundShop.get().getShopId() : staff.getShopId();
            groupId = staff.getGroupId();
            shopId = staff.getShopId();
            userName = staff.getName();
        }

        SalaryExtraProject extraProject = transferBaseExtra(extraDTO);
        if (Objects.isNull(extraProject)) {
            return;
        }
        extraProject.setPostId(extraDTO.getPostId());
        extraProject.setShopId(extraDTO.getShopId());
        extraProject.setGroupId(groupId);
        salaryExtraProjectService.save(extraProject);
        if (Boolean.TRUE.equals(extraDTO.getTimely())) {
            Long dealerId = Optional.ofNullable(oopRpcService.queryShop(fundShopId)).map(ShopDTO::getDealerId).orElse(null);
            PayrollRecord pr = PayrollRecord.builder()
                    .userId(extraProject.getUserId())
                    .userName(userName)
                    .shopId(shopId)
                    .fundShopId(fundShopId)
                    .dealerId(dealerId)
                    .bizId(String.valueOf(extraProject.getId()))
                    .payment(ExtraSalaryTypeEnum.AWARD.equals(extraProject.getSalaryType()) || ExtraSalaryTypeEnum.SUBSIDY.equals(extraProject.getSalaryType()))
                    .salary(Boolean.FALSE)
                    .payrollStatus(SalaryPayrollStatusEnum.WAITING)
                    .monthly(YearMonth.from(extraProject.getDataDate()))
                    .groupId(groupId)
                    .build();
            pr.setAmount(extraProject.getMoney());
            payrollRecordService.save(pr);
        }
    }

    /**
     * 查询薪酬池
     *
     * @param userId
     * @param postId
     * @param shopId
     * @param date
     * @return
     */
    private Optional<SalaryPool> queryPoolByUser(Long userId, Long postId, Long shopId, Date date) {
        SalaryGroupUser user = salaryGroupUserService.queryUserByPostShopAndUserId(userId, postId, shopId, date);
        if (PublicUtil.isEmpty(user)) {
            return Optional.empty();
        }
        SalaryPool salaryPool = salaryPoolCommonService.inspectionPool(user);
        if (PublicUtil.isEmpty(salaryPool)) {
            return Optional.empty();
        }
        return Optional.of(salaryPool);
    }

    /**
     * 缓存处理失败的数据
     *
     * @param dto
     */
    private <T> void cacheFailProject(T dto, String key) {
        BoundListOperations<String, String> listOps = stringRedisTemplate.boundListOps(key);
        String jsonString = JSONObject.toJSONString(dto);
        listOps.rightPush(jsonString);
    }

    /**
     * 对象转换
     *
     * @param dto SalaryExtraDTO
     * @return SalaryExtraProject
     */
    private SalaryExtraProject transferBaseExtra(SalaryExtraDTO dto) {
        if (Objects.isNull(dto)) {
            return null;
        }
        SalaryExtraProject salaryExtraProject = new SalaryExtraProject();
        salaryExtraProject.setUserId(dto.getUserId());
        salaryExtraProject.setMoney(dto.getMoney());
        salaryExtraProject.setSalaryType(dto.getSalaryType());
        salaryExtraProject.setDataId(dto.getDataId());
        salaryExtraProject.setDataName(dto.getDataName());
        salaryExtraProject.setDataDate(DateUtil.date2LocalDate(dto.getDataDate()));
        salaryExtraProject.setTimely(PublicUtil.isEmpty(dto.getTimely()) ? Boolean.FALSE : dto.getTimely());
        salaryExtraProject.setYn(Boolean.TRUE);
        return salaryExtraProject;
    }


    /**
     * 对象转换
     *
     * @param req SalaryRewardReq
     * @return SalaryExtraDTO
     */
    private SalaryExtraDTO transferExtraProject(SalaryRewardReq req) {
        SalaryExtraDTO dto = new SalaryExtraDTO();
        dto.setUserId(req.getUserId());
        dto.setMoney(req.getAmount());
        dto.setSalaryType(ExtraSalaryTypeEnum.AWARD);
        if (!Boolean.TRUE.equals(req.getAward())) {
            dto.setSalaryType(ExtraSalaryTypeEnum.PENALTY);
        }
        dto.setDataId(req.getDataId());
        dto.setDataName(req.getDataName());
        dto.setDataDate(req.getDataTime());
        dto.setPostId(req.getPostId());
        dto.setShopId(req.getShopId());
        dto.setTimely(req.getTimely());
        return dto;
    }

    /**
     * 对象转换
     *
     * @param req SalaryRewardReq
     * @return SalaryExtraDTO
     */
    private SalaryExtraDTO transferExtraProject(GeneralSalaryProjectReq req, ExtraSalaryTypeEnum salaryTypeEnum) {
        SalaryExtraDTO dto = new SalaryExtraDTO();
        dto.setUserId(req.getUserId());
        dto.setSalaryType(salaryTypeEnum);
        dto.setMoney(req.getAmount());
        dto.setDataId(req.getDataId());
        dto.setDataName(req.getDataName());
        dto.setDataDate(req.getDataTime());
        dto.setPostId(req.getPostId());
        dto.setShopId(req.getShopId());
        dto.setTimely(Boolean.FALSE);
        return dto;
    }

    /**
     * 查询薪酬组人员
     *
     * @param salaryGroupUserQuery
     * @return
     */
    public List<SalaryGroupUserResult> querySalaryGroupUser(SalaryGroupUserQuery salaryGroupUserQuery) {
        final String salaryCode = salaryGroupUserQuery.getSalaryCode();
        final Long postId = salaryGroupUserQuery.getPostId();
        final Date dataDate = new Date(salaryGroupUserQuery.getDataDate());
        log.info("查询薪酬组人员，日期：{}", new SimpleDateFormat("yyyy-MM-dd").format(dataDate));

        SalaryProject salaryProject = salaryProjectService.queryByCode(salaryCode, Boolean.FALSE);
        BV.notNull(salaryProject, () -> "指标码不存在或已失效");

        ArrayList<SalaryGroupUserResult> list = new ArrayList<>();

        List<Long> salaryGroupIds = salaryGroupService.querySalaryGroupIdsByCode(salaryCode,
                postId, salaryGroupUserQuery.getGroupId(), dataDate);

        if (CollectionUtils.isEmpty(salaryGroupIds)) {
            log.error("没有对应的薪酬组数据【{}】", salaryGroupIds);
            return list;
        }

        List<SalaryGroupUser> groupUsers = salaryGroupUserService.list(Wrappers.<SalaryGroupUser>lambdaQuery()
                .in(SalaryGroupUser::getSalaryGroupId, new HashSet<>(salaryGroupIds))
                .eq(SalaryGroupUser::getDataDate, DateUtil.date2LocalDate(dataDate))
        );

        if (CollectionUtils.isEmpty(groupUsers)) {
            log.error("没有对应日期的薪酬组人员数据【薪酬组id：{}，日期：{}】", JSON.toJSONString(salaryGroupIds), DateUtil.getStringDateShort(dataDate));
            return list;
        }

        Map<Long, List<SalaryGroupUser>> salaryGroupUserMap = groupUsers.stream().collect(Collectors.groupingBy(SalaryGroupUser::getSalaryGroupId));
        for (List<SalaryGroupUser> valueArr : salaryGroupUserMap.values()) {
            SalaryGroupUserResult result = new SalaryGroupUserResult();
            result.setRoleCodeList(salaryProject.getRoleCodes());
            result.setUserIdList(transferUser(valueArr));
            list.add(result);
        }

        return list;
    }

    /**
     * 转换器  SalaryGroupUser -> SimpleUserData
     *
     * @param groupUsers
     * @return
     */
    private List<SalaryGroupUserResult.SimpleUserData> transferUser(List<SalaryGroupUser> groupUsers) {
        List<SalaryGroupUserResult.SimpleUserData> list = new ArrayList<>();
        for (SalaryGroupUser salaryGroupUser : groupUsers) {
            SalaryGroupUserResult.SimpleUserData simpleUserData = new SalaryGroupUserResult.SimpleUserData();
            simpleUserData.setUserId(salaryGroupUser.getUserId());
            simpleUserData.setUserName(salaryGroupUser.getUserName());
            simpleUserData.setShopId(salaryGroupUser.getShopId());
            simpleUserData.setShopName(salaryGroupUser.getShopName());
            list.add(simpleUserData);
        }

        return list;
    }

    public SalaryGroupUserResult queryGroupSalaryUser(SalaryGroupUserQuery salaryGroupUserQuery) {
        final Long groupId = salaryGroupUserQuery.getGroupId();
        final Date dataDate = new Date(salaryGroupUserQuery.getDataDate());
        log.info("查询薪酬组人员，日期：{}", new SimpleDateFormat("yyyy-MM-dd").format(dataDate));
        final YearMonth monthly = YearMonth.from(DateUtil.date2LocalDateTime(dataDate));
        List<SalaryGroupUserResult.SimpleUserData> userData = new ArrayList<>();

        List<SalaryPool> pools = salaryPoolService.list(Wrappers.<SalaryPool>lambdaQuery()
                .eq(SalaryPool::getGroupId, groupId)
                .eq(SalaryPool::getMonthly, monthly)
                .eq(SalaryPool::getYn, Boolean.TRUE)
        );
        SalaryGroupUserResult result = new SalaryGroupUserResult();
        if (PublicUtil.isEmpty(pools)) {
            result.setUserIdList(new ArrayList<>());
            return result;
        }
        for (SalaryPool pool : pools) {
            SalaryGroupUserResult.SimpleUserData simpleUserData = new SalaryGroupUserResult.SimpleUserData();
            simpleUserData.setUserId(pool.getUserId());
            simpleUserData.setUserName(pool.getUserName());
            simpleUserData.setShopId(pool.getShopId());
            simpleUserData.setShopName(pool.getShopName());
            userData.add(simpleUserData);
        }
        result.setUserIdList(userData);
        return result;
    }
}