package org.springblade.modules.FTP;

import com.alibaba.fastjson.JSON;
import org.json.JSONArray;
import org.json.JSONObject;
import org.springblade.common.utils.DesensitizedUtil;
import org.springblade.common.utils.InvestigateUtil;
import org.springblade.common.utils.SecurityPaperUtil;
import org.springblade.core.log.exception.ServiceException;
import org.springblade.core.mp.support.Condition;
import org.springblade.core.tool.utils.BeanUtil;
import org.springblade.modules.dispatcher.entity.Dispatcher;
import org.springblade.modules.dispatcher.service.IDispatcherService;
import org.springblade.modules.exam.entity.ExamPaper;
import org.springblade.modules.exam.entity.ExamScore;
import org.springblade.modules.exam.service.ExamScoreService;
import org.springblade.modules.experience.entity.Experience;
import org.springblade.modules.experience.service.IExperienceService;
import org.springblade.modules.securitypaper.entity.SecurityPaper;
import org.springblade.modules.securitypaper.service.SecurityPaperService;
import org.springblade.modules.system.entity.Dept;
import org.springblade.modules.system.entity.User;
import org.springblade.modules.system.service.IDeptService;
import org.springblade.modules.system.service.IUserService;
import org.springblade.modules.system.vo.UserVO;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
import java.text.DecimalFormat;
import java.text.SimpleDateFormat;
import java.util.*;

@Component
public class DataHanlder {

	@Autowired
	private IUserService userService;

	//声明对象
	private static DataHanlder hanlder;

	@Autowired
	private SecurityPaperService securityPaperService;

	@Autowired
	private IExperienceService experienceService;

	@Autowired
	private IDispatcherService dispatcherService;

	@Autowired
	private MyAsyncService myAsyncService;

	@Autowired
	private IDeptService iDeptService;

	@Autowired
	private ExamScoreService examScoreService;




    /**
	 * 初始化
	 */
	@PostConstruct
	public void init(){
		hanlder = this;
		hanlder.userService = this.userService;
		hanlder.securityPaperService = this.securityPaperService;
		hanlder.experienceService = this.experienceService;
		hanlder.myAsyncService = this.myAsyncService;
		hanlder.dispatcherService = this.dispatcherService;
		hanlder.iDeptService = this.iDeptService;
	}


	/**
	 * 保安员审查
	 * @param json
	 */
	public static void handlerUserExamine(String json) {
		User user = JSON.parseObject(json, User.class);
		//获取用户cardid
		User user1 = hanlder.userService.getById(user.getId());
		//用户审查
		hanlder.myAsyncService.checkUserExamineByCardNo(user1);
	}

	/**
	 * 生成保安员证编号
	 * @param json
	 */
	public static void handlerSecurityNumerBit(String json) {
		Map map = JSON.parseObject(json, Map.class);
		//取出 key(uuid)
		String key = map.keySet().toArray()[0].toString();
		//获取考试信息
		String value = map.get(key).toString();
		ExamScore examScore = JSON.parseObject(value, ExamScore.class);
		//查询用户
		User user = hanlder.userService.getById(examScore.getUserId());
		if (null!=user) {
			//如果已有保安证编号，不更新用户信息
			if (null == user.getSecuritynumber() || user.getSecuritynumber().equals("")) {
				//去生成保安证编号
				String pre = SecurityPaperUtil.getSecurityPaper();
				//查询当前年份已有的保安证编号
				int count = hanlder.userService.getSecurityPaperCount(pre);
				String result = null;
				if (count == 0) {
					result = pre + "00001";
				} else {
					//格式化
					DecimalFormat decimalFormat = new DecimalFormat("00000");
					count++;
					result = pre + (decimalFormat.format(count));
				}
				user.setSecuritynumber(result);
				//修改为持证保安
				user.setHold("1");
				user.setUpdateTime(new Date());
				user.setUserType(7);
				//更新保安数据
				boolean flag = hanlder.userService.updateById(user);

				if (flag) {
					//生成保安证的同时向保安证管理表中插入一条数据
					SecurityPaper securityPaper = new SecurityPaper();
					securityPaper.setUserId(user.getId());
					securityPaper.setNumber(result);
					securityPaper.setCreateTime(new Date());
					securityPaper.setIdCardNo(user.getCardid());
					securityPaper.setPeopleName(user.getRealName());
					securityPaper.setExamId(Long.parseLong(examScore.getExamId()));
					securityPaper.setApplyId(examScore.getApplyId());
					securityPaper.setSource(1);
					hanlder.securityPaperService.save(securityPaper);

					//内网同步
					String s1 = "update blade_user set hold = " + "'" + user.getHold() + "'" +
						",securitynumber = " + "'" + DesensitizedUtil.desensitizedSecurityNumber(result) + "'" +
						",update_time = " + "'" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(user.getUpdateTime()) + "'" +
						",user_type = " + "'" + user.getUserType() + "'" +
						" " + "where id = " + "'" + user.getId() + "'";
					hanlder.myAsyncService.FTP(s1);
				}
			}
		}
	}

