会员

src/main/java/io/v/nutz/zhgh/data/handle/DataImportPluginHandle.java

@@ -1,7 +1,7 @@
 package io.v.nutz.zhgh.data.handle;
 
 import io.v.nutz.base.annontation.SelectEnum;
-import io.v.nutz.zhgh.member.UserMode;
+import io.v.nutz.zhgh.staffmanage.member.UserMode;
 import lombok.Getter;
 import org.apache.shiro.crypto.hash.Sha256Hash;
 import org.apache.shiro.util.ByteSource;

src/main/java/io/v/nutz/zhgh/data/model/UserHistory.java

@@ -7,6 +7,7 @@ import lombok.EqualsAndHashCode;
 import lombok.experimental.Accessors;
 import org.nutz.dao.entity.annotation.*;
 import org.nutz.dao.interceptor.annotation.PrevInsert;
+import org.nutz.lang.util.NutMap;
 
 import java.util.Date;
 import java.util.List;
@@ -37,26 +38,21 @@ public class UserHistory extends Sys_user {
 
     @Column
     @Comment("更新时间")
+    @ColDefine(type = ColType.DATETIME)
     private Date changeTime;
 
     /**
      * @see UserChangeType
      */
-    @Column
-    @Comment("变更类型")
-    private int changeType;
-
     @Column
     @Comment("变更类型(多种)")
-    private List<Integer> changeTypes;
+    @ColDefine(type = ColType.MYSQL_JSON)
+    private List<String> changeTypes;
 
     @Column
     @Comment("变更来源")
-    private Integer changeOrigin;
-
-    @Column
-    @Comment("变更人")
-    private String changeOperator;
+    @ColDefine(type = ColType.VARCHAR, width = 50)
+    private String changeOrigin;
 
     @Column
     @ColDefine(type = ColType.VARCHAR, width = 100)
@@ -65,10 +61,16 @@ public class UserHistory extends Sys_user {
 
     @Column
     @Comment("会员变更表记录id")
-    private String memberChangeRecordId;
+    @ColDefine(type = ColType.VARCHAR, width = 32)
+    private String recordId;
 
     @Column
-    @ColDefine(type = ColType.VARCHAR, width = 32)
-    @Comment("上一次历史记录id")
-    private String lastHistoryId;
+    @Comment("详细变更记录,用于查询、列表展示")
+    @ColDefine(type = ColType.MYSQL_JSON)
+    private List<NutMap> changeInfos;
+
+    @Column
+    @Comment("详细变更记录,文本类型,可用于导出")
+    @ColDefine(type = ColType.TEXT)
+    private String changeInfosStr;
 }

src/main/java/io/v/nutz/zhgh/data/service/impl/SourceUserServiceImpl.java

@@ -1,20 +1,27 @@
 package io.v.nutz.zhgh.data.service.impl;
 
+import cn.hutool.core.bean.BeanUtil;
 import cn.hutool.core.date.DateTime;
 import cn.hutool.core.date.DateUtil;
+import cn.hutool.core.util.ObjectUtil;
 import cn.hutool.core.util.StrUtil;
+import cn.hutool.http.HtmlUtil;
 import io.v.nutz.base.utils.ManyAddOrRenewUtil;
 import io.v.nutz.base.utils.Roles;
+import io.v.nutz.sys.models.Sys_dict;
 import io.v.nutz.sys.models.Sys_user_role;
+import io.v.nutz.sys.services.SysDictService;
 import io.v.nutz.sys.services.SysUserRoleService;
 import io.v.nutz.web.commons.utils.ShiroUtil;
+import io.v.nutz.zhgh.activity.models.ActivityUserScope;
 import io.v.nutz.zhgh.data.constant.SourceData;
 import io.v.nutz.zhgh.data.constant.UserChangeType;
 import io.v.nutz.zhgh.data.model.UserHistory;
 import io.v.nutz.zhgh.data.model.UserSource;
 import io.v.nutz.zhgh.data.service.HistoryUserService;
 import io.v.nutz.zhgh.data.service.SourceUserService;
-import io.v.nutz.zhgh.member.UserMode;
+import io.v.nutz.zhgh.data.vo.SourceUserCommonVo;
+import io.v.nutz.zhgh.staffmanage.member.UserMode;
 import io.v.nutz.base.service.AsyncService;
 import io.v.nutz.base.service.impl.ViServiceImpl;
 import io.v.nutz.sys.models.Sys_user;
@@ -22,7 +29,11 @@ import io.v.nutz.sys.services.SysRoleService;
 import io.v.nutz.sys.services.SysUserService;
 import io.v.nutz.web.commons.controller.userpartupdate.models.UserPartUp;
 import io.v.nutz.web.commons.controller.userpartupdate.service.UserPatUpService;
-import io.v.nutz.zhgh.member.constant.MemberChangeOrigin;
+import io.v.nutz.zhgh.staffmanage.member.constant.MemberChangeOrigin;
+import io.v.nutz.zhgh.staffmanage.member.constant.MemberChangeType;
+import io.v.nutz.zhgh.staffmanage.member.service.MemberCommonService;
+import io.v.nutz.zhgh.staffmanage.sourcechange.model.SourceChangeConfig;
+import io.v.nutz.zhgh.staffmanage.sourcechange.model.SourceChangeMiddleTable;
 import lombok.extern.slf4j.Slf4j;
 import org.nutz.aop.interceptor.ioc.TransAop;
 import org.nutz.dao.Cnd;
@@ -47,6 +58,7 @@ import java.util.concurrent.*;
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.concurrent.locks.Lock;
 import java.util.concurrent.locks.ReentrantLock;
+import java.util.function.Function;
 import java.util.stream.Collectors;
 
 /**
@@ -60,8 +72,6 @@ public class SourceUserServiceImpl extends ViServiceImpl<UserSource> implements
         super(dao);
     }
 
-    // 是会员的人员类型
-    private final List<String> MEMBER_PERSON_TYPE = List.of("事业编制（员额）", "事业编制", "校聘编外", "同工同酬", "学校编制", "博士后（统招）");
 
     @Inject
     private AsyncService asyncService;
@@ -74,8 +84,12 @@ public class SourceUserServiceImpl extends ViServiceImpl<UserSource> implements
     @Inject
     private SysRoleService sysRoleService;
     @Inject
+    private SysDictService sysDictService;
+    @Inject
     private SysUserRoleService sysUserRoleService;
     @Inject
+    private MemberCommonService memberCommonService;
+    @Inject
     private ManyAddOrRenewUtil manyAddOrRenewUtil;
 
     @Override
@@ -94,13 +108,7 @@ public class SourceUserServiceImpl extends ViServiceImpl<UserSource> implements
     @Aop(TransAop.READ_COMMITTED)
     public void updateSysUser(String pullTime, String sourceType, String[] columnNames, String isUpSet, String partGroupId, boolean isInvert) {
         try {
-            List<Sys_user> users = sysUserService.query(Cnd.where("loginname", "is not", null));
-            Map<String, Sys_user> userMap = users.stream().collect(Collectors.toMap(sys_user -> sys_user.getLoginname().toLowerCase(), sys_user -> sys_user));
-
             List<UserSource> sources = new ArrayList<>();
-
-            List<UserHistory> histories = new CopyOnWriteArrayList<>();
-
             Map<String, String> userPartMap = new HashMap<>();
             if (Strings.isNotBlank(partGroupId)) {
                 //如果为true，更新组别之外人员
@@ -117,6 +125,10 @@ public class SourceUserServiceImpl extends ViServiceImpl<UserSource> implements
                 sources = query(Cnd.where("pullTime", "=", pullTime).groupBy("loginname"));
             }
 
+            // 查询所有用户，判断是否需要更新
+            List<Sys_user> users = sysUserService.query(Cnd.where("loginname", "is not", null));
+            Map<String, Sys_user> userMap = users.stream().collect(Collectors.toMap(Sys_user::getLoginname, user -> user));
+
             AtomicReference<Dao> filterColumnDao = new AtomicReference<>(dao());
 
             // 全部更新时，要修改的用户表
@@ -125,10 +137,35 @@ public class SourceUserServiceImpl extends ViServiceImpl<UserSource> implements
             List<Sys_user> needInitUserList = new CopyOnWriteArrayList<>();
             // 添加角色的用户
             List<Sys_user_role> userRoles = new CopyOnWriteArrayList<>();
+
+            // 人员更新配置的对象
+            SourceChangeConfig changeConfig = dao().fetch(SourceChangeConfig.class, Cnd.NEW());
+
+            boolean isAuto = "automatic".equals(changeConfig.getSourceChangeType());
+
+            // 存储人员变更记录的表
+            List<UserHistory> histories = new CopyOnWriteArrayList<>();
+            // 如果是手动更新暂时存储到SourceChangeMiddleTable表
+            List<SourceChangeMiddleTable> middleTables = new CopyOnWriteArrayList<>();
+
+            // 获取人员变更字段，用于存储记录
+            List<Sys_dict> dictList = sysDictService.getSubListByCode("ALLOW_CHANGE_FIELDS");
+            Set<String> allowChangeFieldNames = dictList.stream().map(Sys_dict::getCode).collect(Collectors.toSet());
+            allowChangeFieldNames.add("member");
+            allowChangeFieldNames.add("welfareMember");
+            Map<String, String> dictMap = dictList.stream().collect(Collectors.toMap(Sys_dict::getCode, Sys_dict::getName));
+            dictMap.put("member", "会员状态");
+            dictMap.put("welfareMember", "福利会员状态");
+
             // 添加会员角色
             List<String> addMemberUserIds = new CopyOnWriteArrayList<>();
             // 移除会员角色
             List<String> deleteMemberUserIds = new CopyOnWriteArrayList<>();
+            // 添加福利会员角色的用户id
+            List<String> addWelfareMemberUserIds = new CopyOnWriteArrayList<>();
+            // 移除福利会员角色的用户id
+            List<String> deleteWelfareMemberUserIds = new CopyOnWriteArrayList<>();
+
 
             // 创建一个固定大小的线程池 可以根据服务器性能调整线程池大小
             int numberOfThreads = Runtime.getRuntime().availableProcessors() * 2;
@@ -148,30 +185,20 @@ public class SourceUserServiceImpl extends ViServiceImpl<UserSource> implements
                         source.setWelfareMember(null);
                         Sys_user user = userMap.get(source.getLoginname().toLowerCase());
 
+                        if (isAuto) {
+                            checkMemberOrWelfareMember(changeConfig, source, user, addMemberUserIds, deleteMemberUserIds,
+                                    addWelfareMemberUserIds, deleteWelfareMemberUserIds);
+                        } else {
+                            if (user != null) {
+                                source.setMember(user.getMember());
+                                source.setWelfareMember(user.getWelfareMember());
+                            }
+                        }
+
                         Sys_user u = new Sys_user();
                         BeanUtils.copyProperties(source, u);
                         switch (sourceType) {
                             case "all" -> {
-                                if (StrUtil.isNotBlank(source.getPersonType())
-                                        && MEMBER_PERSON_TYPE.contains(source.getPersonType())
-                                        && "在职".equals(source.getUserState())) {
-                                    source.setMember(1);
-                                    source.setWelfareMember(1);
-                                    // 符合条件的这类人员 人员性质设为会员
-                                    if (user != null && user.getMember() != 1) {
-                                        addMemberUserIds.add(user.getId());
-                                    }
-                                    if (user == null) {
-                                        addMemberUserIds.add(source.getId());
-                                    }
-                                } else {
-                                    source.setMember(0);
-                                    source.setWelfareMember(0);
-                                    // 不符合条件的这类人员 人员性质设为教职工
-                                    if (user != null && user.getMember() == 1) {
-                                        deleteMemberUserIds.add(user.getId());
-                                    }
-                                }
                                 // 复制属性到一个新的user对象
                                 u.setId(user == null ? source.getId() : user.getId());
                                 if (user != null) {
@@ -194,17 +221,24 @@ public class SourceUserServiceImpl extends ViServiceImpl<UserSource> implements
                             }
                         }
 
-                        List<UserChangeType> changeTypes = getChangeTypes(source, user, sourceType);
-                        if (changeTypes.contains(UserChangeType.NEW)) {
-                            user = UserMode.initUser(u);
-                            needInitUserList.add(user);
-                            Sys_user_role userRole = new Sys_user_role();
-                            userRole.setUserId(user.getId());
-                            userRole.setRoleId(Roles.PUBLIC);
-                            userRoles.add(userRole);
-                            histories.add(createUserHistory(user, changeTypes));
-                        } else if (changeTypes.size() > 0) {
-                            histories.add(createUserHistory(user, changeTypes));
+                        if (isAuto) {
+                            UserHistory history = createHistory(source, user, dictMap, allowChangeFieldNames);
+                            if (Lang.isEmpty(history)) {
+                                continue;
+                            }
+                            histories.add(history);
+                            if (history.getChangeTypes().contains(MemberChangeType.NEW.getType())) {
+                                needInitUserList.add(u);
+                            }
+                        } else {
+                            SourceChangeMiddleTable table = createSourceChangeMiddleTable(source, user, dictMap, allowChangeFieldNames);
+                            if (Lang.isEmpty(table)) {
+                                continue;
+                            }
+                            middleTables.add(table);
+                            if (table.getChangeTypes().contains(MemberChangeType.NEW.getType())) {
+                                needInitUserList.add(u);
+                            }
                         }
                     }
                 }, Executors.newFixedThreadPool(numberOfThreads));
@@ -221,41 +255,37 @@ public class SourceUserServiceImpl extends ViServiceImpl<UserSource> implements
                 sysUserRoleService.insert(userRoles);
             }
 
-            if ("all".equals(sourceType)) {
-                // 添加会员角色
-                if (Lang.isNotEmpty(addMemberUserIds)) {
-                    String memberRoleId = Roles.MEMBER;
-                    List<Sys_user_role> list = addMemberUserIds.stream().map(v -> {
-                        Sys_user_role userRole = new Sys_user_role();
-                        userRole.setUserId(v);
-                        userRole.setRoleId(memberRoleId);
-                        return userRole;
-                    }).toList();
-                    manyAddOrRenewUtil.asyncExecuteInsert(list, 200);
-                }
-                // 不是定义的personType的人员，去除会员角色
-                if (Lang.isNotEmpty(deleteMemberUserIds)) {
-                    dao().clear(Sys_user_role.class, Cnd.where("userId", "in", deleteMemberUserIds).and("roleId", "=", Roles.MEMBER));
-                }
-            }
+            // 添加会员
+            addMemberUser(addMemberUserIds, changeConfig.getIsJoinMemberActivityScope());
+            // 删除会员
+            deleteMemberUser(deleteMemberUserIds, changeConfig.getIsDeleteMemberActivityScope());
 
-//            Collection<String[]> updateColumns = SourceData.USER_FIELD_RELATION.values();
+            // 加入进行中的福利项目，暂时没写
 
-            if ("part".equals(sourceType)) {
-                massUpdatesAsync(needDoUpdateList, true, filterColumnDao);
-            } else {
-                massUpdatesAsync(needDoUpdateList, false, null);
-            }
 
             // 历史记录表插入数据
-            historyUserService.dao().fastInsert(histories);
-            // 人员状态及在职状态更新
-            userPatUpService.renewUserState();
-            // 修改不在人事库的人员，删除角色
+            if ("automatic".equals(changeConfig.getSourceChangeType())) {
+                // 自动更新，修改数据表，存储历史记录
+                if ("part".equals(sourceType)) {
+                    massUpdatesAsync(needDoUpdateList, true, filterColumnDao);
+                } else {
+                    massUpdatesAsync(needDoUpdateList, false, null);
+                }
+
+                manyAddOrRenewUtil.asyncExecuteFastInsert(histories, 200);
+                // 人员状态及在职状态更新
+                // 在职状态关乎变更类型，建议自己手动更新，不要使用自动更新功能，硬要使用，请点进 renewUserState 打开注释
+                userPatUpService.renewUserState();
+
+                // 修改不在人事库的人员，删除角色
 //            userPatUpService.deleteNotInSourceUser(true);
-            //清除缓存
-//            sysUserService.clearCache();
-//            sysRoleService.clearCache();
+                //清除缓存
+                sysUserService.clearCache();
+                sysRoleService.clearCache();
+
+            } else {
+                manyAddOrRenewUtil.asyncExecuteFastInsert(middleTables, 200);
+            }
         } catch (Exception e) {
             e.printStackTrace();
             throw new RuntimeException(e.getMessage());
@@ -263,6 +293,315 @@ public class SourceUserServiceImpl extends ViServiceImpl<UserSource> implements
     }
 
 
+    /**
+     * 判断自动更新的会员和福利会员
+     * @param config 人员更新的配置
+     * @param source
+     * @param user
+     * @param addMemberUserIds
+     * @param deleteMemberUserIds
+     * @param addWelfareMemberUserIds
+     * @param deleteWelfareMemberUserIds
+     */
+    private void checkMemberOrWelfareMember(SourceChangeConfig config, UserSource source, Sys_user user,
+                                           List<String> addMemberUserIds, List<String> deleteMemberUserIds,
+                                           List<String> addWelfareMemberUserIds, List<String> deleteWelfareMemberUserIds){
+        if (config == null || config.getMemberSiftList() == null) {
+            return;
+        }
+
+        config.getMemberSiftList().forEach(memberSift -> {
+            String siftName = memberSift.getSiftName();
+            Object siftValue = memberSift.getSiftValue();
+            boolean shouldAdd = false;
+            boolean shouldRemove = false;
+
+            switch (siftName) {
+                case "userState":
+                    if (siftValue instanceof List<?> && source != null && source.getUserState() != null) {
+                        List<String> userStateList = (List<String>) siftValue;
+                        shouldAdd = userStateList.contains(source.getUserState());
+                        shouldRemove = !shouldAdd && user != null && user.getMember() == 1;
+                    }
+                    break;
+                case "personType":
+                    if (siftValue instanceof List<?> && source != null && source.getPersonType() != null) {
+                        List<String> personTypeList = (List<String>) siftValue;
+                        shouldAdd = personTypeList.contains(source.getPersonType());
+                        shouldRemove = !shouldAdd && user != null && user.getMember() == 1;
+                    }
+                    break;
+                case "loginNameStart":
+                    if (siftValue instanceof String && source != null && source.getLoginname() != null) {
+                        String loginNameStart = (String) siftValue;
+                        shouldAdd = source.getLoginname().startsWith(loginNameStart);
+                        shouldRemove = !shouldAdd && user != null && user.getMember() == 1;
+                    }
+                    break;
+                case "loginNameEnd":
+                    if (siftValue instanceof String && source != null && source.getLoginname() != null) {
+                        String loginNameEnd = (String) siftValue;
+                        shouldAdd = source.getLoginname().endsWith(loginNameEnd);
+                        shouldRemove = !shouldAdd && user != null && user.getMember() == 1;
+                    }
+                    break;
+                case "userQuery":
+                    if (siftValue instanceof List<?> && user != null) {
+                        List<String> userIds = (List<String>) siftValue;
+                        shouldAdd = userIds.contains(user.getId()) && user.getMember() != 1;
+                    }
+                    break;
+            }
+            if (shouldAdd) {
+                if (user == null) {
+                    addMemberUserIds.add(source.getId());
+                } else if (user.getMember() != 1) {
+                    addMemberUserIds.add(user.getId());
+                }
+                source.setMember(1);
+            } else if (shouldRemove) {
+                deleteMemberUserIds.add(user.getId());
+                source.setMember(0);
+            }
+        });
+
+
+        config.getWelfareMemberSiftList().forEach(welfareMember -> {
+            String siftName = welfareMember.getSiftName();
+            Object siftValue = welfareMember.getSiftValue();
+            boolean shouldAdd = false;
+            boolean shouldRemove = false;
+
+            switch (siftName) {
+                case "member":
+                    if ((user != null && addMemberUserIds.contains(user.getId())) || addMemberUserIds.contains(source.getId())) {
+                        shouldAdd = true;
+                    } else {
+                        shouldRemove = true;
+                    }
+                    break;
+                case "userState":
+                    if (siftValue instanceof List<?> && source != null && source.getUserState() != null) {
+                        List<String> userStateList = (List<String>) siftValue;
+                        shouldAdd = userStateList.contains(source.getUserState());
+                        shouldRemove = !shouldAdd && user != null && user.getMember() == 1;
+                    }
+                    break;
+                case "personType":
+                    if (siftValue instanceof List<?> && source != null && source.getPersonType() != null) {
+                        List<String> personTypeList = (List<String>) siftValue;
+                        shouldAdd = personTypeList.contains(source.getPersonType());
+                        shouldRemove = !shouldAdd && user != null && user.getMember() == 1;
+                    }
+                    break;
+                case "loginNameStart":
+                    if (siftValue instanceof String && source != null && source.getLoginname() != null) {
+                        String loginNameStart = (String) siftValue;
+                        shouldAdd = source.getLoginname().startsWith(loginNameStart);
+                        shouldRemove = !shouldAdd && user != null && user.getMember() == 1;
+                    }
+                    break;
+                case "loginNameEnd":
+                    if (siftValue instanceof String && source != null && source.getLoginname() != null) {
+                        String loginNameEnd = (String) siftValue;
+                        shouldAdd = source.getLoginname().endsWith(loginNameEnd);
+                        shouldRemove = !shouldAdd && user != null && user.getMember() == 1;
+                    }
+                    break;
+                case "userQuery":
+                    if (siftValue instanceof List<?> && user != null) {
+                        List<String> userIds = (List<String>) siftValue;
+                        shouldAdd = userIds.contains(user.getId()) && user.getMember() != 1;
+                    }
+                    break;
+            }
+            if (shouldAdd) {
+                if (user == null) {
+                    addWelfareMemberUserIds.add(source.getId());
+                } else if (user.getMember() != 1) {
+                    addWelfareMemberUserIds.add(user.getId());
+                }
+                source.setWelfareMember(1);
+            } else if (shouldRemove) {
+                deleteWelfareMemberUserIds.add(user.getId());
+                source.setWelfareMember(0);
+            }
+        });
+
+    }
+
+
+    /**
+     * 用于人工操作，不自动更新，不改变数据库数据
+     * 待人工手动调整后，变更数据库
+     * @param source
+     * @param user
+     * @param dictMap
+     * @param allowChangeFieldNames
+     * @return 人工操作记录表
+     */
+    private SourceChangeMiddleTable createSourceChangeMiddleTable(UserSource source, Sys_user user, Map<String, String> dictMap, Set<String> allowChangeFieldNames) {
+        List<String> changeTypes = new ArrayList<>();
+        // 手动变更，记录新的数据，并记录变更内容
+        SourceChangeMiddleTable table = new SourceChangeMiddleTable();
+        BeanUtil.copyProperties(source, table);
+        table.setId(R.UU32());
+        table.setChangeTime(DateUtil.date());
+        table.setChangeOrigin(MemberChangeOrigin.SYSTEM.name());
+        // 新入职教职工
+        if (user == null) {
+            changeTypes.add(MemberChangeType.NEW.getType());
+            table.setChangeTypes(changeTypes);
+            return table;
+        }
+
+        // 获取变更记录
+        // 新数据
+        NutMap newMap = Lang.obj2nutmap(source);
+        // 原数据
+        NutMap sourceMap = Lang.obj2nutmap(user);
+        // 变更记录
+        List<NutMap> changeList = new ArrayList<>();
+        for (String fieldName : allowChangeFieldNames) {
+            memberCommonService.extractChange(newMap, sourceMap, fieldName, dictMap, changeList);
+        }
+        if (Lang.isEmpty(changeList)) {
+            return null;
+        }
+        String changeInfos = changeList.stream().map(v -> {
+            return "(变更字段：" + v.getString("fieldName") + "，变更前：" + HtmlUtil.cleanHtmlTag(v.getString("sourceValue")) + "，变更后：" + HtmlUtil.cleanHtmlTag(v.getString("newValue")) + ")";
+        }).collect(Collectors.joining("；"));
+
+        // 比较变更数据
+        commonCompareChange(source, user, changeTypes);
+
+        table.setChangeTypes(changeTypes);
+        table.setChangeInfos(changeList);
+        table.setChangeInfosStr(changeInfos);
+        table.setIsOperate(false);
+        return table;
+    }
+
+
+    /**
+     * 自动更新，创建历史记录
+     * 会直接改变数据库
+     * @param source
+     * @param user
+     * @param dictMap
+     * @param allowChangeFieldNames
+     * @return 历史记录表
+     */
+    private UserHistory createHistory(UserSource source, Sys_user user, Map<String, String> dictMap, Set<String> allowChangeFieldNames) {
+        List<String> changeTypes = new ArrayList<>();
+        UserHistory history = new UserHistory();
+        BeanUtil.copyProperties(user, history);
+        history.setId(R.UU32());
+        history.setChangeTime(DateUtil.date());
+        history.setChangeOrigin(MemberChangeOrigin.SYSTEM.name());
+        if (user == null) {
+            changeTypes.add(MemberChangeType.NEW.getType());
+            history.setChangeTypes(changeTypes);
+            return history;
+        }
+        // 获取变更记录
+        NutMap newMap = Lang.obj2nutmap(source);
+        NutMap sourceMap = Lang.obj2nutmap(user);
+        List<NutMap> changeList = new ArrayList<>();
+        for (String fieldName : allowChangeFieldNames) {
+            memberCommonService.extractChange(newMap, sourceMap, fieldName, dictMap, changeList);
+        }
+        if (Lang.isEmpty(changeList)) {
+            return null;
+        }
+        String changeInfos = changeList.stream().map(v -> {
+            return "(变更字段：" + v.getString("fieldName") + "，变更前：" + HtmlUtil.cleanHtmlTag(v.getString("sourceValue")) + "，变更后：" + HtmlUtil.cleanHtmlTag(v.getString("newValue")) + ")";
+        }).collect(Collectors.joining("；"));
+        // 比较变更数据
+        commonCompareChange(source, user, changeTypes);
+
+        history.setChangeTypes(changeTypes);
+        history.setChangeInfos(changeList);
+        history.setChangeInfosStr(changeInfos);
+        return history;
+    }
+
+
+    /**
+     * 比较变更类型公共方法
+     * @param source
+     * @param user
+     * @param changeTypes
+     */
+    private void commonCompareChange(UserSource source, Sys_user user, List<String> changeTypes){
+        changeTypes.add(MemberChangeType.BASIC_CHANGE.getType());
+
+        if (!ObjectUtil.equals(user.getUserState(), source.getUserState())) {
+            List<MemberChangeType> list = Arrays.stream(MemberChangeType.values())
+                    .filter(v -> v.getChangeTypeName().equals(source.getUserState())).toList();
+            if (Lang.isNotEmpty(list)) {
+                changeTypes.add(list.get(0).getType());
+            }
+        }
+
+        if (!ObjectUtil.equals(user.getMember(), source.getMember())){
+            if (source.getMember() == 1) {
+                changeTypes.add(MemberChangeType.RESTORE.getType());
+            } else {
+                changeTypes.add(MemberChangeType.WITHDRAWAL.getType());
+            }
+        }
+
+        if (!ObjectUtil.equals(user.getUnitid(), source.getUnitid())) {
+            changeTypes.add(MemberChangeType.UNIT_CHANGE.getType());
+        }
+    }
+
+
+    /**
+     * 添加会员
+     * @param addMemberUserIds
+     * @param isJoinMemberActivityScope
+     */
+    private void addMemberUser(List<String> addMemberUserIds, Boolean isJoinMemberActivityScope) {
+        if (Lang.isNotEmpty(addMemberUserIds)) {
+            List<Sys_user_role> roleList = addMemberUserIds.stream().distinct().map(v -> {
+                Sys_user_role role = new Sys_user_role();
+                role.setUserId(v);
+                role.setRoleId(Roles.MEMBER);
+                return role;
+            }).toList();
+            manyAddOrRenewUtil.asyncExecuteInsert(roleList, 200);
+
+            if (isJoinMemberActivityScope) {
+                List<ActivityUserScope> scopeList = addMemberUserIds.stream().distinct().map(v -> {
+                    ActivityUserScope scope = new ActivityUserScope();
+                    scope.setGroupId(1);
+                    scope.setGroupName("工会会员");
+                    scope.setUserId(v);
+                    return scope;
+                }).toList();
+                manyAddOrRenewUtil.asyncExecuteInsert(scopeList, 200);
+            }
+        }
+    }
+
+
+    /**
+     * 删除会员
+     * @param deleteMemberUserIds
+     * @param isDeleteMemberActivityScope
+     */
+    private void deleteMemberUser(List<String> deleteMemberUserIds, Boolean isDeleteMemberActivityScope){
+        if (Lang.isNotEmpty(deleteMemberUserIds)) {
+            dao().clear(Sys_user_role.class, Cnd.where("userId", "in", deleteMemberUserIds).and("roleId", "=", Roles.MEMBER));
+            if (isDeleteMemberActivityScope) {
+                dao().clear(ActivityUserScope.class, Cnd.where("userId", "in", deleteMemberUserIds).and("groupId", "=", 1));
+            }
+        }
+    }
+
+
     @Override
     @Aop(TransAop.READ_COMMITTED)
     public void dailyScheduledUpdates() {
@@ -276,68 +615,6 @@ public class SourceUserServiceImpl extends ViServiceImpl<UserSource> implements
         dao().clear(UserSource.class, Cnd.where("DATE(pullTime)", "<", formatAgoWeekDate));
     }
 
-    private List<UserChangeType> getChangeTypes(Sys_user source, Sys_user user, String sourceType) {
-        List<UserChangeType> userChangeTypes = new ArrayList<>();
-        if (user == null) {
-            userChangeTypes.add(UserChangeType.NEW);
-            return userChangeTypes;
-        } else {
-            if ("add".equals(sourceType)) {
-                return userChangeTypes;
-            }
-            if (!StringUtils.isEmpty(source.getUnitid()) && !source.getUnitid().equals(user.getUnitid())) {
-                userChangeTypes.add(UserChangeType.UNIT_CHANGE);
-            }
-            if (!StringUtils.isEmpty(user.getUserState()) && StrUtil.isNotEmpty(source.getUserState()) && !source.getUserState().equals(user.getUserState())) {
-                for (UserChangeType value : UserChangeType.values()) {
-                    if (value.getDescription().equals(source.getUserState())) {
-                        userChangeTypes.add(value);
-                    }
-                }
-            }
-
-            List<String> columns = List.of("nation", "birthday", "personType", "political", "schoolTime", "jobTitle", "education", "academicDegree", "position", "leaveSchoolDate", "retireDate");
-            for (String column : columns) {
-                NutMap userSourceMap = Lang.obj2nutmap(source);
-                NutMap userMap = Lang.obj2nutmap(user);
-                String sourceValue = userSourceMap.getString(column, "");
-                String value = userMap.getString(column, "");
-                if (!sourceValue.equals(value) && StrUtil.isNotBlank(sourceValue)) {
-                    userChangeTypes.add(UserChangeType.BASIC_CHANGE);
-                    break;
-                }
-            }
-        }
-        return userChangeTypes;
-    }
-
-    /**
-     * 生成一条用户历史记录
-     *
-     * @param user
-     * @param changeTypes
-     * @return
-     */
-    private UserHistory createUserHistory(Sys_user user, List<UserChangeType> changeTypes) {
-        //除仅更新新增人员外的方式都需要往历史记录表插数据
-        UserHistory history = new UserHistory();
-        history.setId(R.UU32());
-        BeanUtils.copyProperties(user, history);
-        history.setChangeTime(new Date());
-        history.setChangeTypes(changeTypes.stream().map(UserChangeType::getCode).collect(Collectors.toList()));
-        history.setChangeOperator(StrUtil.blankToDefault((String) ShiroUtil.getPrincipalProperty("username"), "系统"));
-        history.setChangeOrigin(MemberChangeOrigin.SYSTEM.getCode());
-        history.setChangeReason("数据自动更新");
-
-        //找出上一次更新的记录
-        Sql lastHistorySql = Sqls.fetchString("select id from user_history where loginname = @loginname order by changeTime");
-        lastHistorySql.setParam("loginname",user.getLoginname());
-        dao().execute(lastHistorySql);
-        String lastHistoryId = lastHistorySql.getString();
-        history.setLastHistoryId(lastHistoryId);
-        return history;
-    }
-
 
     /**
      * 数据大批量更新

src/main/java/io/v/nutz/zhgh/data/vo/SourceUserCommonVo.java

@@ -0,0 +1,39 @@
+package io.v.nutz.zhgh.data.vo;
+
+import io.v.nutz.zhgh.staffmanage.sourcechange.model.SourceChangeConfig;
+import lombok.Data;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.CopyOnWriteArrayList;
+
+/**
+ * @version 1.0
+ * @Author zzr
+ * @name：SourceUserCommonVo
+ * @Date 2025/2/18 16:50
+ * @注释
+ */
+@Data
+public class SourceUserCommonVo {
+
+    // 添加会员角色
+    private List<String> addMemberUserIds = new CopyOnWriteArrayList<>();
+
+    // 移除会员角色
+    private List<String> deleteMemberUserIds = new CopyOnWriteArrayList<>();
+
+    // 添加会员分组的用户id
+    private List<String> addMemberGroupUserIds = new CopyOnWriteArrayList<>();
+
+    // 移除会员分组的用户id
+    private List<String> deleteMemberGroupUserIds = new CopyOnWriteArrayList<>();
+
+    // 添加福利会员角色的用户id
+    private List<String> addWelfareMemberUserIds = new CopyOnWriteArrayList<>();
+
+    // 移除福利会员角色的用户id
+    private List<String> deleteWelfareMemberUserIds = new CopyOnWriteArrayList<>();
+
+    private SourceChangeConfig config;
+}