haojing/src/weaver/interfaces/dito/job/WorkflowUserCronJob.java

package weaver.interfaces.dito.job;

import org.apache.commons.lang3.StringUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import weaver.conn.RecordSet;
import weaver.general.BaseBean;
import weaver.general.TimeUtil;
import weaver.interfaces.dito.comInfo.PropBean;
import weaver.interfaces.dito.util.HttpUtils;
import weaver.interfaces.schedule.BaseCronJob;
import weaver.share.ShareManager;

import java.util.*;

import static com.engine.dito.ssologin.constant.DitoConstant.ACTION_TYPE_ADD_USER;
import static com.engine.dito.ssologin.constant.DitoConstant.ACTION_TYPE_DELETE;
import static com.engine.dito.ssologin.constant.DitoConstant.SYNC_ALL;

/**
 * @version 1.0
 * @Title ecology-9
 * @Company 泛微软件
 * @CreateDate 2022/11/14
 * @Description 流程及人员权限同步建模
 * @Author Lee
 */
public class WorkflowUserCronJob extends BaseCronJob {
    private String isAll;
    private static final Log logger = LogFactory.getLog(WorkflowUserCronJob.class);

    @Override
    public void execute() {
        BaseBean bb = new BaseBean();
        bb.writeLog("start WorkflowAuthModelingCronJob");
        RecordSet rs = new RecordSet();
        try {
            //全量则删除建模表数据重新同步
            if (StringUtils.isNotEmpty(isAll) && SYNC_ALL.equals(isAll)) {
                bb.writeLog("DELETE ALL uf_workflow_auth");
                rs.execute("delete from uf_workflow_auth");
            }
            String center = PropBean.getUfPropValue("newWorkflowCenter");
            String formModeId = PropBean.getUfPropValue("uf_workflow_auth_formModeId");
            String synchronizeUserUrl = PropBean.getUfPropValue("synchronizeUserUrl");
            String accountName = PropBean.getUfPropValue("username");
            String password = PropBean.getUfPropValue("passwd");


        /*
        查询出所有E9有效流程id，Set
         */
            //根据流程id查询出所有创建人id,封装成Map<String,Set>
            ShareManager shareManager = new ShareManager();
            Set<String> baseWorkflowIdSet = new HashSet<>();
            Map<String, Set<String>> baseWorkflowMap = new HashMap<>();
            Map<String, String> baseWorkflowName = new HashMap<>();
            Map<String, String> baseWorkflowCataCode = new HashMap<>();
            String baseWorkflowSql = "SELECT w.id,w.workflowname,u.cataCodeName FROM workflow_base w " +
                    "left join uf_syncCataCode u on w.id=u.flowCode WHERE w.ISVALID = 1";
            rs.execute(baseWorkflowSql);
            while (rs.next()) {
                String workflowId = rs.getString("id");
                String workflowname = rs.getString("workflowname");
                String cataCodeName = rs.getString("cataCodeName");
                baseWorkflowIdSet.add(workflowId);
                String userIds = shareManager.getWorkflowCreater(Integer.parseInt(workflowId));
                Set<String> userIdList = new HashSet<>(Arrays.asList(userIds.split(",")));
                baseWorkflowMap.put(workflowId, userIdList);
                baseWorkflowName.put(workflowId, workflowname);
                baseWorkflowCataCode.put(workflowId, cataCodeName);
            }

        /*
        查询出所有建模表流程id,Set
        并将创建人与流程id封装成Map<String,Set>
         */
            RecordSet rs2 = new RecordSet();
            String modelWorkflowSql = "SELECT DISTINCT workflowselect as id FROM uf_workflow_auth";
            rs.execute(modelWorkflowSql);
            Set<String> modelWorkflowIdSet = new HashSet<>();
            Map<String, Set<String>> modeWorkflowMap = new HashMap<>();
            Map<String, String> modeWorkflowCataCode = new HashMap<>();
            Map<String, String> modeWorkflowName = new HashMap<>();
            while (rs.next()) {
                String workflowId = rs.getString("id");
                modelWorkflowIdSet.add(workflowId);
                String modelUserSql = "SELECT w.userselect as userId,w.workflowname,u.cataCodeName FROM uf_workflow_auth w " +
                        "left join uf_syncCataCode u on w.workflowselect=u.flowCode WHERE w.workflowselect =?";
                rs2.executeQuery(modelUserSql, workflowId);
                Set<String> userIdList = new HashSet<>();
                while (rs2.next()) {
                    userIdList.add(rs2.getString("userId"));
                    String workflowName = rs2.getString("workflowname");
                    String cataCodeName = rs2.getString("cataCodeName");
                    modeWorkflowCataCode.put(workflowId, cataCodeName);
                    modeWorkflowName.put(workflowId, workflowName);
                }
                modeWorkflowMap.put(workflowId, userIdList);
            }

        /*
         建模表流程Set与E9有效流程Set取集
         */
            HashMap<String, String> headers = new HashMap<>();
            headers.put("Authorization", "Basic " + Base64.getUrlEncoder().encodeToString((accountName + ":" + password).getBytes()));

            Set<String> updateSet = new HashSet<>(baseWorkflowIdSet);
            updateSet.retainAll(modelWorkflowIdSet);
            Set<String> deleteSet = new HashSet<>(modelWorkflowIdSet);
            deleteSet.removeAll(updateSet);
            Set<String> addSet = new HashSet<>(baseWorkflowIdSet);
            addSet.removeAll(updateSet);
            //人员权限新增同步
            if (addSet.size() != 0) {
                addWorkflow(bb, addSet, baseWorkflowMap, baseWorkflowName, formModeId);
                List<List<Map<String, Object>>> addUserList = new LinkedList<>();
                getUserConditionByWorkflow(center, addSet, baseWorkflowName, baseWorkflowCataCode, addUserList);
                syncUser(synchronizeUserUrl, addUserList, headers);
            }

            //人员权限修改同步
            if (updateSet.size() != 0) {
                HashSet<String> needUpdateSet = updateWorkflow(bb, updateSet, baseWorkflowMap, modeWorkflowMap, baseWorkflowName, formModeId);
                logger.info("needUpdateSet-size:" + needUpdateSet.size());
                //先删除流程再重新同步人员权限
                if (needUpdateSet.size() != 0) {
                    //删除流程
                    syncWorkflowByHttp(ACTION_TYPE_DELETE, center, needUpdateSet, modeWorkflowName, modeWorkflowCataCode, headers);
                    List<List<Map<String, Object>>> updateUserList = new LinkedList<>();
                    getUserConditionByWorkflow(center, needUpdateSet, baseWorkflowName, baseWorkflowCataCode, updateUserList);
                    //重新同步流程及人员权限
                    syncWorkflowByHttp(ACTION_TYPE_ADD_USER, center, needUpdateSet, modeWorkflowName, modeWorkflowCataCode, headers);
                    syncUser(synchronizeUserUrl, updateUserList, headers);
                }
            }

            //失效流程删除人员关联
            if (deleteSet.size() != 0) {
                deleteWorkflow(bb, deleteSet);
            }
        } catch (Exception e) {
            logger.info("WorkflowAuthModelingCronJob-Exception:" + e.getMessage());
        }
    }


