package com.bcxin.sp.work.timer;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.util.ArrayUtil;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.bcxin.sp.work.dao.log.AuditLogMapper;
import com.bcxin.sp.work.dao.third.zj.JZDepartDataMapper;
import com.bcxin.sp.work.dao.third.zj.JZUserDataMapper;
import com.bcxin.sp.work.entity.domain.log.AuditLog;
import com.bcxin.sp.work.entity.domain.third.zj.JZDepartData;
import com.bcxin.sp.work.entity.domain.third.zj.JZUserData;
import com.bcxin.sp.work.entity.dto.AuditLogs;
import com.bcxin.sp.work.util.StringUtil;
import com.bcxin.sp.work.util.XmlUtil;
import com.bcxin.sp.work.util.sys.ConfigUtil;
import com.zl.jwzh.yun.Csh;
import com.zl.jwzh.yun.Department;
import com.zl.jwzh.yun.LogManage;
import com.zl.jwzh.yun.User;
import com.zl.jwzh.yun.comm.MyHelp;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * <b>浙江警综同步 </b>
 *
 * @author LuoPeng
 * @注意事项 </b>
 * <b>
 */
@Service("zjjzScheduleService")
@Transactional
@Slf4j
public class ZJJZScheduleService extends ScheduleService {

    @Resource
    private JZDepartDataMapper jzDepartDataMapper;

    @Resource
    private JZUserDataMapper jzUserDataMapper;

    @Resource
    private AuditLogMapper auditLogMapper;

    /**
     * 调用浙江警综平台
     */
    public void syncZJJZ() {
        if (!"zhejiang".equals(ConfigUtil.getValue("envi"))) {
            return;
        }
        if ("off".equals(ConfigUtil.getValue("switch_synczj"))) {
            return;
        }
        /* 调用警综部门 */
        zjjzSyncDepart();
        /* 调用警综人员 */
        zjjzSyncUser();
    }

    /**
     * 调用浙江警综平台
     */
    public void syncZJJZLog() {
        if (!"zhejiang".equals(ConfigUtil.getValue("envi"))) {
            return;
        }
        if ("off".equals(ConfigUtil.getValue("switch_synczj"))) {
            return;
        }
        /* 调用警综审计日志 */
        zjjzSyncLog();
        //zjjzValidate();
    }

    /**
     * 初始化浙江警综
     */
    public void initZJJZ1() {
        /* 调用警综部门 */
        initSyncDepart();
    }

    /**
     * 初始化浙江警综
     */
    public void initZJJZ2() {
        /* 调用警综人员 */
        initSyncUser();
    }

    /**
     * 初始化部门
     */
    private void initSyncDepart() {
        log.info("调用警综服务初始化同步部门开始");
        /* 第一次要初始化接口 */
        int pageno = 1;
        while (true) {
            Csh ser = new Csh();
            Map<String, Object> map = ser.cshAllToMap("1", String.valueOf(pageno), "1000", "");
            boolean isLastRecord = analysisDepartment(map);
            if (isLastRecord) {
                break;
            }
            pageno++;
        }
    }

    /**
     * 同步部门
     */
    private void zjjzSyncDepart() {
        Department department = new Department();
        log.info("调用警综服务增量同步部门开始");
        String beginId = "1";
        String maxRows = "100";
        //增量接口
        String maxBeginId = jzDepartDataMapper.getMaxBeginId();//获取最高值
        if (StringUtil.isNotEmpty(maxBeginId)) {
            beginId = maxBeginId;
        }
        int beginIdInter = Integer.parseInt(beginId);
        log.info("增量同步部门参数：beginId" + beginIdInter);
        Map<String, Object> map = department.readDepartmentToMap(beginIdInter+"", maxRows);
//        map = XMJHelp.xmlToMap(testSyncDepart());//测试xml
        //解析返回数据
        analysisDepartment(map);
    }