	/**
	 * 培训报名数据处理
	 * @param json
	 */
	public static void handlerListTrain(String json) {
		Map map = JSON.parseObject(json, Map.class);
		//取出 key(uuid)
		String key = map.keySet().toArray()[0].toString();
		Object users = map.get(key);
		List<String > userList = JSON.parseArray(users.toString(), String.class);
		//遍历
		if (userList.size()>0) {
			List<Result> resultList = new ArrayList<>();
			//开始遍历
			for (String userId : userList) {
				//校验用户年龄
				int age = hanlder.userService.getUserAge(Long.parseLong(userId));
				//创建返回对象
				Result result1 = new Result();
				result1.setUserId(Long.parseLong(userId));
				if (age>=18 && age<=60) {
					//年龄符合要求
					result1.setCode(200);
				} else {
					//年龄不符合要求
					result1.setCode(201);
				}
				//存入结果集
				resultList.add(result1);
			}
			Result result = new Result(200, "", resultList);
			Map<String, Object> map1 = new HashMap<>(1);
			map1.put(key, result);
			//向外网发送数据
			FtpUtil.objectFileUploadListTrain(map1);
		}
	}

	/**
	 * 考试实操成绩处理
	 * @param json
	 */
	public static void handlerUserExamScore(String json) {
		Map map = JSON.parseObject(json, Map.class);
		//取出 key(uuid)
		String key = map.keySet().toArray()[0].toString();
		Object value = map.get(key);
		//得到考试成绩
		ExamScore examScore = JSON.parseObject(value.toString(), ExamScore.class);
		//处理实操考试成绩
		examScoreHandler(examScore);
	}