    /**
     * 同步流程至第三方
     *
     * @param action
     * @param center
     * @param needUpdateSet
     * @param modeWorkflowName
     * @param modeWorkflowCataCode
     * @param headers
     */
    private void syncWorkflowByHttp(String action, String center, HashSet<String> needUpdateSet, Map<String, String> modeWorkflowName, Map<String, String> modeWorkflowCataCode, HashMap<String, String> headers) {
        String bpm_app_workflowurl = PropBean.getUfPropValue("bpm_app_workflowurl");
        String synchronizeFlowUrl = PropBean.getUfPropValue("synchronizeFlowUrl");
        for (String workflowId : needUpdateSet) {
            Map<String, Object> workflowMap = new HashMap<>();
            workflowMap.put("flowCode", workflowId);
            workflowMap.put("flowName", modeWorkflowName.get(workflowId));
            workflowMap.put("actionType", action);
            workflowMap.put("cataCode", modeWorkflowCataCode.get(workflowId));
            workflowMap.put("center", center);
            workflowMap.put("urlPc", "/bpm/workflow/request/CreateRequestForward.jsp?workflowid=" + workflowId);
            workflowMap.put("urlApp", bpm_app_workflowurl + "/spa/workflow/static4mobileform/index.html#/req?iscreate=1&workflowid=" + workflowId);
            String data = HttpUtils.doPost(synchronizeFlowUrl, workflowMap, headers);
            logger.info("syncWorkflowByHttp-resultData:" + data);
        }
    }

