From 6ccbfd6a5192d432facf94b6fd91ae3dd26683e4 Mon Sep 17 00:00:00 2001
From: liyj <15602261488@163.com>
Date: Tue, 15 Oct 2024 15:20:26 +0800
Subject: [PATCH] Merge remote-tracking branch 'origin/gzdyh_test' into gzdyh_test
---
dyh-service/dyh-cust/src/main/java/cn/huge/module/ctuser/service/CtAccountService.java | 456 ++++++++++++++++++++++++++++++++++++++++++++++++++------
1 files changed, 402 insertions(+), 54 deletions(-)
diff --git a/dyh-service/dyh-cust/src/main/java/cn/huge/module/ctuser/service/CtAccountService.java b/dyh-service/dyh-cust/src/main/java/cn/huge/module/ctuser/service/CtAccountService.java
index 33acd57..87f5af2 100644
--- a/dyh-service/dyh-cust/src/main/java/cn/huge/module/ctuser/service/CtAccountService.java
+++ b/dyh-service/dyh-cust/src/main/java/cn/huge/module/ctuser/service/CtAccountService.java
@@ -1,133 +1,481 @@
package cn.huge.module.ctuser.service;
+import cn.huge.base.common.bo.R;
+import cn.huge.base.common.bo.ReturnBO;
import cn.huge.base.common.exception.ServiceException;
-import cn.huge.base.common.utils.DateUtils;
-import cn.huge.base.common.utils.IdUtils;
+import cn.huge.base.common.utils.*;
+import cn.huge.module.client.api.impl.SysClientImpl;
import cn.huge.module.client.api.impl.UtilsClientImpl;
import cn.huge.module.ctuser.dao.mapper.CtAccountMapper;
import cn.huge.module.ctuser.domain.po.CtAccount;
+import cn.huge.module.ctuser.domain.po.CtUnit;
+import cn.huge.module.ctuser.domain.po.CtUser;
+import cn.huge.module.ctuser.domain.po.CtUserole;
+import cn.huge.module.ctuser.dto.*;
+import cn.huge.module.cust.constant.UserBaseConsts;
+import cn.huge.module.sys.dto.GridTokenBaseDTO;
+import cn.huge.module.sys.dto.GridUserBaseDTO;
+import cn.huge.module.sys.dto.GridUserRoleDTO;
+import cn.huge.module.sys.vo.GridRoleMenuVo;
+import cn.huge.module.sys.vo.GridUserRoleVo;
+import cn.huge.module.utils.JwtUtils;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import lombok.extern.slf4j.Slf4j;
-import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageImpl;
import org.springframework.data.domain.PageRequest;
import org.springframework.transaction.annotation.Transactional;
+import org.springframework.util.DigestUtils;
-import javax.annotation.PostConstruct;
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;
/**
+ * @author liyj
+ * @version 1.0.0
* @title: 客户用户账号表业务逻辑处理
* @Description 客户用户账号表业务逻辑处理
* @company hugeinfo
- * @author liyj
* @Time 2024-08-19 20:04:18
- * @version 1.0.0
*/
@Slf4j
@Service
@Transactional(rollbackFor = Exception.class)
-public class CtAccountService extends ServiceImpl<CtAccountMapper, CtAccount>{
+public class CtAccountService extends ServiceImpl<CtAccountMapper, CtAccount> {
@Autowired
private CtAccountMapper mapper;
@Autowired
private UtilsClientImpl utilsClient;
+ @Autowired
+ private CtUserService ctUserService;
+ @Autowired
+ private CtUseroleService ctUseroleService;
+ @Autowired
+ private SysClientImpl sysClient;
+ @Autowired
+ private CtUnitService ctUnitService;
/**
- * 更新对象
- * @param entity 对象
- */
- public void updateCtAccount(CtAccount entity){
- try{
+ * 更新对象
+ *
+ * @param entity 对象
+ */
+ public void updateCtAccount(CtAccount entity) {
+ try {
mapper.updateCtAccount(entity);
- }catch (Exception e){
- log.error("[CtAccountService.updateCtAccount]调用失败，异常信息："+e, e);
+ } catch (Exception e) {
+ log.error("[CtAccountService.updateCtAccount]调用失败，异常信息：" + e, e);
throw new ServiceException("CtAccountService.updateCtAccount", e);
}
}
/**
- * 条件更新对象
- * @param entity 对象
- * @param terms 条件
- */
- public void updateCtAccountTerms(CtAccount entity, Map<String, Object> terms){
- try{
+ * 条件更新对象
+ *
+ * @param entity 对象
+ * @param terms 条件
+ */
+ public void updateCtAccountTerms(CtAccount entity, Map<String, Object> terms) {
+ try {
mapper.updateCtAccountTerms(entity, terms);
- }catch (Exception e){
- log.error("[CtAccountService.updateCtAccountTerms]调用失败，异常信息："+e, e);
+ } catch (Exception e) {
+ log.error("[CtAccountService.updateCtAccountTerms]调用失败，异常信息：" + e, e);
throw new ServiceException("CtAccountService.updateCtAccountTerms", e);
}
}
/**
- * 根据编号物理删除
- * @param id 查询条件集合
- */
- public void deleteCtAccount(String id){
- try{
+ * 根据编号物理删除
+ *
+ * @param id 查询条件集合
+ */
+ public void deleteCtAccount(String id) {
+ try {
mapper.deleteCtAccount(id);
- }catch (Exception e){
- log.error("[CtAccountService.deleteCtAccount]调用失败，异常信息："+e, e);
+ } catch (Exception e) {
+ log.error("[CtAccountService.deleteCtAccount]调用失败，异常信息：" + e, e);
throw new ServiceException("CtAccountService.deleteCtAccount", e);
}
}
/**
- * 按条件查询
- * @param terms 条件
- * @return List
- */
- public List<CtAccount> listTerms(Map<String, Object> terms){
+ * 按条件查询
+ *
+ * @param terms 条件
+ * @return List
+ */
+ public List<CtAccount> listTerms(Map<String, Object> terms) {
return mapper.listTerms(terms);
}
/**
- * 按条件统计
- * @param terms 条件
- * @return long
- */
- public long countTerms(Map<String, Object> terms){
+ * 按条件统计
+ *
+ * @param terms 条件
+ * @return long
+ */
+ public long countTerms(Map<String, Object> terms) {
return mapper.countTerms(terms);
}
/**
- * 按条件分页查询
- * @param page 分页对象
- * @param terms 条件
- * @return Page
- */
- public Page<CtAccount> pageQuery(PageRequest page, Map<String, Object> terms){
+ * 按条件分页查询
+ *
+ * @param page 分页对象
+ * @param terms 条件
+ * @return Page
+ */
+ public Page<CtAccount> pageQuery(PageRequest page, Map<String, Object> terms) {
long total = mapper.countTerms(terms);
List<CtAccount> content = mapper.pageTerms(page, terms);
return new PageImpl<CtAccount>(content, page, total);
}
/**
- * 新增或更新对象
- * @param ctAccount 实体对象
- */
- public void saveCtAccount(CtAccount ctAccount){
- try{
- Date nowDate = DateUtils.getMowDate();
+ * 新增或更新对象
+ *
+ * @param ctAccount 实体对象
+ */
+ public void saveCtAccount(CtAccount ctAccount) {
+ try {
+ Date nowDate = DateUtils.getNowDate();
// 判断是否新增
- if (IdUtils.checkNewId(ctAccount.getId())){
+ if (IdUtils.checkNewId(ctAccount.getId())) {
ctAccount.setId(utilsClient.getNewTimeId());
ctAccount.setCreateTime(nowDate);
}
ctAccount.setUpdateTime(nowDate);
this.saveOrUpdate(ctAccount);
- }catch (Exception e){
- log.error("[CtAccountService.saveCtAccount]调用失败，异常信息："+e, e);
+ } catch (Exception e) {
+ log.error("[CtAccountService.saveCtAccount]调用失败，异常信息：" + e, e);
throw new ServiceException("CtAccountService.saveCtAccount", e);
}
}
+ /**
+ * 根据账号和类型查询
+ *
+ * @param acc 账号
+ * @param accType 账号类型
+ * @return
+ */
+ public CtAccount getByAccAndType(String acc, int accType) {
+ QueryWrapper<CtAccount> accountWrapper = new QueryWrapper<>();
+ accountWrapper.eq("acc", acc)
+ .eq("acc_type", accType);
+ CtAccount ctAccount = this.getOne(accountWrapper);
+ return ctAccount;
+ }
+
+ /**
+ * 根据用户编号和类型查询
+ *
+ * @param userId 用户编号
+ * @param accType 账号类型
+ * @return
+ */
+ public CtAccount getByUserIdAndType(String userId, int accType) {
+ QueryWrapper<CtAccount> accountWrapper = new QueryWrapper<>();
+ accountWrapper.eq("user_id", userId)
+ .eq("acc_type", accType);
+ CtAccount ctAccount = this.getOne(accountWrapper);
+ return ctAccount;
+ }
+
+ /**
+ * 判断密码是否正确
+ *
+ * @param cipher 密码
+ * @param ctAccount 账号信息
+ * @return Boolean
+ */
+ public Boolean checkCredential(String cipher, CtAccount ctAccount) {
+ String credentialMd5 = DigestUtils.md5DigestAsHex(cipher.getBytes());
+ if (StringUtils.equals(credentialMd5, ctAccount.getCipher())) {
+ return true;
+ } else {
+ SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmss");
+ String createTime = sdf.format(ctAccount.getCreateTime());
+ String credentialTime = sdf.format(ctAccount.getCreateTime());
+ //是否修改过密码，未修改过可以用默认密码登录
+ if (createTime.equals(credentialTime)) {
+ if (cipher.equals(UserBaseConsts.MR_CIPHER)) {
+ return true;
+ } else {
+ return false;
+ }
+ } else {
+ return false;
+ }
+ }
+ }
+
+ /**
+ * web端-工作人员用户登录
+ *
+ * @param ctAccountLoginDTO 登录账号信息
+ * @return UserLoginDTO
+ */
+ public ReturnBO webLogin(CtAccountLoginDTO ctAccountLoginDTO) {
+ try {
+ // 判断账号密码是否为空
+ if (StringUtils.isBlank(ctAccountLoginDTO.getAcc()) || StringUtils.isBlank(ctAccountLoginDTO.getCipher())) {
+ return ReturnFailUtils.getRepInfo("账号或密码不能为空");
+ }
+ // 判断账号是否存在
+ CtAccount ctAccount = this.getByAccAndType(ctAccountLoginDTO.getAcc(), UserBaseConsts.ACC_TYPE_1);
+ if (ObjectUtils.isNotEmpty(ctAccount)) {
+ // 判断账号是否被锁定
+ if (ObjectUtils.isNotEmpty(ctAccount.getLimitTime())) {
+ Date nowDate = new Date();
+ if (nowDate.before(ctAccount.getLimitTime())) {
+ SimpleDateFormat sdf = new SimpleDateFormat("HH点mm分");
+ return ReturnFailUtils.getRepInfo("账号已锁定，请于" + sdf.format(ctAccount.getLimitTime()) + "后重试，或者请联系管理员解锁！");
+ }
+ }
+ // 判断密码是否正确
+ if (checkCredential(ctAccountLoginDTO.getCipher(), ctAccount)) {
+ //返回结果
+ UserLoginDTO userLoginDTO = new UserLoginDTO();
+ CtUser ctUser = ctUserService.getById(ctAccount.getUserId());
+ if (ObjectUtils.isEmpty(ctUser)) {
+ return ReturnFailUtils.getRepInfo("账号或密码错误，请确认后重试！");
+ }
+ if (ctUser.getStatus() != UserBaseConsts.USER_STATUS_1) {
+ return ReturnFailUtils.getRepInfo("账号或密码错误，请确认后重试！");
+ }
+ // 封装用户信息
+ userLoginDTO.setToken(JwtUtils.buildJWT(ctUser.getId()));
+ userLoginDTO.setUserId(ctUser.getId());
+ userLoginDTO.setTrueName(ctUser.getTrueName());
+ userLoginDTO.setUnit(ctUser.getUnitName());
+ userLoginDTO.setDept(ctUser.getDeptName());
+ userLoginDTO.setCustId(ctUser.getCustId());
+ // 登录用户角色
+ List<CtUserole> ctUseroleList = ctUseroleService.listByUserId(ctUser.getId());
+ userLoginDTO.setCtUseroleList(ctUseroleList);
+ // 登录用户地址信息
+ CtUserAddrDTO ctUserAddrDTO = new CtUserAddrDTO();
+ ctUserAddrDTO.setProv(ctUser.getProv());
+ ctUserAddrDTO.setProvName(ctUser.getProvName());
+ ctUserAddrDTO.setCity(ctUser.getCity());
+ ctUserAddrDTO.setCityName(ctUser.getCityName());
+ ctUserAddrDTO.setArea(ctUser.getArea());
+ ctUserAddrDTO.setAreaName(ctUser.getAreaName());
+ ctUserAddrDTO.setRoad(ctUser.getRoad());
+ ctUserAddrDTO.setRoadName(ctUser.getRoadName());
+ ctUserAddrDTO.setVillage(ctUser.getVillage());
+ ctUserAddrDTO.setVillageName(ctUser.getVillageName());
+ userLoginDTO.setCtUserAddrDTO(ctUserAddrDTO);
+ // 最后登录时间
+ Date loginTime = ctAccount.getLoginTime();
+ if (ObjectUtils.isEmpty(ctAccount.getLoginTime())) {
+ loginTime = DateUtils.getNowDate();
+ }
+ userLoginDTO.setLastLoginTime(loginTime);
+ // 更新最新登录时间
+ UpdateWrapper<CtAccount> accountUpdateWrapper = new UpdateWrapper<>();
+ accountUpdateWrapper.set("login_time", loginTime).eq("id", ctAccount.getId());
+ this.update(accountUpdateWrapper);
+ return ReturnSucUtils.getRepInfo(userLoginDTO);
+ } else {
+ return ReturnFailUtils.getRepInfo("账号或密码错误，请确认后重试！");
+ }
+ } else {
+ return ReturnFailUtils.getRepInfo("账号或密码错误，请确认后重试！");
+ }
+ } catch (Exception e) {
+ log.error("service方法[AccountService.webLogin]调用失败，异常信息：" + e, e);
+ throw new ServiceException("CtAccountService.webLogin", e);
+ }
+ }
+
+ /**
+ * web端-工作人员-修改密码
+ *
+ * @param userId 用户编号
+ * @param ctCipherDTO 修改密码信息
+ * @return
+ */
+ public ReturnBO webChangeCipher(String userId, CtCipherDTO ctCipherDTO) {
+ try {
+ CtUser loginUser = ctUserService.getById(userId);
+ CtAccount ctAccount = this.getByAccAndType(loginUser.getAcc(), UserBaseConsts.ACC_TYPE_1);
+// QueryWrapper<CtAccount> ctAccountQueryWrapper = new QueryWrapper<>();
+// ctAccountQueryWrapper.eq("user_id", loginUser.getId()).
+// eq("acc_type", UserBaseConsts.ACC_TYPE_1);
+// CtAccount ctAccount =mapper.selectOne(ctAccountQueryWrapper);
+ if (ObjectUtils.isEmpty(ctAccount)) {
+ return ReturnFailUtils.getRepInfo("输入账号或密码不正确，请确认后重试！");
+ }
+ String oldCredentialMd5 = DigestUtils.md5DigestAsHex(ctCipherDTO.getOldCipher().getBytes());
+ if (!StringUtils.equals(oldCredentialMd5, ctAccount.getCipher())) {
+ return ReturnFailUtils.getRepInfo("输入账号或密码不正确，请确认后重试！");
+ }
+ String newCredentialMd5 = DigestUtils.md5DigestAsHex(ctCipherDTO.getNewCipher().getBytes());
+ if (StringUtils.equals(newCredentialMd5, ctAccount.getCipher())) {
+ return ReturnFailUtils.getRepInfo("新密码不能和旧密码相同！");
+ }
+ UpdateWrapper<CtAccount> accountUpdateWrapper = new UpdateWrapper<>();
+ accountUpdateWrapper.set("cipher", newCredentialMd5).set("cipher_open", ctCipherDTO.getNewCipher())
+ .set("update_time", DateUtils.getNowDate()).eq("id", ctAccount.getId());
+ this.update(accountUpdateWrapper);
+ return ReturnSucUtils.getRepInfo();
+ } catch (Exception e) {
+ log.error("service方法[AccountService.webChangeCipher]调用失败，异常信息：" + e, e);
+ throw new ServiceException("CtAccountService.webChangeCipher", e);
+ }
+ }
+
+ /**
+ * web端-网格系统单点登录
+ *
+ * @param gridTokenBaseDTO 网格系统token
+ * @return UserLoginDTO
+ */
+ public ReturnBO webGridLogin(GridTokenBaseDTO gridTokenBaseDTO) {
+ try {
+ GridUserBaseDTO gridUserBaseDTO = sysClient.getUserInfo(gridTokenBaseDTO);
+
+ // 判断账号密码是否为空
+ if (ObjectUtils.isEmpty(gridUserBaseDTO)) {
+ return ReturnFailUtils.getRepInfo("gridToken已失效，请重新登录！");
+ }
+ // 判断账号是否存在
+ CtAccount ctAccount = null;
+ CtUser ctUser = null;
+ //如果和亿迅系统的手机号对不上，在用身份证号去查询用户，如果查询得到，就对得上，如果查询不到，就说明用户不存在
+ ctUser = ctUserService.getByIdCard(gridUserBaseDTO.getIdNumber());
+ if (ObjectUtils.isNotEmpty(ctUser)) {
+ ctAccount = this.getByUserIdAndType(ctUser.getId(), UserBaseConsts.ACC_TYPE_1);
+ }
+// CtAccount ctAccount = this.getByAccAndType(gridUserBaseDTO.getAccount(), UserBaseConsts.ACC_TYPE_1);
+// if (ObjectUtils.isEmpty(ctAccount)) {
+// ctAccount = this.getByAccAndType(gridUserBaseDTO.getMobile(), UserBaseConsts.ACC_TYPE_1);
+// }
+
+// if (ObjectUtils.isNotEmpty(ctAccount)) {
+// //返回结果
+// ctUser = ctUserService.getById(ctAccount.getUserId());
+// if (ObjectUtils.isEmpty(ctUser)) {
+// return ReturnFailUtils.getRepInfo("用户不存在！");
+// }
+// } else {
+//
+// }
+ if (ObjectUtils.isNotEmpty(ctUser)) {
+ //有对应用户，则模拟登录，返回对应信息
+ UserLoginDTO userLoginDTO = login(ctAccount, ctUser);
+ return ReturnSucUtils.getRepInfo(userLoginDTO);
+ } else {
+ //没有对应用户，创建用户，根据用户id获取用户信息
+ ReturnBO repInfo = initNewUser(gridUserBaseDTO);
+ if (repInfo.getCode() == 0) {
+ //创建用户成功，模拟登录
+ ctUser = ctUserService.getByIdCard(gridUserBaseDTO.getIdNumber());
+ if (ObjectUtils.isNotEmpty(ctUser)) {
+ ctAccount = this.getByUserIdAndType(ctUser.getId(), UserBaseConsts.ACC_TYPE_1);
+ }
+ UserLoginDTO userLoginDTO = login(ctAccount, ctUser);
+ return ReturnSucUtils.getRepInfo(userLoginDTO);
+ } else {
+ //创建用户失败，返回失败信息
+ return repInfo;
+ }
+
+ }
+ } catch (Exception e) {
+ log.error("service方法[AccountService.webGridLogin]调用失败，异常信息：" + e, e);
+ throw new ServiceException("CtAccountService.webGridLogin", e);
+ }
+ }
+
+ private UserLoginDTO login(CtAccount ctAccount, CtUser ctUser) {
+ UserLoginDTO userLoginDTO = new UserLoginDTO();
+ // 封装用户信息
+ userLoginDTO.setToken(JwtUtils.buildJWT(ctUser.getId()));
+ userLoginDTO.setUserId(ctUser.getId());
+ userLoginDTO.setTrueName(ctUser.getTrueName());
+ userLoginDTO.setUnit(ctUser.getUnitName());
+ userLoginDTO.setDept(ctUser.getDeptName());
+ userLoginDTO.setCustId(ctUser.getCustId());
+ // 登录用户角色
+ List<CtUserole> ctUseroleList = ctUseroleService.listByUserId(ctUser.getId());
+ userLoginDTO.setCtUseroleList(ctUseroleList);
+ // 登录用户地址信息
+ CtUserAddrDTO ctUserAddrDTO = new CtUserAddrDTO();
+ ctUserAddrDTO.setProv(ctUser.getProv());
+ ctUserAddrDTO.setProvName(ctUser.getProvName());
+ ctUserAddrDTO.setCity(ctUser.getCity());
+ ctUserAddrDTO.setCityName(ctUser.getCityName());
+ ctUserAddrDTO.setArea(ctUser.getArea());
+ ctUserAddrDTO.setAreaName(ctUser.getAreaName());
+ ctUserAddrDTO.setRoad(ctUser.getRoad());
+ ctUserAddrDTO.setRoadName(ctUser.getRoadName());
+ ctUserAddrDTO.setVillage(ctUser.getVillage());
+ ctUserAddrDTO.setVillageName(ctUser.getVillageName());
+ userLoginDTO.setCtUserAddrDTO(ctUserAddrDTO);
+ // 最后登录时间
+ Date loginTime = new Date();
+ userLoginDTO.setLastLoginTime(loginTime);
+ // 更新最新登录时间
+ UpdateWrapper<CtAccount> accountUpdateWrapper = new UpdateWrapper<>();
+ accountUpdateWrapper.set("login_time", loginTime).eq("id", ctAccount.getId());
+ this.update(accountUpdateWrapper);
+ return userLoginDTO;
+ }
+
+ private ReturnBO initNewUser(GridUserBaseDTO gridUserBaseDTO) {
+ String userId = gridUserBaseDTO.getId();
+ //拿到用户机构信息
+ GridUserRoleVo gridUserRoleVo = new GridUserRoleVo();
+ gridUserRoleVo.setUserId(userId);
+ GridUserRoleDTO userRoleDTO = sysClient.getUserRoleList(gridUserRoleVo);
+ if (StringUtils.isEmpty(userRoleDTO.getOrgName())) {
+ return ReturnFailUtils.getRepInfo("用户不存在！，请确认后重试！");
+ }
+ if (StringUtils.isNotEmpty(userRoleDTO.getOrgName()) && userRoleDTO.getOrgName().endsWith("网格")) {
+ return ReturnFailUtils.getRepInfo("该用户所在机构禁止登录矛调系统，请切换该用户机构为区、镇街、社区机构");
+ }
+ //拿到用户角色菜单权限信息
+ GridRoleMenuVo gridRoleMenuVo = new GridRoleMenuVo();
+ gridRoleMenuVo.setOrgRoleId(userRoleDTO.getRoleId());
+ gridRoleMenuVo.setMenuSys("sub-mdjfhj");
+ CtUserole roleMenu = sysClient.getRoleMenu(gridRoleMenuVo);
+ if (roleMenu == null || StringUtils.isEmpty(roleMenu.getRoleId())) {
+ return ReturnFailUtils.getRepInfo("该用户没有矛调系统的权限");
+ }
+ List<CtUserole> ctUseroles = new ArrayList<>();
+ ctUseroles.add(roleMenu);
+ log.info("xsd:roleMenu:{}", roleMenu);
+ CtUnit ctUnit = ctUnitService.selectUnitByGridId(userRoleDTO.getOrgId());
+ log.info("xsd:newuser:{}", ctUnit);
+ if (ctUnit != null && StringUtils.isNotEmpty(ctUnit.getId())) {
+ CtUserSaveDTO ctUserSaveDTO = new CtUserSaveDTO();
+ ctUserSaveDTO.setUnitId(ctUnit.getId());
+ ctUserSaveDTO.setUnitName(ctUnit.getUnitName());
+ ctUserSaveDTO.setCipher("byzfw2023!");
+ ctUserSaveDTO.setAcc(gridUserBaseDTO.getMobile());
+ ctUserSaveDTO.setTrueName(gridUserBaseDTO.getName());
+ ctUserSaveDTO.setMobile(gridUserBaseDTO.getMobile());
+ ctUserSaveDTO.setIdcard(gridUserBaseDTO.getIdNumber());
+ ctUserSaveDTO.setCtUseroleList(ctUseroles);
+ ctUserService.webSaveCtUser(ctUserSaveDTO, "-1");
+ log.info("xsd:ctUserSaveDTO:{}", ctUserSaveDTO);
+ } else {
+ return ReturnFailUtils.getRepInfo("该用户所属机构不允许登录矛调系统！请调整机构后重试！");
+ }
+ return ReturnSucUtils.getRepInfo("创建账号成功");
+ }
+
}
--
Gitblit v1.8.0