    private boolean analysisDepartment(Map<String, Object> map) {
        boolean isLastRecord = false;
        if (map != null) {
            log.info("增量同步部门返回：" + map.toString());
            String type = MyHelp.OtoS(map.get("TYPE"));//返回结果类型
            String description = MyHelp.OtoS(map.get("DESCRIPTION"));//返回结果描述
            Object returnmsg = map.get("RETURNMSG");
           log.info("返回结果类型："+type+"；返回结果描述："+description+"；返回详细信息："+returnmsg);
            if (returnmsg!= null && StringUtil.isEmpty(returnmsg.toString())) {
                return true;
            }
           //正常返回数据
            if (StringUtil.equals(type, "10000")) {
                String count = MyHelp.OtoS(((Map<String, Object>) returnmsg).get("COUNT"));
                log.info("获取数据条数：" + count);
                if (StringUtil.isEmpty(count) || "null".equals(count)) {
                    return true;
                }
                //存在数据
                if (Integer.parseInt(count) > 0) {
                    if (((Map<String, Object>) returnmsg).get("DATA") instanceof Map) {
                        //如果数据只返回一条的时候 需要用MAP解析
                        Map<String, Object> sjmap = (Map<String, Object>) ((Map<String, Object>) returnmsg).get("DATA");
                        log.info("返回数据量：" + sjmap);
                        JZDepartData jzDepartData = BeanUtil.mapToBean(sjmap, JZDepartData.class, true);
                        if ("1".equals(jzDepartData.getCZ())) {//插入
                            jzDepartDataMapper.insert(jzDepartData);
                        } else if ("2".equals(jzDepartData.getCZ())) {//更新
                            EntityWrapper<JZDepartData> ew = new EntityWrapper<JZDepartData>();
                            ew.eq("JGBH", jzDepartData.getJGBH());
                            jzDepartDataMapper.update(jzDepartData, ew);
                        } else if ("3".equals(jzDepartData.getCZ())) {//删除
                            EntityWrapper<JZDepartData> ew = new EntityWrapper<JZDepartData>();
                            ew.eq("JGBH", jzDepartData.getJGBH());
                            jzDepartDataMapper.delete(ew);
                        }
                    } else if (((Map<String, Object>) returnmsg).get("DATA") instanceof List<?>) {
                        List<Map<String, Object>> list = (List<Map<String, Object>>) ((Map<String, Object>) returnmsg).get("DATA");
                        log.info("返回数据量：" + list.size());
                        //实际数据
                        for (Map<String, Object> sjmap : list) {
                            JZDepartData jzDepartData = BeanUtil.mapToBean(sjmap, JZDepartData.class, true);
                            if ("1".equals(jzDepartData.getCZ())) {
                                jzDepartDataMapper.insert(jzDepartData);
                            } else if ("2".equals(jzDepartData.getCZ())) {
                                EntityWrapper<JZDepartData> ew = new EntityWrapper<JZDepartData>();
                                ew.eq("JGBH", jzDepartData.getJGBH());
                                jzDepartDataMapper.update(jzDepartData, ew);
                            } else if ("3".equals(jzDepartData.getCZ())) {
                                EntityWrapper<JZDepartData> ew = new EntityWrapper<JZDepartData>();
                                ew.eq("JGBH", jzDepartData.getJGBH());
                                jzDepartDataMapper.delete(ew);
                            }
                        }
                    } else {
                        //没有数据返回的时候
                        log.error("获取到的数据为空");
                        isLastRecord = true;
                    }
                }
            }
        } else {
            log.error("------【未正常返回数据】---------------");
            isLastRecord = true;
        }
        return isLastRecord;
    }


    private void initSyncUser() {
        log.info("调用警综服务初始化同步警员开始");
        /* 第一次要初始化接口 */
        int pageno = 1;
        while (true) {
            Csh ser = new Csh();
            Map<String, Object> map = ser.cshAllToMap("3", String.valueOf(pageno), "1000", "");
            boolean isLastRecord = analysisUser(map);
            if (isLastRecord) {
                break;
            }
            pageno++;
        }
        log.info("调用警综服务初始化同步警员结束");
    }


    /**
     * 同步用户
     */
    private void zjjzSyncUser() {
        log.info("调用警综服务增量同步警员开始");
        //调用服务
        String beginId = "1";
        String maxRows = "100";
        //获取最高值
        String maxBeginId = jzUserDataMapper.getMaxBeginId();
        if (StringUtil.isNotEmpty(maxBeginId)) {
            beginId = maxBeginId;
        }
        int beginIdInter = Integer.parseInt(beginId);
        log.info("增量同步警员参数：beginId" + beginIdInter);
        /* 增量接口 */
        User ser = new User();
        Map<String, Object> map = ser.readJyxxToMap(beginId, maxRows, "");
//        map = XMJHelp.xmlToMap(testSyncUser());//测试xml
        //解析返回数据
        analysisUser(map);
    }


