ltc-eastar/src/main/java/com/malk/eastar/schedule/ScheduleTask9.java

package com.malk.eastar.schedule;

import com.alibaba.fastjson.JSONObject;
import com.malk.eastar.service.AitableService;
import com.malk.eastar.service.DDCoreClient;
import com.malk.eastar.service.YidaService;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.Scheduled;

import java.text.SimpleDateFormat;
import java.util.*;

/**
 * 多系统数据计算定时任务
 */
@Slf4j
@Configuration
@EnableScheduling
@ConditionalOnProperty(name = {"enable.scheduling"})
public class ScheduleTask9 {

    @Autowired
    private AitableService aitableService;

    @Autowired
    private YidaService yidaService;

    @Autowired
    private DDCoreClient ddCoreClient;

    /**
     * 计算新老客户
     */
    @Scheduled(cron = "0 45 6 * * ?")
    public void calculateNewOrOldCustomers() {
        log.info("计算新老客户开始");

        /*
            查询确认收款数据
         */
        log.info("查询确认收款数据");
        List<Map> confirmedReceiptData = new ArrayList<>();
        try {
            confirmedReceiptData = yidaService.queryConfirmedReceiptData();
            log.info("确认收款记录数量="+confirmedReceiptData.size());
        } catch (Exception e) {
            log.error("查询确认收款数据异常",e);
            return;
        }

        /*
            最近一年大货打款客户为老客户
         */
        Set<String> oldCustomerCodes = new HashSet<>();
        String customerCode;
        List<Map> subTableData;
        for (Map confirmedReceiptRecord : confirmedReceiptData){
            customerCode = (String) confirmedReceiptRecord.get("customerCode");
            subTableData = (List<Map>) confirmedReceiptRecord.get("subTableData");
            for (Map subTableRecord : subTableData){
                if(subTableRecord.get("customerCode") != null && customerCode.equals(subTableRecord.get("customerCode"))){
                    //仅大货打款为老客户
                    if("全款".equals(subTableRecord.get("receiptType"))
                            || "大货定金".equals(subTableRecord.get("receiptType"))
                            || "大货尾款".equals(subTableRecord.get("receiptType"))){
                        oldCustomerCodes.add(customerCode);
                    }
                }else{
                    log.info("客户（主表）与客户（子表）不一致："+confirmedReceiptRecord.get("processInstanceId"));
                }
            }
        }
        log.info("最近一年大货打款客户数量="+oldCustomerCodes.size());

        /*
            查询（易思达）客户名册所有记录
         */
        log.info("查询（易思达）客户名册所有记录");
        List<Map> ltcCustomerData = new ArrayList<>();
        try {
            ltcCustomerData = yidaService.queryLtcAllCustomerData();
        } catch (Exception e) {
            log.error("查询（易思达）客户名册异常",e);
            return;
        }

        /*
            更新老客户
         */
        String newOrOldFlag; //新老客户
        String formInstId;
        int count = 0;
        String customerAiTableId;
        Map syncLog;
        for (String oldCustomerCode : oldCustomerCodes){
            try {
                for (Map ltcCustomerRecord : ltcCustomerData){
                    if(oldCustomerCode.equals(ltcCustomerRecord.get("customerCode"))){
                        newOrOldFlag = ltcCustomerRecord.get("newOrOld").toString();
                        if("新".equals(newOrOldFlag)){
                            formInstId = ltcCustomerRecord.get("formInstId").toString();
                            log.info("修改为老客户："+ltcCustomerRecord.get("customerName").toString());
                            yidaService.updateLtcCustomerNewOrOld(formInstId, "老");
                            Thread.sleep(3000);
                            syncLog = new HashMap();
                            syncLog.put("logType","新老客户变更同步");
                            customerAiTableId = ltcCustomerRecord.get("aiTableId").toString();
                            syncLog.put("aiTableID",customerAiTableId);
                            syncLog.put("newOrOld","老客户");
                            log.info("数据同步日志："+JSONObject.toJSONString(syncLog));
                            yidaService.addSyncLog(syncLog);
                            count++;
                        }
                        //已找到该客户
                        break;
                    }
                }
            } catch (Exception e) {
                log.error("修改为老客户异常",e);
            }
        }

        if (count == 0){
            log.info("没有需要修改为老客户的记录");
        }

        /*
            筛选老客户标签的客户记录
         */
        log.info("筛选老客户标签的客户记录");
        List<Map> ltcCustomerDataFilter = new ArrayList<>();
        for (Map ltcCustomerRecord : ltcCustomerData){
            newOrOldFlag = ltcCustomerRecord.get("newOrOld").toString();
            if("老".equals(newOrOldFlag)){
                ltcCustomerDataFilter.add(ltcCustomerRecord);
            }
        }

        /*
            查询项目总表售前台账数据
         */
        log.info("查询项目总表售前台账数据");
        List<Map> sys1SaleData = new ArrayList<>();
        try {
            sys1SaleData = aitableService.querySys1AllSaleData();
            log.info("项目总表售前台账记录数量="+sys1SaleData.size());
        } catch (Exception e) {
            log.error("查询所有项目总表售前台账数据异常",e);
            return;
        }

        /*
            筛选实际成单日期在最近1年的记录
         */
        List<Map> sys1SaleDataFilter = new ArrayList<>();
        Long actualCloseDate;   //实际成单日期
        Long beginTime = System.currentTimeMillis() - 31536000000L;   //起始时间（一年前）
        Long endTime = System.currentTimeMillis();   //结束时间（当前时间）
        for (Map sys1SaleRecord : sys1SaleData){
            if(sys1SaleRecord.get("actualCloseDate") == null){
                continue;
            }
            actualCloseDate = Long.parseLong(sys1SaleRecord.get("actualCloseDate").toString());
            if(actualCloseDate >= beginTime && actualCloseDate < endTime){
                sys1SaleDataFilter.add(sys1SaleRecord);
            }
        }
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        log.info("实际成单日期在"+sdf.format(new Date(beginTime))+"至"+sdf.format(new Date(endTime))+"的记录数量="+sys1SaleDataFilter.size());

        /*
            最近1年有实际成单日期项目的关联客户以及有打款记录的客户保留老客户标识，其他客户更新为新客户标识
         */
        boolean isOrdered;
        count = 0;
        for (Map ltcCustomerRecord : ltcCustomerDataFilter){ //遍历老客户
//            System.out.println("老客户：" + ltcCustomerRecord.get("customerName").toString());
            customerCode = ltcCustomerRecord.get("customerCode").toString();
            if(oldCustomerCodes.contains(customerCode)){
                //有打款记录，保留老客户标识
                continue;
            }
            if(ltcCustomerRecord.get("aiTableId") == null){
                continue;
            }
            customerAiTableId = ltcCustomerRecord.get("aiTableId").toString();
            isOrdered = false;
            for (Map sys1SaleRecord : sys1SaleDataFilter){
                if(sys1SaleRecord.get("customerId") == null){
                    continue;
                }
                if(customerAiTableId.equals(sys1SaleRecord.get("customerId"))){
                    actualCloseDate = Long.parseLong(sys1SaleRecord.get("actualCloseDate").toString());
//                    System.out.println("实际成单日期：" + sdf.format(new Date(actualCloseDate)));
                    //有实际成单日期项目，保留老客户标识
                    isOrdered = true;
                    break;
                }
            }
            if(!isOrdered){
                try {
                    formInstId = ltcCustomerRecord.get("formInstId").toString();
                    //最近1年无实际成单日期项目，修改为新客户
                    log.info("修改为新客户：" + ltcCustomerRecord.get("customerName").toString());
                    yidaService.updateLtcCustomerNewOrOld(formInstId, "新");
                    Thread.sleep(3000);
                    syncLog = new HashMap();
                    syncLog.put("logType","新老客户变更同步");
                    customerAiTableId = ltcCustomerRecord.get("aiTableId").toString();
                    syncLog.put("aiTableID",customerAiTableId);
                    syncLog.put("newOrOld","新客户");
                    yidaService.addSyncLog(syncLog);
                    count++;
                } catch (Exception e) {
                    log.error("修改为新客户异常",e);
                }
            }
        }

        if(count == 0){
            log.info("没有需要修改为新客户的记录");
        }


        log.info("计算新老客户结束");
    }

