/*
 *
 *      Copyright (c) 2018-2025, hnqz All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are met:
 *
 * Redistributions of source code must retain the above copyright notice,
 *  this list of conditions and the following disclaimer.
 *  Redistributions in binary form must reproduce the above copyright
 *  notice, this list of conditions and the following disclaimer in the
 *  documentation and/or other materials provided with the distribution.
 *  Neither the name of the pig4cloud.com developer nor the names of its
 *  contributors may be used to endorse or promote products derived from
 *  this software without specific prior written permission.
 *  Author: hnqz
 *
 */

package com.qunzhixinxi.hnqz.admin.controller;

import cn.hutool.core.util.IdcardUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.json.JSONUtil;
import com.alibaba.nacos.common.utils.Md5Utils;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.pig4cloud.plugin.excel.annotation.RequestExcel;
import com.qunzhixinxi.hnqz.admin.api.dto.UserDTO;
import com.qunzhixinxi.hnqz.admin.api.dto.UserInfo;
import com.qunzhixinxi.hnqz.admin.api.dto.UserPwd;
import com.qunzhixinxi.hnqz.admin.api.entity.SysDept;
import com.qunzhixinxi.hnqz.admin.api.entity.SysRole;
import com.qunzhixinxi.hnqz.admin.api.entity.SysUser;
import com.qunzhixinxi.hnqz.admin.api.entity.SysUserRole;
import com.qunzhixinxi.hnqz.admin.api.vo.UserVO;
import com.qunzhixinxi.hnqz.admin.config.UpmsConfig;
import com.qunzhixinxi.hnqz.admin.entity.dto.CommonUserDTO;
import com.qunzhixinxi.hnqz.admin.entity.input.UserCertificationInput;
import com.qunzhixinxi.hnqz.admin.entity.model.excel.CommonUserExcelModel;
import com.qunzhixinxi.hnqz.admin.enums.SubjectTypeEnum;
import com.qunzhixinxi.hnqz.admin.mapper.*;
import com.qunzhixinxi.hnqz.admin.service.SysDeptService;
import com.qunzhixinxi.hnqz.admin.service.SysUserService;
import com.qunzhixinxi.hnqz.admin.service.WmDaAgentService;
import com.qunzhixinxi.hnqz.admin.service.WmDaDrugEntService;
import com.qunzhixinxi.hnqz.common.core.util.R;
import com.qunzhixinxi.hnqz.common.ding.service.DingService;
import com.qunzhixinxi.hnqz.common.log.annotation.SysLog;
import com.qunzhixinxi.hnqz.common.qcc.entity.EmployeeGetListDataItem;
import com.qunzhixinxi.hnqz.common.qcc.entity.EmployeeGetListResponse;
import com.qunzhixinxi.hnqz.common.qcc.entity.PageInfo;
import com.qunzhixinxi.hnqz.common.qcc.service.QccService;
import com.qunzhixinxi.hnqz.common.security.annotation.Inner;
import com.qunzhixinxi.hnqz.common.security.util.SecurityUtils;
import com.qunzhixinxi.hnqz.common.taxhelper.enums.TaxHelperCertStatus;
import com.qunzhixinxi.hnqz.common.taxhelper.service.TaxHelperService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiOperation;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.ArrayUtils;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.bind.annotation.*;

import javax.validation.Valid;
import java.util.*;
import java.util.stream.Collectors;

/**
 * @author hnqz
 * @date 2018/12/16
 */
@Slf4j
@RestController
@AllArgsConstructor
@RequestMapping("/user")
@Api(value = "user", tags = "用户管理模块")
public class SysUserController {

	private final SysUserService userService;
	private final SysDeptService sysDeptService;
	private final SysDeptMapper sysDeptMapper;
	private final SysUserMapper sysUserMapper;
	private final RedisTemplate redisTemplate;
	private final DingService dingService;
	private final UpmsConfig upmsConfig;
	private final SysUserRoleMapper sysUserRoleMapper;
	private final SysRoleMapper sysRoleMapper;
	private final TaxHelperService taxHelperService;
	private final WmDaAgentService wmDaAgentService;
	private final WmDaDrugEntService wmDaDrugEntService;
	private final SysCertResultRecordMapper sysCertResultRecordMapper;
	private final QccService qccService;


	private boolean isZbOrDbUsers(Integer[] roles) {
		if (null == roles) {
			return false;
		}

		if (Arrays.asList(roles).contains(1) || Arrays.asList(roles).contains(2) || Arrays.asList(roles).contains(3)
				|| Arrays.asList(roles).contains(4) || Arrays.asList(roles).contains(7)
				|| Arrays.asList(roles).contains(9) || Arrays.asList(roles).contains(11)) {
			// 1-管理员，2-平台管理员，3-药企管理员，4-CSO管理员，7-财务管理员，9-CRO管理员，11-患教管理员
			return true;
		}
		return false;
	}

	/**
	 * 用户管理-认证
	 *
	 * @param input
	 * @return R
	 */
	@ApiOperation(value = "用户管理-认证", notes = "用户管理-认证")
	@SysLog("用户管理-认证")
	@GetMapping("/getAuthInfo")
	public R getAuthInfo(UserCertificationInput input) {
		//参数校验
		return userService.getAuthInfo(input);
	}

	/**
	 * 用户管理-认证-确定
	 *
	 * @param input
	 * @return R
	 */
	@ApiOperation(value = "用户管理-认证-确定", notes = "用户管理-认证-确定")
	@SysLog("用户管理-认证-确定")
	@PostMapping("/batchChannelCert")
	public R batchChannelCert(@RequestBody UserCertificationInput input) {
		//参数校验
		return userService.batchChannelCert(input);
	}


	/**
	 * 获取指定用户全部信息
	 *
	 * @return 用户信息
	 */
	@Inner
	@GetMapping("/info/{username}")
	public R info(@PathVariable String username) {

		// //排除众包用户
		// List<Integer> roleList=new ArrayList<>();
		// roleList.add(5); //医药代表
		// roleList.add(6); //众包代表
		// QueryWrapper<SysUserRole> wrappers=Wrappers.query();
		//
		// List<SysUserRole>
		// list=sysUserRoleService.list(wrappers.lambda().notIn(SysUserRole::getRoleId,roleList));
		// List<Integer> listZbUserList=new ArrayList<>();
		// for (SysUserRole sysUserRole:list) {
		// listZbUserList.add(sysUserRole.getUserId());
		// }
		//
		// if(null==listZbUserList)
		// {
		// return R.failed(null, String.format("用户信息为空 %s", username));
		// }

		// 根据用户名查询用户时，过滤掉已删除和已禁用的用户
		List<SysUser> user = userService.list(Wrappers.<SysUser>query().lambda().eq(SysUser::getUsername, username)
				.eq(SysUser::getDelFlag, 0).eq(SysUser::getLockFlag, 0));

		if (user == null) {
			return R.failed(null, String.format("用户信息为空 %s", username));
		}

		if (user.size() == 1) {
			UserInfo userInfo = userService.findUserInfo(user.get(0));
			// 校验用户角色是否包含众包用户和医药代表用户

			if (isZbOrDbUsers(userInfo.getRoles())) {
				return R.ok(userInfo);
			} else {
				return R.failed(null, String.format("用户信息为空 %s", username));
			}
		} else {
			String password = redisTemplate.opsForValue().get(username) + "";
			if (null != password) {
				for (int i = 0; i < user.size(); i++) {
					UserInfo userInfo = userService.findUserInfo(user.get(i));
					if (Md5Utils.getMD5(password.getBytes()).equals(user.get(i).getW1())) {
						if (isZbOrDbUsers(userInfo.getRoles())) {
							redisTemplate.delete(username);
							return R.ok(userInfo);
						}
					}
				}
			}
		}
		return R.failed(null, String.format("用户信息为空 %s", username));
	}

