package org.security.basicDataSync.service.impl;

import cn.hutool.core.date.DateUtil;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.google.common.base.Preconditions;
//import com.ynhtbank.emb.base.message.HtbMessage;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;
import org.security.basicDataSync.dto.DeptLevlSyncHistoryDTO;
import org.security.basicDataSync.util.ExcelUtil;
import org.security.common.Constant;
import org.security.basicDataSync.entity.*;
import org.security.basicDataSync.mapper.DeptLevlSyncHistoryMapper;
import org.security.basicDataSync.service.IDeptLevlSyncHistoryService;
import org.security.basicDataSync.service.IDeptSyncHistoryService;
import org.security.basicDataSync.service.IUserSyncHistoryService;
import org.security.config.ESMProperties;
import org.security.ht.entity.basic.Department;
import org.security.ht.entity.basic.Employee;
import org.security.ht.feign.basic.IDepartmentClient;
import org.security.ht.feign.basic.IEmployeeClient;
import org.security.system.entity.Dept;
import org.security.system.feign.ISysClient;
import org.security.system.user.entity.User;
import org.security.system.user.entity.UserDept;
import org.security.system.user.feign.IUserClient;
import org.security.system.user.vo.UserVO;
import org.springblade.core.tool.api.R;
import org.springblade.core.tool.utils.DigestUtil;
import org.springblade.core.tool.utils.Func;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.multipart.MultipartFile;


import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

/**
 * @author ：wzf
 * @since ：Created in 2022/8/26 9:22
 */
@Service
@Slf4j
@AllArgsConstructor
public class DeptLevlSyncHistoryServiceImpl extends ServiceImpl<DeptLevlSyncHistoryMapper, DeptLevlSyncHistory> implements IDeptLevlSyncHistoryService {

	private final IDeptSyncHistoryService deptSyncHistoryService;
	private final IUserSyncHistoryService userSyncHistoryService;
	private IUserClient userClient;
	private IEmployeeClient employeeClient;
	private IDepartmentClient departmentClient;
	private ISysClient sysClient;
	private final ESMProperties esmProperties;

//	@Override
//	@Transactional(rollbackFor = Exception.class)
//	public void consumeMsg(HtbMessage message) {
//		log.info("--------------接收到消息总线消息--------------");
//		log.info("消息内容【】" + message.toString());
//		//根据消息HtbMessage中的-topicName，判断接收到的消息是机构层级同步、机构信息同步、用户信息同步
//		log.info("--------------消息解析开始--------------");
//		//机构层级信息同步
//		syncDeptLevelData(message);
//		//行政机构信息同步
//		syncDeptData(message);
//		//用户信息同步
//		syncUserData(message);
//
//		//将机构信息同步至blade_dept表和t_department表
//		//2022-12-27 updated by yzy:该动作放到机构层级信息同步和行政机构信息同步方法中去，避免重复验证生产者系统流水号
//		//		copyDeptDataToAimTable(message);
//
//		//将用户信息同步至blade_user表、blade_user_dept表和t_employee表
//		//2022-12-27 updated by yzy:该动作放到用户信息同步方法中去，避免重复验证生产者系统流水号
//		//		copyUserDataToAimTable(message);
//	}

	@Override
	public boolean importData(MultipartFile file) {
		ArrayList<DeptLevlSyncHistory> list = new ArrayList<>();
		List<DeptLevlSyncHistoryDTO> deptLevelDatas = ExcelUtil.read(file, DeptLevlSyncHistoryDTO.class);
		if (Func.isNotEmpty(deptLevelDatas)){
			deptLevelDatas.forEach(item ->{
				DeptLevlSyncHistory deptLevel = Func.copy(item, DeptLevlSyncHistory.class);
				deptLevel.setOrgSte("0");
				list.add(deptLevel);
			});
		}
		return this.saveBatch(list);
	}

	@Override
	@Transactional(rollbackFor = Exception.class)
	public boolean synData() {
		syncUSerDataInfo();
		syncDeptDataInfo();
		return true;
	}