    private boolean analysisUser(Map<String, Object> map) {
        boolean isLastRecord = false;
        if (map != null) {
            log.info("增量同步警员返回：" + map.toString());
            String type = MyHelp.OtoS(map.get("TYPE"));//返回结果类型
            String description = MyHelp.OtoS(map.get("DESCRIPTION"));//返回结果描述
            Object returnmsg = map.get("RETURNMSG");
            log.info("返回结果类型：" + type + "；返回结果描述：" + description + "；返回详细信息：" + returnmsg);
            if (returnmsg!= null && StringUtil.isEmpty(returnmsg.toString())) {
                return true;
            }
            //正常返回数据
            if (StringUtil.equals(type, "10000")) {
                String count = MyHelp.OtoS(((Map<String, Object>) returnmsg).get("COUNT"));
                log.info("获取数据条数：" + count);
                if (StringUtil.isEmpty(count) || "null".equals(count)) {
                    return true;
                }
                //存在数据
                if (Integer.parseInt(count) > 0) {
                    if (((Map<String, Object>) returnmsg).get("DATA") instanceof Map) {
                        //如果数据只返回一条的时候 需要用MAP解析
                        Map<String, Object> sjmap = (Map<String, Object>) ((Map<String, Object>) returnmsg).get("DATA");
                        JZUserData jzDepartData = BeanUtil.mapToBean(sjmap, JZUserData.class, true);
                        if ("insert".equals(jzDepartData.getCHANGETYPE())) {//插入
                            jzUserDataMapper.insert(jzDepartData);
                        } else if ("update".equals(jzDepartData.getCHANGETYPE())) {//更新
                            EntityWrapper<JZUserData> ew = new EntityWrapper<JZUserData>();
                            ew.eq("IDCARD", jzDepartData.getIDCARD());
                            jzUserDataMapper.update(jzDepartData, ew);
                        } else if ("delete".equals(jzDepartData.getCHANGETYPE())) {//删除
                            EntityWrapper<JZUserData> ew = new EntityWrapper<JZUserData>();
                            ew.eq("IDCARD", jzDepartData.getIDCARD());
                            jzUserDataMapper.delete(ew);
                        }
                        log.info("返回数据量：" + sjmap);
                    } else if (((Map<String, Object>) returnmsg).get("DATA") instanceof List<?>) {
                        List<Map<String, Object>> list = (List<Map<String, Object>>) ((Map<String, Object>) returnmsg).get("DATA");
                        log.info("返回数据量：" + list.size());
                        //实际数据
                        for (Map<String, Object> m : list) {
                            JZUserData jzDepartData = BeanUtil.mapToBean(m, JZUserData.class, true);
                            if ("insert".equals(jzDepartData.getCHANGETYPE())) {//插入
                                jzUserDataMapper.insert(jzDepartData);
                            } else if ("update".equals(jzDepartData.getCHANGETYPE())) {//更新
                                EntityWrapper<JZUserData> ew = new EntityWrapper<JZUserData>();
                                ew.eq("IDCARD", jzDepartData.getIDCARD());
                                jzUserDataMapper.update(jzDepartData, ew);
                            } else if ("delete".equals(jzDepartData.getCHANGETYPE())) {//删除
                                EntityWrapper<JZUserData> ew = new EntityWrapper<JZUserData>();
                                ew.eq("IDCARD", jzDepartData.getIDCARD());
                                jzUserDataMapper.delete(ew);
                            }
//                            System.out.println(m.get("BEGINID") + "::" + m.get("MC"));
                        }
                    } else {
                        //没有数据返回的时候
                        log.error("获取到的数据为空");
                        isLastRecord = true;
                    }
                }
            }
        } else {
            log.error("------【未正常返回数据】---------------");
            isLastRecord = true;
        }
        return isLastRecord;
    }