	/**
	 * 通过ID查询用户信息
	 *
	 * @param id ID
	 * @return 用户信息
	 */
	@GetMapping("/{id}")
	public R user(@PathVariable Integer id) {
		return R.ok(userService.selectUserVoById(id));
	}

	/**
	 * 根据用户名查询用户信息
	 *
	 * @param username 用户名
	 * @return
	 */
	@GetMapping("/details/{username}")
	public R user(@PathVariable String username) {
		SysUser condition = new SysUser();
		condition.setUsername(username);
		return R.ok(userService.getOne(new QueryWrapper<>(condition)));
	}

	/**
	 * 根据用户名查询用户信息
	 *
	 * @param username 用户名
	 * @return
	 */
	@GetMapping("/getDetails")
	public R getuser(String deptId, String username) {
		SysUser condition = new SysUser();
		condition.setUsername(username);
		SysDept sysDept1 = sysDeptService.getById(Integer.parseInt(deptId));
		if (null != sysDept1) {
			condition.setDeptId(sysDept1.getDeptId());
		}
		return R.ok(userService.getOne(new QueryWrapper<>(condition)));
	}

	/**
	 * 删除用户信息
	 *
	 * @param id ID
	 * @return R
	 */
	@SysLog("删除用户信息")
	@DeleteMapping("/{id}")
	@PreAuthorize("@pms.hasPermission('sys_user_del')")
	@ApiOperation(value = "删除用户", notes = "根据ID删除用户")
	@ApiImplicitParam(name = "id", value = "用户ID", required = true, dataType = "int", paramType = "path")
	public R userDel(@PathVariable Integer id) {
		SysUser sysUser = userService.getById(id);
		return R.ok(userService.deleteUserById(sysUser));
	}

	/**
	 * 添加用户
	 *
	 * @param userPwd 用户信息
	 * @return success/false
	 */
	@Inner(value = false)
	@SysLog("修改密码")
	@PostMapping("/upd")
	public R updatePwd(@RequestBody @Valid UserPwd userPwd) {

		return userService.updatePwd(userPwd);
	}