	/**
	 * 实操成绩处理
	 * @param examScore0
	 */
	private static void examScoreHandler(ExamScore examScore0) {
		//取第一个
		List<ExamScore> examScoreList = hanlder.examScoreService.getExamScoreInfoByIdCardNo(examScore0.getCandidateNo(), new SimpleDateFormat("yyyy-MM-dd").format(examScore0.getExamTime()));
		if (examScoreList.size()>0) {
			//遍历集合
			examScoreList.forEach(examScore -> {
				if (null != examScore) {
					//查询当前保安信息
					UserVO user = hanlder.userService.getUserAgeById(Long.parseLong(examScore.getUserId()));
					//设置实操成绩
					examScore.setLearnGrade(examScore0.getLearnGrade());
					if (null != examScore.getTheoryGrade()) {
						if (examScore.getTheoryGrade() >= 60 && examScore.getLearnGrade() >= 60) {
							//合格
							examScore.setQualified(0);
							//修改制证状态为未制证
							user.setUserType(7);
							//如果已有保安证编号，不更新用户信息
							if (null == user.getSecuritynumber() || user.getSecuritynumber().equals("")) {
								//去生成保安证编号
								String pre = SecurityPaperUtil.getSecurityPaper();
								//查询当前年份已有的保安证编号
								int count = hanlder.userService.getSecurityPaperCount(pre);
								String result = null;
								if (count == 0) {
									result = pre + "00001";
								} else {
									//格式化
									DecimalFormat decimalFormat = new DecimalFormat("00000");
									count++;
									result = pre + (decimalFormat.format(count));
								}
								//脱敏处理
								user.setSecuritynumber(DesensitizedUtil.desensitizedSecurityNumber(result));
								//修改为持证保安
								user.setHold("1");
								user.setUpdateTime(new Date());
								//更新保安数据
								hanlder.userService.updateById(user);

								//生成保安证的同时向保安证管理表中插入一条数据
								SecurityPaper securityPaper = new SecurityPaper();
								securityPaper.setUserId(user.getId());
								securityPaper.setNumber(result);
								securityPaper.setCreateTime(new Date());
								securityPaper.setIdCardNo(user.getCardid());
								securityPaper.setPeopleName(user.getRealName());
								securityPaper.setExamId(Long.parseLong(examScore.getExamId()));
								securityPaper.setApplyId(examScore.getApplyId());
								securityPaper.setSource(1);
								hanlder.securityPaperService.save(securityPaper);

								//内网同步
								String s1 = "update blade_user set hold = " + "'" + user.getHold() + "'" +
									",securitynumber = " + "'" + DesensitizedUtil.desensitizedSecurityNumber(result) + "'" +
									",update_time = " + "'" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(user.getUpdateTime()) + "'" +
									",user_type = " + "'" + user.getUserType() + "'" +
									" " + "where id = " + "'" + user.getId() + "'";
								hanlder.myAsyncService.FTP(s1);
							}
						}
					} else {
						//不合格
						examScore.setQualified(1);
					}
					//总成绩
					if (user.getAge() <= 50) {
						if (null != examScore.getTheoryGrade()) {
							examScore.setAllGrade(Math.round((examScore.getTheoryGrade() + examScore0.getLearnGrade()) / 2));
						} else {
							examScore.setAllGrade(Math.round(examScore0.getLearnGrade() / 2));
						}
					}
					if (user.getAge() > 50) {
						if (null != examScore.getTheoryGrade()) {
							examScore.setAllGrade(Integer.parseInt(String.valueOf(Math.round(examScore.getTheoryGrade() * 0.5)))
								+ Integer.parseInt(String.valueOf(Math.round(examScore0.getLearnGrade() * 0.5))));
						} else {
							examScore.setAllGrade(Math.round(examScore0.getLearnGrade() / 2));
						}
					}

					//外网同步
					String s1 =
						"update exam_score set learn_grade = " + "'" + examScore.getLearnGrade() + "'" +
							",all_grade = " + "'" + examScore.getAllGrade() + "'" +
							",qualified = " + "'" + examScore.getQualified() + "'" +
							" " + "where id = " + "'" + examScore.getId() + "'";
					hanlder.myAsyncService.FTP(s1);
					//更新成绩数据
					hanlder.examScoreService.updateById(examScore);
				}
			});
		}else {
			//根据身份证号查询用户
			User user0 = hanlder.userService.getUserInfoByIdCardNo(examScore0.getCandidateNo());
			if (null == user0) {
				String msg = "没有找到用户:[" + examScore0.getCandidateNo() + "]相关考试成绩信息,请检查身份证是否有误!";
				//向外网推送
				Result result = new Result(200,null,msg);
				Map<String, Object> map = new HashMap<>(1);
				map.put("key", result);
				//向外网发送数据
				FtpUtil.objectFileUploadExamScore(map);
			}
		}
	}