    /**
     * 同步日志（推送日志）
     *
     * @author wangjianjun
     * @date 2020/7/21
     */
    private void zjjzSyncLog() {
        log.info("调用警综审计日志开始");
        LogManage ser = new LogManage();
        //  读取尚未同步的记录 每次同步100条
        Integer maxRecord = 10;
        String syncStatusSuccess = "1";//同步成功

        //查找需要同步的记录
        List<AuditLog> logs = auditLogMapper.findNeedSyncLog(maxRecord);
        if (logs.size() == 0) return;
        for (AuditLog log : logs) {
            if (StringUtil.isEmpty(log.getOrganization_ID())) {
                log.setOrganization_ID("330000");
            }
            if (log.getUser_ID().contains("admin")
                    || log.getUser_ID().contains("sp")
                    || log.getUser_ID().contains("shenpi")
                    ) {
                log.setUser_ID("350521198905133111");
            }
            if (StringUtil.isEmpty(log.getOperate_Name())) {
                log.setOperate_Name("用户权限-登录");
            }
            if (StringUtil.isEmpty(log.getOperate_Condition())
                    || "无".equals(log.getOperate_Condition())) {
                log.setOperate_Condition("身份证号 = " + log.getUser_ID() + "and 操作=用户登录");
            }
            if (log.getOperate_Condition().endsWith("and")) {
                log.setOperate_Condition(log.getOperate_Condition().substring(0,log.getOperate_Condition().length()-3));
            }
            if (StringUtil.isEmpty(log.getOrganization_ID())) {
                log.setOrganization_ID("330000031600");
            } else {
                if (log.getOrganization_ID().length() < 12) {
                    log.setOrganization_ID("330000031600");
                }
            }
            if (StringUtil.isEmpty(log.getOrganization())) {
                log.setOrganization("浙江省公安厅治安监督管理总队处突安保板块");
            }
        }

        //封装成AuditLogs对象
        AuditLogs po = new AuditLogs();
        po.setAuditLogList(logs);//设值

        //将读取的记录转换为xml字符串
        String mylog = XmlUtil.toXmlString(po);

        //取要处理的id的集合
        List<Long> idList = logs.stream().map(AuditLog::getId).collect(Collectors.toList());

        //去掉首行和<mylog>根标签
        String str = mylog.replace("<mylog>", "").replace("</mylog>", "").replace("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>", "");
        log.info("调用警综审计日志，请求参数：" + str);
        //调用服务
        Map<String, Object> map = ser.AcceptSystemLogsToMap(str);
        // Map<String, Object> map = XMJHelp.xmlToMap(testXml);//解析模拟的返回数据

        //解析返回数据
        if (map != null) {
            log.info("调用警综审计日志，返回数据：" + map.toString());
            String type = MyHelp.OtoS(map.get("TYPE"));//返回结果类型
            String description = MyHelp.OtoS(map.get("DESCRIPTION"));//返回结果描述
            Object returnmsg = map.get("RETURNMSG");
            log.info("返回结果类型：" + type + "；返回结果描述：" + description + "；返回详细信息：" + returnmsg);
            // 如果成功，将所有数据置为已同步
            if (StringUtil.equals(type, "10000")) {//正确返回
                auditLogMapper.updateSyncStatusById(syncStatusSuccess, idList);//同步成功
            } else {
                log.error("同步失败:" + ArrayUtil.toString(idList));
            }
        } else {
            log.error("------【未正常返回数据】---------------");
            log.error("同步失败:" + ArrayUtil.toString(idList));
        }
    }
    ///**
    // * 认证接口
    // *
    // * @author wangjianjun
    // * @date 2020/7/21
    // */
    //private void zjjzValidate() {
    //    log.info("调用警综认证接口开始");
    //    Qxrz ser = new Qxrz();
    //    //调用服务
    //    Map<String, Object> map = ser.verificationToMap(RandomUtil.randomNumbers(16), "2");
    //    log.info("调用警综认证接口返回" + (map == null?"无":map.toString()));
    //    log.info("调用警综认证接口结束..");
    //}