	/**
	 * 添加用户
	 *
	 * @param userDto 用户信息
	 * @return success/false
	 */
	@SysLog("添加用户")
	@PostMapping
	@PreAuthorize("@pms.hasPermission('sys_user_add')")
	public R user(@RequestBody UserDTO userDto) {

		// 姓名去除空格（包括字符之间的所有空格都会去除）
		userDto.setRealname(StrUtil.cleanBlank(userDto.getRealname()));

		SysDept sysDept = sysDeptService.getById(userDto.getDeptId());

		// TODO qcc调用企查查查询是否为主要人员
		/**
		 * @Modify: start qcc调用企查查查询是否为主要人员
		 * @Version: v2021.4.16
		 * @Author: ryz
		 * @Date: 2021/5/6
		*/
		if (userDto.getRole().contains(6) || userDto.getRole().contains(10)) {
			Map<String, String> params = new HashMap<>();
			params.put("searchKey", sysDept.getName());
			params.put("pageIndex", "1");
			params.put("pageSize", "10");
			EmployeeGetListResponse qccRes = qccService.getList(params);
			if (qccRes.isSuccess()) {
				for (EmployeeGetListDataItem item : qccRes.getResult()) {
					if (userDto.getRealname().equals(item.getName())) {
						if(userDto.getRole().contains(10)){
							return R.failed(String.format("%s为该公司%s，不能为兼职CRC",item.getName(),item.getJob()));
						}else{
							return R.failed(String.format("%s为该公司%s，不能为兼职学术推广员",item.getName(),item.getJob()));
						}

					}
				}
				if(null != qccRes.getPaging()){
					PageInfo qccPage = qccRes.getPaging();
					// 需要分页查询
					if (qccPage.getTotalRecords() > qccPage.getPageIndex() * qccPage.getPageSize()) {
						int totalPage = qccPage.getTotalRecords() / qccPage.getPageSize();

						for (int i = 2; i < totalPage + 2; i++) {
							params.put("pageIndex", i + "");
							qccRes = qccService.getList(params);
							if (qccRes.isSuccess()) {
								for (EmployeeGetListDataItem item : qccRes.getResult()) {
									if (userDto.getRealname().equals(item.getName())) {
										if(userDto.getRole().contains(10)){
											return R.failed(String.format("%s为该公司%s，不能为兼职CRC",item.getName(),item.getJob()));
										}else{
											return R.failed(String.format("%s为该公司%s，不能为兼职学术推广员",item.getName(),item.getJob()));
										}
									}
								}
							} else {
								break;
							}
						}
					}
				}

			}
		}

		if(ArrayUtils.contains(sysDept.getSubjectType(),SubjectTypeEnum.TYPE_SHUIBANGYUN.getCode())){
			userDto.setCertStatus(TaxHelperCertStatus.UN_CERT.getCode());
		}


		if (userDto.getRole().contains(2)) {
			UserDTO userDTO = new UserDTO();
			userDTO.setUsername(userDto.getUsername());
			userDTO.setDelFlag("0");
			List<UserVO> userDTOList = sysUserMapper.selectByPhone(userDTO);
			if (userDTOList.size() > 0) {
				for (UserVO userVO : userDTOList) {
					if (null != userVO.getRoleList()) {
						for (SysRole sysRole : userVO.getRoleList()) {
							if (sysRole.getRoleId() == 3) {
								return R.failed("用户已存在平台管理员角色,不能同时为药企管理员");
							}
							if (sysRole.getRoleId() == 4) {
								return R.failed("用户已存在平台管理员角色,不能同时为CSO管理员");
							}
							if (sysRole.getRoleId() == 5) {
								return R.failed("用户已存在平台管理员角色,不能同时为全职学术推广员");
							}
							if (sysRole.getRoleId() == 6) {
								return R.failed("用户已存在平台管理员角色,不能同时为兼职学术推广员");
							}
							if (sysRole.getRoleId() == 7) {
								return R.failed("用户已存在平台管理员角色,不能同时为财务管理员");
							}
						}
					}
				}
			}

		} else if (userDto.getRole().contains(3)) {
			UserDTO userDTO = new UserDTO();
			userDTO.setUsername(userDto.getUsername());
			userDTO.setDelFlag("0");
			List<UserVO> userDTOList = sysUserMapper.selectByPhone(userDTO);
			if (userDTOList.size() > 0) {
				for (UserVO userVO : userDTOList) {
					if (null != userVO.getRoleList()) {
						for (SysRole sysRole : userVO.getRoleList()) {
							if (sysRole.getRoleId() == 2) {
								return R.failed("用户已存在药企管理员角色,不能同时为平台管理员");
							}

							if (sysRole.getRoleId() == 4) {
								return R.failed("用户已存在药企管理员角色,不能同时为CSO管理员");
							}
//							SysDept sysDept = sysDeptService.getById(userVO.getDeptId());
							if (sysDept.getLevel() == 3 || sysDept.getLevel() == 4) {
								if (sysRole.getRoleId() == 5) {
									return R.failed("用户已存在CSO关系角色,不能同时为药企管理员");
								}
							}
						}
					}
				}
			}

		} else if (userDto.getRole().contains(4)) {
			UserDTO userDTO = new UserDTO();
			userDTO.setUsername(userDto.getUsername());
			userDTO.setDelFlag("0");
			List<UserVO> userDTOList = sysUserMapper.selectByPhone(userDTO);
			if (userDTOList.size() > 0) {
				for (UserVO userVO : userDTOList) {
					if (null != userVO.getRoleList()) {
						for (SysRole sysRole : userVO.getRoleList()) {
							if (sysRole.getRoleId() == 2) {
								return R.failed("用户已存在平台管理员角色,不能同时为CSO管理员");
							}
							if (sysRole.getRoleId() == 4) {
								return R.failed("用户已存在CSO管理员角色,不能为其他机构CSO管理员");
							}
							if (sysRole.getRoleId() == 9) {
								return R.failed("用户已存在CRO管理员,不能同时为CSO管理员");
							}

							if (sysRole.getRoleId() == 3) {
								return R.failed("用户已存在药企管理员角色,不能同时为CSO管理员");
							}
							if (sysRole.getRoleId() == 5) {
								SysUserRole sysUserRole = new SysUserRole();
								sysUserRole.setUserId(userVO.getUserId());
								List<SysUserRole> sysUserRoleList = sysUserRoleMapper.selectById(sysUserRole);
								for (int i = 0; i < sysUserRoleList.size(); i++) {
									SysUser sysUser = userService.getById(sysUserRoleList.get(i).getUserId());
									if (!sysUser.getDeptId().equals(userDto.getDeptId())) {
										return R.failed("用户已存在全职学术推广员角色,不能为其他机构CSO管理员");
									}
								}
							}
						}
					}
				}
			}

		} else if (userDto.getRole().contains(7)) {
			UserDTO userDTO = new UserDTO();
			userDTO.setUsername(userDto.getUsername());
			userDTO.setDelFlag("0");
			List<UserVO> userDTOList = sysUserMapper.selectByPhone(userDTO);
			if (userDTOList.size() > 0) {
				for (UserVO userVO : userDTOList) {
					if (null != userVO.getRoleList()) {
						for (SysRole sysRole : userVO.getRoleList()) {
							if (sysRole.getRoleId() == 2) {
								return R.failed("用户已存在平台管理员,不能同时为财务管理员");
							}
							if (sysDept.getLevel() == 3 || sysDept.getLevel() == 4) {
								if (sysRole.getRoleId() == 3) {
									return R.failed("用户已存在药企管理员,不能同时为CSO机构财务管理员");
								}
							}
						}
					}
				}
			}

		} else if (userDto.getRole().contains(5)) {
			UserDTO userDTO = new UserDTO();
			userDTO.setUsername(userDto.getUsername());
			userDTO.setDelFlag("0");
			List<UserVO> userDTOList = sysUserMapper.selectByPhone(userDTO);
			if (userDTOList.size() > 0) {
				for (UserVO userVO : userDTOList) {
					if (null != userVO.getRoleList()) {
						for (SysRole sysRole : userVO.getRoleList()) {
							if (sysRole.getRoleId() == 2) {
								return R.failed("用户已存在平台管理员,不能同时为全职学术推广员");
							}
							if (sysRole.getRoleId() == 3) {
								if (sysDept.getLevel() == 3 || sysDept.getLevel() == 4) {
									return R.failed("用户已存在药企管理员,不能为CSO的全职学术推广员");
								}
							}
							if (sysRole.getRoleId() == 4) {
								if (sysDept.getLevel() == 3 || sysDept.getLevel() == 4) {
									return R.failed("用户已存在CSO管理员,不能为其他CSO的全职学术推广员");
								}
							}

						}
					}
				}
			}

		} else if (userDto.getRole().contains(6)) {

			UserDTO userDTO = new UserDTO();
			userDTO.setUsername(userDto.getUsername());
			userDTO.setDelFlag("0");
			List<UserVO> userDTOList = sysUserMapper.selectByPhone(userDTO);
			if (userDTOList.size() > 0) {
				for (UserVO userVO : userDTOList) {
					if (null != userVO.getRoleList()) {
						for (SysRole sysRole : userVO.getRoleList()) {
							if (sysRole.getRoleId() == 2) {
								return R.failed("用户已存在平台管理员,不能同时为兼职学术推广员");
							}
							SysUserRole sysUserRole = new SysUserRole();
							sysUserRole.setUserId(userVO.getUserId());
							List<SysUserRole> sysUserRoleList = sysUserRoleMapper.selectById(sysUserRole);
							for (int i = 0; i < sysUserRoleList.size(); i++) {
								if (sysUserRoleList.get(i).getRoleId().equals(7)) {
									SysUser sysUser = userService.getById(sysUserRoleList.get(i).getUserId());
									if (sysUser.getDeptId().equals(userDto.getDeptId())) {
										return R.failed("用户已存在财务管理员角色，不能同时为兼职学术推广员");
									}
								}
							}
						}
					}
				}
			}

		} else if (userDto.getRole().contains(9)) {
			UserDTO userDTO = new UserDTO();
			userDTO.setUsername(userDto.getUsername());
			userDTO.setDelFlag("0");
			List<UserVO> userDTOList = sysUserMapper.selectByPhone(userDTO);
			if (userDTOList.size() > 0) {
				for (UserVO userVO : userDTOList) {
					if (null != userVO.getRoleList()) {
						for (SysRole sysRole : userVO.getRoleList()) {
							if (sysRole.getRoleId() == 2) {
								return R.failed("用户已存在平台管理员,不能同时为CRO管理员");
							}
							if (sysRole.getRoleId() == 3) {
								return R.failed("用户已存在药企管理员,不能同时为CRO管理员");
							}
							if (sysRole.getRoleId() == 4) {
								return R.failed("用户已存在CSO管理员角色,不能同时为CRO管理员");
							}
							if (sysRole.getRoleId() == 9) {
								return R.failed("用户已存在CRO管理员角色");
							}
						}
					}
				}
			}

		}
		if (userDto.getRole().contains(3)) {
			if (sysDept.getLevel() != 2) {
				return R.failed("角色选为药企管理员时,组织架构必须为药企");
			}
		}
		// }
		if (!userDto.getDeptId().equals(SecurityUtils.getUser().getDeptId())) {
			if (userDto.getRole().contains(5) || userDto.getRole().contains(6)) {
				return R.failed("不能跨机构维护学术推广员");
			}
		}
		SysUser query = new SysUser();
		query.setUsername(userDto.getUsername());
		query.setDeptId(userDto.getDeptId());
		Integer count = sysUserMapper.selectCount(Wrappers.query(query));
		// TODO  用户是否存在
		if (count != 0) {
			return R.failed("当前机构已存在该账号");
		}


		// 校验身份证上的年龄
		if (StringUtils.isNotEmpty(userDto.getIdCardNumber())) {
			// 获取更新操作的用户角色
			List<Integer> roles = userDto.getRole();
			// 如果角色中包含全职和兼职就需要校验身份证年龄
			if (roles.contains(5) || roles.contains(6)) {
				int ageByIdCard = IdcardUtil.getAgeByIdCard(userDto.getIdCardNumber());
				if (ageByIdCard < 18) {
					return R.failed("年龄未满十八");
				} else if (ageByIdCard > 65) {
					return R.failed("年龄已超过六十五");
				}
			}
		}

		return R.ok(userService.saveUser(userDto));
	}