	/**
	 * 将用户信息同步至blade_user表、blade_user_dept表和t_employee表(全量同步t_user_sync_history中的数据到目标表)
	 */
//	private void copyUserDataToAimTable(HtbMessage message) {
//		if (Func.isNotEmpty(message.getTopicName()) && Constant.TOPIC_NAME_USER_DATA.equals(message.getTopicName().substring(message.getTopicName().indexOf("/") + 1))) {
//			UserDataResponse userDataResponse = JSONObject.parseObject(message.getMessageInfo(), UserDataResponse.class);
//
//			List<UserSyncHistory> userDataList = userSyncHistoryService.list(new QueryWrapper<UserSyncHistory>().lambda()
//				.eq(Func.isNotEmpty(userDataResponse.getSysHead().getPdcSysSeqNo()), UserSyncHistory::getPdcSysSeqNo, userDataResponse.getSysHead().getPdcSysSeqNo()));
//
//			Preconditions.checkArgument(Func.isEmpty(userDataList), "【用户信息同步】消息总线的生产者系统流水号已经存在，本次消息不同步至相关信息表，生产者系统流水号【】" + userDataResponse.getSysHead().getPdcSysSeqNo());
//			log.info("--------------------------用户信息全量同步至blade_user表、blade_user_dept表和t_employee表开始---------------------------");
//			//获取所有启用状态的用户层级信息
//			syncUSerDataInfo();
//			log.info("--------------------------用户信息全量同步至blade_user表、blade_user_dept表和t_employee表结束---------------------------");
//		}
//	}

	/**
	 * 同步用户信息至lade_user表、blade_user_dept表和t_employee表
	 */
	private void syncUSerDataInfo() {
		List<UserSyncHistory> userList = userSyncHistoryService.list(new QueryWrapper<UserSyncHistory>().lambda().eq(UserSyncHistory::getForbidSts, "1"));
		if (Func.isNotEmpty(userList)) {
			List<Employee> employeeList = new ArrayList<>();
			List<UserDept> userDeptList = new ArrayList<>();
			List<User> userInfoList = new ArrayList<>();
			userList.forEach(item -> {
				User user = setUserData(item);
				Employee employee = setEmployeeData(item, user);
				UserDept userDept = setUserDeptData(item, user);
				employeeList.add(employee);
				userDeptList.add(userDept);
				userInfoList.add(user);
			});
			//保存employee员工信息
			employeeClient.synData(employeeList);
			//移除user_dept表中的用户和机构关联信息
			List<String> userIdList = new ArrayList<>();
			userDeptList.forEach(item -> {
				userIdList.add(String.valueOf(item.getUserId()));
			});
			userClient.removeUserDept(userIdList);
			//新增user_dept表中的用户和机构关联信息
			userClient.saveUserDept(userDeptList);
			//更新blade_user用户信息
			userClient.saveUserData(userInfoList);
		}
	}


	/**
	 * UserDept赋值
	 */
	private UserDept setUserDeptData(UserSyncHistory item, User user) {
		//UserDept赋值
		UserDept userDept = new UserDept();
		userDept.setUserId(Func.isNotEmpty(item.getId()) ? Long.valueOf(item.getId()) : null);
		userDept.setDeptId(Func.isNotEmpty(user.getDeptId()) ? Long.valueOf(user.getDeptId()) : null);
		return userDept;
	}


	/**
	 * Employee赋值
	 */
	private Employee setEmployeeData(UserSyncHistory item, User user) {
		//Employee赋值
		Employee employee = Func.copy(user,Employee.class);
		employee.setId(item.getId());
		employee.setName(user.getName());
		DeptSyncHistory deptSyncHistory = deptSyncHistoryService.getOne(new QueryWrapper<DeptSyncHistory>().lambda().eq(DeptSyncHistory::getInstiEnc, item.getOrganNo()));
		employee.setDeptId(Func.isNotEmpty(deptSyncHistory) ? deptSyncHistory.getId() : null);
		employee.setGender(item.getGender());
		employee.setPhone(user.getPhone());
		employee.setEmployeeNo(item.getEmpeNum());
		return employee;
	}


	/**
	 * user赋值
	 */
	private User setUserData(UserSyncHistory item) {
		//user赋值
		User user = new User();
		user.setId(Long.valueOf(item.getId()));
		user.setTenantId("000000");
		user.setUserType(1);
		user.setCode(item.getEmpeNum());
		user.setAccount(item.getEmpeNum());
		user.setPassword(DigestUtil.encrypt("123456"));
		user.setName(item.getFulNam());
		user.setRealName(item.getFulNam());
		DeptSyncHistory deptSyncHistory = deptSyncHistoryService.getOne(new QueryWrapper<DeptSyncHistory>().lambda().eq(DeptSyncHistory::getInstiEnc, item.getOrganNo()));
		setUserAimDept(user, deptSyncHistory);
		user.setEmail(item.getMaiBx());
		user.setPhone(item.getCellPneNum());
		user.setSex(Func.isNotEmpty(item.getGender()) ? Integer.valueOf(item.getGender()) : null);
		user.setStatus(1);
		return user;
	}