    /**
     * 新增流程
     *
     * @param bb
     * @param addSet
     * @param baseWorkflowMap
     * @param baseWorkflowName
     * @param formModeId
     */
    private void addWorkflow(BaseBean bb, Set<String> addSet, Map<String, Set<String>> baseWorkflowMap, Map<String, String> baseWorkflowName, String formModeId) {
        String staffIdField = PropBean.getUfPropValue("staffIdFieldByCus");
        RecordSet rs = new RecordSet();
        RecordSet rs2 = new RecordSet();
        String currentDate = TimeUtil.getCurrentDateString();
        String onlyCurrentTime = TimeUtil.getOnlyCurrentTimeString();
        String addSql = "INSERT INTO uf_workflow_auth (userselect,effective,formmodeid,modedatacreatedate,modedatacreatetime,workflowselect,workflowname,staffid) values (?,?,?,?,?,?,?,?)";
        for (String workflowId : addSet) {
            List<List> lists = new ArrayList<>();
            Set<String> userIds = baseWorkflowMap.get(workflowId);
            for (String addUserId : userIds) {
                String workflowName = baseWorkflowName.get(workflowId);
                String workCodeQuery = "SELECT " + staffIdField + " as staffId FROM cus_fielddata WHERE id=? and SCOPEID=-1";
                rs2.executeQuery(workCodeQuery, addUserId);
                String staffId = "";
                if (rs2.next()) {
                    staffId = rs2.getString("staffId");
                }
                ArrayList<Object> list = new ArrayList<>();
                list.add(addUserId);
                list.add(0);
                list.add(formModeId);
                list.add(currentDate);
                list.add(onlyCurrentTime);
                list.add(workflowId);
                list.add(workflowName);
                list.add(staffId);
                lists.add(list);
            }
            rs.executeBatchSql(addSql, lists);
        }
    }

    /**
     * 更新建模表数据
     *
     * @param bb
     * @param updateSet
     * @param baseWorkflowMap
     * @param modeWorkflowMap
     * @param baseWorkflowName
     * @param formModeId
     */
    private HashSet<String> updateWorkflow(BaseBean bb, Set<String> updateSet, Map<String, Set<String>> baseWorkflowMap, Map<String, Set<String>> modeWorkflowMap, Map<String, String> baseWorkflowName, String formModeId) {
        bb.writeLog("updateWorkflow-----start");
        HashSet<String> needUpdateSet = new HashSet<>();
        String staffIdField = PropBean.getUfPropValue("staffIdFieldByCus");
        RecordSet rs = new RecordSet();
        RecordSet rs2 = new RecordSet();
        String currentDate = TimeUtil.getCurrentDateString();
        String onlyCurrentTime = TimeUtil.getOnlyCurrentTimeString();

        //对比人员Set
        for (String workflowId : updateSet) {
            String workflowName = baseWorkflowName.get(workflowId);
            Set<String> baseUsers = baseWorkflowMap.get(workflowId);
            Set<String> modeUsers = modeWorkflowMap.get(workflowId);
            //如果差集集为0，则跳过
            if (baseUsers.containsAll(modeUsers) && baseUsers.size() == modeUsers.size()) {
                continue;
            }
            //有变动的流程
            needUpdateSet.add(workflowId);

            //e9users与建模流程人员取差集，新增
            List<List> addLists = new ArrayList<>();
            HashSet<String> diffUsers = new HashSet<>(baseUsers);
            diffUsers.removeAll(modeUsers);
            if (diffUsers.size() != 0) {
                String addSql = "INSERT INTO uf_workflow_auth (userselect,effective,formmodeid,modedatacreatedate,modedatacreatetime,workflowselect,workflowname,staffid) values (?,?,?,?,?,?,?,?)";
                for (String addUserId : diffUsers) {
                    String workCodeQuery = "SELECT " + staffIdField + " as staffId FROM cus_fielddata WHERE id=? and SCOPEID=-1";
                    rs2.executeQuery(workCodeQuery, addUserId);
                    String staffId = "";
                    if (rs2.next()) {
                        staffId = rs2.getString("staffId");
                    }
                    ArrayList<Object> list = new ArrayList<>();
                    list.add(addUserId);
                    list.add(0);
                    list.add(formModeId);
                    list.add(currentDate);
                    list.add(onlyCurrentTime);
                    list.add(workflowId);
                    list.add(workflowName);
                    list.add(staffId);
                    addLists.add(list);
                }
                boolean b2 = rs.executeBatchSql(addSql, addLists);
            }
            //建模users与现流程人员取差集，删除
            HashSet<String> deleteUsers = new HashSet<>(modeUsers);
            deleteUsers.removeAll(baseUsers);
            if (deleteUsers.size() != 0) {
                List<List> deleteLists = new ArrayList<>();
                String deleteSql = "DELETE FROM uf_workflow_auth WHERE userselect=? AND workflowselect=?";
                for (String deleteUserId : deleteUsers) {
                    ArrayList<String> list = new ArrayList<>();
                    list.add(deleteUserId);
                    list.add(workflowId);
                    deleteLists.add(list);
                }
                boolean b1 = rs.executeBatchSql(deleteSql, deleteLists);
            }
        }
        return needUpdateSet;
    }