	/**
	 * 批量导入用户
	 *
	 * @param commonUserExcelModelList 用户信息列表
	 * @return success/false
	 */
	@SysLog("批量导入用户")
	@PostMapping(value = "/batch")
	@PreAuthorize("@pms.hasPermission('sys_user_add')")
	public R batchUser(@RequestExcel List<CommonUserExcelModel> commonUserExcelModelList){

		// 参数校验
		if (CollectionUtils.isEmpty(commonUserExcelModelList)) {
			log.error("空报表，不能上传");
			return R.failed("空报表，不能上传");
		}

		Map<String, List<CommonUserDTO>> collect = commonUserExcelModelList.stream().map(commonUserExcelModel ->
				BeanUtil.copyProperties(commonUserExcelModel, CommonUserDTO.class)
		).collect(Collectors.groupingBy(CommonUserDTO::getUsername));


		// 实际的处理业务
		Map<String, String> errorMap = userService.batchByExcel(collect);

		// 返回上传结果
		Map<String, Object> result = new HashMap<>(3);
		if (CollectionUtil.isEmpty(errorMap)) {
			result.put("code", "SUCCESS");
			result.put("message", "上传成功");
			result.put("data", null);
			return R.ok(result);
		} else {
			log.error("上传数据错误，{}", JSONUtil.toJsonStr(errorMap));
			result.put("code", "FAILURE");
			result.put("message", "上传数据错误");
			result.put("data", errorMap);
			return R.failed(result);

		}
	}

// 	/**
// 	 * 批量导入用户
// 	 *
// 	 * @param file 用户信息文件
// 	 * @return success/false
// 	 */
// 	@SysLog("批量导入用户")
// 	@PostMapping(value = "/batch")
// 	@PreAuthorize("@pms.hasPermission('sys_user_add')")
// 	public R batchUser(@RequestPart("file") MultipartFile file) {
//
// 		// 获取操作员和操作员所在的结算主体
// 		HnqzUser operator = SecurityUtils.getUser();
// 		SysDept sysDept = sysDeptService.getById(operator.getDeptId());
//
// 		// 读取excel
// 		try {
// 			String fileName = file.getOriginalFilename().toLowerCase();
// 			InputStream inputStream = file.getInputStream();
//
// 			// 校验文件信息
// 			Workbook wbs = null;
// 			if (fileName.endsWith("xls")) {
// 				//2003
// 				wbs = new HSSFWorkbook(inputStream);
// 			} else if (fileName.endsWith("xlsx")) {
// 				//2007
// 				wbs = new XSSFWorkbook(inputStream);
// 			} else {
// 				return R.failed("上传文件格式错误!");
// 			}
// 			if (wbs.isSheetHidden(0)) {
// 				return R.failed("导入表中有隐藏列");
// 			}
//
// 			// 校验页（数据页）
// 			Sheet sheet = wbs.getSheetAt(1);
//
// 			// 校验模板
// 			Row row0 = sheet.getRow(0);
// 			if (row0 == null) {
// 				return R.failed("导入模版错误！");
// 			}
//
// 			// 校验记录数
// 			int rowNum = sheet.getLastRowNum();
// 			if (rowNum < 1) {
// 				return R.failed("导入表中缺少数据！");
// 			} else if (rowNum > 1000) {
// 				return R.failed("单次批量导入最大支持1000行数据！");
// 			}
//
// 			// 校验列信息
// 			String name = row0.getCell(0).getStringCellValue();
// 			if (!"姓名".equals(name)) {
// 				return R.failed("导入模版第一列错误！");
// 			}
// 			String phone = row0.getCell(1).getStringCellValue();
// 			if (!"手机号".equals(phone)) {
// 				return R.failed("导入模版第二列错误！");
// 			}
// 			String prov = row0.getCell(2).getStringCellValue();
// 			if (!"省".equals(prov)) {
// 				return R.failed("导入模版第三列错误！");
// 			}
// 			String city = row0.getCell(3).getStringCellValue();
// 			if (!"市".equals(city)) {
// 				return R.failed("导入模版第四列错误！");
// 			}
// 			String role = row0.getCell(4).getStringCellValue();
// 			if (!"角色".equals(role)) {
// 				return R.failed("导入模版第五列错误！");
// 			}
// 			String userStatus = row0.getCell(5).getStringCellValue();
// 			if (!"状态".equals(userStatus)) {
// 				return R.failed("导入模版第六列错误！");
// 			}
// 			String provinceCode = row0.getCell(6).getStringCellValue();
// 			if (!"省份编码".equals(provinceCode)) {
// 				return R.failed("导入模版第七列错误！");
// 			}
// 			String cityCode = row0.getCell(7).getStringCellValue();
// 			if (!"城市编码".equals(cityCode)) {
// 				return R.failed("导入模版第八列错误！");
// 			}
//
// 			//数据
// 			List<UserDTO> userDTOList = new ArrayList<>();
// 			List<ErrorInfoVo> errorList = new ArrayList<>();
// 			log.info(">>> 通过excel批量创建用户开始 <<<");
// 			// 行数据
// 			for (int i = 1; i <= rowNum; i++) {
//
// 				// 行编号
// 				int rNum = i;
// 				Row row = sheet.getRow(i);
// 				log.info(">>>当前导入第{}行<<<", i);
//
// 				if (row == null) {
// 					ErrorInfoVo errorInfoVo = new ErrorInfoVo();
// 					errorInfoVo.setRowNum(rNum);
// 					errorInfoVo.setColumnName(null);
// 					errorInfoVo.setContent(null);
// 					errorInfoVo.setReason("当前行没有数据信息");
// 					errorList.add(errorInfoVo);
// 					continue;
// 				}
//
// 				int colNum = row.getLastCellNum();
// 				UserDTO userDTO = new UserDTO();
//
// 				userDTO.setDeptId(sysDept.getDeptId());
// 				if(ArrayUtils.contains(sysDept.getSubjectType(),SubjectTypeEnum.TYPE_SHUIBANGYUN.getCode())){
// 					userDTO.setCertStatus(TaxHelperCertStatus.UN_CERT.getCode());
// 				}
// //				if(ArrayUtils.contains(sysDept.getSubjectType(),SubjectTypeEnum.TYPE_RENLIJIA.getCode())){
// //					userDTO.setRljCertStatus(DingEnum.CER_STATUS_4.getType());
// //				}
// //				if ("1".equals(sysDept.getSubjectType())) {
// //					userDTO.setCertStatus(TaxHelperCertStatus.UN_CERT.getCode());
// //					userDTO.setUserType("1");
// //				} else {
// //					userDTO.setUserType("0");
// //				}
// 				userDTO.setCreateTime(LocalDateTime.now());
//
// 				for (int j = 0; j < colNum; j++) {//列数据
//
// 					// 获取列名称
// 					String columnName = row0.getCell(j).getStringCellValue();
// 					int columnNum = j + 1;
//
// 					if (null == row.getCell(j)) {
// 						ErrorInfoVo errorInfoVo = new ErrorInfoVo();
// 						errorInfoVo.setRowNum(rNum);
// 						errorInfoVo.setColumnNum(columnNum);
// 						errorInfoVo.setColumnName(columnName);
// 						errorInfoVo.setContent(null);
// 						errorInfoVo.setReason("列数据为空");
// 						errorList.add(errorInfoVo);
// 						continue;
// 					}
//
// 					// 格式化字符串
// 					row.getCell(j).setCellType(CellType.STRING);
// 					String value = row.getCell(j).getStringCellValue()
// 							.replaceAll(" ", "")
// 							.replaceAll(",", "")
// 							.replaceAll("\\u00A0", "")
// 							.replaceAll((char) 12288 + "", "")
// 							.replace("+", "·");
//
// 					// 校验value
// 					if (StringUtil.isEmpty(value)) {
// 						ErrorInfoVo errorInfoVo = new ErrorInfoVo();
// 						errorInfoVo.setRowNum(rNum);
// 						errorInfoVo.setColumnNum(columnNum);
// 						errorInfoVo.setColumnName(columnName);
// 						errorInfoVo.setContent(value);
// 						errorInfoVo.setReason("数据为空");
// 						errorList.add(errorInfoVo);
// 						continue;
// 					}
//
// 					if (j == 0) {
// 						userDTO.setRealname(value);
// 					} else if (j == 1) {
// 						// 记录错误说明
// 						String errorInfo = null;
// 						// 正则校验手机号
// 						if (ValidateUtils.validPhoneNum("0", value)) {
// 							// 判断同一个dept下用户是否重复
// 							SysUser query = new SysUser();
// 							query.setUsername(value);
// 							query.setDeptId(userDTO.getDeptId());
// 							SysUser sysUser = sysUserMapper.selectUserByName(query);
// 							if (sysUser != null) {
// 								errorInfo = "手机号已被占用";
// 							}
// 						} else {
// 							errorInfo = "不是手机号";
// 						}
//
// 						// 封装错误信息
// 						if (StringUtils.isNotEmpty(errorInfo)) {
// 							ErrorInfoVo errorInfoVo = new ErrorInfoVo();
// 							errorInfoVo.setRowNum(rNum);
// 							errorInfoVo.setColumnNum(columnNum);
// 							errorInfoVo.setColumnName(columnName);
// 							errorInfoVo.setContent(value);
// 							errorInfoVo.setReason(errorInfo);
// 							errorList.add(errorInfoVo);
// 							continue;
// 						}
//
// 						userDTO.setPlatId(value);
// 						userDTO.setPhone(value);
// 						userDTO.setUsername(value);
// 					} else if (j == 2) {
// 						if ("全国".equals(value)) {
// 							userDTO.setProvince("");
// 						} else {
// 							userDTO.setProvince(value);
// 						}
// 					} else if (j == 3) {
// 						if (StringUtils.isEmpty(userDTO.getProvince())) {
// 							userDTO.setCity("");
// 						} else {
// 							userDTO.setCity(value);
// 						}
// 					} else if (j == 4) {
// 						// 声明错误信息记录
// 						String errorInfo = "";
//
// 						// 根据角色名称获取角色
// 						SysRole sysRole = sysRoleMapper.selectOne(Wrappers.<SysRole>query().eq("role_name", value));
// 						if (sysRole != null) {
// 							userDTO.setRole(Arrays.asList(sysRole.getRoleId()));
// 							if (userDTO.getRole().contains(2)) {
// 								UserDTO tmp = new UserDTO();
// 								tmp.setUsername(userDTO.getUsername());
// 								tmp.setDelFlag("0");
// 								List<UserVO> userVoList = sysUserMapper.selectByPhone(tmp);
// 								if (userVoList.size() > 0) {
// 									for (UserVO userVO : userVoList) {
// 										if (null != userVO.getRoleList()) {
// 											for (SysRole r : userVO.getRoleList()) {
// 												if (r.getRoleId() == 3) {
// 													errorInfo = errorInfo + "用户已存在平台管理员角色,不能同时为药企管理员！";
// 													continue;
// 												}
// 												if (r.getRoleId() == 4) {
// 													errorInfo = errorInfo + "用户已存在平台管理员角色,不能同时为CSO管理员！";
// 													continue;
// 												}
// 												if (r.getRoleId() == 5) {
// 													errorInfo = errorInfo + "用户已存在平台管理员角色,不能同时为全职学术推广员！";
// 													continue;
// 												}
// 												if (r.getRoleId() == 6) {
// 													errorInfo = errorInfo + "用户已存在平台管理员角色,不能同时为兼职学术推广员！";
// 													continue;
// 												}
// 												if (r.getRoleId() == 7) {
// 													errorInfo = errorInfo + "用户已存在平台管理员角色,不能同时为财务管理员！";
// 													continue;
// 												}
// 											}
// 										}
// 									}
// 								}
//
// 							} else if (userDTO.getRole().contains(3)) {
// 								UserDTO tmp = new UserDTO();
// 								tmp.setUsername(userDTO.getUsername());
// 								tmp.setDelFlag("0");
// 								List<UserVO> userVoList = sysUserMapper.selectByPhone(tmp);
// 								if (userVoList.size() > 0) {
// 									for (UserVO userVO : userVoList) {
// 										if (null != userVO.getRoleList()) {
// 											for (SysRole r : userVO.getRoleList()) {
// 												if (r.getRoleId() == 2) {
// 													errorInfo = errorInfo + "用户已存在药企管理员角色,不能同时为平台管理员！";
// 													continue;
// 												}
// 												if (r.getRoleId() == 4) {
// 													errorInfo = errorInfo + "用户已存在药企管理员角色,不能同时为CSO管理员！";
// 													continue;
// 												}
// 												if (sysDept.getLevel() == 3 || sysDept.getLevel() == 4) {
// 													if (r.getRoleId() == 5) {
// 														errorInfo = errorInfo + "用户已存在CSO关系角色,不能同时为药企管理员！";
// 														continue;
// 													}
// 												}
// 											}
// 										}
// 									}
// 								}
//
// 							} else if (userDTO.getRole().contains(4)) {
// 								UserDTO tmp = new UserDTO();
// 								tmp.setUsername(userDTO.getUsername());
// 								tmp.setDelFlag("0");
// 								List<UserVO> userVoList = sysUserMapper.selectByPhone(tmp);
// 								if (userVoList.size() > 0) {
// 									for (UserVO userVO : userVoList) {
// 										if (null != userVO.getRoleList()) {
// 											for (SysRole r : userVO.getRoleList()) {
// 												if (sysRole.getRoleId() == 2) {
// 													errorInfo = errorInfo + "用户已存在平台管理员角色,不能同时为！";
// 													continue;
// 												}
//
// 												if (r.getRoleId() == 3) {
// 													errorInfo = errorInfo + "用户已存在药企管理员角色,不能同时为CSO管理员！";
// 													continue;
// 												}
// 												if (r.getRoleId() == 5) {
// 													SysUserRole sysUserRole = new SysUserRole();
// 													sysUserRole.setUserId(userVO.getUserId());
// 													List<SysUserRole> sysUserRoleList = sysUserRoleMapper.selectById(sysUserRole);
// 													for (int k = 0; k < sysUserRoleList.size(); k++) {
// 														SysUser sysUser = userService.getById(sysUserRoleList.get(k).getUserId());
// 														if (!sysUser.getDeptId().equals(userDTO.getDeptId())) {
// 															errorInfo = errorInfo + "用户已存在全职学术推广员角色,不能为其他机构CSO管理员！";
// 															continue;
// 														}
// 													}
// 												}
// 											}
// 										}
// 									}
// 								}
//
// 							} else if (userDTO.getRole().contains(7)) {
// 								UserDTO tmp = new UserDTO();
// 								tmp.setUsername(userDTO.getUsername());
// 								tmp.setDelFlag("0");
// 								List<UserVO> userVoList = sysUserMapper.selectByPhone(tmp);
// 								if (userVoList.size() > 0) {
// 									for (UserVO userVO : userVoList) {
// 										if (null != userVO.getRoleList()) {
// 											for (SysRole r : userVO.getRoleList()) {
// 												if (r.getRoleId() == 2) {
// 													errorInfo = errorInfo + "用户已存在平台管理员,不能同时为财务管理员！";
// 													continue;
// 												}
// 												if (sysDept.getLevel() == 3 || sysDept.getLevel() == 4) {
// 													if (r.getRoleId() == 3) {
// 														errorInfo = errorInfo + "用户已存在药企管理员,不能同时为CSO机构财务管理员！";
// 														continue;
// 													}
// 												}
// 											}
// 										}
// 									}
// 								}
//
// 							} else if (userDTO.getRole().contains(5)) {
// 								UserDTO tmp = new UserDTO();
// 								tmp.setUsername(userDTO.getUsername());
// 								tmp.setDelFlag("0");
// 								List<UserVO> userVoList = sysUserMapper.selectByPhone(tmp);
// 								if (userVoList.size() > 0) {
// 									for (UserVO userVO : userVoList) {
// 										if (null != userVO.getRoleList()) {
// 											for (SysRole r : userVO.getRoleList()) {
// 												if (r.getRoleId() == 2) {
// 													errorInfo = errorInfo + "用户已存在平台管理员,不能同时为全职学术推广员！";
// 													continue;
// 												}
// 												if (r.getRoleId() == 3) {
// 													if (sysDept.getLevel() == 3 || sysDept.getLevel() == 4) {
// 														errorInfo = errorInfo + "用户已存在药企管理员,不能为CSO的全职学术推广员！";
// 														continue;
// 													}
// 												}
// 												if (r.getRoleId() == 4) {
// 													if (sysDept.getLevel() == 3 || sysDept.getLevel() == 4) {
// 														errorInfo = errorInfo + "用户已存在CSO管理员,不能为其他CSO的全职学术推广员！";
// 														continue;
// 													}
// 												}
//
// 											}
// 										}
// 									}
// 								}
//
// 							} else if (userDTO.getRole().contains(6)) {
// 								UserDTO tmp = new UserDTO();
// 								tmp.setUsername(userDTO.getUsername());
// 								tmp.setDelFlag("0");
// 								List<UserVO> userVoList = sysUserMapper.selectByPhone(tmp);
// 								if (userVoList.size() > 0) {
// 									for (UserVO userVO : userVoList) {
// 										if (null != userVO.getRoleList()) {
// 											for (SysRole r : userVO.getRoleList()) {
// 												if (r.getRoleId() == 2) {
// 													errorInfo = errorInfo + "用户已存在平台管理员,不能同时为兼职学术推广员！";
// 													continue;
// 												}
// 												SysUserRole sysUserRole = new SysUserRole();
// 												sysUserRole.setUserId(userVO.getUserId());
// 												List<SysUserRole> sysUserRoleList = sysUserRoleMapper.selectById(sysUserRole);
// 												for (int k = 0; k < sysUserRoleList.size(); k++) {
// 													if (sysUserRoleList.get(k).getRoleId().equals(7)) {
// 														SysUser sysUser = userService.getById(sysUserRoleList.get(k).getUserId());
// 														if (sysUser.getDeptId().equals(userDTO.getDeptId())) {
// 															errorInfo = errorInfo + "用户已存在财务管理员角色，不能同时为兼职学术推广员！";
// 															continue;
// 														}
// 													}
// 												}
// 											}
// 										}
// 									}
// 								}
//
// 							} else if (userDTO.getRole().contains(9)) {
// 								UserDTO tmp = new UserDTO();
// 								tmp.setUsername(userDTO.getUsername());
// 								tmp.setDelFlag("0");
// 								List<UserVO> userVoList = sysUserMapper.selectByPhone(tmp);
// 								if (userVoList.size() > 0) {
// 									for (UserVO userVO : userVoList) {
// 										if (null != userVO.getRoleList()) {
// 											for (SysRole r : userVO.getRoleList()) {
// 												if (sysRole.getRoleId() == 2) {
// 													errorInfo = errorInfo + "用户已存在平台管理员,不能同时为CRO管理员！";
// 													continue;
// 												}
// 												if (r.getRoleId() == 3) {
// 													errorInfo = errorInfo + "用户已存在药企管理员,不能同时为CRO管理员！";
// 													continue;
// 												}
// 											}
// 										}
// 									}
// 								}
// 							}
// 							if (userDTO.getRole().contains(3)) {
// 								if (sysDept.getLevel() != 2) {
// 									errorInfo = errorInfo + "角色选为药企管理员时,组织架构必须为药企！";
// 								}
// 							}
// 							if (!userDTO.getDeptId().equals(SecurityUtils.getUser().getDeptId())) {
// 								if (userDTO.getRole().contains(5) || userDTO.getRole().contains(6)) {
// 									errorInfo = errorInfo + "不能跨机构维护学术推广员！";
// 								}
// 							}
// 						}
//
// 						// 存在错误
// 						if (StringUtils.isNotEmpty(errorInfo) || sysRole == null) {
// 							ErrorInfoVo errorInfoVo = new ErrorInfoVo();
// 							errorInfoVo.setRowNum(rNum);
// 							errorInfoVo.setColumnNum(columnNum);
// 							errorInfoVo.setColumnName(columnName);
// 							errorInfoVo.setContent(errorInfo);
// 							errorInfoVo.setReason("角色信息有误");
// 							errorList.add(errorInfoVo);
// 							continue;
// 						}
// 					} else if (j == 5) {
// 						if (!"活跃".equals(value) && !"休眠".equals(value)) {
// 							ErrorInfoVo errorInfoVo = new ErrorInfoVo();
// 							errorInfoVo.setRowNum(rNum);
// 							errorInfoVo.setColumnNum(columnNum);
// 							errorInfoVo.setColumnName(columnName);
// 							errorInfoVo.setContent(value);
// 							errorInfoVo.setReason("角色状态有误");
// 							errorList.add(errorInfoVo);
// 							continue;
// 						}
// 						userDTO.setLockFlag("活跃".equals(value) ? "0" : "9");
// 					} else if (j == 6) {
// 						userDTO.setProvinceCode(value);
// 					} else if (j == 7) {
// 						userDTO.setCityCode(value);
// 					}
// 				}
//
// 				// 记录争取额的信息
// 				userDTOList.add(userDTO);
// 			}
//
// 			// 判断是否有错误的数据行，如果没有，执行入库操作
// 			if (CollectionUtils.isEmpty(errorList)) {
// 				userDTOList.forEach(userDTO -> {
// 					userService.saveUser(userDTO);
// 				});
// 			}
// 			return R.ok(errorList);
//
// 		} catch (Exception e) {
// 			log.error("批量创建用户失败:{}",e.getMessage());
// 			e.printStackTrace();
// 			return R.failed("批量创建用户失败");
// 		}
// 	}