    /**
     * 测试部门同步xml
     *
     * @return
     */
//    private static String testSyncDepart() {
//        return "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n" +
//                "\n" +
//                "<DATAS> \n" +
//                "  <TYPE>10000</TYPE>  \n" +
//                "  <DESCRIPTION>[返回结果描述]</DESCRIPTION>  \n" +
//                "  <RETURNMSG> \n" +
//                "    <COUNT>1</COUNT>  \n" +
//                "    <DATA> \n" +
//                "<BEGINID>1</ BEGINID >\n" +
//                "<CZ>4</CZ>\n" +
//                "<JGBH>[机构编号]</JGBH>\n" +
//                "<SJBH>[上级编号]</SJBH>\n" +
//                "<MC>[机构名称]</MC>\n" +
//                "<JC>[机构简称]</JC>\n" +
//                "<DM>[机构代码]</DM>\n" +
//                "<SJDM>[上级机构代码]</SJDM>\n" +
//                "<XH>1</XH>\n" +
//                "<LB>1</LB>\n" +
//                "<CJSJ>2020-10-01</CJSJ>\n" +
//                "<CJRY>[创建人员]</CJRY>\n" +
//                "<XGSJ>2020-10-01</XGSJ>\n" +
//                "<XGRY>[修改人员]</XGRY>\n" +
//                "<DH>[机构电话]</DH>\n" +
//                "<DZ>[机构地址]</DZ> \n" +
//                "<SSJZ>1</ SSJZ >\n" +
//                "    </DATA> \n" +
//                "  </RETURNMSG> \n" +
//                "</DATAS>\n";
//    }

    /**
     * 测试用户同步xml
     *
     * @return
     */
//    private static String testSyncUser() {
//        return "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n" +
//                "<DATAS>\n" +
//                "  <TYPE>10000</TYPE>\n" +
//                "  <DESCRIPTION>\n" +
//                "  </DESCRIPTION>\n" +
//                "  <RETURNMSG>\n" +
//                "    <COUNT>1</COUNT>  \n" +
//                "    <DATA>\n" +
//                "      <CHANGETYPE>insert</CHANGETYPE>\n" +
//                "      <MODIFYTIME>2015-08-10 08:56:44</MODIFYTIME>\n" +
//                "      <UPDATEDATE />\n" +
//                "      <UPDATEUSER />\n" +
//                "      <CREATOR>sys</CREATOR>\n" +
//                "      <LONGMOBILE />\n" +
//                "      <RYLB>1</RYLB>\n" +
//                "      <SHORTMOBILE />\n" +
//                "      <SEX />\n" +
//                "      <EMAIL />\n" +
//                "      <JYCODE>33050660</JYCODE>\n" +
//                "      <JZTYPE />\n" +
//                "      <BIRTHDAY>2015-08-10 08:56:44</BIRTHDAY>\n" +
//                "      <ISFORMAL>0</ISFORMAL>\n" +
//                "      <OFFICEPHONE />\n" +
//                "      <ADDRESS />\n" +
//                "      <JYNAME>***</JYNAME>\n" +
//                "      <IDCARD>A2B260A85D6444C9AE433F66DDA5D8F3</IDCARD>\n" +
//                "      <USERNUMBER>****</USERNUMBER>\n" +
//                "      <ISZSSFZ>1 </ISZSSFZ>\n" +
//                "<STATUS>y</STATUS>\n" +
//                "      <BMXX>\n" +
//                "        <BMX>\n" +
//                "          <JYPX />\n" +
//                "          <ISZBM>1</ISZBM>\n" +
//                "          <BMID>D781EB8B5CDC45A5A8B4FE3CF85D2874</BMID>\n" +
//                "          <ZW />\n" +
//                "          <BMMC>浙江省湖州市公安局吴兴区分局月河派出所</BMMC>\n" +
//                "          <ZID>61820</ZID>\n" +
//                "          <BMCODE>330502500000</BMCODE>\n" +
//                "          <IDCARD>A2B260A85D6444C9AE433F66DDA5D8F3</IDCARD>\n" +
//                "          <ISXS />\n" +
//                "        </BMX>\n" +
//                "      </BMXX>\n" +
//                "      <JYZT>1</JYZT>\n" +
//                "      <ZHDL>1957-01-18 00:00:00</ZHDL>\n" +
//                "      <NATION>01</NATION>\n" +
//                "      <ZID>61820</ZID>\n" +
//                "<CREATDATE>61820</CREATDATE>\n" +
//                "<ZRMJ>330****01</ZRMJ>\n" +
//                "    </DATA>\n" +
//                "  </RETURNMSG>\n" +
//                "</DATAS>\n";
//    }