	/**
	 *设置用户部门id
	 */
	private void setUserAimDept(User user, DeptSyncHistory deptSyncHistory) {
		if (Func.isNotEmpty(deptSyncHistory)) {
			//如果该用户所在机构层级是支行，则该用户的部门id为所属支行的id(机构层级-OrgHier：3)
			//支行
			if ("3".equals(deptSyncHistory.getOrgHier()) && "01".equals(deptSyncHistory.getBrnTp()) && deptSyncHistory.getInstShrtNm().endsWith("支行")) {
				user.setDeptId(deptSyncHistory.getId());
			}
			//分行营业部
			if ("3".equals(deptSyncHistory.getOrgHier()) && "01".equals(deptSyncHistory.getBrnTp()) && deptSyncHistory.getInstShrtNm().endsWith("分行营业室")){
//				DeptSyncHistory syncHistory = getParentDeptCode(deptSyncHistory);
				user.setDeptId(deptSyncHistory.getId());
			}
			//总行营业部的营业部营业室
			if ("3".equals(deptSyncHistory.getOrgHier()) && "01".equals(deptSyncHistory.getBrnTp()) && deptSyncHistory.getInstShrtNm().endsWith("营业部营业室")){
//				DeptSyncHistory syncHistory = getParentDeptCode(deptSyncHistory);
				user.setDeptId(deptSyncHistory.getId());
			}
			//总行营业部
			if ("1".equals(deptSyncHistory.getOrgHier()) && "02".equals(deptSyncHistory.getBrnTp()) && deptSyncHistory.getInstShrtNm().endsWith("总行营业部")){
				user.setDeptId(deptSyncHistory.getId());
			}
			//山水支行
			if ("2".equals(deptSyncHistory.getOrgHier()) && "01".equals(deptSyncHistory.getBrnTp())){
				user.setDeptId(deptSyncHistory.getId());
			}
			//分行
			if ("1".equals(deptSyncHistory.getOrgHier()) && "02".equals(deptSyncHistory.getBrnTp()) && deptSyncHistory.getInstShrtNm().endsWith("分行")){
				user.setDeptId(deptSyncHistory.getId());
			}
			//如果改用户所在机构层级是分行下面的所属部门，则该用户的部门id为该部门直属的分行机构id
			if ("2".equals(deptSyncHistory.getOrgHier()) && "02".equals(deptSyncHistory.getBrnTp())){
				DeptSyncHistory syncHistory = getParentDeptCode(deptSyncHistory);
				user.setDeptId(syncHistory.getId());
			}
			//如果该用户所在的机构是总行下面的所属部门，则该用户的部门id为总行机构id
			if ("1".equals(deptSyncHistory.getOrgHier()) && "02".equals(deptSyncHistory.getBrnTp()) && !(deptSyncHistory.getInstShrtNm().endsWith("分行"))){
				DeptSyncHistory syncHistory = getParentDeptCode(deptSyncHistory);
				user.setDeptId(syncHistory.getId());
			}
			//如果该用户挂在云南红塔银行股份有限公司上
			if ("9".equals(deptSyncHistory.getOrgHier()) && "02".equals(deptSyncHistory.getBrnTp())){
				user.setDeptId(deptSyncHistory.getId());
			}
		}else {
			user.setDeptId(null);
		}
	}

	/**
	 *获取机构直属上级的部门id
	 */
	private DeptSyncHistory getParentDeptCode(DeptSyncHistory deptSyncHistory) {
		String parentCode = baseMapper.getParentDeptCode(deptSyncHistory.getInstiEnc());
		return deptSyncHistoryService.getOne(new QueryWrapper<DeptSyncHistory>().lambda().eq(Func.isNotEmpty(parentCode), DeptSyncHistory::getInstiEnc, parentCode));
	}