	/**
	 * 数据处理(集合)
	 * @param json
	 */
	public static void handlerList(String json) {
		Map map = JSON.parseObject(json, Map.class);
		//取出 key(uuid)
		String key = map.keySet().toArray()[0].toString();
		Object users = map.get(key);
		List<User> userList = JSON.parseArray(users.toString(), User.class);
		//遍历
		if (userList.size()>0) {
			List<Result> resultList = new ArrayList<>();
			//创建更新用户集合对象
			List<User> updateUser = new ArrayList<>();
			//开始遍历
			for (User user : userList) {
				//取出 uuid
				String uuid = user.getReasonForLeav();
				//用户数据校验,是否已导入(本单位或其他单位)
				Result result = userCheckOut(user);
				//创建返回对象
				Result result1 = new Result();
				if (result.getCode() == 200) {
					user.setReasonForLeav("");
					//校验保安员证编号
					Result result2 = hanlder.checkSecurityNumber(user);
					User user1 = result2.getUser();
					//去新增
					boolean save = hanlder.userService.save(user1);
					if (save) {
						//异步新增从业记录
						hanlder.myAsyncService.insertExperience(user1);
						//异步审查
						hanlder.myAsyncService.checkUserExamineByCardNo(user1);
					}

					if (result2.getCode() == 200) {
						//设置返回结果
						result1.setCode(200);
						result1.setUserId(user1.getId());
					} else {
						//设置返回结果
						result1.setCode(203);
						result1.setUserId(user1.getId());
					}
				} else if (result.getCode() == 201) {
					//去修改
					user.setReasonForLeav("");
					User data = result.getUser();
					user.setId(data.getId());
					user.setCreateTime(data.getCreateTime());
					//校验保安员证编号
					Result result2 = hanlder.checkSecurityNumber(user);
					User user2 = result2.getUser();
					user2.setId(data.getId());

					hanlder.userService.updateById(user2);
					//设置返回结果
					if (result2.getCode() == 200) {
						result1.setCode(201);
						result1.setUserId(user.getId());
					} else {
						//设置返回结果
						result1.setCode(203);
						result1.setUserId(user.getId());
					}
				} else {
					//不新增,不修改
					//设置返回结果,以在其他单位存在
					result1.setCode(202);
					result1.setUserId(null);
				}
				result1.setMsg(uuid);
				//存入结果集
				resultList.add(result1);
			}
			Result result = new Result(200, "", resultList);
			Map<String, Object> map1 = new HashMap<>(1);
			map1.put(key, result);
			System.out.println("map1 = " + map1);
			//向外网发送数据
			FtpUtil.objectFileUploadList(map1);
		}
	}

	/**
	 * 管理人员保安员导入并生成保安证编号
	 * @param json
	 */
	public static void handlerSecurityPaperList(String json) {
		Map map = JSON.parseObject(json, Map.class);
		//取出 key(uuid)
		String key = map.keySet().toArray()[0].toString();
		Object users = map.get(key);
		List<User> userList = JSON.parseArray(users.toString(), User.class);
		//遍历
		if (userList.size()>0) {
			List<Result> resultList = new ArrayList<>();
			//开始遍历
			for (User user : userList) {
				//取出 uuid
				String uuid = user.getReasonForLeav();
				//用户数据校验,是否已导入(本单位或其他单位)
				Result result = userCheckOut(user);
				//创建返回对象
				Result result1 = new Result();
				result1.setMsg(uuid);
				if (result.getCode() == 200) {
					user.setReasonForLeav("");
					//直接去审查，审查异常则不新增
					//异步审查
					User user1 = hanlder.checkUserExamineByCardNos(user);
					if (null!=user1){
						if (user1.getExaminationType().equals("0")){
							//生成保安证编号和记录
							//去生成保安证编号
							String pre = SecurityPaperUtil.getSecurityPaper();
							//查询当前年份已有的保安证编号
							int count = hanlder.userService.getSecurityPaperCount(pre);
							String result0 = null;
							if (count == 0) {
								result0 = pre + "00001";
							} else {
								//格式化
								DecimalFormat decimalFormat = new DecimalFormat("00000");
								count++;
								result0 = pre + (decimalFormat.format(count));
							}
							//修改制证状态为未制证
							user.setUserType(7);
							user.setSecuritynumber(result0);
							//修改为持证保安
							user.setHold("1");
							user.setUpdateTime(new Date());
							//更新保安数据
							boolean save = hanlder.userService.save(user);

							if (save) {
								//生成保安证的同时向保安证管理表中插入一条数据
								SecurityPaper securityPaper = new SecurityPaper();
								securityPaper.setUserId(user.getId());
								securityPaper.setNumber(result0);
								securityPaper.setCreateTime(new Date());
								securityPaper.setIdCardNo(user.getCardid());
								securityPaper.setPeopleName(user.getRealName());
								securityPaper.setSource(3);
								hanlder.securityPaperService.save(securityPaper);

								//异步新增从业记录
								hanlder.myAsyncService.insertExperience(user);

								//设置返回结果
								result1.setCode(200);
								result1.setUserId(user.getId());
								result1.setMsg(result1.getMsg()+","+DesensitizedUtil.desensitizedSecurityNumber(result0));
							}
						}else {
							//不新增,审查异常
							result1.setCode(205);
							result1.setUserId(null);
						}
					}
				} else if (result.getCode() == 201) {
				} else {
					//不新增,不修改
					//设置返回结果,以在其他单位存在
					result1.setCode(202);
					result1.setUserId(null);
				}
				//存入结果集
				resultList.add(result1);
			}
			Result result = new Result(200, "", resultList);
			Map<String, Object> map1 = new HashMap<>(1);
			map1.put(key, result);
			//向外网发送数据
			FtpUtil.objectFileUploadPaperList(map1);
		}
	}