	/**
	 * 更新用户信息
	 *
	 * @param userDto 用户信息
	 * @return R
	 */
	@SysLog("更新用户信息")
	@PutMapping
	@PreAuthorize("@pms.hasPermission('sys_user_edit')")
	public R updateUser(@Valid @RequestBody UserDTO userDto) {

		// TODO qcc调用企查查查询是否为主要人员
		/**
		 * @Modify: start qcc调用企查查查询是否为主要人员
		 * @Version: v2021.4.16
		 * @Author: ryz
		 * @Date: 2021/5/6
		 */
		SysDept sysDept = sysDeptService.getById(userDto.getDeptId());

		if (null != userDto.getUserId()) {
			// 姓名去除空格（包括字符之间的所有空格都会去除）
			userDto.setRealname(StrUtil.cleanBlank(userDto.getRealname()));

			SysUser oldData = userService.getById(userDto.getUserId());
			if (!userDto.getRealname().equals(oldData.getRealname())) {
				if (userDto.getRole().contains(6) || userDto.getRole().contains(10)) {
					Map<String, String> params = new HashMap<>();
					params.put("searchKey", sysDept.getName());
					params.put("pageIndex", "1");
					params.put("pageSize", "10");
					EmployeeGetListResponse qccRes = qccService.getList(params);
					if (qccRes.isSuccess()) {
						for (EmployeeGetListDataItem item : qccRes.getResult()) {
							if (userDto.getRealname().equals(item.getName())) {
								if(userDto.getRole().contains(10)){
									return R.failed(String.format("%s为该公司%s，不能为兼职CRC",item.getName(),item.getJob()));
								}else{
									return R.failed(String.format("%s为该公司%s，不能为兼职学术推广员",item.getName(),item.getJob()));
								}

							}
						}
						if(null != qccRes.getPaging()){
							PageInfo qccPage = qccRes.getPaging();
							// 需要分页查询
							if (qccPage.getTotalRecords() > qccPage.getPageIndex() * qccPage.getPageSize()) {
								int totalPage = qccPage.getTotalRecords() / qccPage.getPageSize();

								for (int i = 2; i < totalPage + 2; i++) {
									params.put("pageIndex", i + "");
									qccRes = qccService.getList(params);
									if (qccRes.isSuccess()) {
										for (EmployeeGetListDataItem item : qccRes.getResult()) {
											if(userDto.getRole().contains(10)){
												return R.failed(String.format("%s为该公司%s，不能为兼职CRC",item.getName(),item.getJob()));
											}else{
												return R.failed(String.format("%s为该公司%s，不能为兼职学术推广员",item.getName(),item.getJob()));
											}
										}
									} else {
										break;
									}
								}
							}
						}

					}
				}
			}


			List<Integer> cetList = new ArrayList<>();
			cetList.add(1);
			cetList.add(3);
			cetList.add(11);
			cetList.add(12);
			cetList.add(13);
			cetList.add(14);
			cetList.add(15);
			cetList.add(16);

			/**
			 * @Modify: start
			 * @Version: v2021.4.16
			 * @Author: ryz
			 * @Date: 2021/4/29
			 * 去掉修改用户信息时候的认证
			 */
			boolean updateFlag = true;
			if (null != oldData.getCertStatus()) {
				if (oldData.getCertStatus() != 10) {
					updateFlag = false;
				}

			}
			if (null != oldData.getRljCertStatus()) {
				if (oldData.getRljCertStatus() == 1 || oldData.getRljCertStatus() == 3) {
					updateFlag = false;
				}
			}
			if (!updateFlag) {
				if (!userDto.getRealname().equals(oldData.getRealname())) {
					return R.failed("用户认证通过或正在认证，暂不能修改姓名");
				}
				if (!userDto.getIdCardNumber().equals(oldData.getIdCardNumber())) {
					return R.failed("用户认证通过或正在认证，暂不能修改身份证号");
				}
			}
		}

		if (SecurityUtils.getRoles().contains(2) || SecurityUtils.getRoles().contains(1)) {
			if (userDto.getRole().contains(2)) {
				UserDTO userDTO = new UserDTO();
				userDTO.setPlatId(userDto.getUsername());
				userDTO.setDelFlag("0");
				List<UserVO> userDTOList = userService.getUserVoByPlatId(userDTO);
				if (userDTOList.size() > 0) {
					for (UserVO userVO : userDTOList) {
						if (null != userVO.getRoleList()) {
							for (SysRole sysRole : userVO.getRoleList()) {
								if (sysRole.getRoleId() == 3) {
									return R.failed("用户不能同时为平台管理员和药企管理员");
								}
							}
						}
					}
				}

			} else if (userDto.getRole().contains(3)) {
				UserDTO userDTO = new UserDTO();
				userDTO.setPlatId(userDto.getUsername());
				userDTO.setDelFlag("0");
				List<UserVO> userDTOList = userService.getUserVoByPlatId(userDTO);
				if (userDTOList.size() > 0) {
					for (UserVO userVO : userDTOList) {
						if (null != userVO.getRoleList()) {
							for (SysRole sysRole : userVO.getRoleList()) {
								if (sysRole.getRoleId() == 2) {
									return R.failed("用户不能同时为平台管理员和药企管理员");
								}
								if (userDto.getDeptId().equals(userVO.getDeptId())) {
									if (sysRole.getRoleId() == 6) {
										return R.failed("用户已存在本机构药企管理员,不能同时为兼职学术推广员");
									}
								}
							}
						}
					}
				}
				SysUser query = new SysUser();
				query.setUsername(userDto.getUsername());
				query.setDeptId(userDto.getDeptId());
				SysUser sysUser = sysUserMapper.selectUserByName(query);
				if (sysUser != null) {
					if (sysDept.getLevel() != 2) {
						return R.failed("角色选为药企管理员时,组织架构必须为药企");
					}
				}

			} else if (userDto.getRole().contains(4)) {
				UserDTO userDTO = new UserDTO();
				userDTO.setPlatId(userDto.getUsername());
				userDTO.setDelFlag("0");
				List<UserVO> userDTOList = userService.getUserVoByPlatId(userDTO);
				if (userDTOList.size() > 0) {
					for (UserVO userVO : userDTOList) {
						if (null != userVO.getRoleList()) {
							for (SysRole sysRole : userVO.getRoleList()) {
								if (sysRole.getRoleId() == 2) {
									return R.failed("用户不能同时为平台管理员和经销商管理员");
								}

								if (sysRole.getRoleId() == 3) {
									return R.failed("用户不能同时为药企管理员和经销商管理员");
								}
								if(!userDto.getUserId().equals(userVO.getUserId()) && sysRole.getRoleId() == 4){
									return R.failed("用户已存在CSO管理员角色,不能维护为其他经销商组织的CSO管理员角色");
								}
								if(!userDto.getUserId().equals(userVO.getUserId()) && sysRole.getRoleId() == 9){
									return R.failed("用户已存在CRO管理员角色,不能维护为其他经销商组织的CSO管理员角色");
								}
							}
						}
					}
				}

			} else if (userDto.getRole().contains(9)) {
				UserDTO userDTO = new UserDTO();
				userDTO.setPlatId(userDto.getUsername());
				userDTO.setDelFlag("0");
				List<UserVO> userDTOList = userService.getUserVoByPlatId(userDTO);
				if (userDTOList.size() > 0) {
					for (UserVO userVO : userDTOList) {
						if (null != userVO.getRoleList()) {
							for (SysRole sysRole : userVO.getRoleList()) {
								if (sysRole.getRoleId() == 2) {
									return R.failed("用户不能同时为平台管理员和CRO管理员");
								}

								if (sysRole.getRoleId() == 3) {
									return R.failed("用户不能同时为药企管理员和CRO管理员");
								}
								if(!userDto.getUserId().equals(userVO.getUserId()) && sysRole.getRoleId() == 4){
									return R.failed("用户已存在CSO管理员角色,不能维护为其他经销商组织的CRO管理员角色");
								}
								if(!userDto.getUserId().equals(userVO.getUserId()) && sysRole.getRoleId() == 9){
									return R.failed("用户已存在CRO管理员角色,不能维护为其他经销商组织的CRO管理员角色");
								}
							}
						}
					}
				}

			}else if (userDto.getRole().contains(6)) {
				UserDTO userDTO = new UserDTO();
				userDTO.setPlatId(userDto.getUsername());
				userDTO.setDelFlag("0");
				List<UserVO> userDTOList = userService.getUserVoByPlatId(userDTO);
				if (userDTOList.size() > 0) {
					for (UserVO userVO : userDTOList) {
						if (null != userVO.getRoleList()) {
							for (SysRole sysRole : userVO.getRoleList()) {
								if (sysRole.getRoleId() == 2) {
									return R.failed("用户不能同时为平台管理员和兼职学术推广员");
								}
								if (userDto.getDeptId().equals(userVO.getDeptId())) {
									if (sysRole.getRoleId() == 3) {
										return R.failed("用户已存在本药企药企管理员,不能同时为兼职学术推广员");
									}
								}
							}
						}
					}
				}

			} else {
				if (!userDto.getDeptId().equals(SecurityUtils.getUser().getDeptId())) {
					if (userDto.getRole().contains(5) || userDto.getRole().contains(6)) {
						return R.failed("不能跨机构维护学术推广员");
					}
				}
			}

		} else {
			if (!userDto.getDeptId().equals(SecurityUtils.getUser().getDeptId())) {
				if (userDto.getRole().contains(5) || userDto.getRole().contains(6)) {
					return R.failed("不能跨机构维护学术推广员");
				}
			}

			SysUser query = new SysUser();
			query.setUsername(userDto.getUsername());
			query.setDeptId(userDto.getDeptId());
			SysUser sysUser = sysUserMapper.selectUserByName(query);
			if (sysUser != null) {
				if (userDto.getRole().contains(6) && userDto.getRole().contains(4)) {
					return R.failed("用户不能同时为经销商管理员角色和兼职学术推广员角色");
				}
				if (userDto.getRole().contains(7) && userDto.getRole().contains(6)) {
					return R.failed("用户不能同时为财务管理员角色和兼职学术推广员角色");
				}
				if (userDto.getRole().contains(3)) {
					if (sysDept.getLevel() != 2) {
						return R.failed("角色选为药企管理员时,组织架构必须为药企");
					}
				}
			}
		}

		// 校验身份证上的年龄
		if (StringUtils.isNotEmpty(userDto.getIdCardNumber())) {
			// 获取更新操作的用户角色
			List<Integer> roles = userDto.getRole();
			// 如果角色中包含全职和兼职就需要校验身份证年龄
			if (roles.contains(5) || roles.contains(6)) {
				int ageByIdCard = IdcardUtil.getAgeByIdCard(userDto.getIdCardNumber());
				if (ageByIdCard < 18) {
					return R.failed("年龄未满十八");
				} else if (ageByIdCard > 65) {
					return R.failed("年龄已超过六十五");
				}
			}
		}

		return R.ok(userService.updateUser(userDto));
	}