	/**
	 * 将机构信息同步至blade_dept表和t_department表（全量同步t_dept_sync_history表和t_dept_levl_sync_history表中的数据到目标表）
	 */
//	private void copyDeptDataToAimTable(HtbMessage message) {
//		if ((Func.isNotEmpty(message.getTopicName())) && ((Constant.TOPIC_NAME_DEPT_DATA.equals(message.getTopicName().substring(message.getTopicName().indexOf("/") + 1)))
//			|| (Constant.TOPIC_NAME_DEPT_LEVEL.equals(message.getTopicName().substring(message.getTopicName().indexOf("/") + 1))))) {
//
//			DeptDataResponse deptDataResponse = JSONObject.parseObject(message.getMessageInfo(), DeptDataResponse.class);
//
//			List<DeptSyncHistory> deptDataList = deptSyncHistoryService.list(new QueryWrapper<DeptSyncHistory>().lambda()
//				.eq(Func.isNotEmpty(deptDataResponse.getSysHead().getPdcSysSeqNo()), DeptSyncHistory::getPdcSysSeqNo, deptDataResponse.getSysHead().getPdcSysSeqNo()));
//
//			DeptLevelResponse deptLevelResponse = JSONObject.parseObject(message.getMessageInfo(), DeptLevelResponse.class);
//
//			List<DeptLevlSyncHistory> deptLevlSyncHistoryList = this.list(new QueryWrapper<DeptLevlSyncHistory>().lambda()
//				.eq(Func.isNotEmpty(deptLevelResponse.getSysHead().getPdcSysSeqNo()), DeptLevlSyncHistory::getPdcSysSeqNo, deptLevelResponse.getSysHead().getPdcSysSeqNo()));
//
//			//判断生产者流水号在t_dept_levl_sync_history表和t_dept_sync_history表中是否存在，若存在则不进行数据同步
//			Preconditions.checkArgument(Func.isEmpty(deptDataList), "【机构信息同步】消息总线的生产者系统流水号已经存在，本次消息不同步至相关信息表，生产者系统流水号【】" + deptDataResponse.getSysHead().getPdcSysSeqNo());
//			Preconditions.checkArgument(Func.isEmpty(deptLevlSyncHistoryList), "【机构层级同步】消息总线的生产者系统流水号已经存在，本次消息不同步至相关信息表，生产者系统流水号【】" + deptLevelResponse.getSysHead().getPdcSysSeqNo());
//
//			log.info("--------------------------机构信息全量同步至blade_dept表和t_department表开始---------------------------");
//			syncDeptDataInfo();
//			log.info("--------------------------机构信息全量同步至blade_dept表和t_department表结束---------------------------");
//		}
//	}

	/**
	 * 同步机构信息至blade_dept表和t_department表
	 */
	private void syncDeptDataInfo() {
		//获取所有启用状态的机构层级信息
		List<DeptLevlSyncHistory> deptLevelList = this.list(new QueryWrapper<DeptLevlSyncHistory>().lambda().eq(DeptLevlSyncHistory::getOrgSte, "0"));
		//获取所有启用状态的行政机构信息
		List<DeptSyncHistory> deptInfoList = deptSyncHistoryService.list(new QueryWrapper<DeptSyncHistory>().lambda().eq(DeptSyncHistory::getOrgSte, "0"));
		//判断启用状态的机构层级信息和行政机构信息是否为空,若有一个集合为空则不进行同步处理
		if (Func.isNotEmpty(deptLevelList) && Func.isNotEmpty(deptInfoList)) {
			//组装机构信息数据
			List<Dept> bladeDepartments = new ArrayList<>();
			ArrayList<Department> departments = new ArrayList<>();
			deptInfoList.forEach(item -> {
				Dept dept = setDeptData(item);
				Department department = setDepartmentData(item, dept);
				if ("99999".equals(item.getInstiEnc())){
					dept.setParentId(0L);
					dept.setAncestors("0");
					department.setParentId(0L);
					department.setAncestors("0");
				}else {
					setParentData(deptLevelList, deptInfoList, item, dept, department);
				}
				bladeDepartments.add(dept);
				departments.add(department);
				//同步机构负责人用户的角色id
				setUserRoleId(item);
			});
			//同步departments信息
			departmentClient.saveData(departments);
			//同步dept机构信息
			sysClient.synSaveDeptData(bladeDepartments);
		}
	}

	/**
	 *同步机构负责人用户的角色id
	 */
	private void setUserRoleId(DeptSyncHistory item) {
		if (Func.isNotEmpty(item.getPernChrgNum())){
			R<UserVO> userVOR = userClient.getUserByCode(item.getPernChrgNum());
			if (Func.isNotEmpty(userVOR.getData())){
				ArrayList<User> userArrayList = new ArrayList<>();
				User user = Func.copy(userVOR.getData(), User.class);
				//根据角色名称获取角色id
				String aimRoleId = baseMapper.getAimRoleId(esmProperties.getDeptLeaderName());
				user.setRoleId(Func.isNotEmpty(aimRoleId) ? aimRoleId : null);
				userArrayList.add(user);
				userClient.saveUserData(userArrayList);
			}
		}
	}