	/**
	 * 异步审查新增的保安员,审查通过并生成保安员证编号
	 * @param user0
	 */
	public User checkUserExamineByCardNos(User user0){
		//如果是保安员
		if (user0.getRoleId().equals("1412226235153731586")){
			//创建用户对象
			User user = new User();
			user.setId(user0.getId());
			//远程调用接口
			String body = InvestigateUtil.httpGetOne(user0.getCardid());
			JSONObject jsonObject = new JSONObject(body);
			Object data = jsonObject.get("data");
			JSONObject jsonData = new JSONObject(data.toString());
			JSONArray res = jsonData.getJSONArray("res");
			//设置审核时间
			user.setAuditTime(new Date());
			//如果有结果返回
			if (res.length() == 0) {
				//没有数据正常
				user.setExaminationType("0");
			} else {
				int count = 0;
				user.setExaminationType("1");
				for (int i = 0; i < res.length(); i++) {
					if (res.getJSONObject(i).get("zdrylbjh").toString() != null
						&& res.getJSONObject(i).get("zdrylbjh").toString() != ""
						&& res.getJSONObject(i).get("zdrylbjh").toString() != "null"
					) {
						user.setExaminationMx(res.getJSONObject(i).get("zdrylbjh").toString());
						//更新用户数据
//						userService.updateById(user);
						break;
					}
					if (res.getJSONObject(i).get("zdryxlmc").toString() != null
						&& res.getJSONObject(i).get("zdryxlmc").toString() != ""
						&& res.getJSONObject(i).get("zdryxlmc").toString() != "null"
					) {
						user.setExaminationMx(res.getJSONObject(i).get("zdryxlmc").toString());
						//更新用户数据
//						userService.updateById(user);
						break;
					}
					if (res.getJSONObject(i).get("ztrylx").toString() != null
						&& res.getJSONObject(i).get("ztrylx").toString() != ""
						&& res.getJSONObject(i).get("ztrylx").toString() != "null"
					) {
						user.setExaminationMx(res.getJSONObject(i).get("ztrylx").toString());
						//更新用户数据
//						userService.updateById(user);
						break;
					}
					count++;
					//条件中的数据都为空，则审查为正常
					if (count==res.length()){
						//更新用户数据,设为正常
						user.setExaminationType("0");
//						userService.updateById(user);
					}
				}
			}
			//更新用户数据
			return user;
		}
		return null;
	}