	/**
	 * 分页查询用户
	 *
	 * @param page    参数集
	 * @param userDTO 查询参数列表
	 * @return 用户集合
	 */
	@GetMapping("/page")
	public R getUserPage(Page page, UserDTO userDTO) {

		return R.ok(userService.getUsersWithRolePageNoLock(page, userDTO));
	}

	/**
	 * 分页查询用户
	 *
	 * @param page    参数集
	 * @param userDTO 查询参数列表
	 * @return 用户集合
	 */
	@GetMapping("/selectUserList")
	public R selectUserList(Page page, UserDTO userDTO) {
		if(!"0".equals(userDTO.getSubType()) && !"1".equals(userDTO.getSubType())){
			userDTO.setSubType(null);
		}

		IPage<UserVO> userVosPage = userService.selectUserList(page, userDTO);
		if("0".equals(userDTO.getSubType())){
			List<UserVO> userDTOList = userVosPage.getRecords();
			userDTOList.forEach(item->item.setCertStatus(null));
		}
		if("1".equals(userDTO.getSubType())){
			List<UserVO> userDTOList = userVosPage.getRecords();
			userDTOList.forEach(item->item.setRljCertStatus(null));
		}
		return R.ok(userVosPage);
	}

	/**
	 * 修改个人信息
	 *
	 * @param userDto userDto
	 * @return success/false
	 */
	@SysLog("修改个人信息")
	@PutMapping("/edit")
	public R updateUserInfo(@Valid @RequestBody UserDTO userDto) {
		userDto.setUserId(SecurityUtils.getUser().getId());
		return userService.updateUserInfo(userDto);
	}