	/**
	 * 赋值父级id和祖级id信息
	 */
	private void setParentData(List<DeptLevlSyncHistory> deptLevelList, List<DeptSyncHistory> deptInfoList, DeptSyncHistory item, Dept dept, Department department) {
		deptLevelList.forEach(item2 -> {
			//判断机构号相同项，取出父级机构号
			if (item.getInstiEnc().equals(item2.getInstiEnc())) {
				//取出t_dept_sync_history表中机构号等于T_DEPT_LEVL_SYNC_HISTORY表的父级机构号的机构信息
				List<DeptSyncHistory> collect = deptInfoList.stream().filter(item3 -> item3.getInstiEnc().equals(item2.getSprrOrgNum())).collect(Collectors.toList());
				dept.setParentId(Func.isNotEmpty(collect) ? Long.valueOf(collect.get(0).getId()) : 0);
				department.setParentId(Func.isNotEmpty(collect) ? Long.valueOf(collect.get(0).getId()) : 0);
				ArrayList<String> list = new ArrayList<>();
				String aimDeptCode = null;
				//获取祖级机构信息
				getAncestors(department, list, aimDeptCode);
				list.add(0,"0");
				dept.setAncestors(StringUtils.join(list,","));
				department.setAncestors(dept.getAncestors());
			}
		});
	}

	/**
	 * 获取祖级机构信息
	 */
	private void getAncestors(Department department, ArrayList<String> list, String aimDeptCode) {
		while (true) {
			if (Func.isEmpty(aimDeptCode)){
				aimDeptCode = department.getDeptNo();
			}
			//获取机构代码等于aimDeptCode，且机构层级状态为启用状态的数据，该数据一般只存在一条
			List<DeptLevlSyncHistory> deptLevlList = this.list(new QueryWrapper<DeptLevlSyncHistory>().lambda().eq(Func.isNotEmpty(aimDeptCode),DeptLevlSyncHistory::getInstiEnc,aimDeptCode)
				.eq(DeptLevlSyncHistory::getOrgSte,"0"));
			if (Func.isEmpty(deptLevlList)){
				break;
			}
			DeptSyncHistory history = deptSyncHistoryService.getOne(new QueryWrapper<DeptSyncHistory>().lambda().eq(Func.isNotEmpty(deptLevlList.get(0).getSprrOrgNum()), DeptSyncHistory::getInstiEnc, deptLevlList.get(0).getSprrOrgNum()));
			aimDeptCode = deptLevlList.get(0).getSprrOrgNum();
			if (Func.isNotEmpty(history)) {
				list.add(history.getId());
			}
		}
	}

	/**
	 * Department赋值
	 */
	private Department setDepartmentData(DeptSyncHistory item, Dept dept) {
		//Department赋值
		Department department = new Department();
		department.setId(Long.valueOf(item.getId()));
		department.setDeptName(dept.getDeptName());
		department.setFullName(dept.getFullName());
		department.setDeptCategory(String.valueOf(dept.getDeptCategory()));
		department.setDeptLevel(item.getOrgMgmtLv());
		department.setAddress(item.getDtlAdr());
		department.setConstructionDate(item.getOrgCraDt());
		department.setOpenDate(item.getBsnStrTm());
		department.setLeader(item.getPernChrgNm());
		department.setDeptNo(item.getInstiEnc());
		department.setLatitude(item.getLatd());
		department.setLongitude(item.getLontd());
		department.setPeopleNumber(userSyncHistoryService.list(new QueryWrapper<UserSyncHistory>().lambda().eq(UserSyncHistory::getOrganNo, department.getDeptNo())).size());
		return department;
	}

	/**
	 * Dept赋值
	 */
	private Dept setDeptData(DeptSyncHistory item) {
		//Dept赋值
		Dept dept = new Dept();
		dept.setId(Long.valueOf(item.getId()));
		//映射机构层级
		setDeptCategory(item, dept);
		dept.setDeptName(item.getInstShrtNm());
		dept.setFullName(Func.isNotEmpty(item.getInstNm()) ? item.getInstNm() : item.getInstShrtNm());
		dept.setDeptCode(item.getInstiEnc());
		return dept;
	}

