package com.bcxin.sp.work.timer;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.text.StrSpliter;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.StrUtil;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.TypeReference;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.bcxin.sp.work.dao.activity.approve.ApproveHistoryMapper;
import com.bcxin.sp.work.dao.activity.base.ActivityMapper;
import com.bcxin.sp.work.dao.activity.extend.*;
import com.bcxin.sp.work.dao.sys.RegionMapper;
import com.bcxin.sp.work.entity.domain.activity.approve.ApproveHistory;
import com.bcxin.sp.work.entity.domain.activity.base.Activity;
import com.bcxin.sp.work.entity.domain.activity.expand.ActivityContractor;
import com.bcxin.sp.work.entity.domain.activity.expand.ActivityDetail;
import com.bcxin.sp.work.entity.domain.activity.expand.ActivityMaterial;
import com.bcxin.sp.work.entity.domain.activity.expand.SyncTask;
import com.bcxin.sp.work.entity.domain.activity.session.ActivitySession;
import com.bcxin.sp.work.entity.domain.log.ChangeLog;
import com.bcxin.sp.work.entity.domain.log.FileSyncLog;
import com.bcxin.sp.work.entity.domain.upgrade.SystemUpgrade;
import com.bcxin.sp.work.entity.dto.ContractorSPDTO;
import com.bcxin.sp.work.service.activity.approve.ApproveFileService;
import com.bcxin.sp.work.service.activity.approve.ApproveService;
import com.bcxin.sp.work.service.activity.base.ActivityService;
import com.bcxin.sp.work.service.common.NotifyService;
import com.bcxin.sp.work.service.log.ChangeLogService;
import com.bcxin.sp.work.service.log.LogService;
import com.bcxin.sp.work.service.upgrade.SystemUpgradeService;
import com.bcxin.sp.work.util.BcxinDateUtil;
import com.bcxin.sp.work.util.BcxinFileUtil;
import com.bcxin.sp.work.util.Const.DictConst;
import com.bcxin.sp.work.util.Const.GlobalConst;
import com.bcxin.sp.work.util.Const.TipsConst;
import com.bcxin.sp.work.util.StringUtil;
import com.bcxin.sp.work.util.sys.ConfigUtil;
import com.google.common.base.Joiner;
import com.google.common.collect.Lists;
import com.google.common.io.Files;
import lombok.extern.slf4j.Slf4j;
import org.apache.tools.ant.util.FileUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.io.BufferedReader;
import java.io.File;
import java.io.IOException;
import java.math.BigDecimal;
import java.nio.file.*;
import java.nio.file.attribute.BasicFileAttributes;
import java.text.SimpleDateFormat;
import java.util.*;

import static com.google.common.base.CharMatcher.DIGIT;

/**
 * <b>Function </b> 浠巔ss鑾峰彇娲诲姩淇℃伅
 *
 * @author LuoPeng
 * @娉ㄦ剰浜嬮」 </b>
 * <b>
 */
@Service("syncActivityService")
@Transactional
@Slf4j
public class SyncActivityService {

    /**
     * 鍚屾娲诲姩璇︾粏淇℃伅锛屾枃浠舵爣璇�
     */
    private final static String ACD = "_acd_";

    /**
     * 鍚屾娲诲姩绛夌骇璇勫畾閲嶆柊鐢宠鍘熷洜淇℃伅锛屾枃浠舵爣璇�
     */
    private final static String ACGR = "_acgr_";

    /**
     * 鍚屾璁稿彲瀹℃壒鏉愭枡锛屾枃浠舵爣璇�
     */
    private final static String AXKSP = "_axksp_";

    /**
     * 鍚屾瀹夊叏宸ヤ綔鏂规锛屾枃浠舵爣璇�
     */
    private final static String ACAF = "_acaf_";

    /**
     * 鍚屾璇勪及鏉愭枡锛屾枃浠舵爣璇�
     */
    private final static String APGCL = "_apgcl_";

    /**
     * 鍚屾娲诲姩璇勪及鎶ュ憡锛屾枃浠舵爣璇�
     */
    private final static String ACR = "_acr_";

    /**
     * 鍚屾娲诲姩宸紓鏃ュ織
     */
    private final static String ACT_CHANGE_LOG = "_ACT_CHANGE_LOG_";

    /**
     * 鍚屾鍐呯綉鍗囩骇鏃ュ織
     */
    private final static String SP_UPGRADE_LOG = "_SP_UPGRADE_LOG_";

    /**
     * 鍚屾鎵垮姙鏂逛俊鎭紝鏂囦欢鏍囪瘑
     */
    private final static String ACC = "_acc_";

    /**
     * 鍚屾娲诲姩鏂囦欢澶瑰悕绉�
     */
    private final static String HD_FOLDER = "hd";

    /**
     * 姘镐箙瀛樻斁鏂囦欢澶�
     */
    private final static String STORE_FOLDER = "store";

    /**
     * 鍚屾瀹℃壒缁撴灉鏍囪瘑锛屾枃浠舵爣璇�
     */
    private final static String APPR = "_appr_";

    /**
     * 鍚屾瀹℃壒鏂囦欢澶瑰悕绉�
     */
    private final static String SP_FOLDER = "sp";

    /**
     * 灏唘rl鍖呰鎴愬彲涓嬭浇鐨勮矾寰勫墠缂€
     */
    private final static String PACK_DOWNLOAD = "/getResource?path=";

    @Resource
    private ActivityService activityService;

    @Resource
    private NotifyService notifyService;

    @Resource
    private ActivityMapper activityMapper;

    @Resource
    private ActivityMaterialMapper activityMaterialMapper;

    @Resource
    private ApproveHistoryMapper approveHistoryMapper;

    @Resource
    private SyncTaskMapper syncTaskMapper;

    @Resource
    private ActivityContractorMapper activityContractorMapper;
    @Resource
    private ActivitySessionMapper activitySessionMapper;

    @Resource
    private LogService logService;

    @Resource
    private ApproveService approveService;

    @Resource
    private RegionMapper regionMapper;

    @Resource
    private ActivityDetailMapper activityDetailMapper;

    @Resource
    private ApproveFileService approveFileService;

    @Resource
    private SystemUpgradeService upgradeService;

    public List findAllFilesInDirectory(Path pathToDir) throws IOException {

        final List<File> pathsToFiles = new ArrayList<>();
        java.nio.file.Files.walkFileTree(pathToDir, new SimpleFileVisitor() {
            public FileVisitResult visitFile(Path path, BasicFileAttributes attrs) throws IOException {
                log.info("鍚屾鐨勭洰褰曟枃浠�.findAllFilesInDirectory.path锛�" + path.toString());
                if (java.nio.file.Files.isRegularFile(path)) {
                    pathsToFiles.add(path.toFile());
                }
                return FileVisitResult.CONTINUE;
            }
        });
        log.info("鍚屾鐨勭洰褰曟枃浠�.pathsToFiles.size锛�" + pathsToFiles.size());
        return pathsToFiles;

    }