	/**
	 * @param username 用户名称
	 * @return 上级部门用户列表
	 */
	@GetMapping("/ancestor/{username}")
	public R listAncestorUsers(@PathVariable String username) {
		return R.ok(userService.listAncestorUsers(username));
	}

	/**
	 * 修改个人信息
	 *
	 * @param userDTO userDTO
	 * @return success/false
	 */
	@SysLog("查询用户列表")
	@GetMapping("/list")
	public R listScope(Page page, UserDTO userDTO) {
		if (null != userDTO.getRole() && userDTO.getRole().size() > 0) {
			userDTO.setDeptId(SecurityUtils.getUser().getDeptId());
			page.setSize(10000);
			List<UserVO> sysUserList = userService.getUsersWithRolePage(page, userDTO).getRecords();
			List<Map<String, String>> answerList = new ArrayList<>();
			if (sysUserList.size() > 0) {
				for (UserVO sysUser : sysUserList) {
					Map<String, String> map = new HashMap<>();
					map.put("id", sysUser.getUserId() + "");
					map.put("realname", sysUser.getRealname() + "");
					answerList.add(map);
				}

			}
			return R.ok(answerList);
		} else {
			page.setSize(10000);
			List<Integer> list = new ArrayList<>();
			list.add(5);
			list.add(6);
			userDTO.setRole(list);

			List<UserVO> sysUserList = userService.getUsersWithRolePage(page, userDTO).getRecords();
			List<Map<String, String>> answerList = new ArrayList<>();
			if (sysUserList.size() > 0) {
				for (UserVO sysUser : sysUserList) {
					Map<String, String> map = new HashMap<>();
					map.put("id", sysUser.getUserId() + "");
					map.put("realname", sysUser.getRealname() + "");
					answerList.add(map);
				}

			}
			return R.ok(answerList);
		}
	}