	/**
	 * 数据处理（单个保安员新增）
	 * @param json
	 */
	public static void handler(String json){
		//以分号分割
		List<String> list = Arrays.asList(json.split(";"));
		//对象转换
		for (String s : list) {
			Map map = JSON.parseObject(s, Map.class);
			Object user = map.get("user");
			User user1 = JSON.parseObject(user.toString(), User.class);
			System.out.println("user1 = " + user1);

			//获取 uuid
			String uuid = user1.getReasonForLeav();
			//用户数据校验
			Result result = userCheckOut(user1);
			//创建返回对象
			Result result1 = new Result();
			if (result.getCode()==200){
				user1.setReasonForLeav("");
				//校验保安员证编号
				Result result2 = hanlder.checkSecurityNumber(user1);
				User user2 = result2.getUser();
				//去新增
				boolean save = hanlder.userService.save(user2);
				if (save){
					//异步新增从业记录
					hanlder.myAsyncService.insertExperience(user2);
					//异步审查
					hanlder.myAsyncService.checkUserExamineByCardNo(user2);
				}

				if (result2.getCode()==200){
					//设置返回结果
					result1.setCode(200);
					result1.setUserId(user1.getId());
					result1.setMsg("新增成功");
				}else {
					//设置返回结果
					result1.setCode(203);
					result1.setUserId(user1.getId());
					result1.setMsg(result2.getMsg());
				}

			}else if (result.getCode()==201){
				//去修改
				user1.setReasonForLeav("");
				User data = result.getUser();
				user1.setId(data.getId());
				user1.setCreateTime(data.getCreateTime());

				//校验保安员证编号
				Result result2 = hanlder.checkSecurityNumber(user1);
				User user2 = result2.getUser();
				user2.setId(data.getId());

				hanlder.userService.updateById(user2);
				//设置返回结果
				if (result2.getCode()==200) {
					result1.setCode(201);
					result1.setUserId(user1.getId());
					result1.setMsg("修改成功");
				}else {
					//设置返回结果
					result1.setCode(204);
					result1.setUserId(user1.getId());
					result1.setMsg(result2.getMsg());
				}
			}else {
				//不新增,不修改
				//设置返回结果
				result1.setCode(400);
				result1.setUserId(null);
				result1.setMsg(result.getMsg());
			}
			Map<String, Object> map1 = new HashMap<>(1);
			map1.put(uuid,result1);
			System.out.println("用户新增：开始向外网推送数据............");
			//向外网发送数据
			FtpUtil.objectFileUpload(map1,uuid);
		}
	}

	/**
	 * 用户校验
	 * @param user
	 */
	public static Result userCheckOut(User user) {
		//1. 校验是否有重复导入
		User user1 = new User();
		user1.setCardid(user.getCardid());
		user1.setStatus(1);
		user1.setIsDeleted(0);
		User one = hanlder.userService.getOne(Condition.getQueryWrapper(user1));
		if (null!=one){
			//判断单位是否一致
			if (!one.getDeptId().equals(user.getDeptId())){
				//判断是否为机读身份证录入
				if (null!=user.getCell() && !user.getCell().equals("")){
					if (user.getCell().equals("2")){
						// cell 2为机读录入
						//先将原有人员离职
						one.setStatus(2);
						one.setUpdateTime(new Date());
						//离职
						hanlder.userService.updateById(one);
						//同步外网
						String s1 = "update blade_user set status = " + one.getStatus() +
							",update_time = " + "'" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(one.getUpdateTime()) + "'" +
							" where id = " + "'" + one.getId() + "'";
						hanlder.myAsyncService.FTP(s1);

						//人员离职后修改派遣记录，修改从业记录
						hanlder.updateUserDispatcherExp(one);
						//返回
						return new Result(200,null,"");
					}
				}
				return new Result(400,null,user.getRealName() + "已在其他单位导入");
			}else {
				return new Result(201,"已在本单位导入",one);
			}
		}
		return new Result(200,null,"");
	}