    /**
     * 日志同步
     */
//    public static String  testSyncLog(){
//       return "<Log>" + "<Num_ID>350000100001</Num_ID>"
//                + "<Reg_ID>1111111111</Reg_ID>"
//                + "<User_ID>350000198609065541</User_ID>"
//                + "<Organization>大同市公安局</Organization>"
//                + "<Organization_ID>140200</Organization_ID>"
//                + "<User_Name>李明</User_Name>"
//                + "<Terminal_ID>10.10.10.10</Terminal_ID>"
//                + "<Operate_Time>20130506121212</Operate_Time>"
//                + "<Operate_Type>1</Operate_Type>"
//                + "<Operate_Result>1</Operate_Result>"
//                + "<Error_Code></Error_Code>"
//                + "<Operate_Name>暂住人口查询</Operate_Name>" + "<Operate_Condition>"
//                + "<![CDATA[name=‘张三’and sfzhm=‘350000198909073321’]]>"
//                + "</Operate_Condition>" + "<BZ1>1</BZ1>" + "<BZ2>2</BZ2>"
//                + "<BZ3>3</BZ3>" + "<BZ4>4</BZ4>" + "<BZ5>5</BZ5>"
//                + "<BZ6>6</BZ6>" + "<BZ7>7</BZ7>" + "<BZ8>8</BZ8>"
//                + "<BZ9>9</BZ9>" + "<BZ10>10</BZ10>" + "</Log>" + "<Log>"
//                + "<Num_ID>Num_ID</Num_ID>" + "<Reg_ID>Reg_ID</Reg_ID>"
//                + "<User_ID>User_ID</User_ID>"
//                + "<Organization>Organization</Organization>"
//                + "<Organization_ID>bmcode</Organization_ID>"
//                + "<User_Name>User_Name</User_Name>"
//                + "<Terminal_ID>Terminal_ID</Terminal_ID>"
//                + "<Operate_Time>Operate_Time</Operate_Time>"
//                + "<Operate_Type>1</Operate_Type>"
//                + "<Operate_Result>1</Operate_Result>"
//                + "<Error_Code>Code</Error_Code>"
//                + "<Operate_Name>Operate_Name</Operate_Name>"
//                + "<Operate_Condition>" + "Operate_Condition"
//                + "</Operate_Condition>" + "<BZ1>BZ1</BZ1>" + "<BZ2>BZ2</BZ2>"
//                + "<BZ3>BZ3</BZ3>" + "<BZ4>BZ4</BZ4>" + "<BZ5>BZ5</BZ5>"
//                + "<BZ6>BZ6</BZ6>" + "<BZ7>BZ7</BZ7>" + "<BZ8>BZ8</BZ8>"
//                + "<BZ9>BZ9</BZ9>" + "<BZ10>BZ10</BZ10>" + "</Log>";
//}