    /**
     * 计算业务员私海客户数量
     */
    @Scheduled(cron = "0 30 10,16 * * ?")
    public void calculateBusinessUserPrivateCustomerNum() {
        log.info("计算业务员私海客户数量开始");

        /*
            查询易思达系统所有在职业务员档案
         */
        log.info("查询易思达系统所有在职业务员档案");
        List<Map> ltcBusinessUserData = new ArrayList<>();
        try {
            ltcBusinessUserData = yidaService.queryEmployedBusinessUserData();
            log.info("所有在职业务员档案数量="+ltcBusinessUserData.size());
        } catch (Exception e) {
            log.error("查询易思达系统所有在职业务员档案异常",e);
            return;
        }

        /*
            1、获取userId列表和unionId列表
            2、获取userId与formInstId映射
            3、获取unionId与formInstId映射
         */
        List<String> userIdList = new ArrayList<>();
        List<String> unionIdList = new ArrayList<>();
        Map<String, String> userIdFormInstIdMap = new HashMap<>();
        Map<String, String> unionIdFormInstIdMap = new HashMap<>();
        String userId;
        String unionId;
        String formInstId;
        for(Map ltcBusinessUserRecord : ltcBusinessUserData){
            userId = "";
            unionId = "";
            formInstId = "";
            try {
                userId = ltcBusinessUserRecord.get("userId").toString();
                if(userId == null || StringUtils.isEmpty(userId)){
                    System.out.println("userId为空！");
                    continue;
                }
                unionId = ddCoreClient.getUnionIdByUserId(userId);
                if(unionId == null || StringUtils.isEmpty(unionId)){
                    System.out.println("userId="+userId+"，unionId为空！");
                    continue;
                }
                userIdList.add(userId);
                unionIdList.add(unionId);
                formInstId = ltcBusinessUserRecord.get("formInstId").toString();
                userIdFormInstIdMap.put(userId, formInstId);
                unionIdFormInstIdMap.put(unionId, formInstId);
            } catch (Exception e) {
                System.out.println(userId);
                log.error("获取userId和unionId映射关系异常",e);
                return;
            }

        }

        /*
            查询（易思达）客户名册所有记录
         */
        log.info("查询（易思达）客户名册所有记录");
        List<Map> ltcCustomerData = new ArrayList<>();
        try {
            ltcCustomerData = yidaService.queryLtcAllCustomerData();
            log.info("易思达系统客户数量="+ltcCustomerData.size());
        } catch (Exception e) {
            log.error("查询（易思达）客户名册异常",e);
            return;
        }

        /*
            从项目总表（系统1）获取客户数据
         */
        log.info("查询项目总表客户名册所有记录");
        List<Map> sys1CustomerData = new ArrayList<>();
        try {
            sys1CustomerData = aitableService.querySys1CustomerData();
            log.info("项目总表客户数量="+sys1CustomerData.size());
        } catch (Exception e) {
            log.error("查询项目总表客户数据异常",e);
            return;
        }

        String testUseFlag; //测试使用
        String seaType; //公海/私海
        String newOrOldFlag; //新老客户
        String businessUserId; //业务员userId
        String businessUnionId; //业务员unionId
        Map<String, Integer> privateCustomerNumMap; //业务员私海客户数量
        int numOfPrivateCustomer;
        Map<String, Integer> privateNewCustomerNumMap; //业务员新客户数量
        int numOfPrivateNewCustomer;
        Map<String, Integer> privateOldCustomerNumMap; //业务员老客户数量
        int numOfPrivateOldCustomer;

        /*
            统计易思达系统私海客户数量
            同时按新老客户统计
         */
        privateCustomerNumMap = new HashMap<>();
        privateNewCustomerNumMap = new HashMap<>();
        privateOldCustomerNumMap = new HashMap<>();
        for(Map ltcCustomerRecord : ltcCustomerData){
            businessUserId = "";
            try {
                testUseFlag = "";
                if(ltcCustomerRecord.get("testUseFlag") != null){
                    testUseFlag = ltcCustomerRecord.get("testUseFlag").toString();
                }
                if(!"否".equals(testUseFlag)){
                    //忽略测试使用的客户
                    continue;
                }
                seaType = "";
                if(ltcCustomerRecord.get("seaType") != null){
                    seaType = ltcCustomerRecord.get("seaType").toString();
                }
                if(!"私".equals(seaType)){
                    //忽略非私海客户
                    continue;
                }
                if(ltcCustomerRecord.get("userId") != null && StringUtils.isNotEmpty(ltcCustomerRecord.get("userId").toString())){
                    businessUserId = ltcCustomerRecord.get("userId").toString();
                    if(userIdList.contains(businessUserId)){
                        if(privateCustomerNumMap.containsKey(businessUserId)){
                            privateCustomerNumMap.put(businessUserId, privateCustomerNumMap.get(businessUserId) + 1);
                        }else{
                            privateCustomerNumMap.put(businessUserId, 1);
                        }
                        newOrOldFlag = ltcCustomerRecord.get("newOrOld").toString();
                        if("新".equals(newOrOldFlag)){
                            if(privateNewCustomerNumMap.containsKey(businessUserId)){
                                privateNewCustomerNumMap.put(businessUserId, privateNewCustomerNumMap.get(businessUserId) + 1);
                            }else{
                                privateNewCustomerNumMap.put(businessUserId, 1);
                            }
                        }else if("老".equals(newOrOldFlag)){
                            if(privateOldCustomerNumMap.containsKey(businessUserId)){
                                privateOldCustomerNumMap.put(businessUserId, privateOldCustomerNumMap.get(businessUserId) + 1);
                            }else{
                                privateOldCustomerNumMap.put(businessUserId, 1);
                            }
                        }else{
                            //忽略非新老客户
                        }
                    }else{
                        log.info("业务员已离职：" + businessUserId);
                    }
                }else{
                    log.info("私海客户["+ltcCustomerRecord.get("customerName")+"]业务员为空");
                }
            } catch (Exception e) {
                log.info("业务员ID：" + businessUserId);
                log.error("匹配客户名册表业务员与业务员档案表业务员异常",e);
            }
        }

//        if(privateCustomerNumMap.isEmpty()){
//            log.info("业务员私海客户数量获取不正确");
//            return;
//        }

        /*
            更新各业务员私海客户数量
         */
//        for (String userIdKey : userIdList){
//            if(privateCustomerNumMap.containsKey(userIdKey)){
//                numOfPrivateCustomer = privateCustomerNumMap.get(userIdKey);
//            }else{
//                //私海客户归0
//                numOfPrivateCustomer = 0;
//            }
//            try {
//                formInstId = userIdFormInstIdMap.get(userIdKey);
//                log.info("更新各业务员私海客户数量：" + formInstId + " " + numOfPrivateCustomer);
//                yidaService.updateLtcBusinessUserPrivateCustomerNum(formInstId, numOfPrivateCustomer);
//            } catch (Exception e) {
//                log.error("更新各业务员私海客户数量异常",e);
//            }
//            if(privateNewCustomerNumMap.containsKey(userIdKey)){
//                numOfPrivateNewCustomer = privateNewCustomerNumMap.get(userIdKey);
//            }else{
//                //新客户归0
//                numOfPrivateNewCustomer = 0;
//            }
//            try {
//                formInstId = userIdFormInstIdMap.get(userIdKey);
//                log.info("更新各业务员新客户数量：" + formInstId + " " + numOfPrivateNewCustomer);
//                yidaService.updateLtcBusinessUserPrivateNewCustomerNum(formInstId, numOfPrivateNewCustomer);
//            } catch (Exception e) {
//                log.error("更新各业务员新客户数量异常",e);
//            }
//            if(privateOldCustomerNumMap.containsKey(userIdKey)){
//                numOfPrivateOldCustomer = privateOldCustomerNumMap.get(userIdKey);
//            }else{
//                //老客户归0
//                numOfPrivateOldCustomer = 0;
//            }
//            try {
//                formInstId = userIdFormInstIdMap.get(userIdKey);
//                log.info("更新各业务员老客户数量：" + formInstId + " " + numOfPrivateOldCustomer);
//                yidaService.updateLtcBusinessUserPrivateOldCustomerNum(formInstId, numOfPrivateOldCustomer);
//            } catch (Exception e) {
//                log.error("更新各业务员老客户数量异常",e);
//            }
//        }



        /*
            统计项目总表私海客户数量
            私海客户总数
            同时按新老客户统计
         */
        privateCustomerNumMap = new HashMap<>();
        privateNewCustomerNumMap = new HashMap<>();
        privateOldCustomerNumMap = new HashMap<>();
        for(Map sys1CustomerRecord : sys1CustomerData){
            try {
                testUseFlag = "";
                if(sys1CustomerRecord.get("testUseFlag") != null){
                    testUseFlag = sys1CustomerRecord.get("testUseFlag").toString();
                }
                if(!"否".equals(testUseFlag)){
                    //忽略测试使用的客户
                    continue;
                }
                if(sys1CustomerRecord.get("businessUserUnionId") != null && StringUtils.isNotEmpty(sys1CustomerRecord.get("businessUserUnionId").toString())){
                    businessUnionId = sys1CustomerRecord.get("businessUserUnionId").toString();
                    if(unionIdList.contains(businessUnionId)){
                        if(privateCustomerNumMap.containsKey(businessUnionId)){
                            privateCustomerNumMap.put(businessUnionId, privateCustomerNumMap.get(businessUnionId) + 1);
                        }else{
                            privateCustomerNumMap.put(businessUnionId, 1);
                        }
                        newOrOldFlag = sys1CustomerRecord.get("newOrOld").toString();
                        if("新".equals(newOrOldFlag)){
                            if(privateNewCustomerNumMap.containsKey(businessUnionId)){
                                privateNewCustomerNumMap.put(businessUnionId, privateNewCustomerNumMap.get(businessUnionId) + 1);
                            }else{
                                privateNewCustomerNumMap.put(businessUnionId, 1);
                            }
                        }else if("老".equals(newOrOldFlag)){
                            if(privateOldCustomerNumMap.containsKey(businessUnionId)){
                                privateOldCustomerNumMap.put(businessUnionId, privateOldCustomerNumMap.get(businessUnionId) + 1);
                            }else{
                                privateOldCustomerNumMap.put(businessUnionId, 1);
                            }
                        }else{
                            //忽略非新老客户
                        }
                    }else{
                        log.info("业务员已离职：" + businessUnionId);
                    }
                }
            } catch (Exception e) {
                log.error("匹配项目总表客户名册表业务员与业务员档案表业务员异常",e);
            }
        }

        if(privateCustomerNumMap.isEmpty()){
            log.info("业务员私海客户数量（项目总表）获取不正确");
            return;
        }


        /*
            更新各业务员私海客户数量（项目总表）
         */
        for (String unionIdKey : unionIdList){
            if(privateCustomerNumMap.containsKey(unionIdKey)){
                numOfPrivateCustomer = privateCustomerNumMap.get(unionIdKey);
            }else{
                //私海客户归0
                numOfPrivateCustomer = 0;
            }
            try {
                formInstId = unionIdFormInstIdMap.get(unionIdKey);
                log.info("更新各业务员私海客户数量（项目总表）：" + formInstId + " " + numOfPrivateCustomer);
                yidaService.updateLtcBusinessUserPrivateCustomerNum2(formInstId, numOfPrivateCustomer);
            } catch (Exception e) {
                log.error("更新各业务员私海客户数量（项目总表）异常",e);
            }
            if(privateNewCustomerNumMap.containsKey(unionIdKey)){
                numOfPrivateNewCustomer = privateNewCustomerNumMap.get(unionIdKey);
            }else{
                //新客户归0
                numOfPrivateNewCustomer = 0;
            }
            try {
                formInstId = unionIdFormInstIdMap.get(unionIdKey);
                log.info("更新各业务员新客户数量（项目总表）：" + formInstId + " " + numOfPrivateNewCustomer);
                yidaService.updateLtcBusinessUserPrivateNewCustomerNum2(formInstId, numOfPrivateNewCustomer);
            } catch (Exception e) {
                log.error("更新各业务员新客户数量（项目总表）异常",e);
            }
            if(privateOldCustomerNumMap.containsKey(unionIdKey)){
                numOfPrivateOldCustomer = privateOldCustomerNumMap.get(unionIdKey);
            }else{
                //老客户归0
                numOfPrivateOldCustomer = 0;
            }
            try {
                formInstId = unionIdFormInstIdMap.get(unionIdKey);
                log.info("更新各业务员老客户数量（项目总表）：" + formInstId + " " + numOfPrivateOldCustomer);
                yidaService.updateLtcBusinessUserPrivateOldCustomerNum2(formInstId, numOfPrivateOldCustomer);
            } catch (Exception e) {
                log.error("更新各业务员老客户数量（项目总表）异常",e);
            }
        }

        log.info("计算业务员私海客户数量结束");
    }

}