	/**
	 * 修改派遣记录，修改从业记录
	 *
	 * @param user
	 */
	private void updateUserDispatcherExp(User user) {
		//修改派遣状态
		user.setDispatch("1");
		//同时将派遣记录中的派遣状态修改
		//查询派遣记录(还在派遣中的)
		Dispatcher dispatcher = new Dispatcher();
		dispatcher.setUserIds(user.getId().toString());
		dispatcher.setStatus(0);
		List<Dispatcher> dispatcherList = dispatcherService.list(Condition.getQueryWrapper(dispatcher));
		if (dispatcherList.size() > 0) {
			dispatcherList.forEach(dispatcher1 -> {
				dispatcher1.setStatus(1);
				dispatcher1.setUpdateTime(new Date());
				String s1 =
					"update sys_dispatcher set status = " + "'" + dispatcher1.getStatus() + "'"
						+ ",update_time = " + "'" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(dispatcher1.getUpdateTime()) + "'"
						+ " " + "where id = " + "'" + dispatcher1.getId() + "'";
				myAsyncService.FTP(s1);
			});
		}

		//查询当前用户是否有从业记录，没有的话新增，有就更新
		//根据公司名查询单位
		Dept dept = iDeptService.getById(user.getDeptId());
		Experience experience = new Experience();
		experience.setCompanyname(dept.getDeptName());
		//按id降序
		List<Experience> list = experienceService.list(Condition.getQueryWrapper(experience).orderByDesc("id"));
		if (list.size() > 0) {
			//如果有多条取第一条更新
			Experience experience1 = list.get(0);
			//设置离职时间
			experience1.setDeparturetime(new Date());
			//更新从业记录信息
			experienceService.updateById(experience1);
			//数据同步
			String s1 =
				"update sys_experience set departureTime = " + "'" + new SimpleDateFormat("yyyy-MM-dd").format(experience1.getDeparturetime()) + "'"
					+ " " + "where id = " + "'" + experience1.getId() + "'";
			myAsyncService.FTP(s1);
		} else {
			//新增
			if (null != user.getRtime()) {
				experience.setEntrytime(user.getRtime());
			} else {
				experience.setEntrytime(new Date());
			}
			experience.setDeparturetime(new Date());
			experience.setName(user.getRealName());
			if (null != user.getReasonForLeav() && !user.getReasonForLeav().equals("")) {
				experience.setLeaving(user.getReasonForLeav());
			}
			experience.setCardid(user.getCardid());
			experience.setSecurityid(user.getId().toString());
			//新增
			experienceService.save(experience);

			// 身份证号脱敏
			String cardid = DesensitizedUtil.desensitizedIdNumberBy4(user.getCardid());

			//内网同步
			String s = "insert into sys_experience(id,name,entryTime,departureTime,leaving,cardId,companyname,securityId) " +
				"values(" + "'" + experience.getId() + "'" +
				"," + "'" + experience.getName() + "'" +
				"," + "'" + new SimpleDateFormat("yyyy-MM-dd").format(experience.getEntrytime()) + "'" +
				"," + "'" + new SimpleDateFormat("yyyy-MM-dd").format(experience.getDeparturetime()) + "'" +
				"," + "'" + experience.getLeaving() + "'" +
				"," + "'" + cardid + "'" +
				"," + "'" + experience.getCompanyname() + "'" +
				"," + "'" + experience.getSecurityid() + "'"
				+ ")";
			myAsyncService.FTP(s);
		}
	}

	/**
	 * 保安员证编号校验
	 * @param user
	 * @return
	 */
	public Result checkSecurityNumber(User user){
		//2.保安证编号校验
		//判断是否持证
		boolean states = false;
		if (null!= user.getHold()
			&& user.getHold().equals("1")
			&& null!=user.getSecuritynumber()
			&& !user.getSecuritynumber().equals("")){
			//截取，这个范围的不校验
			String pre = user.getSecuritynumber().substring(0,6);
			String number = user.getSecuritynumber().substring(6);
			if (pre.equals("赣洪2022")){
				int num = Integer.parseInt(number);
				if (num>=21000 && num<=23000){
					user.setSecuritynumber(DesensitizedUtil.desensitizedSecurityNumber(user.getSecuritynumber()));
					return new Result(200,null,"",user);
				}
			}
			//持证，校验保安证编号是否合法
			SecurityPaper securityPaper = new SecurityPaper();
			securityPaper.setIdCardNo(user.getCardid());
			List<SecurityPaper> securityPaperList = hanlder.securityPaperService.list(Condition.getQueryWrapper(securityPaper));
			if (securityPaperList.size()>0){
				//遍历
				for (SecurityPaper paper : securityPaperList) {
					if (paper.getNumber().equals(user.getSecuritynumber())){
						states = true;
					}
				}
				if (!states){
					user.setHold("2");
					user.setSecuritynumber("");
				}
			}else {
				states = false;
				user.setHold("2");
				user.setSecuritynumber("");
			}
		}else {
			states = true;
		}

		if (!states) {
			return new Result(201,null,"保安证编号不匹配,请核实!也可通过提供保安证件信息提交核实申请!",user);
		}

		return new Result(200,null,"",user);
	}


}