    /**
     * 鍚屾娲诲姩淇℃伅
     * 鍚屾鎶ユ壒鏉愭枡
     *
     * @throws Exception
     */
    public synchronized void importData() throws Exception {
        log.info("寮€濮嬪悓姝ユ椿鍔ㄤ俊鎭�");
        String month = DateUtil.today().substring(0, 7);
        String envi = ConfigUtil.getValue("envi");
        String mode = ConfigUtil.getValue("pss-communicate-mode");
        String materialPath = ConfigUtil.getValue("stuff-path");
        List<File> allFileList = Lists.newArrayList();

        String[] dateDirs = new String[]{BcxinDateUtil.getCurrentDate(), BcxinDateUtil.getPastDate(1),
                BcxinDateUtil.getPastDate(2), BcxinDateUtil.getPastDate(3),
                BcxinDateUtil.getPastDate(4), BcxinDateUtil.getPastDate(5),
                BcxinDateUtil.getPastDate(6)};

        /* 鏂囦欢鑷姩璇诲彇锛屽彧瑕佽涓ゅぉ鐨勬枃浠跺氨鍙互浜� */
        if ("file".equals(mode)) {
            dateDirs = new String[]{BcxinDateUtil.getCurrentDate(), BcxinDateUtil.getPastDate(1)};
        }

        for (String dateDir : dateDirs) {
            //閬嶅巻褰撳ぉ鐨勬枃浠跺す
            String[] folderPath = new String[]{materialPath, envi, dateDir, HD_FOLDER};
            String dir = BcxinFileUtil.appendFolderPath(folderPath);

            File dirFile = new File(dir);
            log.info("鍚屾鐨勭洰褰曪細" + dir);
            if (dirFile.exists()) {
                File[] files = dirFile.listFiles();
                if (files != null) {
                    allFileList.addAll(Arrays.asList(files));
                }
            } else {
                dirFile.mkdirs();
            }
            //TODO
            findAllFilesInDirectory(Paths.get(dir));
        }

        if (CollectionUtil.isEmpty(allFileList)) {
            log.info("鏂囦欢澶规槸绌虹殑");
            return;
        }

        List<String> syncFileNameList = Lists.newArrayList();
        for (File file : allFileList) {
            String fileName = file.getName();
            // 淇濆瓨宸紓鏃ュ織
            if (fileName.startsWith(ACT_CHANGE_LOG)) {
                saveChangeLog(syncFileNameList, file);
                continue;
            }
            // 淇濆瓨鍗囩骇鏃ュ織
            if (fileName.startsWith(SP_UPGRADE_LOG)) {
                saveUpgradeLog(syncFileNameList, file);
                continue;
            }
            FileSyncLog fileSyncLog = logService.findRecord(fileName);
            /*濡傛灉鏂囦欢鍚嶅瓨鍦紝璇佹槑宸茬粡鍚屾杩囷紝鍒欎笉鍐嶅悓姝�*/
            if (fileSyncLog != null) {
                if (DictConst.Y.equals(fileSyncLog.getMarkRead())) {
                    continue;
                }
            }
            if (syncFileNameList.contains(fileName)) {
                continue;
            }
            if (fileSyncLog == null) {
                fileSyncLog = new FileSyncLog();
            }
            fileSyncLog.setFileName(fileName);
            //鍚屾娲诲姩淇℃伅
            if (fileName.startsWith(ACD)) {
                String activityId = DIGIT.retainFrom(BcxinFileUtil.filterTimestamp(fileName));
                if (isNotEmpty(activityId)) {
                    try {
                        Activity activity = activityService.findByPssId(Long.parseLong(activityId));
                        //杩樻湭寮€濮嬪鍏�
                        if (activity == null) {
                            log.info("寮€濮嬭В鏋愭枃浠讹細" + fileName);
                            boolean flag = saveActivity(null, file, allFileList, syncFileNameList);
                            if (flag) {
                                fileSyncLog.setMarkRead(DictConst.Y);
                            }
                        }
                        //宸茬粡瀵煎叆锛岀浜屾涓轰慨鏀规椿鍔ㄤ俊鎭�
                        else {
                            log.info("寮€濮嬭В鏋愭枃浠讹細" + fileName);
                            log.info("淇敼娲诲姩淇℃伅锛�" + activity.getFullName());
                            boolean flag = saveActivity(activity, file, allFileList, syncFileNameList);
                            if (flag) {
                                fileSyncLog.setMarkRead(DictConst.Y);
                            }
                        }
                    } catch (Exception e) {
                        e.printStackTrace();
                        continue;
                    }
                }

                logService.mergeMark(fileSyncLog);
                syncFileNameList.add(fileName);
                if (DictConst.Y.equals(fileSyncLog.getMarkRead())) {
                    /* 闃呰瀹屽悗鍒犻櫎鏂囦欢 */
                    FileUtils.delete(file);
                }
            }
            //鍚屾璇勪及鏉愭枡
            else if (fileName.startsWith(APGCL)) {
                String activityId = DIGIT.retainFrom(BcxinFileUtil.filterTimestamp(fileName));
                if (isNotEmpty(activityId)) {
                    Activity activity = activityService.findByPssId(Long.parseLong(activityId));
                    if (activity == null) {
                        continue;
                    }
                    /* 鏄斂搴滈」鐩�+澶囨椤圭洰锛岀洿鎺ユ洿鏂版潗鏂欏唴瀹� */
                    if (activity.isGov() && Objects.equals(DictConst.Y, activity.getIsBackUp())) {
                        ActivityMaterial material = activityMaterialMapper.findByActivityId(activity.getId());
                        material.setPgcl(PACK_DOWNLOAD + file.getPath());
                        activityMaterialMapper.updateById(material);

                        // 鏀垮簻椤圭洰锛氶噸鏂版彁浜ゆ姤澶囷紝鐘舵€佽閲嶇疆涓烘姤澶�
                        activity.setApproveStatus(DictConst.STATUS_YES);
                        activityMapper.updateById(activity);

                        fileSyncLog.setMarkRead(DictConst.Y);
                        logService.mergeMark(fileSyncLog);
                        syncFileNameList.add(fileName);
                        /* 閲嶆柊鎻愪氦鎶ュ */
                        saveBBCLComment(activity, file, allFileList, syncFileNameList);
                        continue;
                    }
                    // 濡傛灉娲诲姩灏氭湭杩涜鍒濆鍖栬繃锛屽垯璁剧疆鎶ユ壒鏉愭枡璺緞
                    if (Objects.equals(activity.getApproveStatus(), DictConst.STATUS_CSZ)) {
                        ActivityMaterial material = activityMaterialMapper.findByActivityId(activity.getId());
                        /* 濡傛灉鎶ユ壒鏉愭枡涔嬪墠涓嶄负绌猴紝璇存槑鏄噸鏂版彁浜ょ殑锛屽鍔犲悇鍘嗗彶璁板綍 */
                        if (StringUtil.isNotEmpty(material.getPgcl())) {
                            ApproveHistory history = new ApproveHistory();
                            history.setIsReset(DictConst.Y);
                            history.setApproveType(DictConst.APPROVETYPE_CS);
                            history.setAddTime(new Date());
                            history.setActivityId(activity.getId());
                            history.setContent(TipsConst.TJPGCL);
                            history.setUserName(activity.getSponsor());
                            approveHistoryMapper.insert(history);
                            /* 澧炲姞閫氱煡 */
                            notifyService.cxtjcl(activity);
                        }
                        material.setPgcl(PACK_DOWNLOAD + file.getPath());
                        activityMaterialMapper.updateById(material);

                        fileSyncLog.setMarkRead(DictConst.Y);
                        logService.mergeMark(fileSyncLog);
                    } else {
                        /* 鍙洿鏂拌瘎浼版潗鏂� */
                        ActivityMaterial material = activityMaterialMapper.findByActivityId(activity.getId());
                        /* 濡傛灉璇勪及鏉愭枡涔嬪墠涓嶄负绌猴紝璇存槑鏄噸鏂版彁浜ょ殑锛屽鍔犲悇鍘嗗彶璁板綍 */
                        if (StringUtil.isNotEmpty(material.getPgcl())) {
                            ApproveHistory history = new ApproveHistory();
                            history.setIsReset(DictConst.Y);
                            history.setApproveType(DictConst.APPROVETYPE_CS);
                            history.setAddTime(new Date());
                            history.setActivityId(activity.getId());
                            history.setContent(TipsConst.TJPGCL);
                            history.setUserName(activity.getSponsor());
                            approveHistoryMapper.insert(history);
                            /* 澧炲姞閫氱煡 */
                            notifyService.cxtjpgcl(activity);
                        }
                        material.setPgcl(PACK_DOWNLOAD + file.getPath());
                        activityMaterialMapper.updateById(material);

                        fileSyncLog.setMarkRead(DictConst.Y);
                        logService.mergeMark(fileSyncLog);
                    }
                    syncFileNameList.add(fileName);
                    /* 闃呰瀹屽悗鍒犻櫎鏂囦欢 */
                    //FileUtils.delete(file);
                    if ("on".equalsIgnoreCase(ConfigUtil.getValue("switch_zjzw20"))) {
                        if ("330000".equals(activity.getProvince())) {
                            activityMapper.updateActivityByIsAddFiles(null,Long.valueOf(activityId), DictConst.Y);
                        }
                    }
                }
            } else if (fileName.startsWith(ACR) && !fileName.contains("_comment")) { //鍚屾璇勪及鎶ュ憡
                String activityId = DIGIT.retainFrom(BcxinFileUtil.filterTimestamp(fileName));
                if (isNotEmpty(activityId)) {
                    Activity activity = activityService.findByPssId(Long.parseLong(activityId));
                    if (activity == null) {
                        continue;
                    }
                    /* 濡傛灉鏄垵瀹￠€氳繃锛屽垯鍚屾鎶ュ憡锛屽彉鎴愬彈鐞嗕腑 */
                    /* 濡傛灉鏄紑鍚紑鍚瓑绾ц瘎瀹氾紝鍒欓渶瑕佸畨鍏ㄥ伐浣滄柟妗堟墠鍙互鍙樻垚鍙楃悊涓紝鏇存柊璇勪及鎶ュ憡涓嶅仛澶勭悊*/
                    if (DictConst.STATUS_CSTG.equals(activity.getApproveStatus())
                            && !GlobalConst.SWITCH_ON.equals(ConfigUtil.getValue("switch_gradeRank"))) {

                        activity.setApproveStatus(DictConst.STATUS_SLZ);

                        ApproveHistory history = new ApproveHistory();
                        history.setIsReset(DictConst.Y);
                        history.setApproveType(DictConst.APPROVETYPE_SL);
                        history.setAddTime(new Date());
                        history.setActivityId(activity.getId());
                        history.setContent(TipsConst.TJSP);
                        history.setUserName(activity.getSponsor());
                        approveHistoryMapper.insert(history);

                        /* 娑堟伅閫氱煡 */
                        notifyService.submitApprovalNotify(activity);
                    }

                    // 瀹℃壒闃舵锛屾棤闇€鏍￠獙浜烘暟
                    activityService.createOrUpdate(activity, true);

                    boolean logHistory = false;
                    for (File f : allFileList) {
                        /* 鎵惧埌璇勪及鎶ュ憡瀵瑰簲鐨勫娉� */
                        if (f.getName().equals(Files.getNameWithoutExtension(fileName) + "_comment.txt")) {
                            /* 鏍囪鏂囨。鍚屾 */
                            FileSyncLog fileSyncLog2 = logService.findRecord(f.getName());
                            if (fileSyncLog2 == null) {
                                fileSyncLog2 = new FileSyncLog();
                            }
                            fileSyncLog2.setFileName(f.getName());
                            fileSyncLog2.setMarkRead(DictConst.Y);
                            String comment = "";
                            try {
                                /* 璇诲彇澶囨敞 */
                                Path fpath = Paths.get(f.getPath());
                                BufferedReader bfr = java.nio.file.Files.newBufferedReader(fpath);
                                comment = bfr.readLine();
                                bfr.close();
                            } catch (Exception e) {
                                e.printStackTrace();
                            }
                            ApproveHistory history2 = new ApproveHistory();
                            history2.setIsReset(DictConst.Y);
                            history2.setApproveType(DictConst.APPROVETYPE_SP);
                            history2.setAddTime(new Date());
                            history2.setActivityId(activity.getId());
                            history2.setContent(TipsConst.CXTJPGBG);
                            history2.setUserName(activity.getSponsor());
                            history2.setOpinion(comment);
                            try {
                                approveHistoryMapper.insert(history2);
                                /* 娑堟伅閫氱煡 */
                                notifyService.resubmitAssessmentNotify(activity);
                                logHistory = true;
                            } catch (Exception e) {
                                fileSyncLog2.setMarkRead(DictConst.N);
                                e.printStackTrace();
                            }
                            logService.mergeMark(fileSyncLog2);
                            syncFileNameList.add(f.getName());
                        }
                    }
                    /* 鏇存柊璇勪及鎶ュ憡 */
                    ActivityMaterial material = activityMaterialMapper.findByActivityId(activity.getId());
                    if (fileName.contains("third")) {
                        material.setPgbgProvider("2");
                    } else {
                        material.setPgbgProvider("1");
                    }
                    String[] folderPath = new String[]{materialPath, STORE_FOLDER, month};
                    String dir = BcxinFileUtil.appendFolderPath(folderPath);
                    File newFile = new File(dir + File.separator + file.getName());
                    Files.copy(file, newFile);
                    material.setPgbg(PACK_DOWNLOAD + newFile.getPath());
                    activityMaterialMapper.updateById(material);
                    if (!logHistory) {
                        /* 娑堟伅閫氱煡 */
                        notifyService.submitAssessmentNotify(activity);
                        /* 璁板綍鍘嗗彶璁板綍 */
                        ApproveHistory history = new ApproveHistory();
                        history.setIsReset(DictConst.Y);
                        history.setApproveType(DictConst.APPROVETYPE_SP);
                        history.setAddTime(new Date());
                        history.setActivityId(activity.getId());
                        history.setContent(TipsConst.TJPGBG);
                        history.setUserName(activity.getSponsor());
                        approveHistoryMapper.insert(history);
                    }
                    fileSyncLog.setMarkRead(DictConst.Y);
                    logService.mergeMark(fileSyncLog);
                    syncFileNameList.add(fileName);
                    /* 闃呰瀹屽悗鍒犻櫎鏂囦欢 */
                    FileUtils.delete(file);
                }
            } else if (fileName.startsWith(AXKSP)) { //鍚屾璁稿彲瀹℃壒鏉愭枡
                String activityId = DIGIT.retainFrom(BcxinFileUtil.filterTimestamp(fileName));
                if (isNotEmpty(activityId)) {
                    Activity activity = activityService.findByPssId(Long.parseLong(activityId));
                    if (activity == null) {
                        continue;
                    }
                    /* 濡傛灉鏄瓑绾ц瘎瀹氶€氳繃锛屽垯鍚屾瀹夊叏宸ヤ綔鏂规锛屽彉鎴愬彈鐞嗕腑 */
                    /* 濡傛灉鏄紑鍚紑鍚瓑绾ц瘎瀹氾紝鍒欓渶瑕佸畨鍏ㄥ伐浣滄柟妗堟墠鍙互鍙樻垚鍙楃悊涓紝鏇存柊璇勪及鎶ュ憡涓嶅仛澶勭悊*/
                    if (DictConst.STATUS_CSTG.equals(activity.getApproveStatus())
                            && GlobalConst.SWITCH_ON.equals(ConfigUtil.getValue("switch_gradeRank"))) {
                        activity.setApproveStatus(DictConst.STATUS_SLZ);

                        ApproveHistory history = new ApproveHistory();
                        history.setIsReset(DictConst.Y);
                        history.setApproveType(DictConst.APPROVETYPE_SL);
                        history.setAddTime(new Date());
                        history.setActivityId(activity.getId());
                        history.setContent(TipsConst.TJSL);
                        history.setUserName(activity.getSponsor());
                        approveHistoryMapper.insert(history);
                        /* 娑堟伅閫氱煡 */
                        notifyService.submitApprovalNotify(activity);
                    }

                    // 瀹℃壒闃舵锛屾棤闇€鏍￠獙浜烘暟
                    activityService.createOrUpdate(activity, true);

                    /* 鏇存柊鎶ユ壒鏉愭枡锛岃鍙鎵规潗鏂� */
                    String[] folderPath = new String[]{materialPath, STORE_FOLDER, month};
                    String dir = BcxinFileUtil.appendFolderPath(folderPath);
                    File newFile = new File(dir + File.separator + file.getName());
                    Files.copy(file, newFile);
                    ActivityMaterial material = activityMaterialMapper.findByActivityId(activity.getId());
                    material.setBpcl(PACK_DOWNLOAD + newFile.getPath());
                    activityMaterialMapper.updateById(material);

                    /* 璁板綍鍘嗗彶璁板綍 */
                    ApproveHistory history = new ApproveHistory();
                    history.setIsReset(DictConst.Y);
                    history.setApproveType(DictConst.APPROVETYPE_SL);
                    history.setAddTime(new Date());
                    history.setActivityId(activity.getId());
                    history.setContent(TipsConst.TJAQGZFA);
                    history.setUserName(activity.getSponsor());
                    approveHistoryMapper.insert(history);

                    fileSyncLog.setMarkRead(DictConst.Y);
                    logService.mergeMark(fileSyncLog);
                    syncFileNameList.add(fileName);
                    /* 闃呰瀹屽悗鍒犻櫎鏂囦欢 */
                    //FileUtils.delete(file);
                    if ("on".equalsIgnoreCase(ConfigUtil.getValue("switch_zjzw20"))) {
                        if ("330000".equals(activity.getProvince())) {
                            activityMapper.updateActivityByIsAddFiles(null,Long.valueOf(activityId), DictConst.Y);
                        }
                    }
                }
            } else if (fileName.startsWith(ACAF)) { //鍚屾瀹夊叏宸ヤ綔鏂规
                String activityId = DIGIT.retainFrom(BcxinFileUtil.filterTimestamp(fileName));
                if (isNotEmpty(activityId)) {
                    Activity activity = activityService.findByPssId(Long.parseLong(activityId));
                    if (activity == null) {
                        continue;
                    }
                    /* 濡傛灉鏄瓑绾ц瘎瀹氶€氳繃锛屽垯鍚屾瀹夊叏宸ヤ綔鏂规锛屽彉鎴愬彈鐞嗕腑 */
                    /* 濡傛灉鏄紑鍚紑鍚瓑绾ц瘎瀹氾紝鍒欓渶瑕佸畨鍏ㄥ伐浣滄柟妗堟墠鍙互鍙樻垚鍙楃悊涓紝鏇存柊璇勪及鎶ュ憡涓嶅仛澶勭悊*/
                    if (DictConst.STATUS_CSTG.equals(activity.getApproveStatus())
                            && GlobalConst.SWITCH_ON.equals(ConfigUtil.getValue("switch_gradeRank"))) {
                        activity.setApproveStatus(DictConst.STATUS_SLZ);

                        ApproveHistory history = new ApproveHistory();
                        history.setIsReset(DictConst.Y);
                        history.setApproveType(DictConst.APPROVETYPE_SL);
                        history.setAddTime(new Date());
                        history.setActivityId(activity.getId());
                        history.setContent(TipsConst.TJSL);
                        history.setUserName(activity.getSponsor());
                        approveHistoryMapper.insert(history);
                        /* 娑堟伅閫氱煡 */
                        notifyService.submitApprovalNotify(activity);
                    }

                    // 瀹℃壒闃舵锛屾棤闇€鏍￠獙浜烘暟
                    activityService.createOrUpdate(activity, true);

                    /* 鏇存柊鎶ユ壒鏉愭枡锛岃鍙鎵规潗鏂� */
                    String[] folderPath = new String[]{materialPath, STORE_FOLDER, month};
                    String dir = BcxinFileUtil.appendFolderPath(folderPath);
                    File newFile = new File(dir + File.separator + file.getName());
                    Files.copy(file, newFile);
                    ActivityMaterial material = activityMaterialMapper.findByActivityId(activity.getId());
                    material.setAqgzfa(PACK_DOWNLOAD + newFile.getPath());
                    activityMaterialMapper.updateById(material);

                    /* 璁板綍鍘嗗彶璁板綍 */
                    ApproveHistory history = new ApproveHistory();
                    history.setIsReset(DictConst.Y);
                    history.setApproveType(DictConst.APPROVETYPE_SL);
                    history.setAddTime(new Date());
                    history.setActivityId(activity.getId());
                    history.setContent(TipsConst.TJAQGZFA);
                    history.setUserName(activity.getSponsor());
                    approveHistoryMapper.insert(history);

                    fileSyncLog.setMarkRead(DictConst.Y);
                    logService.mergeMark(fileSyncLog);
                    syncFileNameList.add(fileName);
                    /* 闃呰瀹屽悗鍒犻櫎鏂囦欢 */
                    FileUtils.delete(file);
                }
          } else if (fileName.startsWith(ACC)) { //鍚屾鎵垮姙鏂逛俊鎭�
                String activityId = DIGIT.retainFrom(BcxinFileUtil.filterTimestamp(fileName));
                if (isNotEmpty(activityId)) {
                    Activity activity = activityService.findByPssId(Long.parseLong(activityId));
                    if (activity == null) {
                        continue;
                    }
                    /* 璇诲彇鎵垮姙鏂逛俊鎭� */
                    String comment = "";
                    try {
                        Path fpath = Paths.get(file.getPath());
                        BufferedReader bfr = java.nio.file.Files.newBufferedReader(fpath);
                        comment = bfr.readLine();
                        bfr.close();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    Map<String, ContractorSPDTO> map = JSON.parseObject(comment, new TypeReference<HashMap<String, ContractorSPDTO>>() {
                    });
                    if (map == null) {
                        continue;
                    }
                    /* 鎻愬墠鍏堟竻绌哄師鏉ョ殑鎵垮姙鍗曚綅 */
                    activityContractorMapper.deleteByActivityId(activity.getId());
                    StringBuilder stringBuilder = new StringBuilder();
                    for (String key : map.keySet()) {
                        ActivityContractor activityContractor = new ActivityContractor();
                        BeanUtil.copyProperties(map.get(key), activityContractor);
                        if (StringUtil.isEmpty(activityContractor.getFullName())) {
                            activityContractor.setFullName(map.get(key).getName());
                        }
                        activityContractor.setActivityId(activity.getId());

                        /* 鍊间负 610000,610100,610101 */
                        if (StringUtil.isNotEmpty(activityContractor.getAddress())) {
                            List<String> regionList = StrSpliter.split(activityContractor.getAddress(), ",", true, true);
                            List<String> address = Lists.newArrayList();
                            for (String regionId : regionList) {
                                if (StringUtil.isEmpty(regionId)) {
                                    continue;
                                }
                                if ("null".equals(regionId)) {
                                    continue;
                                }
                                String region = regionMapper.findNameById(Long.parseLong(regionId));
                                address.add(region);
                            }
                            String addressCN = Joiner.on("#").skipNulls().join(address);
                            activityContractor.setAddress(addressCN);
                        }
                        activityContractorMapper.insert(activityContractor);
                        stringBuilder.append(activityContractor.getFullName()).append(",");
                    }
                    activity.setSponsor(StringUtil.isEmpty(stringBuilder.toString()) ? stringBuilder.toString() : stringBuilder.toString().substring(0, stringBuilder.toString().length() - 1));
                    fileSyncLog.setMarkRead(DictConst.Y);
                    logService.mergeMark(fileSyncLog);
                    syncFileNameList.add(fileName);
                    /* 闃呰瀹屽悗鍒犻櫎鏂囦欢 */
                    FileUtils.delete(file);
                }
            } else if (fileName.startsWith(ACGR)) { //鍚屾鎵垮姙鏂归噸鏂扮敵璇烽噸璇�
                String activityId = DIGIT.retainFrom(BcxinFileUtil.filterTimestamp(fileName));
                if (isNotEmpty(activityId)) {
                    Activity activity = activityService.findByPssId(Long.parseLong(activityId));
                    if (activity == null) {
                        continue;
                    }
                    /* 鍙湁鍦ㄥ凡璇勫畾鐘舵€佷笅鎵嶈兘鍙樻洿涓虹敵璇烽噸璇� */
                    if (DictConst.STATUS_CSTG.equals(activity.getApproveStatus())) {
                        /* 璇诲彇閲嶆柊鐢宠閲嶈瘎鍘熷洜 */
                        String comment = "";
                        try {
                            Path fpath = Paths.get(file.getPath());
                            BufferedReader bfr = java.nio.file.Files.newBufferedReader(fpath);
                            comment = bfr.readLine();
                            bfr.close();
                        } catch (Exception e) {
                            e.printStackTrace();
                        }

                        /* 淇敼鐢宠鍐呭锛屼慨鏀圭姸鎬佷负鎵垮姙鏂归噸璇� */
                        activityMapper.updateActivityReContent(activity.getId(), DictConst.STATUS_SQCP, comment);

                        /* 璁板綍鍘嗗彶璁板綍 */
                        ApproveHistory history = new ApproveHistory();
                        history.setIsReset(DictConst.Y);
                        history.setApproveType(DictConst.APPROVETYPE_CS);
                        history.setAddTime(new Date());
                        history.setActivityId(activity.getId());
                        history.setContent(TipsConst.TJDJPDRE);
                        history.setUserName(activity.getSponsor());
                        history.setOpinion(comment);
                        approveHistoryMapper.insert(history);
                    }

                    fileSyncLog.setMarkRead(DictConst.Y);
                    logService.mergeMark(fileSyncLog);
                    syncFileNameList.add(fileName);
                    /* 闃呰瀹屽悗鍒犻櫎鏂囦欢 */
                    FileUtils.delete(file);
                }
            }
        }
    }

    private boolean saveActivity(Activity activity, File file, List<File> files, List<String> syncFileNameList) throws Exception {
        String content = BcxinFileUtil.txt2String(file);
        Map<String, String> valueMap = JSON.parseObject(content,Map.class);

        ActivityDetail activityDetail;
        String oldWorkFlowVersion = "";
        String newWorkFlowVersion = "";
        String sourceArea = "";
        // 鏄惁浜屾鎻愪氦
        boolean isResubmit = false;
        if (activity == null) {
            activity = new Activity();
            activityDetail = new ActivityDetail();
        } else {
            isResubmit = true;
            activityDetail = activityDetailMapper.findByActivityId(activity.getId());
            oldWorkFlowVersion = activity.getWorkflowVersion();
            sourceArea = getApproveArea(activity.getProvince(), activity.getCity(), activity.getArea());
        }

        if (valueMap.size() == 0) {
            return false;
        }

        if (StringUtil.isEmpty(valueMap.get("activityNo"))) {
            log.info("鏈兘妫€娴嬪埌鏁版嵁");
            return false;
        }

        log.info(valueMap.get("activityNo"));


        // 楠岃瘉鏄惁鏀垮簻鎶ュ椤圭洰杞鍙」鐩�
        boolean isTransferXK = false;
        // 褰撳墠鍐呯綉鏄姤澶囨椿鍔ㄧ姸鎬侊紝涓斿鎵归€€鍥�
        if (ObjectUtil.equal(activity.getIsBackUp(), DictConst.Y)) {
            // 浼犲叆鐨刬sBackUp鍜屽唴缃戠殑涓嶄竴鑷�,琛ㄧず鏀垮簻鎶ュ椤圭洰杞鍙」鐩�
            if (!ObjectUtil.equal(valueMap.get("isBackUp"), DictConst.Y)) {
                isTransferXK = true;
            }
        }

        // 鎶ュ,鎶ュ杞鍙」鐩紝鍒犻櫎涔嬪墠鐨勫鎵硅褰曪紝鍚﹀垯浼氬奖鍝嶄箣鍚庣殑瀹℃壒娴佺▼
        if (isTransferXK) {
            if (activity.getId() != null) {
                approveService.removeApprove(activity.getId());
            }
        }
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm");
        // 鏄惁鎶ュ椤圭洰
        activity.setIsBackUp(valueMap.get("isBackUp"));
        // 鏄惁闇€瑕侀璇勬姤鍛�
        activity.setIsNeedReport(valueMap.get("isNeedReport"));
        activity.setSponsorAddress(valueMap.get("sponsorAddress"));
        activity.setCoordinate(valueMap.get("coordinate"));
        activity.setIntroduce(valueMap.get("introduce"));
        activity.setPssId(Long.parseLong(valueMap.get("pssId")));
        activity.setActivityNo(valueMap.get("activityNo"));
        activity.setFullName(valueMap.get("name"));
        activity.setTypeCode(valueMap.get("typeCode"));
        activity.setProvince(StringUtil.isEmpty(valueMap.get("province")) ? null : valueMap.get("province"));
        activity.setCity(StringUtil.isEmpty(valueMap.get("city")) ? null : valueMap.get("city"));
        //瑕佺粰鍒扮粡寮€鍖虹殑鐗规畩澶勭悊
        String area = StringUtil.isEmpty(valueMap.get("area")) ? null : valueMap.get("area");
        String unit = StringUtil.isEmpty(valueMap.get("unit")) ? null : valueMap.get("unit");
        if("13040302".equals(area)){
            area = "13049101";
            unit = "13049101";
        }
        activity.setArea(area);
        activity.setUnit(unit);
        activity.setAddress(valueMap.get("address"));
        activity.setNumber(isNotEmpty(valueMap.get("number")) ? new BigDecimal(valueMap.get("number")).intValue() : 0);
        activity.setStartDate(isNotEmpty(valueMap.get("startDate")) ? sdf.parse(valueMap.get("startDate")) : new Date());
        activity.setEndDate(isNotEmpty(valueMap.get("endDate")) ? sdf.parse(valueMap.get("endDate")) : new Date());
        activity.setAmount(isNotEmpty(valueMap.get("amount")) ? new BigDecimal(valueMap.get("amount")).intValue() : 0);
        activity.setOrganizer(isNotEmpty(valueMap.get("organizer")) ? valueMap.get("organizer") : "鏃�");
        activity.setSponsor(isNotEmpty(valueMap.get("sponsor")) ? valueMap.get("sponsor") : "鏃�");
        activity.setZsponsor(isNotEmpty(valueMap.get("zsponsor")) ? valueMap.get("zsponsor") : "鏃�");
        activity.setAssessmentorg(isNotEmpty(valueMap.get("assessmentorg")) ? valueMap.get("assessmentorg") : "鏃�");
        activity.setGov(Objects.equals(valueMap.get("gov"), DictConst.Y));
        activity.setHistory(valueMap.get("history"));
        activity.setIsAddFiles("1");//榛樿鏄凡缁忚ˉ鍏呭畬鏉愭枡

        /* 娲诲姩淇℃伅璇︽儏 */
        activityDetail.setBags(valueMap.get("bags"));
        activityDetail.setHdnr(valueMap.get("hdnr"));
        activityDetail.setBaryzs(valueMap.get("baryzs"));
        activityDetail.setCdrl(valueMap.get("cdrl"));
        activityDetail.setNzjs(valueMap.get("nzjs"));
        activityDetail.setCdmj(valueMap.get("cdmj"));
        activityDetail.setXccys(valueMap.get("xccys"));
        activityDetail.setZyzzs(valueMap.get("zyzzs"));

        /* 闇€瑕佸垵瀹� */
        if (Objects.equals(valueMap.get("primary"), DictConst.Y) && StrUtil.isEmpty(activity.getApproveStatus())) {
            activity.setApproveStatus(DictConst.STATUS_CSZ);
            activity.setSync(DictConst.N);
        }

        /* 鎶ュ椤圭洰杞鍙紝涔熼渶瑕佸垵瀹� */
        if (isTransferXK && Objects.equals(valueMap.get("primary"), DictConst.Y)) {
            activity.setApproveStatus(DictConst.STATUS_CSZ);
            activity.setSync(DictConst.N);
        }

        for (File f : files) {
            if (f.getName().startsWith(APGCL) && f.getName().contains(valueMap.get("pssId"))) {
                /* 杩樻湭淇濆瓨娲诲姩淇℃伅锛屼笉鍋氬悓姝�*/
                if (activity.getId() == null) {
                    continue;
                }
                /* 鍒濆涓垨鏈鎵癸紝璇存槑鍙互杩涜鍚屾鎶ュ鏉愭枡*/
                if (StringUtil.isEmpty(activity.getApproveStatus()) || DictConst.STATUS_CSZ.equals(activity.getApproveStatus())) {
                    FileSyncLog fileSyncLog = logService.findRecord(f.getName());
                    /*濡傛灉鏂囦欢鍚嶅瓨鍦紝璇佹槑宸茬粡鍚屾杩囷紝鍒欎笉鍐嶅悓姝�*/
                    if (fileSyncLog != null) {
                        if (DictConst.Y.equals(fileSyncLog.getMarkRead())) {
                            continue;
                        }
                    } else {
                        fileSyncLog = new FileSyncLog();
                        fileSyncLog.setFileName(f.getName());
                    }
                    fileSyncLog.setMarkRead(DictConst.Y);
                    logService.mergeMark(fileSyncLog);

                    /* 鏇存柊璇勪及鏉愭枡 */
                    ActivityMaterial material = activityMaterialMapper.findByActivityId(activity.getId());
                    material.setPgcl(PACK_DOWNLOAD + f.getPath());
                    activityMaterialMapper.updateById(material);

                    syncFileNameList.add(f.getName());
                }
            }
        }

        /*
         * 鏄斂搴滈」鐩笖鏄妗堥」鐩�
         */
        if (activity.isGov() && Objects.equals(activity.getIsBackUp(), DictConst.Y)) {
            activity.setApproveStatus(DictConst.STATUS_YES);

            // 浜屾鎻愪氦鐨勬斂搴滃妗堥」鐩紝涓嶉渶瑕佸啀鏂板瀹℃壒鍘嗗彶
            if (!isResubmit) {
                ApproveHistory history = new ApproveHistory();
                history.setIsReset(DictConst.Y);
                history.setApproveType(DictConst.APPROVETYPE_SP);
                history.setAddTime(new Date());
                history.setActivityId(activity.getId());
                history.setContent(TipsConst.TJBB);
                history.setUserName(activity.getSponsor());
                approveHistoryMapper.insert(history);

                /* 娑堟伅閫氱煡 */
                notifyService.submitReport(activity);
            }
        }else{
            /* 娌冲寳寮哄埗鍙樻垚鍙楃悊涓紝闇€瑕佽蛋鍙楃悊娴佺▼ */
            if ("130000".equals(activity.getProvince())) {
                activity.setApproveStatus(DictConst.STATUS_SLZ);
            }
        }


        activityService.createOrUpdate(activity);
        //澶栫綉鍦烘淇℃伅鎻掑叆鍐呯綉鏁版嵁搴撳叧鑱斿搴旀椿鍔�
        if(StringUtil.isNotEmpty(valueMap.get("activitySessions")) && !activity.getApproveStatus().equals(DictConst.STATUS_YES)){
            List<Map> maps = JSONArray.parseArray(valueMap.get("activitySessions"),Map.class);
            ActivitySession activitySession;
            if(maps.size()>0){
                //鍏堝垹闄�
                activitySessionMapper.deleteByActivityId(activity.getId());
            }
            for (Map map:maps){
                activitySession = new ActivitySession();
                activitySession.setAddTime(new Date());
                activitySession.setActivityId(activity.getId());
                activitySession.setUpdateTime(new Date());
                activitySession.setStartDate(map.get("startDate")+"");
                activitySession.setEndDate(map.get("endDate")+"");
                activitySession.setContactName(map.get("contactName")+"");
                activitySession.setContactPosition(map.get("contactPosition")+"");
                activitySession.setContactPhone(map.get("contactPhone")+"");
                activitySessionMapper.insert(activitySession);
            }
        }

        // 閲嶆柊鎻愪氦椤圭洰 && 璁稿彲椤圭洰
        if (isResubmit && Objects.equals(activity.getIsBackUp(), DictConst.N)) {
            // 瀹℃壒娴佺▼鍙戠敓鏀瑰彉
            newWorkFlowVersion = activity.getWorkflowVersion();
            if (!Objects.equals(oldWorkFlowVersion, newWorkFlowVersion)) {
                // 鍙戦€佹秷鎭粰宸茬粡瀹℃壒杩囩殑浜哄憳
                List<Map> alreadyUserList = activityMapper.findAlreadyApproveUser(activity.getId());
                String transferAddr = getApproveArea(activity.getProvince(), activity.getCity(), activity.getArea());
                notifyService.contractorTransferActNotify(activity, alreadyUserList, transferAddr);

                /* 鍙戦€佹秷鎭粰鏂扮殑瀹℃壒浜哄憳 */
                notifyService.tjcsAndChangeArea(activity, sourceArea, transferAddr);
            }
        }

        /* 鏇存柊鍙楃悊鍑瘉 */
        if (DictConst.fullSPList().contains(activity.getApproveStatus())) {
            /* 鐢熸垚鏂囦功 */
            approveFileService.generateslws(DictConst.STATUS_SL, activity, null);
        }


        if (activityDetail.getId() == null) {
            activityDetail.setActivityId(activity.getId());
            activityDetailMapper.insert(activityDetail);
        } else {
            activityDetailMapper.updateById(activityDetail);
        }
        return true;
    }


    /**
     * 閲嶆柊鎻愪氦鎶ュ鏉愭枡
     *
     * @param activity
     * @param file
     * @param files
     * @param syncFileNameList
     * @return
     * @throws Exception
     */
    private boolean saveBBCLComment(Activity activity, File file, List<File> files, List<String> syncFileNameList) {
        if (activity.isGov()) {
            /* 鎵惧埌鎶ュ鏉愭枡瀵瑰簲鐨勫娉� */
            String comment = "";
            for (File f : files) {
                if (f.getName().equals(Files.getNameWithoutExtension(file.getName()) + "_comment.txt")) {
                    /* 鏍囪鏂囨。鍚屾 */
                    FileSyncLog fileSyncLog = logService.findRecord(f.getName());
                    if (fileSyncLog == null) {
                        fileSyncLog = new FileSyncLog();
                    }
                    fileSyncLog.setFileName(f.getName());
                    fileSyncLog.setMarkRead(DictConst.Y);
                    try {
                        /* 璇诲彇閲嶆柊鎻愪氦鐨勫師鍥� */
                        Path fpath = Paths.get(f.getPath());
                        BufferedReader bfr = java.nio.file.Files.newBufferedReader(fpath);
                        comment = bfr.readLine();
                        bfr.close();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }

                    ApproveHistory history = new ApproveHistory();
                    history.setIsReset(DictConst.Y);
                    history.setApproveType(DictConst.APPROVETYPE_SP);
                    history.setAddTime(new Date());
                    history.setActivityId(activity.getId());
                    history.setContent(TipsConst.CXTJBB);
                    history.setUserName(activity.getSponsor());
                    history.setOpinion(comment);
                    try {
                        approveHistoryMapper.insert(history);
                    } catch (Exception e) {
                        fileSyncLog.setMarkRead(DictConst.N);
                        e.printStackTrace();
                    }
                    logService.mergeMark(fileSyncLog);
                    syncFileNameList.add(f.getName());
                }
            }
            // 閲嶆柊鎻愪氦鎶ュ娑堟伅閫氱煡
            if (StringUtil.isNotEmpty(comment)) {
                notifyService.resubmitTJBB(activity, comment);
            }
        }
        return true;
    }


    private boolean isNotEmpty(String value) {
        if (value == null) {
            return false;
        }
        if ("".equals(value.trim())) {
            return false;
        }
        return true;
    }


    /*-----------------------------鍚屾瀹℃壒缁撴灉----------------------------------*/

    /**
     * 鍚屾瀹℃壒缁撴灉淇℃伅
     *
     * @throws Exception
     */
    public void importApprovalData() throws Exception {
        log.info("寮€濮嬪悓姝ュ鎵圭粨鏋滀俊鎭�");
        String envi = ConfigUtil.getValue("envi");
        String mode = ConfigUtil.getValue("pss-communicate-mode");
        String upload_path = ConfigUtil.getValue("stuff-path");

        List<File> allFileList = Lists.newArrayList();

        String[] dateDirs = new String[]{BcxinDateUtil.getCurrentDate(), BcxinDateUtil.getPastDate(1),
                BcxinDateUtil.getPastDate(2), BcxinDateUtil.getPastDate(3),
                BcxinDateUtil.getPastDate(4),
                BcxinDateUtil.getPastDate(5), BcxinDateUtil.getPastDate(6)};

        /* 鏂囦欢鑷姩璇诲彇锛屽彧瑕佽涓ゅぉ鐨勬枃浠跺氨鍙互浜� */
        if ("file".equals(mode)) {
            dateDirs = new String[]{BcxinDateUtil.getCurrentDate(), BcxinDateUtil.getPastDate(1)};
        }

        for (String dateDir : dateDirs) {
            //閬嶅巻褰撳ぉ鐨勬枃浠跺す
            String[] folerPath = new String[]{upload_path, envi, dateDir, SP_FOLDER};
            String dir = BcxinFileUtil.appendFolderPath(folerPath);

            File dirFile = new File(dir);
            log.info("鍚屾鐨勭洰褰曪細" + dir);
            if (dirFile.exists()) {
                File[] files = dirFile.listFiles();
                allFileList.addAll(Arrays.asList(files));
            } else {
                dirFile.mkdirs();
            }
        }

        if (CollectionUtil.isEmpty(allFileList)) {
            log.info("鏂囦欢澶规槸绌虹殑");
            return;
        }

        List<String> fileNameList = Lists.newArrayList();
        for (File file : allFileList) {
            String fileName = file.getName();
            //鍚屾娲诲姩淇℃伅
            if (fileName.startsWith(APPR)) {
                FileSyncLog fileSyncLog = logService.findRecord(fileName);
                /*濡傛灉鏂囦欢鍚嶅瓨鍦紝璇佹槑宸茬粡鍚屾杩囷紝鍒欎笉鍐嶅悓姝�*/
                if (fileSyncLog != null) {
                    if (DictConst.Y.equals(fileSyncLog.getMarkRead())) {
                        continue;
                    }
                }
                if (fileNameList.contains(fileName)) {
                    continue;
                }
                log.info("寮€濮嬭В鏋愭枃浠讹細" + fileName);

                if (fileSyncLog == null) {
                    fileSyncLog = new FileSyncLog();
                }
                fileSyncLog.setFileName(fileName);
                try {
                    boolean flag = saveApproval(file);
                    if (flag) {
                        fileSyncLog.setMarkRead(DictConst.Y);
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }

                logService.mergeMark(fileSyncLog);
                fileNameList.add(fileName);
            }
        }

    }


    private boolean saveApproval(File file) throws Exception {
        String content = BcxinFileUtil.txt2String(file);
        List<Map> contentList = JSON.parseArray(content,Map.class);
        List<String> activityNoList = Lists.newArrayList();
        List<String> primaryStatusList = Lists.newArrayList();
        List<String> approvalStatusList = Lists.newArrayList();

        for (Map map : contentList) {
            activityNoList.add(map.get("activityNo").toString());
            primaryStatusList.add(map.get("primaryStatus").toString());
            approvalStatusList.add(map.get("approvalStatus").toString());
        }

        if (CollectionUtil.isNotEmpty(activityNoList)) {
            for (int i = 0; i < activityNoList.size(); i++) {
                Activity activity = activityService.findByActivityNo(activityNoList.get(i));
                if (activity == null) {
                    continue;
                }
                if (approvalStatusList.size() == 0 || approvalStatusList.size() <= i) {
                    activity.setSync(DictConst.Y);
                    activityMapper.updateById(activity);
                    continue;
                }

                /* 鎻愬墠澶勭悊 鐩存帴璺宠繃鍒濆閫氳繃鍚屾 鐨勪换鍔� */
                if (GlobalConst.SWITCH_ON.equals(ConfigUtil.getValue("switch_redirectsl"))
                        && Objects.equals(primaryStatusList.get(i), DictConst.STATUS_CSTG)) {
                    List<SyncTask> syncTaskList = syncTaskMapper.selectList(new EntityWrapper<SyncTask>()
                            .eq("sync", DictConst.N)
                            .eq("activityId", activity.getId())
                            .eq("approveStatus", DictConst.STATUS_CSTG)
                            .eq("syncTaskType", DictConst.SYNCTASKTYPE_CS));
                    if (CollectionUtil.isNotEmpty(syncTaskList)) {
                        syncTaskList.forEach(s -> {
                            s.setSync(DictConst.Y);
                            syncTaskMapper.updateById(s);
                        });
                    }
                }
                /* 鎻愬墠澶勭悊 鐩存帴璺宠繃鍙楃悊閫氳繃鍚屾 鐨勪换鍔� */
                if (GlobalConst.SWITCH_ON.equals(ConfigUtil.getValue("switch_redirectsp"))
                        && Objects.equals(primaryStatusList.get(i), DictConst.STATUS_SL)) {
                    List<SyncTask> syncTaskList = syncTaskMapper.selectList(new EntityWrapper<SyncTask>()
                            .eq("sync", DictConst.N)
                            .eq("activityId", activity.getId())
                            .eq("approveStatus", DictConst.STATUS_SL)
                            .eq("syncTaskType", DictConst.SYNCTASKTYPE_SL));
                    if (CollectionUtil.isNotEmpty(syncTaskList)) {
                        syncTaskList.forEach(s -> {
                            s.setSync(DictConst.Y);
                            syncTaskMapper.updateById(s);
                        });
                    }
                }

                /* 璁剧疆鎵撳洖鐨勭姸鎬� */
                List<SyncTask> syncTaskList1 = syncTaskMapper.selectList(new EntityWrapper<SyncTask>()
                        .eq("sync", DictConst.N)
                        .eq("activityId", activity.getId())
                        .eq("approveStatus", DictConst.STATUS_REJECT)
                        .eq("syncTaskType", DictConst.SYNCTASKTYPE_SP));
                if (CollectionUtil.isNotEmpty(syncTaskList1)) {
                    syncTaskList1.forEach(s -> {
                        s.setSync(DictConst.Y);
                        syncTaskMapper.updateById(s);
                    });
                }

                /* 璁剧疆杞氦鐨勭姸鎬� */
                List<SyncTask> syncTaskList2 = syncTaskMapper.selectList(new EntityWrapper<SyncTask>()
                        .eq("sync", DictConst.N)
                        .eq("activityId", activity.getId())
                        .eq("approveStatus", DictConst.STATUS_TRANSFER)
                        .eq("syncTaskType", DictConst.SYNCTASKTYPE_TRANSFER));
                if (CollectionUtil.isNotEmpty(syncTaskList2)) {
                    syncTaskList2.forEach(s -> {
                        s.setSync(DictConst.Y);
                        syncTaskMapper.updateById(s);
                    });
                }

                /*濡傛灉鏄鎵规墦鍥�*/
                if (Objects.equals(approvalStatusList.get(i), "4")) {
                    /*鍒ゆ柇褰撳墠娲诲姩鏄惁鏄鎵规墦鍥烇紝濡傛灉鏄垯淇敼鐘舵€侊紝濡傛灉涓嶆槸锛屽垯涓嶄慨鏀瑰悓姝ョ姸鎬侊紝闃叉鍚屾杩囧揩*/
                    if (Objects.equals(activity.getApproveStatus(), DictConst.STATUS_REJECT)) {
                        activity.setSync(DictConst.Y);
                        activityMapper.updateById(activity);
                        continue;
                    }
                }
                /*鍒ゆ柇褰撳墠娲诲姩鏄垵瀹￠€氳繃 骞朵笖鍚屾娲诲姩鐨勭姸鎬佹槸鍒濆閫氳繃锛屽垯淇敼鍚屾鐘舵€�*/
                if (Objects.equals(primaryStatusList.get(i), "30")) {
                    if (Objects.equals(activity.getApproveStatus(), DictConst.STATUS_CSTG)) {
                        activity.setSync(DictConst.Y);
                        activityMapper.updateById(activity);
                    }
                    continue;
                }

                /*鍒ゆ柇褰撳墠娲诲姩鏄彈鐞嗛€氳繃 骞朵笖鍚屾娲诲姩鐨勭姸鎬佹槸鍙楃悊閫氳繃锛屽垯淇敼鍚屾鐘舵€�*/
                if (Objects.equals(primaryStatusList.get(i), DictConst.STATUS_SL)
                        && Objects.equals(approvalStatusList.get(i), "1")) {
                    if (Objects.equals(activity.getApproveStatus(), DictConst.STATUS_SL)) {
                        /* 杩涘叆瀹℃壒鐜妭 */
                        activity.setApproveStatus(DictConst.STATUS_NONE);
                        activity.setSync(DictConst.N);
                        activityMapper.updateById(activity);
                    }
                    continue;
                }

                /* 杩欎簺鐘舵€佷笅锛岃鏄庢鍦ㄨ繘琛屼腑锛屼笉闇€瑕佷慨鏀瑰悓姝ョ姸鎬� */
                if (Objects.equals(primaryStatusList.get(i), DictConst.STATUS_CSZ)
                        || Objects.equals(primaryStatusList.get(i), DictConst.STATUS_SLZ)
                        || Objects.equals(approvalStatusList.get(i), DictConst.STATUS_IN)
                        || Objects.equals(approvalStatusList.get(i), DictConst.STATUS_NONE)) {
                    continue;
                }

                activity.setSync(DictConst.Y);
                activityMapper.updateById(activity);
            }
        }
        return true;
    }


    @Autowired
    private ChangeLogService changeLogService;

    /**
     * 淇濆瓨宸紓鏃ュ織
     *
     * @param file
     */
    public void saveChangeLog(List<String> syncFileNameList, File file) {
        String fileName = file.getName();
        FileSyncLog fileSyncLog = logService.findRecord(fileName);
        /*濡傛灉鏂囦欢鍚嶅瓨鍦紝璇佹槑宸茬粡鍚屾杩囷紝鍒欎笉鍐嶅悓姝�*/
        if (fileSyncLog != null) {
            if (DictConst.Y.equals(fileSyncLog.getMarkRead())) {
                return;
            }
        }
        if (syncFileNameList.contains(fileName)) {
            return;
        }

        if (fileSyncLog == null) {
            fileSyncLog = new FileSyncLog();
        }
        fileSyncLog.setFileName(fileName);

        // 璇诲彇鏂囨湰鏁版嵁
        String content = BcxinFileUtil.txt2String(file);
        if (StringUtil.isNotEmpty(content)) {
            // 淇濆瓨宸紓鏃ュ織
            List<ChangeLog> changeLogList = JSON.parseArray(content, ChangeLog.class);
            for (ChangeLog changeLog : changeLogList) {
                changeLogService.deleteBySourceOid(changeLog.getSourceOid());
                changeLogService.save(changeLog);
            }
        }
        fileSyncLog.setMarkRead(DictConst.Y);
        logService.mergeMark(fileSyncLog);
        syncFileNameList.add(fileName);
    }

    /**
     * 淇濆瓨鍗囩骇鏃ュ織
     *
     * @param syncFileNameList
     * @param file
     */
    public void saveUpgradeLog(List<String> syncFileNameList, File file) {
        String fileName = file.getName();
        System.out.println("fileName:" + fileName);
        FileSyncLog fileSyncLog = logService.findRecord(fileName);
        /*濡傛灉鏂囦欢鍚嶅瓨鍦紝璇佹槑宸茬粡鍚屾杩囷紝鍒欎笉鍐嶅悓姝�*/
        if (fileSyncLog != null) {
            if (DictConst.Y.equals(fileSyncLog.getMarkRead())) {
                return;
            }
        }
        if (syncFileNameList.contains(fileName)) {
            return;
        }

        if (fileSyncLog == null) {
            fileSyncLog = new FileSyncLog();
        }
        fileSyncLog.setFileName(fileName);

        // 璇诲彇鏂囨湰鏁版嵁
        String upgradeContent = BcxinFileUtil.txt2String(file);
        if (StringUtil.isNotEmpty(upgradeContent)) {
            // 淇濆瓨鍗囩骇鏃ュ織
            Map<String, String> map = JSON.parseObject(upgradeContent, new TypeReference<HashMap<String, String>>() {
            });
            String pssId = map.containsKey("pssId") ? map.get("pssId") : "";
            String title = map.containsKey("title") ? map.get("title") : "";
            String content = map.containsKey("content") ? map.get("content") : "";
            String deleteFlag = map.containsKey("deleteFlag") ? map.get("deleteFlag") : "";
            SystemUpgrade upgrade = null;
            boolean isUpdate = true;
            if (StringUtil.isNotEmpty(pssId)) {
                upgrade = upgradeService.findUpgradeByPssId(Long.parseLong(pssId));
            }
            if (upgrade == null) {
                upgrade = new SystemUpgrade();
                isUpdate = false;
            }

            // 璧嬪€�
            upgrade.setContent(content);
            upgrade.setTitle(title);
            if (StringUtil.isNotEmpty(pssId)) {
                upgrade.setPssId(Long.parseLong(pssId));
            }
            if (StringUtil.isNotEmpty(deleteFlag)) {
                upgrade.setDeleteFlag(Integer.parseInt(deleteFlag));
            }
            if (isUpdate) {
                upgrade.setUpdateTime(new Date());
                upgradeService.update(upgrade);
            } else {
                upgrade.setCreateTime(new Date());
                upgrade.setUpdateTime(new Date());
                upgradeService.insert(upgrade);
            }
        }
        fileSyncLog.setMarkRead(DictConst.Y);
        logService.mergeMark(fileSyncLog);
        syncFileNameList.add(fileName);
    }


    /**
     * 鑾峰彇瀹℃壒鍦板尯
     *
     * @param province
     * @param city
     * @param area
     * @return
     */
    private String getApproveArea(String province, String city, String area) {
        String addr = "";
        if (StringUtil.isNotEmpty(province)) {
            addr += regionMapper.findNameById(Long.parseLong(province));
        }
        if (StringUtil.isNotEmpty(city)) {
            addr += "-" + regionMapper.findNameById(Long.parseLong(city));
        }
        if (StringUtil.isNotEmpty(area)) {
            addr += "-" + regionMapper.findNameById(Long.parseLong(area));
        }
        return addr;
    }

}