    /**
     * 删除建模表数据
     *
     * @param baseBean
     * @param deleteSet
     */
    private void deleteWorkflow(BaseBean baseBean, Set<String> deleteSet) {
        RecordSet rs = new RecordSet();
        String sql = "DELETE FROM  uf_workflow_auth WHERE workflowselect=?";
        for (String id : deleteSet) {
            boolean b = rs.executeUpdate(sql, id);
        }
    }

    /**
     * 组装人员同步API请求参数
     *
     * @param addSet
     * @param baseWorkflowName
     * @param baseWorkflowCataCode
     */
    private void getUserConditionByWorkflow(String center, Set<String> addSet, Map<String, String> baseWorkflowName, Map<String, String> baseWorkflowCataCode, List<List<Map<String, Object>>> userLists) {
        for (String flowCode : addSet) {
            //没有维护目录的跳过
            String cataCode = baseWorkflowCataCode.get(flowCode);
            if (StringUtils.isEmpty(cataCode)) {
                continue;
            }
            List<Map<String, Object>> userList = new LinkedList<>();
            Map<String, Object> userCondition = new HashMap<>();
            Map<String, Object> staffCodeMap = new HashMap<>();
            HashSet<String> staffCodeSet = new HashSet<>();
            String userSql = "SELECT staffid FROM uf_workflow_auth WHERE workflowselect=?";
            RecordSet rs = new RecordSet();
            rs.executeQuery(userSql, flowCode);
            while (rs.next()) {
                String staffid = rs.getString("staffid");
                if (StringUtils.isNotEmpty(staffid)) {
                    staffCodeSet.add(staffid);
                }
            }
            staffCodeMap.put("staffCodeSet", staffCodeSet);
            userList.add(staffCodeMap);
            //组建人员同步map
            userCondition.put("flowCode", flowCode);
            userCondition.put("flowName", baseWorkflowName.get(flowCode));
            //同步所需参数一并拼接
            userCondition.put("actionType", ACTION_TYPE_ADD_USER);
            userCondition.put("center", center);

            userCondition.put("cataCode", cataCode);
            Map<String, Object> userMap = new HashMap<>();
            userMap.put("userCondition", userCondition);
            userList.add(userMap);
            userLists.add(userList);
        }
    }

    /**
     * 人员同步方法
     *
     * @param synchronizeUserUrl
     * @param headers
     */
    private void syncUser(String synchronizeUserUrl, List<List<Map<String, Object>>> userLists, HashMap<String, String> headers) {
        for (List<Map<String, Object>> userList : userLists) {
            Map<String, Object> staffCodeMap = userList.get(0);
            Map<String, Object> userConditionMap = userList.get(1);
            Map<String, Object> userCondition = (Map<String, Object>) userConditionMap.get("userCondition");
            HashSet<String> staffCodeSet = (HashSet<String>) staffCodeMap.get("staffCodeSet");
            StringBuilder stringBuilder = new StringBuilder();
            for (String staffCode : staffCodeSet) {
                //超出字段长度限制请求接口后清空一次
                if (stringBuilder.length() >= 10000) {
                    userCondition.put("staffIds", stringBuilder.toString());
                    String data = HttpUtils.doPost(synchronizeUserUrl, userCondition, headers);
                    logger.info("synchronizeUser-data" + data);
                    stringBuilder.delete(0, stringBuilder.length());
                }
                stringBuilder.append(staffCode).append("|");
            }
            //最后字段可能没有超限，再同步最后的人员
            if (stringBuilder.length() != 0) {
                userCondition.put("staffIds", stringBuilder.toString());
                String data = HttpUtils.doPost(synchronizeUserUrl, userCondition, headers);
                logger.info("synchronizeUser-last-data" + data);
            }
        }
    }
}