	/**
	 *映射机构层级
	 */
	private void setDeptCategory(DeptSyncHistory item, Dept dept) {
		//当机构层级OrgHier-9，机构类别BrnTp-02时，该机构为：云南红塔银行股份有限公司
		if ("9".equals(item.getOrgHier()) && "02".equals(item.getBrnTp())){
			dept.setDeptCategory(1);
		}
		//当机构层级OrgHier-1，机构类别BrnTp-02且机构中文简称-InstNm 以分行结尾时，该机构为：为分行机构
		if ("1".equals(item.getOrgHier()) && "02".equals(item.getBrnTp()) && item.getInstShrtNm().endsWith("分行")){
			dept.setDeptCategory(2);
		}
		//当机构层级OrgHier-1，机构类别BrnTp-02且机构中文简称-InstNm 不以分行结尾时，该机构为：总行直属部门
		if ("1".equals(item.getOrgHier()) && "02".equals(item.getBrnTp()) && !(item.getInstShrtNm().endsWith("分行"))){
			dept.setDeptCategory(6);
		}
		//当机构层级OrgHier-2，机构类别BrnTp-02时，该机构为：分行直属部门
		if ("2".equals(item.getOrgHier()) && "02".equals(item.getBrnTp())){
			dept.setDeptCategory(7);
		}
		//当机构层级OrgHier-2，机构类别BrnTp-01时，该机构为：支行
		if ("2".equals(item.getOrgHier()) && "01".equals(item.getBrnTp())){
			dept.setDeptCategory(3);
		}
		//当机构层级OrgHier-3，机构类别BrnTp-01，以支行结尾时，该机构为：支行
		if ("3".equals(item.getOrgHier()) && "01".equals(item.getBrnTp()) && item.getInstShrtNm().endsWith("支行")){
			dept.setDeptCategory(3);
		}
		//当机构层级OrgHier-3，机构类别BrnTp-01，以分行营业室结尾时，该机构为：分行营业室-规划为支行
		if ("3".equals(item.getOrgHier()) && "01".equals(item.getBrnTp()) && item.getInstShrtNm().endsWith("分行营业室")){
			dept.setDeptCategory(3);
		}
		//当机构层级OrgHier-3，机构类别BrnTp-01，InstShrtNm为营业部营业室时，该机构为：总行营业部的营业部营业室-规划为支行
		if ("3".equals(item.getOrgHier()) && "01".equals(item.getBrnTp()) && item.getInstShrtNm().endsWith("营业部营业室")){
			dept.setDeptCategory(3);
		}
		//当机构层级OrgHier-1，机构类别BrnTp-02，InstShrtNm为总行营业部时，该机构为：总行营业部-规划为分行
		if ("1".equals(item.getOrgHier()) && "02".equals(item.getBrnTp()) && item.getInstShrtNm().endsWith("总行营业部")){
			dept.setDeptCategory(2);
		}
	}

	/**
	 * 用户信息同步
	 */
//	private void syncUserData(HtbMessage message) {
//		if (Func.isNotEmpty(message.getTopicName()) && Constant.TOPIC_NAME_USER_DATA.equals(message.getTopicName().substring(message.getTopicName().indexOf("/") + 1))) {
//			UserDataResponse userDataResponse = JSONObject.parseObject(message.getMessageInfo(), UserDataResponse.class);
//			log.info("生产者系统流水号【】" + userDataResponse.getSysHead().getPdcSysSeqNo());
//			log.info("--------------消息解析结束--------------");
//			//判断生产者系统流水号-PdcSysSeqNo是否存在
//			List<UserSyncHistory> userDataList = userSyncHistoryService.list(new QueryWrapper<UserSyncHistory>().lambda()
//				.eq(Func.isNotEmpty(userDataResponse.getSysHead().getPdcSysSeqNo()), UserSyncHistory::getPdcSysSeqNo, userDataResponse.getSysHead().getPdcSysSeqNo()));
//			Preconditions.checkArgument(Func.isEmpty(userDataList), "【用户信息同步】消息总线的生产者系统流水号已经存在，本次消息不做入库处理，生产者系统流水号【】" + userDataResponse.getSysHead().getPdcSysSeqNo());
//			//消息入库开始
//			log.info("--------------用户信息入库开始--------------");
//			List<UserSyncHistory> sameData = new ArrayList<>();
//			List<UserSyncHistory> differentData = new ArrayList<>();
//			List<UserSyncHistory> list = userSyncHistoryService.list();
//			List<UserSyncHistory> userDatas = userDataResponse.getBody().getInfArray();
//			//给数据赋值相关生产系统流水号
//			userDatas.forEach(item -> {
//				item.setPdcSysSeqNo(userDataResponse.getSysHead().getPdcSysSeqNo());
//			});
//			//本地数据库已有行政机构信息
//			if (Func.isNotEmpty(list)) {
//				setUpdateUserData(sameData, differentData, list, userDatas);
//				//更新和新增消息总线同步的数据
//				if (Func.isNotEmpty(sameData)) {
//					userSyncHistoryService.updateBatchById(sameData);
//				}
//				if (Func.isNotEmpty(differentData)) {
//					userSyncHistoryService.saveBatch(differentData);
//				}
//				log.info("--------------用户信息入库结束--------------");
//			}//第一次接收消息总线同步的消息
//			else {
//				userSyncHistoryService.saveBatch(userDatas);
//				log.info("--------------【首次】用户信息入库结束--------------");
//			}
//			//			用户信息入库完成后即可执行同步动作
//			log.info("--------------------------用户信息全量同步至blade_user表、blade_user_dept表和t_employee表开始---------------------------");
//			//获取所有启用状态的用户层级信息
//			syncUSerDataInfo();
//			log.info("--------------------------用户信息全量同步至blade_user表、blade_user_dept表和t_employee表结束---------------------------");
//		}
//	}