	/**
	 * 查询用户列表
	 *
	 * @param userDTO
	 * @return
	 */
	@SysLog("查询用户列表")
	@GetMapping("/listNoScope")
	public R listNoScope(UserDTO userDTO) {

		SysUser sysUserSel = new SysUser();

		if (SecurityUtils.getRoles().contains(2) || SecurityUtils.getRoles().contains(1)) {

		} else {
			sysUserSel.setDrugEntId(SecurityUtils.getUser().getDrugEntId());
		}
		QueryWrapper<SysUser> query = Wrappers.query(sysUserSel);
		if (StringUtils.isNotEmpty(userDTO.getRealname())) {
			query.lambda().like(SysUser::getRealname, userDTO.getRealname());
		}
		List<SysUser> sysUserList = userService.list(query);
		List<Map<String, String>> answerList = new ArrayList<>();
		if (sysUserList.size() > 0) {
			for (SysUser sysUser : sysUserList) {
				Map<String, String> map = new HashMap<>();
				map.put("id", sysUser.getUserId() + "");
				map.put("realname", sysUser.getRealname() + "");
				map.put("name", sysUser.getUsername() + "");

				answerList.add(map);
			}

		}
		return R.ok(answerList);
	}

	/**
	 * 修改个人信息
	 *
	 * @param userDTO userDTO
	 * @return success/false
	 */
	@SysLog("查询用户列表")
	@GetMapping("/listNoScopeAll")
	public R listNoScopeAll(Page page, UserDTO userDTO) {
		page.setSize(10000);
		QueryWrapper<SysUser> queryWrapper = null;
		if (userDTO.getDeptId() != null){
			SysUser sysUser = new SysUser();
			sysUser.setDeptId(userDTO.getDeptId());
			queryWrapper = Wrappers.query(sysUser);
		} else {
			queryWrapper = Wrappers.query();
		}

		List<SysUser> sysUserList = userService.list(queryWrapper);
		List<Map<String, String>> answerList = new ArrayList<>();
		if (sysUserList.size() > 0) {
			for (SysUser sysUser : sysUserList) {
				Map<String, String> map = new HashMap<>();
				map.put("id", sysUser.getUserId() + "");
				map.put("realname", sysUser.getRealname() + "");
				map.put("name", sysUser.getUsername() + "");

				answerList.add(map);
			}

		}
		return R.ok(answerList);
	}

}
