open-JSD-10625/src/main/java/com/fr/plugin/user/tuomin/controller/TableDataSyncAction.java

package com.fr.plugin.user.tuomin.controller;

import com.fr.decision.authority.base.constant.type.operation.SyncOperationType;
import com.fr.decision.authority.controller.personnel.PersonnelController;
import com.fr.decision.authority.controller.personnel.PersonnelWork;
import com.fr.decision.sync.CascadeData;
import com.fr.decision.sync.SourceConflictData;
import com.fr.decision.sync.SourceConflictStrategy;
import com.fr.decision.sync.SyncDetail;
import com.fr.decision.sync.data.RowData;
import com.fr.decision.sync.result.FailedData;
import com.fr.decision.sync.result.SyncResultData;
import com.fr.decision.sync.result.SyncWorkResult;
import com.fr.decision.sync.work.SyncWork;
import com.fr.decision.sync.work.impl.*;
import com.fr.decision.webservice.interceptor.handler.PreHandlerFactory;
import com.fr.general.data.DataModel;
import com.fr.log.FineLoggerFactory;
import com.fr.script.Calculator;

import java.lang.reflect.Field;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.Map.Entry;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class TableDataSyncAction implements PersonnelWork {
    private SyncDetail syncDetail;
    private DataModel dm;
    private Map<Integer, SyncWork> syncWorks = new TreeMap();
    private UserSyncWork userSyncWork;

    public static com.fr.plugin.user.tuomin.controller.TableDataSyncAction create(SyncDetail var0) {
        return new com.fr.plugin.user.tuomin.controller.TableDataSyncAction(var0);
    }

    private TableDataSyncAction(SyncDetail var1) {
        this.syncDetail = var1;
        this.dm = var1.getSyncSource().buildTableData(var1.getDataSetName()).createDataModelWithTimeout(Calculator.createCalculator(), (int)var1.getRate());
    }

    public void before(PersonnelController var1) throws Exception {
        this.registerSyncWorks(var1);
        this.checkPlatformDirtyData();
    }


    private static final String PW_PATTERN = "^(?![A-Za-z0-9]+$)(?![a-z0-9\\W]+$)(?![A-Za-z\\W]+$)(?![A-Z0-9\\W]+$)[a-zA-Z0-9\\W]{8,}$";

    private boolean validatePwd(String pswd,String userName){
        boolean falg = false;
        try {
            if (null==pswd&&pswd.isEmpty()&&pswd.length()>9){
                return  falg;
            }
            //不全是特殊符号 不全是数字 不全是字母 不全是大写 不全是小写
            if (pswd.matches(PW_PATTERN)){
                falg = true;
            }

        } catch (Exception e) {
            falg = false;
        }

        if(falg == false){
            FineLoggerFactory.getLogger().info("密码强度验证：长度，大小写字母，符号不符合");
            return false;
        }

        if(pswd.toLowerCase().indexOf(userName.toLowerCase()) != -1){
            FineLoggerFactory.getLogger().info("密码强度验证：密码不能包含用户名");
            return false;
        }
        return true;
    }

    public SyncResultData execute(PersonnelController var1) throws Exception {
        this.clearDiffSource();
        this.preparePlatformData();
        this.beforePrepareSyncData();
        this.prepareSyncData();
        this.afterPrepareSyncData();
        Field[] fileds = this.userSyncWork.getClass().getDeclaredFields();
        for(int i = 0 ; i < fileds.length;i++) {
            Field field = fileds[i];
            String fieldName = field.getName();
            FineLoggerFactory.getLogger().info("fieldName:"+fieldName);
            if(fieldName.equals("syncNamePasswordMap")){
                try {
                    field.setAccessible(true);
                    Object obj = field.get( this.userSyncWork);
                    Map<String, String> syncNamePasswordMap = (Map<String, String>)obj;
                    FineLoggerFactory.getLogger().info("一共有几个用户导入:"+syncNamePasswordMap.size());
                    Set<String> keys =  syncNamePasswordMap.keySet();
                    for(String key : keys){
                        String pwd = syncNamePasswordMap.get(key).toString();
                        //这里判断密码强度
                        boolean isOk = validatePwd(pwd,key);

                        if(isOk == false){
                            SyncResultData resultData = new SyncResultData();
                            resultData.setSuccessUserCount(-100);
                            return resultData;
                        }
                    }
                }
                catch (IllegalAccessException e) {
                    e.printStackTrace();
                }
            }
        }

        this.sourceCover();
        this.addOrUpdate();
        this.delete();
        return this.over();
    }

    private void registerSyncWorks(PersonnelController var1) {
        this.userSyncWork = new UserSyncWork(var1, this.syncDetail);
        SyncWork[] var2 = new SyncWork[]{userSyncWork, new DepartmentSyncWork(var1, this.syncDetail), new PostSyncWork(var1, this.syncDetail), new CustomRoleSyncWork(var1, this.syncDetail), new DepRoleSyncWork(var1, this.syncDetail), new UserRoleMiddleSyncWork(var1, this.syncDetail)};
        SyncWork[] var3 = var2;
        int var4 = var2.length;

        for(int var5 = 0; var5 < var4; ++var5) {
            SyncWork var6 = var3[var5];
            this.syncWorks.put(var6.processOrder(), var6);
        }

    }

    private void checkPlatformDirtyData() throws Exception {
        Iterator var1 = this.syncWorks.values().iterator();

        while(var1.hasNext()) {
            SyncWork var2 = (SyncWork)var1.next();
            var2.checkPlatformDirtyData();
        }

    }

    private void preparePlatformData() throws Exception {
        Iterator var1 = this.syncWorks.values().iterator();

        while(var1.hasNext()) {
            SyncWork var2 = (SyncWork)var1.next();
            var2.preparePlatformData();
        }

    }

    private void beforePrepareSyncData() throws Exception {
        Iterator var1 = this.syncWorks.values().iterator();

        while(var1.hasNext()) {
            SyncWork var2 = (SyncWork)var1.next();
            var2.beforePrepareSyncData(this.dm);
        }

    }

    private void prepareSyncData() throws Exception {
        for(int var1 = 0; var1 < this.dm.getRowCount(); ++var1) {
            RowData var2 = new RowData(var1);
            Iterator var3 = this.syncWorks.values().iterator();

            while(var3.hasNext()) {
                SyncWork var4 = (SyncWork)var3.next();
                var4.prepareSyncData(this.dm, var2);
            }
        }

        this.dm.release();
    }

    private void afterPrepareSyncData() throws Exception {
        CascadeData var1 = new CascadeData();

        SyncWork var3;
        for(Iterator var2 = this.syncWorks.values().iterator(); var2.hasNext(); var1 = var3.afterPrepareSyncData(var1)) {
            var3 = (SyncWork)var2.next();
        }

    }

    private void sourceCover() throws Exception {
        SourceConflictData var1 = new SourceConflictData();

        SyncWork var3;
        for(Iterator var2 = this.syncWorks.values().iterator(); var2.hasNext(); var1 = var3.resolveSourceConflict(var1)) {
            var3 = (SyncWork)var2.next();
        }

    }

    private void addOrUpdate() throws Exception {
        Iterator var1 = this.syncWorks.values().iterator();

        while(var1.hasNext()) {
            SyncWork var2 = (SyncWork)var1.next();
            var2.addOrUpdate();
        }

    }

    private void delete() throws Exception {
        if (this.syncDetail.getOperationType() == SyncOperationType.KEY) {
            CascadeData var1 = new CascadeData();
            Iterator var2 = this.syncWorks.values().iterator();

            while(var2.hasNext()) {
                SyncWork var3 = (SyncWork)var2.next();
                var3.delete(var1);
            }

        }
    }

    private void clearDiffSource() throws Exception {
        if (this.syncDetail.getSourceConflictStrategy() == SourceConflictStrategy.CLEAR) {
            SyncWork[] var1 = new SyncWork[]{(SyncWork)this.syncWorks.get(1), (SyncWork)this.syncWorks.get(5), (SyncWork)this.syncWorks.get(2), (SyncWork)this.syncWorks.get(3), (SyncWork)this.syncWorks.get(4)};
            SyncWork[] var2 = var1;
            int var3 = var1.length;

            for(int var4 = 0; var4 < var3; ++var4) {
                SyncWork var5 = var2[var4];
                var5.clearDiffSource();
            }
        }

    }

    private SyncResultData over() throws Exception {
        SyncResultData var1 = new SyncResultData();
        Iterator var2 = this.syncWorks.entrySet().iterator();

        while(var2.hasNext()) {
            Entry var3 = (Entry)var2.next();
            SyncWorkResult var4 = ((SyncWork)var3.getValue()).over();
            if (var4 != null) {
                if ((Integer)var3.getKey() == 1) {
                    var1.setSuccessUserCount(var4.getAddOrUpdateCount());
                    var1.setCurrentUserCount(var4.getCurrentCount());
                }

                var1.addFailedData(var4.getRoleType(), (FailedData[])var4.getFailedData().toArray(new FailedData[0]));
                var1.addOtherSourceRole(var4.getRoleType(), (String[])var4.getDiffSourceData().toArray(new String[0]));
            }
        }

        return var1;
    }
}