	/**
	 *获取消息总线变更的用户信息
	 */
	private void setUpdateUserData(List<UserSyncHistory> sameData, List<UserSyncHistory> differentData, List<UserSyncHistory> list, List<UserSyncHistory> userDatas) {
		list.forEach(item -> {
			//消息总线的生产者系统流水号在本地数据库不存在
			userDatas.forEach(item4 -> {
				//用户变更数据
				if (item4.getEmpeNum().equals(item.getEmpeNum())) {
					item4.setId(item.getId());
					sameData.add(item4);
				}
			});
		});
		//新增用户数据
		userDatas.removeAll(sameData);
		differentData.addAll(userDatas);
	}

	/**
	 * 行政机构信息同步
	 */
//	private void syncDeptData(HtbMessage message) {
//		if (Func.isNotEmpty(message.getTopicName()) && Constant.TOPIC_NAME_DEPT_DATA.equals(message.getTopicName().substring(message.getTopicName().indexOf("/") + 1))) {
//			DeptDataResponse deptDataResponse = JSONObject.parseObject(message.getMessageInfo(), DeptDataResponse.class);
//			log.info("生产者系统流水号【】" + deptDataResponse.getSysHead().getPdcSysSeqNo());
//			log.info("--------------消息解析结束--------------");
//			//判断生产者系统流水号-PdcSysSeqNo是否存在
//			List<DeptSyncHistory> deptDataList = deptSyncHistoryService.list(new QueryWrapper<DeptSyncHistory>().lambda()
//				.eq(Func.isNotEmpty(deptDataResponse.getSysHead().getPdcSysSeqNo()), DeptSyncHistory::getPdcSysSeqNo, deptDataResponse.getSysHead().getPdcSysSeqNo()));
//			Preconditions.checkArgument(Func.isEmpty(deptDataList), "【机构信息同步】消息总线的生产者系统流水号已经存在，本次消息不做入库处理，生产者系统流水号【】" + deptDataResponse.getSysHead().getPdcSysSeqNo());
//			//消息入库开始
//			log.info("--------------行政机构信息入库开始--------------");
//			List<DeptSyncHistory> sameData = new ArrayList<>();
//			List<DeptSyncHistory> differentData = new ArrayList<>();
//			List<DeptSyncHistory> list = deptSyncHistoryService.list();
//			List<DeptSyncHistory> deptDatas = deptDataResponse.getBody().getInfArray();
//			deptDatas.forEach(item -> {
//				item.setUpdateTime(DateUtil.format(DateUtil.date(), "yyyyMMddHHmmss"));
//				item.setPdcSysSeqNo(deptDataResponse.getSysHead().getPdcSysSeqNo());
//			});
//			//本地数据库已有行政机构信息
//			if (Func.isNotEmpty(list)) {
//				setUpdateDeptData(sameData, differentData, list, deptDatas);
//				//更新和新增消息总线同步的数据
//				if (Func.isNotEmpty(sameData)) {
//					deptSyncHistoryService.updateBatchById(sameData);
//				}
//				if (Func.isNotEmpty(differentData)) {
//					deptSyncHistoryService.saveBatch(differentData);
//				}
//				log.info("--------------行政机构信息入库结束--------------");
//			}//第一次接收消息总线同步的消息
//			else {
//				deptSyncHistoryService.saveBatch(deptDatas);
//				log.info("--------------【首次】行政机构信息入库结束--------------");
//			}
//			log.info("--------------------------机构信息全量同步至blade_dept表和t_department表开始---------------------------");
//			syncDeptDataInfo();
//			log.info("--------------------------机构信息全量同步至blade_dept表和t_department表结束---------------------------");
//		}
//	}