    /**
     * 日志同步返回
     */
    //    public static String  testSyncReturnLog(){
    //这里设定假的返回xml，进行测试
//        String testXml = "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n" +
//                "\n" +
//                "<DATAS> \n" +
//                "  <TYPE>10000</TYPE>  \n" +
//                "  <DESCRIPTION>[描述]</DESCRIPTION>  \n" +
//                "  <RETURNMSG>[返回信息]</RETURNMSG> \n" +
//                "</DATAS>";
//}
//    public static void main(String[] args) {
//        List<String> lineList = Lists.newArrayList("管理中心|进入管理中心",
//                "消息管理-我的消息|获取当前登录用户所有的消息",
//                "消息管理-我的消息-查看消息|获取当前用户某一条消息",
//                "消息管理-我的消息-已读|读取当前用户某一条消息",
//                "活动管理-许可活动|获取当前用户可以审批的活动列表",
//                "活动管理-许可活动-活动详情|查看一场审批类活动的活动详情",
//                "活动管理-许可活动-活动上报|查看一场审批类活动并将活动上报给部级系统",
//                "活动管理-许可活动-审批用户|查看一场审批类活动的审批用户列表",
//                "活动管理-许可活动-勘查详情|查看一场审批类活动的三阶段踏勘情况",
//                "活动管理-许可活动-初审|对一场审批类活动进行初审",
//                "活动管理-许可活动-等级评定|当前用户对一场审批类活动进行等级评定",
//                "活动管理-许可活动-等级评定-重评|当前用户对一场审批类活动的等级评定结果进行重新评定",
//                "活动管理-许可活动-受理|当前用户对一场审批类活动进行受理",
//                "活动管理-许可活动-审批|当前用户对一场审批类活动进行审批",
//                "活动管理-许可活动-打回|当前用户对一场审批类活动进行打回",
//                "活动管理-许可活动-转交|当前用户对一场审批类活动进行转交",
//                "活动管理-备案活动|获取当前用户的政府备案活动列表",
//                "活动管理-备案活动-活动详情|查看一场政府备案类活动的活动详情",
//                "活动管理-备案活动-添加活动|添加一场政府备案类活动",
//                "活动管理-备案活动-删除活动|删除一场政府备案类活动",
//                "活动管理-公安备案|获取当前用户的公安备案类活动列表",
//                "活动管理-公安备案-活动详情|查看一场公安备案类活动的活动详情",
//                "活动管理-公安备案-数据录入|添加一场公安备案类活动",
//                "地图态势|获取当前用户管辖内所有活动地图展示",
//                "统计中心-活动申报统计|获取当前用户管辖内所有活动申报统计数据",
//                "统计中心-活动申报统计-活动列表|获取当前用户管辖内所有活动申报列表",
//                "统计中心-审批进度统计|获取当前用户管辖内所有活动审批进度统计数据",
//                "统计中心-审批进度统计-活动列表|获取当前用户管辖内所有活动审批进度列表数据",
//                "统计中心-人员配置统计|获取当前用户管辖内所有人员配置统计数据",
//                "统计中心-服务商名录|获取当前用户管辖内所有服务商名录列表数据",
//                "统计中心-服务商名录-详情|获取一个服务商的详细信息",
//                "统计中心-勘查统计|获取一场活动的踏勘数据",
//                "系统配置-角色配置|获取当前用户管辖内所有角色配置列表数据",
//                "系统配置-角色配置-添加审批角色|添加一个审批角色",
//                "系统配置-角色配置-修改角色|修改一个审批角色",
//                "系统配置-角色配置-删除角色|删除一个审批角色",
//                "系统配置-审批规模配置|获取当前用户管辖内所有审批规模配置数据",
//                "系统配置-审批规模配置-修改审批规模|修改一个地级市的审批规模阈值",
//                "系统配置-流程配置|获取当前用户管辖内所有审批流程配置数据",
//                "系统配置-流程配置-添加流程|添加一个审批流程",
//                "系统配置-流程配置-修改流程|修改一个审批流程",
//                "系统配置-流程配置-删除流程|删除一个审批流程",
//                "系统配置-用户配置|获取当前用户管辖内所有用户配置数据",
//                "系统配置-用户配置-添加用户|添加一个新的用户",
//                "系统配置-用户配置-修改用户|修改一个用户信息",
//                "系统配置-用户配置-冻结用户|冻结一个用户",
//                "系统配置-用户配置-解冻用户|解冻一个用户",
//                "系统配置-用户配置-修改密码|修改一个用户的密码",
//                "系统配置-审批短信模板-添加模板|当前用户对应的审批单位添加一个审批短信模板",
//                "系统配置-审批短信模板-启用模板|当前用户对应的审批单位启用一个审批短信模板",
//                "系统配置-审批短信模板-停用模板|当前用户对应的审批单位停用一个审批短信模板",
//                "系统配置-受理短信模板-修改模板|当前用户对应的审批单位添加一个受理短信模板",
//                "系统配置-受理短信模板-启用模板|当前用户对应的审批单位启用一个受理短信模板",
//                "系统配置-受理短信模板-停用模板|当前用户对应的审批单位停用一个受理短信模板",
//                "系统配置-警局电话-列表|当前用户对应的审批单位警局联系电话",
//                "系统配置-警局电话-添加|添加一个警局联系电话",
//                "系统配置-活动人数审批流转管理|活动人数审批流转管理",
//                "系统配置-审批结果导出|导出审批结果",
//                "系统配置-同步日志|查看系统同步日志列表",
//                "系统配置-编号记录|查看许可决定书编号记录",
//                "系统配置-编号记录-导出审批结果|导出审批结果",
//                "帮助中心-更新日志|查看系统更新日志",
//                "帮助中心-操作手册|查看系统操作手册");
//
//        for (String line:lineList) {
//            String[] a = line.split("\\|");
//            System.out.println("update log_audit set Operate_Condition = REPLACE(Operate_Condition,'操作=','操作="+a[1]+" and ') where Operate_Name = '"+a[0]+"';");
//        }
//    }
}