	/**
	 * 获取消息总线变更行政机构信息
	 */
	private void setUpdateDeptData(List<DeptSyncHistory> sameData, List<DeptSyncHistory> differentData, List<DeptSyncHistory> list, List<DeptSyncHistory> deptDatas) {
		list.forEach(item -> {
			//消息总线的生产者系统流水号在本地数据库不存在
			deptDatas.forEach(item3 -> {
				//机构变更数据
				if (item3.getInstiEnc().equals(item.getInstiEnc())) {
					item3.setId(item.getId());
					sameData.add(item3);
				}
			});
		});
		//机构新增数据
		deptDatas.removeAll(sameData);
		differentData.addAll(deptDatas);
	}

	/**
	 * 机构层级信息同步
	 */
//	private void syncDeptLevelData(HtbMessage message) {
//		if (Func.isNotEmpty(message.getTopicName()) && Constant.TOPIC_NAME_DEPT_LEVEL.equals(message.getTopicName().substring(message.getTopicName().indexOf("/") + 1))) {
//			//解析消息
//			DeptLevelResponse deptLevelResponse = JSONObject.parseObject(message.getMessageInfo(), DeptLevelResponse.class);
//			log.info("生产者系统流水号【】" + deptLevelResponse.getSysHead().getPdcSysSeqNo());
//			log.info("--------------消息解析结束--------------");
//			//判断生产者系统流水号-PdcSysSeqNo是否存在
//			List<DeptLevlSyncHistory> deptLevlSyncHistoryList = this.list(new QueryWrapper<DeptLevlSyncHistory>().lambda()
//				.eq(Func.isNotEmpty(deptLevelResponse.getSysHead().getPdcSysSeqNo()), DeptLevlSyncHistory::getPdcSysSeqNo, deptLevelResponse.getSysHead().getPdcSysSeqNo()));
//			Preconditions.checkArgument(Func.isEmpty(deptLevlSyncHistoryList), "【机构层级同步】消息总线的生产者系统流水号已经存在，本次消息不做入库处理，生产者系统流水号【】" + deptLevelResponse.getSysHead().getPdcSysSeqNo());
//			//消息入库开始
//			log.info("--------------机构层级信息入库开始--------------");
//			List<DeptLevlSyncHistory> sameData = new ArrayList<>();
//			List<DeptLevlSyncHistory> differentData = new ArrayList<>();
//			List<DeptLevlSyncHistory> list = this.list();
//			List<DeptLevlSyncHistory> deptLevelDatas = deptLevelResponse.getBody().getInfArray();
//			deptLevelDatas.forEach(item -> {
//				item.setUpdateTime(DateUtil.format(DateUtil.date(), "yyyyMMddHHmmss"));
//				item.setPdcSysSeqNo(deptLevelResponse.getSysHead().getPdcSysSeqNo());
//			});
//			//本地数据库已有机构层级信息
//			if (Func.isNotEmpty(list)) {
//				setUpdateDeptLevel(sameData, differentData, list, deptLevelDatas);
//				//更新和新增消息总线同步的数据
//				if (Func.isNotEmpty(sameData)) {
//					this.updateBatchById(sameData);
//				}
//				if (Func.isNotEmpty(differentData)) {
//					this.saveBatch(differentData);
//				}
//				log.info("--------------机构层级信息入库结束--------------");
//			}//第一次接收消息总线同步的消息
//			else {
//				this.saveBatch(deptLevelDatas);
//				log.info("--------------【首次】机构层级信息入库结束--------------");
//			}
//			log.info("--------------------------机构信息全量同步至blade_dept表和t_department表开始---------------------------");
//			syncDeptDataInfo();
//			log.info("--------------------------机构信息全量同步至blade_dept表和t_department表结束---------------------------");
//		}
//	}

	/**
	 *获取消息总线变更的机构层级信息
	 */
	private void setUpdateDeptLevel(List<DeptLevlSyncHistory> sameData, List<DeptLevlSyncHistory> differentData, List<DeptLevlSyncHistory> list, List<DeptLevlSyncHistory> deptLevelDatas) {
		list.forEach(item -> {
			//消息总线的生产者系统流水号在本地数据库不存在
			deptLevelDatas.forEach(item2 -> {
				//机构层级变更数据
				if (item2.getInstiEnc().equals(item.getInstiEnc())) {
					item2.setId(item.getId());
					sameData.add(item2);
				}
			});
		});
		//机构层级新增数据
		deptLevelDatas.removeAll(sameData);
		differentData.addAll(deptLevelDatas);
	}
}
