Merge branch 'dev' of http://192.168.2.240:7070/r/kidgrow-microservices-pla...

zhaoxiaohao

2020-06-19 04c359a40d51c391fdfea626e7f147422a33b89f

Merge branch 'dev' of http://192.168.2.240:7070/r/kidgrow-microservices-platform into dev

 kidgrow-business/kidgrow-filecenter/kidgrow-filecenter-biz/src/main/java/com/kidgrow/filecenter/service/impl/AbstractIFileService.java

@@ -157,12 +157,12 @@
                newfileInfo.setCreateTime(new Date());
                //文件上传到oss
                this.fileUpLoadOss(newfileInfo,filefloder+newFileName,inputStream);
                inputStream.close();
                //删除暂存文件
                MultipartFileUtils.delteTempFile(thuFile);
                // 将文件信息保存到数据库
                baseMapper.insert(newfileInfo);
                fileInfo.setPath(newfileInfo.getUrl());
                //删除暂存文件
                MultipartFileUtils.delteTempFile(thuFile);
                inputStream.close();
            }
            return fileInfo;
        }

 kidgrow-business/kidgrow-opration-center/kidgrow-opration-center-api/src/main/java/com/kidgrow/oprationcenter/model/BusinessRecords.java

@@ -2,6 +2,8 @@

import com.baomidou.mybatisplus.annotation.TableLogic;
import com.baomidou.mybatisplus.annotation.TableName;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
import com.kidgrow.common.model.SuperModel;
import lombok.AllArgsConstructor;
import lombok.Data;
@@ -34,6 +36,7 @@
    /**
     * 操作人ID
     */
    @JsonSerialize(using = ToStringSerializer.class)
    private Long userId;
    /**
     * 操作人姓名

 kidgrow-business/kidgrow-opration-center/kidgrow-opration-center-api/src/main/java/com/kidgrow/oprationcenter/model/BusinessServer.java

@@ -2,14 +2,17 @@

import com.baomidou.mybatisplus.annotation.TableLogic;
import com.baomidou.mybatisplus.annotation.TableName;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
import com.kidgrow.common.model.SuperModel;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.NoArgsConstructor;
import org.hibernate.validator.constraints.NotBlank;
import org.hibernate.validator.constraints.NotEmpty;

import javax.validation.constraints.NotNull;
import java.util.Date;

/**
@@ -32,17 +35,19 @@
    /**
     * 科室ID
     */
    @JsonSerialize(using = ToStringSerializer.class)
    @NotEmpty(message = "科室ID不能为空")
    private Long departmentId;
    /**
     * 医生账户数量
     */
    @NotEmpty(message = "医生账户数量不能为空")
    @NotNull(message = "医生账户数量不能为空")
    private Integer doctorCount;
    /**
     * 服务到期时间
     */
    @NotEmpty(message = "服务到期时间不能为空")
    @NotNull(message = "服务到期时间不能为空")
    @JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
    private Date serverEndDate;
    /**
     * 累积读片量

 kidgrow-business/kidgrow-opration-center/kidgrow-opration-center-api/src/main/java/com/kidgrow/oprationcenter/model/DataNeed.java

@@ -1,7 +1,9 @@
package com.kidgrow.oprationcenter.model;

import com.baomidou.mybatisplus.annotation.TableLogic;
import com.baomidou.mybatisplus.annotation.TableName;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
import com.kidgrow.common.model.SuperModel;
import lombok.AllArgsConstructor;
import lombok.Data;
@@ -9,6 +11,7 @@
import lombok.NoArgsConstructor;
import org.hibernate.validator.constraints.NotEmpty;

import javax.validation.constraints.NotNull;
import java.util.Date;

/**
@@ -31,12 +34,13 @@
    /**
     * 需求类型 0就诊数据 1筛查
     */
    @NotEmpty(message = "需求类型 0就诊数据 1筛查不能为空")
    @NotNull(message = "需求类型 0就诊数据 1筛查不能为空")
    private Integer needType;
    /**
     * 提需求的医生
     */
    @NotEmpty(message = "提需求的医生不能为空")
    @JsonSerialize(using = ToStringSerializer.class)
    @NotNull(message = "提需求的医生不能为空")
    private Long doctorId;
    /**
     * 医生姓名
@@ -44,9 +48,19 @@
    @NotEmpty(message = "医生姓名不能为空")
    private String doctorName;
    /**
     * 医院id
     */
    @JsonSerialize(using = ToStringSerializer.class)
    private Long hospitalId;
    /**
     * 医院名称
     */
    private String hospitalName;
    /**
     * 科室id
     */
    @JsonSerialize(using = ToStringSerializer.class)
    private Long departmentId;
    /**
     * 科室名称
     */
@@ -58,12 +72,14 @@
    /**
     * 需求数据的开始时间
     */
    @NotEmpty(message = "需求数据的开始时间不能为空")
    @NotNull(message = "需求数据的开始时间不能为空")
    @JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
    private Date needBegintime;
    /**
     * 需求数据的结束时间
     */
    @NotEmpty(message = "需求数据的结束时间不能为空")
    @NotNull(message = "需求数据的结束时间不能为空")
    @JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
    private Date needEndtime;
    /**
     * 需求标签
@@ -73,7 +89,6 @@
    /**
     * 是否删除，1删除（已下载），0未删除（未下载）
     */
    @TableLogic
    private Boolean isDel;
    /**
     * 文件路径
@@ -82,6 +97,7 @@
    /**
     * 下载时间
     */
    @JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
    private Date downTime;
    /**
     * 状态，1已上传了数据文件，0未处理

 kidgrow-business/kidgrow-opration-center/kidgrow-opration-center-api/src/main/java/com/kidgrow/oprationcenter/model/DoctorTemplete.java

@@ -1,7 +1,8 @@
package com.kidgrow.oprationcenter.model;

import com.baomidou.mybatisplus.annotation.TableLogic;
import com.baomidou.mybatisplus.annotation.TableName;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
import com.kidgrow.common.model.SuperModel;
import lombok.AllArgsConstructor;
import lombok.Data;
@@ -29,6 +30,7 @@
    /**
     * 医院标识id
     */
    @JsonSerialize(using = ToStringSerializer.class)
    private Long hospitalId;
    /**
     * 医院名称
@@ -37,6 +39,7 @@
    /**
     * 科室ID
     */
    @JsonSerialize(using = ToStringSerializer.class)
    private Long departmentId;
    /**
     * 科室名称
@@ -45,6 +48,7 @@
    /**
     * 医生id
     */
    @JsonSerialize(using = ToStringSerializer.class)
    private Long doctorId;
    /**
     * 医生姓名

 kidgrow-business/kidgrow-opration-center/kidgrow-opration-center-api/src/main/java/com/kidgrow/oprationcenter/model/HospitalScreening.java

@@ -2,12 +2,16 @@

import com.baomidou.mybatisplus.annotation.TableLogic;
import com.baomidou.mybatisplus.annotation.TableName;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
import com.kidgrow.common.model.SuperModel;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.NoArgsConstructor;
import org.hibernate.validator.constraints.NotEmpty;

import javax.validation.constraints.NotNull;

/**
 * 石家庄喜高科技有限责任公司 版权所有 © Copyright 2020<br>
@@ -29,7 +33,8 @@
    /**
     * 医院ID
     */
    @NotEmpty(message = "医院ID不能为空")
    @NotNull(message = "医院ID不能为空")
    @JsonSerialize(using = ToStringSerializer.class)
    private Long hospitalId;
    /**
     * 医院名称

 kidgrow-business/kidgrow-opration-center/kidgrow-opration-center-api/src/main/java/com/kidgrow/oprationcenter/model/ProductOrder.java

@@ -2,6 +2,9 @@

import com.baomidou.mybatisplus.annotation.TableLogic;
import com.baomidou.mybatisplus.annotation.TableName;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
import com.kidgrow.common.model.SuperModel;
import lombok.AllArgsConstructor;
import lombok.Data;
@@ -33,6 +36,7 @@
     * 医院标识id
     */
    @NotNull(message = "医院标识id不能为空")
    @JsonSerialize(using = ToStringSerializer.class)
    private Long hospitalId;
    /**
     * 医院名称
@@ -43,6 +47,7 @@
     * 科室ID
     */
    @NotNull(message = "科室ID不能为空")
    @JsonSerialize(using = ToStringSerializer.class)
    private Long departmentId;
    /**
     * 科室名称
@@ -62,14 +67,17 @@
    /**
     * 合同开始时间
     */
    @JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
    private Date contractBeginTime;
    /**
     * 合同结束时间
     */
    @JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
    private Date contractEndTime;
    /**
     * 合同签订日期
     */
    @JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
    private Date contractTime;
    /**
     * 是否删除，1删除，0未删除

 kidgrow-business/kidgrow-opration-center/kidgrow-opration-center-api/src/main/java/com/kidgrow/oprationcenter/model/ProductOrderDetail.java

@@ -2,6 +2,9 @@

import com.baomidou.mybatisplus.annotation.TableLogic;
import com.baomidou.mybatisplus.annotation.TableName;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
import com.kidgrow.common.model.SuperModel;
import lombok.AllArgsConstructor;
import lombok.Data;
@@ -33,11 +36,13 @@
     * 对应product_order表中的id
     */
    @NotEmpty(message = "对应product_order表中的id不能为空")
    @JsonSerialize(using = ToStringSerializer.class)
    private Long orderId;
    /**
     * 产品/明细ID
     */
    @NotEmpty(message = "产品/明细ID不能为空")
    @JsonSerialize(using = ToStringSerializer.class)
    private Long proId;
    /**
     * 产品/明细名称
@@ -63,20 +68,22 @@
    /**
     * 读片量
     */
    @NotEmpty(message = "读片量不能为空")
    @NotNull(message = "读片量不能为空")
    private Integer ailightCount;
    /**
     * 报告量
     */
    @NotEmpty(message = "报告量不能为空")
    @NotNull(message = "报告量不能为空")
    private Integer recordCount;
    /**
     * 有效的开始时间
     */
    @JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
    private Date proBegintime;
    /**
     * 有效的结束时间
     */
    @JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
    private Date proEndtime;
    /**
     * 状态，1启用，0停用

 kidgrow-business/kidgrow-opration-center/kidgrow-opration-center-api/src/main/java/com/kidgrow/oprationcenter/model/ProductOrderRecord.java

@@ -2,6 +2,9 @@

import com.baomidou.mybatisplus.annotation.TableLogic;
import com.baomidou.mybatisplus.annotation.TableName;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
import com.kidgrow.common.model.SuperModel;
import lombok.AllArgsConstructor;
import lombok.Data;
@@ -32,12 +35,14 @@
    /**
     * 对应product_order表中的id
     */
    @NotEmpty(message = "对应product_order表中的id不能为空")
    @NotNull(message = "对应product_order表中的id不能为空")
    @JsonSerialize(using = ToStringSerializer.class)
    private Long orderId;
    /**
     * 产品/明细ID
     */
    @NotEmpty(message = "产品/明细ID不能为空")
    @NotNull(message = "产品/明细ID不能为空")
    @JsonSerialize(using = ToStringSerializer.class)
    private Long proId;
    /**
     * 产品/明细名称
@@ -63,20 +68,22 @@
    /**
     * 读片量
     */
    @NotEmpty(message = "读片量不能为空")
    @NotNull(message = "读片量不能为空")
    private Integer ailightCount;
    /**
     * 报告量
     */
    @NotEmpty(message = "报告量不能为空")
    @NotNull(message = "报告量不能为空")
    private Integer recordCount;
    /**
     * 有效的开始时间
     */
    @JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
    private Date proBegintime;
    /**
     * 有效的结束时间
     */
    @JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
    private Date proEndtime;
    /**
     * 状态，1启用，0停用

 kidgrow-business/kidgrow-opration-center/kidgrow-opration-center-api/src/main/java/com/kidgrow/oprationcenter/model/SysFeedback.java

@@ -2,12 +2,16 @@

import com.baomidou.mybatisplus.annotation.TableLogic;
import com.baomidou.mybatisplus.annotation.TableName;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
import com.kidgrow.common.model.SuperModel;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.NoArgsConstructor;
import org.hibernate.validator.constraints.NotEmpty;

import javax.validation.constraints.NotNull;

/**
 * 石家庄喜高科技有限责任公司 版权所有 © Copyright 2020<br>
@@ -29,7 +33,8 @@
    /**
     * 提需求的医生
     */
    @NotEmpty(message = "提需求的医生不能为空")
    @JsonSerialize(using = ToStringSerializer.class)
    @NotNull(message = "提需求的医生不能为空")
    private Long doctorId;
    /**
     * 医生姓名
@@ -43,7 +48,8 @@
    /**
     * 科室ID
     */
    @NotEmpty(message = "科室ID不能为空")
    @JsonSerialize(using = ToStringSerializer.class)
    @NotNull(message = "科室ID不能为空")
    private Long departmentId;
    /**
     * 科室名称
@@ -53,7 +59,8 @@
    /**
     * 医院标识id
     */
    @NotEmpty(message = "医院标识id不能为空")
    @JsonSerialize(using = ToStringSerializer.class)
    @NotNull(message = "医院标识id不能为空")
    private Long hospitalId;
    /**
     * 医院名称

 kidgrow-business/kidgrow-opration-center/kidgrow-opration-center-api/src/main/java/com/kidgrow/oprationcenter/model/SysProduct.java

@@ -2,6 +2,7 @@

import com.baomidou.mybatisplus.annotation.TableLogic;
import com.baomidou.mybatisplus.annotation.TableName;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.kidgrow.common.model.SuperModel;
import lombok.AllArgsConstructor;
import lombok.Data;
@@ -77,10 +78,12 @@
    /**
     * 产品结束时间-供前端使用
     */
    @JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
    private Date endTime;
    /**
     * 产品结束时间-供前端使用
     */
    @JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
    private Date beginTime;
    /**
     * 共享，1是，0不

 kidgrow-business/kidgrow-opration-center/kidgrow-opration-center-api/src/main/java/com/kidgrow/oprationcenter/vo/ProductOrderJoinDetail.java

@@ -2,6 +2,7 @@

import com.baomidou.mybatisplus.annotation.TableLogic;
import com.baomidou.mybatisplus.extension.activerecord.Model;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
import lombok.AllArgsConstructor;
@@ -83,14 +84,17 @@
    /**
     * 有效的开始时间
     */
    @JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
    private Date proBegintime;
    /**
     * 有效的结束时间
     */
    @JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
    private Date proEndtime;
    /**
     *创建时间
     */
    @JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
    private Date createTime;
    /**
     * 是否删除，1删除，0未删除

 kidgrow-business/kidgrow-opration-center/kidgrow-opration-center-biz/src/main/java/com/kidgrow/oprationcenter/mapper/DataNeedMapper.java

@@ -24,6 +24,12 @@
     * @return
     */
    List<DataNeed> findList(Page<DataNeed> page, @Param("p") Map<String, Object> params);
    /**
     * 查询医生的数据需求列表 不分页
     * @param params
     * @return
     */
    List<DataNeed> findHList(@Param("p") Map<String, Object> params);

    /**
     * 根据DataNeed对象当做查询条件进行查询

 kidgrow-business/kidgrow-opration-center/kidgrow-opration-center-biz/src/main/java/com/kidgrow/oprationcenter/service/IDataNeedService.java

@@ -1,6 +1,7 @@
package com.kidgrow.oprationcenter.service;

import com.kidgrow.common.model.ResultBody;
import com.kidgrow.common.model.SysUser;
import com.kidgrow.oprationcenter.model.DataNeed;
import com.kidgrow.common.model.PageResult;
import com.kidgrow.common.service.ISuperService;
@@ -44,5 +45,17 @@
     *更新状态和文件地址
     */
    ResultBody updateEnabled(Map<String, Object> map);

    /**
     * 用户点击下载后，下载成功需要调用这个接口更新状态
     * @param id
     * @return
     */
    ResultBody updateDelete(Long id, SysUser sysUser);
    /**
     *获取某个医院的所有需求数据
     */
    ResultBody FindAllByHId(Map<String, Object> map, SysUser sysUser);

}


 kidgrow-business/kidgrow-opration-center/kidgrow-opration-center-biz/src/main/java/com/kidgrow/oprationcenter/service/impl/DataNeedServiceImpl.java

@@ -1,22 +1,23 @@
package com.kidgrow.oprationcenter.service.impl;

import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.kidgrow.common.model.PageResult;
import com.kidgrow.common.model.ResultBody;
import com.kidgrow.common.model.SysUser;
import com.kidgrow.common.service.impl.SuperServiceImpl;
import com.kidgrow.oprationcenter.mapper.DataNeedMapper;
import com.kidgrow.oprationcenter.model.DataNeed;
import com.kidgrow.oprationcenter.service.IDataNeedService;
import com.kidgrow.oprationcenter.vo.DataNeedExcel;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.MapUtils;
import org.springframework.cglib.beans.BeanCopier;
import org.springframework.stereotype.Service;
import com.kidgrow.common.model.PageResult;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.kidgrow.common.service.impl.SuperServiceImpl;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;
import org.apache.commons.collections4.MapUtils;
import lombok.extern.slf4j.Slf4j;

import com.kidgrow.oprationcenter.model.DataNeed;
import com.kidgrow.oprationcenter.mapper.DataNeedMapper;
import com.kidgrow.oprationcenter.service.IDataNeedService;

/**
 * 石家庄喜高科技有限责任公司 版权所有 © Copyright 2020<br>
@@ -83,4 +84,34 @@
            return ResultBody.ok();
        }
    }
    @Override
    public ResultBody updateDelete(Long id,SysUser sysUser) {
        if(id==null){
            return ResultBody.failed("请选择一条数据");
        }else {
            DataNeed dataNeed = baseMapper.selectById(id);
            if (dataNeed != null) {
                dataNeed.setIsDel(true);
                dataNeed.setUpdateTime(new Date());
                dataNeed.setUpdateUserId(sysUser.getId());
                dataNeed.setUpdateUserName(sysUser.getUsername());
                int u=baseMapper.updateById(dataNeed);
                return ResultBody.ok().data(u>0);
            }else {
                return ResultBody.failed("查找数据失败");
            }
        }
    }

    @Override
    public ResultBody FindAllByHId(Map<String, Object> map, SysUser sysUser) {
        if (sysUser != null&&sysUser.isHAdminUser()) {
            List<DataNeed> dataNeedList=baseMapper.findHList(map);
            return ResultBody.ok().data(dataNeedList);
        }
        else
        {
            return ResultBody.failed("非管理用户无权查看");
        }
    }
}

 kidgrow-business/kidgrow-opration-center/kidgrow-opration-center-biz/src/main/resources/mapper/DataNeedMapper.xml

@@ -11,7 +11,6 @@
    <sql id="where">
        <where>
            <!--查询条件自行添加-->
            is_del=0
            <if test="p.id != null and p.id !=''">
                and id = #{p.id}
            </if>
@@ -24,8 +23,14 @@
            <if test="p.doctorName != null and p.doctorName !=''">
                and doctor_name like '%${p.doctorName}%'
            </if>
            <if test="p.hospitalId != null and p.hospitalId !=''">
                and hospital_id = #{p.hospitalId}
            </if>
            <if test="p.hospitalName != null and p.hospitalName !=''">
                and hospital_name = #{p.hospitalName}
            </if>
            <if test="p.departmentId != null and p.departmentId !=''">
                and department_id = #{p.departmentId}
            </if>
            <if test="p.departmentName != null and p.departmentName !=''">
                and department_name = #{p.departmentName}
@@ -93,4 +98,16 @@
        <include refid="where"/>
        order by id desc
    </select>
    <!--定义根据-DataNeed当作查询条件返回对象集合-->
    <select id="findHList" resultType="com.kidgrow.oprationcenter.model.DataNeed">
        select
        <include refid="H_Column_List"/>
        from data_need
        <include refid="where"/>
        order by id desc
    </select>
    <!--定义查询列-->
    <sql id="H_Column_List">
       id,need_type,doctor_name,hospital_id,department_id,need_begintime,need_endtime,data_file,down_time,enabled
    </sql>
</mapper>

 kidgrow-business/kidgrow-opration-center/kidgrow-opration-center-server/src/main/java/com/kidgrow/oprationcenter/controller/DataNeedController.java

@@ -1,8 +1,10 @@
package com.kidgrow.oprationcenter.controller;

import com.kidgrow.common.annotation.LoginUser;
import com.kidgrow.common.controller.BaseController;
import com.kidgrow.common.model.PageResult;
import com.kidgrow.common.model.ResultBody;
import com.kidgrow.common.model.SysUser;
import com.kidgrow.common.utils.ExcelUtil;
import com.kidgrow.oprationcenter.model.DataNeed;
import com.kidgrow.oprationcenter.service.IDataNeedService;
@@ -55,7 +57,14 @@
        }
        return dataNeedService.findList(params);
    }

    /**
     * H端列表  需要医院和科室id
     */
    @ApiOperation(value = "H端列表,需要医院和科室id")
    @GetMapping("/hlist")
    public ResultBody list(@RequestParam Map<String, Object> params, @LoginUser(isFull = true)SysUser sysUser) {
        return dataNeedService.FindAllByHId(params,sysUser);
    }
    /**
     * 查询
     */
@@ -68,11 +77,19 @@
    /**
     *更新状态和文件地址
     */
    @ApiOperation(value = "查询")
    @ApiOperation(value = "更新状态和文件地址")
    @GetMapping("updateEnabled")
    public ResultBody updateEnabled(@RequestParam Map<String,Object> map) {
        return dataNeedService.updateEnabled(map);
    }
    /**
     *更新使用状态
     */
    @ApiOperation(value = "更新使用状态")
    @GetMapping("updateDelete")
    public ResultBody updateDelete(@RequestParam Long id,@LoginUser(isFull = true) SysUser sysUser) {
        return dataNeedService.updateDelete(id,sysUser);
    }

    /**
     * 根据DataNeed当做查询条件进行查询

 kidgrow-business/kidgrow-usercenter/kidgrow-usercenter-api/src/main/java/com/kidgrow/usercenter/model/SysArea.java

@@ -3,6 +3,8 @@
import com.baomidou.mybatisplus.annotation.TableLogic;
import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.extension.activerecord.Model;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.EqualsAndHashCode;
@@ -28,6 +30,7 @@
    /**
     * 区域id
     */
    @JsonSerialize(using = ToStringSerializer.class)
    private Long id;
    /**
     * 区域名称
@@ -37,6 +40,7 @@
    /**
     * 父级区域id
     */
    @JsonSerialize(using = ToStringSerializer.class)
    private Long areaParentId;
    /**
     * 简称

 kidgrow-business/kidgrow-usercenter/kidgrow-usercenter-api/src/main/java/com/kidgrow/usercenter/model/SysDepartment.java

@@ -86,4 +86,8 @@
     * 销售代表电话
     */
    private String saleUserTel;
    /**
     * 帐号数量,默认6
     */
    private Integer accountsCount;
}

 kidgrow-business/kidgrow-usercenter/kidgrow-usercenter-api/src/main/java/com/kidgrow/usercenter/model/SysDoctor.java

@@ -33,6 +33,7 @@
    /**
     * 关联的登录帐号ID
     */
    @JsonSerialize(using = ToStringSerializer.class)
    private Long userId;
    /**
     * 所属医院ID

 kidgrow-business/kidgrow-usercenter/kidgrow-usercenter-api/src/main/java/com/kidgrow/usercenter/model/SysMenu.java

@@ -1,12 +1,16 @@
package com.kidgrow.usercenter.model;

import com.baomidou.mybatisplus.annotation.TableName;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
import com.kidgrow.common.model.SuperModel;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.NoArgsConstructor;
import org.hibernate.validator.constraints.NotEmpty;

import javax.validation.constraints.NotNull;

/**
 * 石家庄喜高科技有限责任公司 版权所有 © Copyright 2020<br>
@@ -28,7 +32,8 @@
    /**
     * 父ID
     */
    @NotEmpty(message = "父ID不能为空")
    @NotNull(message = "父ID不能为空")
    @JsonSerialize(using = ToStringSerializer.class)
    private Long parentId;
    /**
     * 菜单名称
@@ -54,22 +59,22 @@
    /**
     * 排序
     */
    @NotEmpty(message = "排序不能为空")
    @NotNull(message = "排序不能为空")
    private Integer sort;
    /**
     * 类型，1菜单，2API资源
     */
    @NotEmpty(message = "类型，1菜单，2API资源不能为空")
    @NotNull(message = "类型，1菜单，2API资源不能为空")
    private Integer type;
    /**
     * 是否显示
     */
    @NotEmpty(message = "是否显示不能为空")
    @NotNull(message = "是否显示不能为空")
    private Integer hidden;
    /**
     * 是否删除，1删除，0未删除
     */
    @NotEmpty(message = "是否删除，1删除，0未删除不能为空")
    @NotNull(message = "是否删除，1删除，0未删除不能为空")
    private Integer isDel;
    /**
     * 租户字段
@@ -78,6 +83,6 @@
    /**
     * 是否启用，1启用，0停用
     */
    @NotEmpty(message = "是否启用，1启用，0停用不能为空")
    @NotNull(message = "是否启用，1启用，0停用不能为空")
    private Integer enabled;
}

 kidgrow-business/kidgrow-usercenter/kidgrow-usercenter-api/src/main/java/com/kidgrow/usercenter/model/SysRole.java

@@ -8,6 +8,8 @@
import lombok.NoArgsConstructor;
import org.hibernate.validator.constraints.NotEmpty;

import javax.validation.constraints.NotNull;

/**
 * 石家庄喜高科技有限责任公司 版权所有 © Copyright 2020<br>
 *
@@ -38,7 +40,7 @@
    /**
     * 是否删除，1删除，0未删除
     */
    @NotEmpty(message = "是否删除，1删除，0未删除不能为空")
    @NotNull(message = "是否删除，1删除，0未删除不能为空")
    private Integer isDel;
    /**
     * 租户字段
@@ -47,7 +49,7 @@
    /**
     * 状态，1启用，0停用
     */
    @NotEmpty(message = "状态，1启用，0停用不能为空")
    @NotNull(message = "状态，1启用，0停用不能为空")
    private Integer enabled;

}

 kidgrow-business/kidgrow-usercenter/kidgrow-usercenter-api/src/main/java/com/kidgrow/usercenter/model/SysUser.java

@@ -8,6 +8,8 @@
import lombok.NoArgsConstructor;
import org.hibernate.validator.constraints.NotEmpty;

import javax.validation.constraints.NotNull;

/**
 * 石家庄喜高科技有限责任公司 版权所有 © Copyright 2020<br>
 *
@@ -50,7 +52,7 @@
    /**
     * 是否启用，1启用，0停用
     */
    @NotEmpty(message = "是否启用，1启用，0停用不能为空")
    @NotNull(message = "是否启用，1启用，0停用不能为空")
    private Integer enabled;
    /**
     *
@@ -68,7 +70,7 @@
    /**
     * 是否删除，1删除，0未删除
     */
    @NotEmpty(message = "是否删除，1删除，0未删除不能为空")
    @NotNull(message = "是否删除，1删除，0未删除不能为空")
    private Integer isDel;
    /**
     * 租户字段

 kidgrow-business/kidgrow-usercenter/kidgrow-usercenter-biz/src/main/java/com/kidgrow/usercenter/service/ISysUserService.java

@@ -143,7 +143,7 @@
     * @param userRegVo
     * @return
     */
    ResultBody doctorUserReg(UserRegVo userRegVo);
    ResultBody doctorUserReg(UserRegVo userRegVo,SysUser sysUser);
    /**
     * 获取医院科室下的所有有效的医生
     * @param hospitalId

 kidgrow-business/kidgrow-usercenter/kidgrow-usercenter-biz/src/main/java/com/kidgrow/usercenter/service/impl/SysDoctorServiceImpl.java

@@ -144,7 +144,7 @@
    }

    @Override
    @Transactional
    @Transactional(rollbackFor = Exception.class)
    public boolean saveOrUpdateSer(SysDoctorDto sysDoctor, HttpServletRequest request,SysUser user) {
        String id = request.getHeader(SecurityConstants.USER_ID_HEADER);
        if(null==sysDoctor){
@@ -239,7 +239,7 @@
    }

    @Override
    @Transactional
    @Transactional(rollbackFor = Exception.class)
    public ResultBody setAdminDoctor(Map<String, Object> params) {
        Long id = MapUtils.getLong(params, "id");
        Long adminId = MapUtils.getLong(params, "adminId");

 kidgrow-business/kidgrow-usercenter/kidgrow-usercenter-biz/src/main/java/com/kidgrow/usercenter/service/impl/SysOrganizationServiceImpl.java

@@ -183,7 +183,7 @@
     * @return
     */
    @Override
    @Transactional
    @Transactional(rollbackFor = Exception.class)
    public boolean saveOrUpdateSer(SysOrganization sysOrganization) {
        //获取code


 kidgrow-business/kidgrow-usercenter/kidgrow-usercenter-biz/src/main/java/com/kidgrow/usercenter/service/impl/SysRoleServiceImpl.java

@@ -70,7 +70,7 @@
    }

    @Override
    @Transactional
    @Transactional(rollbackFor = Exception.class)
    public ResultBody saveOrUpdateRole(SysRole sysRole) {
        if (sysRole.getId() == null) {
            this.saveRole(sysRole);

 kidgrow-business/kidgrow-usercenter/kidgrow-usercenter-biz/src/main/java/com/kidgrow/usercenter/service/impl/SysUserServiceImpl.java

@@ -87,8 +87,6 @@
    @Autowired
    private SysUserRoleMapper sysUserRoleMapper;

    private final String HOSPITAL_ADMIN="hospital_admin";

    @Override
    public LoginAppUser findByUsername(String username) {
        SysUser sysUser = this.selectByUsername(username);
@@ -117,6 +115,11 @@
    public LoginAppUser getLoginAppUser(SysUser sysUser) {
        LoginAppUser loginAppUser = new LoginAppUser();
        if (sysUser != null) {
            //返回的数据为什么要把密码也返回？清空!!
            loginAppUser.setPassword("");
            loginAppUser.setNewPassword("");
            loginAppUser.setOldPassword("");

            BeanUtils.copyProperties(sysUser, loginAppUser);
            //获取用户所属组织机构列表
            List<SysOrganization> sysOrganizations = organizationService.findListByUserId(sysUser.getId());
@@ -221,7 +224,7 @@
        }
    }

    @Transactional
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ResultBody updatePassword(Long id, String oldPassword, String newPassword, Boolean isdefault) {
        SysUser sysUser = baseMapper.selectById(id);
@@ -633,44 +636,59 @@
     * @param userRegVo
     * @return
     */
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ResultBody doctorUserReg(UserRegVo userRegVo) {
    public ResultBody doctorUserReg(UserRegVo userRegVo, SysUser sysUserd) {
        //检查手机号是否已经注册 H端登录名和手机号存一样的值
        if (phoneIsUsed(userRegVo.getMobile())) {
            return ResultBody.failed("该手机号已经注册");
        }
        //检查判断是注册 还是添加用户，注册用户先走基本数据建设
        //创建人id
        Long createUserId=0L;
        //创建人id
        String createUserName="自动创建";
        //是否注册用户
        Boolean isReg=false;
        //业务成功
        Boolean isSuccess=true;
        //业务失败提示信息
        String expMsg="";
        //检查判断是注册 还是添加用户，注册用户先走基本数据建设 组织/医院/科室
        SysOrganization sysOrganizationHos=new SysOrganization();
        SysOrganization sysOrganizationDe=new SysOrganization();
        SysUserOrg sysUserOrgH=new SysUserOrg();
        SysUserOrg sysUserOrgD=new SysUserOrg();
        SysDictionaries sysDictionaries=new SysDictionaries();
        List<SysOrganization> sysOrganizationList=new ArrayList<SysOrganization>();
        SysDoctor sysDoctor=new SysDoctor();
        if (userRegVo.getHospitalId()==null) {
            isReg=true;
            userRegVo.setDoctorState(true);
            //添加医院组织结构数据
            List<SysOrganization> sysOrganizationList=new ArrayList<SysOrganization>();
            SysOrganization sysOrganizationHos=new SysOrganization();
            sysOrganizationHos.setOrgAttr(1);
            sysOrganizationHos.setOrgLevel(1);
            sysOrganizationHos.setOrgName(userRegVo.getHospitalName());
            sysOrganizationHos.setCreateUserName("自主注册");
            sysOrganizationHos.setCreateUserId(0L);
            sysOrganizationHos.setCreateUserName(createUserName);
            sysOrganizationHos.setCreateUserId(createUserId);
            Boolean H=organizationService.save(sysOrganizationHos);
            if (H) {
            sysOrganizationList.add(sysOrganizationHos);

            //添加科室组织数据
            SysOrganization sysOrganizationDe=new SysOrganization();
            sysOrganizationDe.setOrgAttr(2);
            sysOrganizationDe.setOrgLevel(2);
            sysOrganizationDe.setOrgName(userRegVo.getDepartmentName());
            sysOrganizationDe.setCreateUserName("自主注册");
            sysOrganizationDe.setCreateUserId(0L);
                sysOrganizationDe.setCreateUserName(createUserName);
                sysOrganizationDe.setCreateUserId(createUserId);
                Boolean D=organizationService.save(sysOrganizationDe);
                if (D) {
            sysOrganizationList.add(sysOrganizationDe);
            //批量写入
            boolean orgRe= organizationService.saveBatch(sysOrganizationList);
            if (orgRe) {
                //写医院数据
                SysHospital sysHospital=new SysHospital();
                sysHospital.setHospitalName(userRegVo.getHospitalName());
                sysHospital.setOrgId(sysOrganizationHos.getId());
                sysHospital.setAccountsCount(1);
                sysHospital.setHospitalState(0);
                sysHospital.setCreateUserId(0L);
                sysHospital.setCreateUserName("自主注册");
                    sysHospital.setCreateUserId(createUserId);
                    sysHospital.setCreateUserName(createUserName);

                boolean h=hospitalService.save(sysHospital);
                if (h) {
@@ -680,15 +698,17 @@
                    sysDepartment.setHospitalId(sysHospital.getId());
                    sysDepartment.setOrgId(sysOrganizationDe.getId());
                    sysDepartment.setDepartmentName(userRegVo.getDepartmentName());
                    sysDepartment.setSaleUserId(0L);
                    sysDepartment.setSaleUserName("自主注册");
                        sysDepartment.setSaleUserId(createUserId);
                        sysDepartment.setAccountsCount(1);
                        sysDepartment.setSaleUserName(createUserName);
                    sysDepartment.setSaleUserTel("0");
                    sysDepartment.setServerUserId(0L);
                        sysDepartment.setServerUserId(createUserId);
                    sysDepartment.setServerUserTel("0");
                    sysDepartment.setServerUserName("自主注册");
                        sysDepartment.setServerUserName(createUserName);
                    boolean d=departmentService.save(sysDepartment);
                    if (!d) {
                        return ResultBody.failed("科室数据写入失败");
                            isSuccess=false;
                            expMsg="科室数据写入失败";
                    }
                    else
                    {
@@ -697,13 +717,32 @@
                }
                else
                {
                    return ResultBody.failed("医院数据写入失败");
                        isSuccess=false;
                        expMsg="医院数据写入失败";
                }
            }
            else
            {
                return ResultBody.failed("组织数据写入失败");
                    isSuccess=false;
                    expMsg="科室组织数据写入失败";
            }
            }
            else
            {
                isSuccess=false;
                expMsg="医院组织数据写入失败";
            }
        }

        //业务执行中途出错  手动撤回数据
        if (isReg&&!isSuccess) {
            RollBackData(sysOrganizationList,userRegVo.getHospitalId(),
                    userRegVo.getDepartmentId(),0L,0L,
                    0L,0L, 0L);
            return ResultBody.failed(expMsg);
        }
        if (!isReg&&departmetAccountsCount(userRegVo.getDepartmentId())<1) {
            return ResultBody.failed("当前科室可创建账户数量已满");
        }
        //添加用户数据  如果没有输入密码，将会创建一个默认密码返回
        String defaultPassWord="";
@@ -735,22 +774,22 @@
        sysUser.setDel(false);
        sysUser.setTenantId("hospital");
        boolean u=this.save(sysUser);
        SysRoleUser sysRoleUser=new SysRoleUser();
        if(u)
        {
            //保存  角色信息
            //保存角色用户绑定信息  sys_role_user
            Map<String,Object> map= new HashMap<>();
            map.put("code",HOSPITAL_ADMIN);
            map.put("code",CommonConstant.HOSPITAL_DOCTOR_CODE);
            map.put("enabled",1);
            map.put("is_del",0);
            List<SysRole> sysRoles = sysRoleMapper.selectByMap(map);
            if(sysRoles.size()>0){
                //保存一个角色
                //保存角色和用户绑定关系数据
                SysRole sysRole = sysRoles.get(0);
                SysRoleUser sysRoleUser=new SysRoleUser();
                sysRoleUser.setRoleId(sysRole.getId());
                sysRoleUser.setUserId(sysUser.getId());
                int insert = sysUserRoleMapper.insert(sysRoleUser);
            }
                if (insert>0) {
            //写入职务数据
            if (StringUtils.isNotBlank(userRegVo.getDoctorRank())) {
                //检查医生职务是否存在
@@ -768,23 +807,33 @@
                else
                {
                    //创建字典数据
                    SysDictionaries sysDictionaries=new SysDictionaries();
                    sysDictionaries.setDictionariesKey(DictionariesConstants.DOCTOR_RANK);
                    sysDictionaries.setDictionariesClassId(DictionariesConstants.DOCTOR_RANK_ID.toString());
                    //将名称汉字转为拼音

                    sysDictionaries.setDictionariesKey(Pinyin4jUtil.makeStringByStringSet(Pinyin4jUtil.getPinyin(userRegVo.getDoctorRank(),true)));
                    sysDictionaries.setDictionariesName(userRegVo.getDoctorRank());
                    sysDictionaries.setCreateUserId(0L);
                    sysDictionaries.setCreateUserName("自动创建");
                            sysDictionaries.setCreateUserId(createUserId);
                            sysDictionaries.setCreateUserName(createUserName);
                    boolean d=sysDictionariesService.save(sysDictionaries);
                    if (d) {
                        userRegVo.setDoctorRankId(sysDictionaries.getId());
                    }
                }
            }
                                //写用户组织关系表
                                List<SysUserOrg> sysUserOrgList=new ArrayList<SysUserOrg>();

                                sysUserOrgH.setUserId(sysUser.getId());
                                sysUserOrgH.setOrgId(sysOrganizationHos.getId());
                                sysUserOrgH.setCreateUserId(isReg?createUserId:sysUserd.getId());
                                sysUserOrgH.setCreateUserName(isReg?createUserName:sysUserd.getUsername());
                                sysUserOrgList.add(sysUserOrgH);

                                sysUserOrgD.setUserId(sysUser.getId());
                                sysUserOrgD.setOrgId(sysOrganizationHos.getId());
                                sysUserOrgD.setCreateUserId(isReg?createUserId:sysUserd.getId());
                                sysUserOrgD.setCreateUserName(isReg?createUserName:sysUserd.getUsername());
                                sysUserOrgList.add(sysUserOrgD);
                                boolean uOrg=iSysUserOrgService.saveBatch(sysUserOrgList);
                                if (uOrg) {
            //写入医生数据
            SysDoctor sysDoctor=new SysDoctor();
            sysDoctor.setUserId(sysUser.getId());
            sysDoctor.setHospitalId(userRegVo.getHospitalId());
            sysDoctor.setHospitalName(userRegVo.getHospitalName());
@@ -792,26 +841,121 @@
            sysDoctor.setDepartmentName(userRegVo.getDepartmentName());
            sysDoctor.setDoctorRank(userRegVo.getDoctorRank());
            sysDoctor.setDoctorRankId(userRegVo.getDoctorRankId());
            sysDoctor.setCreateUserId(0L);
            sysDoctor.setCreateUserName("自主注册");
                                    sysDoctor.setCreateUserId(isReg?createUserId:sysUserd.getId());
                                    sysDoctor.setCreateUserName(isReg?createUserName:sysUserd.getUsername());
            sysDoctor.setDoctorState(userRegVo.getDoctorState());
            sysDoctor.setDoctorTel(userRegVo.getMobile());
            sysDoctor.setDoctorName(userRegVo.getNickname());
            sysDoctor.setServerUserId(0L);
            sysDoctor.setServerUserName("自主注册");
                                    sysDoctor.setServerUserId(isReg?createUserId:sysUserd.getId());
                                    sysDoctor.setServerUserName(isReg?createUserName:sysUserd.getUsername());
            if (sysDoctorMapper.insert(sysDoctor)==1) {
                                        //非自主注册的 返回信息带密码
                                        if (!isReg) {
                sysUser.setPassword(userRegVo.getPassword());
                                        }
                                        else
                                        {
                                            sysUser.setPassword("");
                                        }
                                    }
                                    else
                                    {
                                        isSuccess=false;
                                        expMsg="医生数据写入失败";
                                    }
                                }
                                else
                                {
                                    isSuccess=false;
                                    expMsg="用户组织数据写入失败";
                                }
                            }
                            else
                            {
                                isSuccess=false;
                                expMsg="职称数据写入失败";
                            }
                        }
                    }
                    else
                    {
                        //没有职务数据
                        isSuccess=false;
                        expMsg="没有职称数据";
                    }
                }
                else
                {
                    isSuccess=false;
                    expMsg="角色绑定数据写入失败";
                }
            }
            else
            {
                isSuccess=false;
                expMsg="对应角色没有数据";
            }
        }
        else
        {
            isSuccess=false;
            expMsg="用户数据写入失败";
        }
        /***返回数据***/
        if (!isSuccess) {
            //撤回数据
            RollBackData(null,0L,
                    0L,sysUser.getId(),sysUserOrgH.getId(),
                    sysUserOrgH.getId(),sysDictionaries.getId(),
                    sysDoctor.getId());
            return ResultBody.failed(expMsg);
        }
        else
        {
                return ResultBody.ok().data(sysUser);
//                return ResultBody.ok(200,"注册成功").data(sysUser);
            }
            else
    }

    /**
     * 手动撤回数据，需要撤回那个，给那个id传值，不需要的传0
     * @param sysOrganizationList
     * @param hospitalId
     * @param departmentId
     * @param userId
     * @param userOrgIdH
     * @param userOrgIdD
     * @param dicId
     * @param doctorId
     */
    private void RollBackData(List<SysOrganization> sysOrganizationList,Long hospitalId,Long departmentId,
                              Long userId,Long userOrgIdH,Long userOrgIdD,Long dicId,Long doctorId)
            {
                return ResultBody.failed("医生数据写入失败");
        if (sysOrganizationList!=null&&sysOrganizationList.size()>0) {
            for (int i = 0; i < sysOrganizationList.size(); i++) {
                organizationService.removeById(sysOrganizationList.get(i));
            }
        }
        else
        {
            return ResultBody.failed("用户数据写入失败");
        if (hospitalId>0) {
            hospitalService.removeById(hospitalId);
        }
        if (departmentId>0) {
            departmentService.removeById(departmentId);
        }
        if (userId>0) {
            baseMapper.deleteById(userId);
            sysUserRoleMapper.deleteById(userId);
        }
        if (userOrgIdH>0) {
            sysUserRoleMapper.deleteById(userOrgIdH);
        }
        if (userOrgIdD>0) {
            sysUserRoleMapper.deleteById(userOrgIdD);
        }
        if (dicId>0) {
            sysDictionariesService.removeById(dicId);
        }
        if (doctorId>0) {
            sysDoctorMapper.deleteById(doctorId);
        }
    }
    /**
@@ -844,7 +988,33 @@
        List<SysUser> sysUsers = baseMapper.selectByMap(selectMap);
        return (sysUsers.size() > 0);
    }

    /**
     * 检查科室有效剩余账户数量
     *
     * @param depatmentId
     * @return
     */
    private Integer departmetAccountsCount(Long depatmentId) {
        SysDepartment sysDepartment = departmentService.getById(depatmentId);
        if (sysDepartment == null) {
            return 0;
        }
        else {
            Map<String, Object> selectMap = new HashMap<>();
            selectMap.put("departmentId",depatmentId);
            selectMap.put("enabled",1);
            List<SysDoctor> sysDoctorList=sysDoctorMapper.selectByMap(selectMap);
            if (sysDoctorList == null) {
                int doctorCount=sysDoctorList.size();
                int accountCount=sysDepartment.getAccountsCount();
                return (accountCount-doctorCount);
            }
            else
            {
                return 0;
            }
        }
    }
    /**
     * 检查用户登录名是否已经注册 true存在  false不存在
     *

 kidgrow-business/kidgrow-usercenter/kidgrow-usercenter-biz/src/main/resources/mapper/SysUserMapper.xml

@@ -128,11 +128,9 @@
        syshos.hospital_logo,
        syshos.is_screen hosisscreen,
        syshos.is_answer hosisanswer,
        syshos.accounts_count,
        syshos.hospital_state,
        syshos.enabled hosenabled,
        syshos.is_del hosdel,
        syshos.accounts_count,

        sysdep.id department_id,
        sysdep.department_name,
@@ -141,6 +139,7 @@
        sysdep.sale_user_name,
        sysdep.sale_user_tel,
        sysdep.enabled depenabled,
        sysdep.accounts_count,
        sysdep.is_del depdel
        FROM sys_user sysuser
        left JOIN sys_doctor sysdoctor on sysuser.id=sysdoctor.user_id

 kidgrow-business/kidgrow-usercenter/kidgrow-usercenter-server/src/main/java/com/kidgrow/usercenter/controller/SysUserController.java

@@ -327,10 +327,16 @@
        return appUserService.saveOrUpdateUser(sysUser);
    }

    /**
     * 用户注册，添加用户
     * @param userRegVo 注册信息
     * @param sysUser  当前登录用户
     * @return
     */
    @PostMapping("/users/doctorUserReg")
    @AuditLog(operation = "'注册用户:' + #userRegVo.mobile")
    public ResultBody doctorUserReg(@RequestBody UserRegVo userRegVo) {
        return appUserService.doctorUserReg(userRegVo);
    @AuditLog(operation = "'注册/添加用户:' + #userRegVo.mobile")
    public ResultBody doctorUserReg(@RequestBody UserRegVo userRegVo,SysUser sysUser) {
        return appUserService.doctorUserReg(userRegVo,sysUser);
    }

    /**

 kidgrow-commons/kidgrow-common-spring-boot-starter/src/main/java/com/kidgrow/common/constant/CommonConstant.java

@@ -247,4 +247,21 @@
     * 生成缩略图需要的图片暂存目录
     */
    public static final String TEMP_IMAGE_PATH="D:/resources/images/";
    /**
     * 普通医生角色ID
     */
    public static final Long HOSPITAL_DOCTOR_ID=1268826800663289858L;
    /**
     * 普通医生角色code标识
     */
    public static final String HOSPITAL_DOCTOR_CODE="hospital_doctor";

    /**
     * 管理员医生角色ID
     */
    public static final Long HOSPITAL_ADMIN_ID=9L;
    /**
     * 管理员医生角色code标识
     */
    public static final String HOSPITAL_ADMIN_CODE="hospital_admin";
}

 kidgrow-uaa/kidgrow-uaa-server/src/main/java/com/kidgrow/oauth2/config/AuthorizationServerConfig.java

@@ -1,10 +1,15 @@
package com.kidgrow.oauth2.config;

import com.kidgrow.oauth2.handler.SingleTokenServices;
import com.kidgrow.oauth2.service.impl.RedisClientDetailsService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.AutoConfigureAfter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.ProviderManager;
import org.springframework.security.core.userdetails.UserDetailsByNameServiceWrapper;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.oauth2.config.annotation.configurers.ClientDetailsServiceConfigurer;
import org.springframework.security.oauth2.config.annotation.web.configuration.AuthorizationServerConfigurerAdapter;
@@ -17,6 +22,7 @@
import org.springframework.security.oauth2.provider.token.TokenEnhancerChain;
import org.springframework.security.oauth2.provider.token.TokenStore;
import org.springframework.security.oauth2.provider.token.store.JwtAccessTokenConverter;
import org.springframework.security.web.authentication.preauth.PreAuthenticatedAuthenticationProvider;

import javax.annotation.Resource;
import java.util.Arrays;
@@ -45,6 +51,9 @@

    @Autowired
    private TokenStore tokenStore;

//    @Autowired
//    private CustomRedisTokenStore tokenStore;

    @Autowired(required = false)
    private JwtAccessTokenConverter jwtAccessTokenConverter;
@@ -77,13 +86,57 @@
                endpoints.accessTokenConverter(jwtAccessTokenConverter);
            }
        }
        endpoints.tokenStore(tokenStore)
        endpoints
                //扩展tokenServices
//                .tokenServices(tokenServices(endpoints))
                .tokenServices(KidgrowTokenServices())
                .authenticationManager(authenticationManager)
                .userDetailsService(userDetailsService)
//                .tokenStore(tokenStore)
                .authorizationCodeServices(authorizationCodeServices)
                .exceptionTranslator(webResponseExceptionTranslator);
    }


    @Bean
    @Primary
    public SingleTokenServices KidgrowTokenServices(){
        SingleTokenServices tokenServices = new SingleTokenServices();
        tokenServices.setTokenStore(tokenStore);
        tokenServices.setSupportRefreshToken(true);//支持刷新token
        tokenServices.setReuseRefreshToken(true);
        addUserDetailsService(tokenServices, this.userDetailsService);
        return tokenServices;
    }

//    private SingleTokenServices tokenServices(AuthorizationServerEndpointsConfigurer endpoints) {
//        SingleTokenServices tokenServices = new SingleTokenServices();
//        tokenServices.setTokenStore(tokenStore);
//        tokenServices.setSupportRefreshToken(true);//支持刷新token
//        tokenServices.setReuseRefreshToken(true);
//        tokenServices.setClientDetailsService(endpoints.getClientDetailsService());
//        tokenServices.setTokenEnhancer(endpoints.getTokenEnhancer());
//        addUserDetailsService(tokenServices, this.userDetailsService);
//        return tokenServices;
//    }
//    private void addUserDetailsService(SingleTokenServices tokenServices, UserDetailsService userDetailsService) {
//        if (userDetailsService != null) {
//            PreAuthenticatedAuthenticationProvider provider = new PreAuthenticatedAuthenticationProvider();
//            provider.setPreAuthenticatedUserDetailsService(new UserDetailsByNameServiceWrapper<>(
//                    userDetailsService));
//            tokenServices.setAuthenticationManager(new ProviderManager(Arrays.asList(provider)));
//        }
//    }

    private void addUserDetailsService(SingleTokenServices tokenServices, UserDetailsService userDetailsService) {
        if (userDetailsService != null) {
            PreAuthenticatedAuthenticationProvider provider = new PreAuthenticatedAuthenticationProvider();
            provider.setPreAuthenticatedUserDetailsService(new UserDetailsByNameServiceWrapper<>(
                    userDetailsService));
            tokenServices.setAuthenticationManager(new ProviderManager(Arrays.asList(provider)));
        }
    }

    /**
     * 配置应用名称 应用id
     * 配置OAuth2的客户端相关信息

 kidgrow-uaa/kidgrow-uaa-server/src/main/java/com/kidgrow/oauth2/handler/KidgrowTokenServices.java

New file
@@ -0,0 +1,115 @@
package com.kidgrow.oauth2.handler;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.oauth2.common.*;
import org.springframework.security.oauth2.provider.ClientDetailsService;
import org.springframework.security.oauth2.provider.OAuth2Authentication;
import org.springframework.security.oauth2.provider.token.DefaultTokenServices;
import org.springframework.security.oauth2.provider.token.TokenEnhancer;
import org.springframework.security.oauth2.provider.token.TokenStore;

import java.util.Date;
import java.util.UUID;

/**
 * 石家庄喜高科技有限责任公司 版权所有 © Copyright 2020<br>
 *
 * @Description: <br>
 * @Project: <br>
 * @CreateDate: Created in 2020/6/18 12:41 <br>
 * @Author: <a href="4345453@kidgrow.com">liuke</a>
 */
public class KidgrowTokenServices extends DefaultTokenServices {

    private int refreshTokenValiditySeconds = 2592000;
    private int accessTokenValiditySeconds = 43200;
    private boolean supportRefreshToken = false;
    private boolean reuseRefreshToken = true;
    private ClientDetailsService clientDetailsService;
    private TokenEnhancer accessTokenEnhancer;
    private AuthenticationManager authenticationManager;

    @Autowired
    private TokenStore tokenStore;



    @Override
    public OAuth2AccessToken createAccessToken(OAuth2Authentication authentication) throws AuthenticationException {
        OAuth2AccessToken existingAccessToken = super.getAccessToken(authentication);
        OAuth2RefreshToken refreshToken = null;
        if (existingAccessToken != null) {
//            if (!existingAccessToken.isExpired()) {
//                this.tokenStore.storeAccessToken(existingAccessToken, authentication);
//                return existingAccessToken;
//            }
            existingAccessToken.getRefreshToken();
            if (existingAccessToken.getRefreshToken() != null) {
                refreshToken = existingAccessToken.getRefreshToken();
                this.tokenStore.removeRefreshToken(refreshToken);
            }

            this.tokenStore.removeAccessToken(existingAccessToken);
        }


        if (refreshToken == null) {
            refreshToken = this.createRefreshToken(authentication);
        } else if (refreshToken instanceof ExpiringOAuth2RefreshToken) {
            ExpiringOAuth2RefreshToken expiring = (ExpiringOAuth2RefreshToken)refreshToken;
            if (System.currentTimeMillis() > expiring.getExpiration().getTime()) {
                refreshToken = this.createRefreshToken(authentication);
            }
        }

        OAuth2AccessToken accessToken = this.createAccessToken(authentication, refreshToken);
        this.tokenStore.storeAccessToken(accessToken, authentication);
        refreshToken = accessToken.getRefreshToken();
        if (refreshToken != null) {
            this.tokenStore.storeRefreshToken(refreshToken, authentication);
        }

        return accessToken;
    }

//    @Override
//    public void setTokenStore(TokenStore tokenStore) {
//        this.tokenStore = tokenStore;
//    }



    @Override
    public void setSupportRefreshToken(boolean supportRefreshToken) {
        this.supportRefreshToken = supportRefreshToken;
    }

    @Override
    public void setReuseRefreshToken(boolean reuseRefreshToken) {
        this.reuseRefreshToken = reuseRefreshToken;
    }

    private OAuth2AccessToken createAccessToken(OAuth2Authentication authentication, OAuth2RefreshToken refreshToken) {
        DefaultOAuth2AccessToken token = new DefaultOAuth2AccessToken(UUID.randomUUID().toString());
        int validitySeconds = this.getAccessTokenValiditySeconds(authentication.getOAuth2Request());
        if (validitySeconds > 0) {
            token.setExpiration(new Date(System.currentTimeMillis() + (long)validitySeconds * 1000L));
        }

        token.setRefreshToken(refreshToken);
        token.setScope(authentication.getOAuth2Request().getScope());
        return (OAuth2AccessToken)(this.accessTokenEnhancer != null ? this.accessTokenEnhancer.enhance(token, authentication) : token);
    }

    private OAuth2RefreshToken createRefreshToken(OAuth2Authentication authentication) {
        if (!this.isSupportRefreshToken(authentication.getOAuth2Request())) {
            return null;
        } else {
            int validitySeconds = this.getRefreshTokenValiditySeconds(authentication.getOAuth2Request());
            String value = UUID.randomUUID().toString();
            return (OAuth2RefreshToken)(validitySeconds > 0 ? new DefaultExpiringOAuth2RefreshToken(value, new Date(System.currentTimeMillis() + (long)validitySeconds * 1000L)) : new DefaultOAuth2RefreshToken(value));
        }
    }
}

 kidgrow-uaa/kidgrow-uaa-server/src/main/java/com/kidgrow/oauth2/handler/SingleTokenServices.java

New file
@@ -0,0 +1,308 @@
package com.kidgrow.oauth2.handler;
/**
 * 石家庄喜高科技有限责任公司 版权所有 © Copyright 2020<br>
 *
 * @Description: <br>
 * @Project: <br>
 * @CreateDate: Created in 2020/6/18 09:17 <br>
 * @Author: <a href="4345453@kidgrow.com">liuke</a>
 */

import org.springframework.beans.factory.InitializingBean;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.oauth2.common.*;
import org.springframework.security.oauth2.common.exceptions.InvalidGrantException;
import org.springframework.security.oauth2.common.exceptions.InvalidScopeException;
import org.springframework.security.oauth2.common.exceptions.InvalidTokenException;
import org.springframework.security.oauth2.provider.*;
import org.springframework.security.oauth2.provider.token.*;
import org.springframework.security.web.authentication.preauth.PreAuthenticatedAuthenticationToken;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.Assert;

import java.util.Date;
import java.util.Set;
import java.util.UUID;

/** @deprecated */
@Deprecated
public class SingleTokenServices implements AuthorizationServerTokenServices, ResourceServerTokenServices, ConsumerTokenServices, InitializingBean {
    private int refreshTokenValiditySeconds = 2592000;
    private int accessTokenValiditySeconds = 43200;
    private boolean supportRefreshToken = false;
    private boolean reuseRefreshToken = true;
    private TokenStore tokenStore;
    private ClientDetailsService clientDetailsService;
    private TokenEnhancer accessTokenEnhancer;
    private AuthenticationManager authenticationManager;

    public SingleTokenServices() {
    }

    public void afterPropertiesSet() throws Exception {
        Assert.notNull(this.tokenStore, "tokenStore must be set");
    }

    @Transactional
    public OAuth2AccessToken createAccessToken(OAuth2Authentication authentication) throws AuthenticationException {
        OAuth2AccessToken existingAccessToken = this.tokenStore.getAccessToken(authentication);
        OAuth2RefreshToken refreshToken = null;
        if (existingAccessToken != null) {
//            if (!existingAccessToken.isExpired()) {
//                this.tokenStore.storeAccessToken(existingAccessToken, authentication);
//                return existingAccessToken;
//            }

            if (existingAccessToken.getRefreshToken() != null) {
                refreshToken = existingAccessToken.getRefreshToken();
                this.tokenStore.removeRefreshToken(refreshToken);
            }

            this.tokenStore.removeAccessToken(existingAccessToken);
        }

        if (refreshToken == null) {
            refreshToken = this.createRefreshToken(authentication);
        } else if (refreshToken instanceof ExpiringOAuth2RefreshToken) {
            ExpiringOAuth2RefreshToken expiring = (ExpiringOAuth2RefreshToken)refreshToken;
            if (System.currentTimeMillis() > expiring.getExpiration().getTime()) {
                refreshToken = this.createRefreshToken(authentication);
            }
        }

        OAuth2AccessToken accessToken = this.createAccessToken(authentication, refreshToken);
        this.tokenStore.storeAccessToken(accessToken, authentication);
        refreshToken = accessToken.getRefreshToken();
        if (refreshToken != null) {
            this.tokenStore.storeRefreshToken(refreshToken, authentication);
        }

        return accessToken;
    }

    @Transactional(
            noRollbackFor = {InvalidTokenException.class, InvalidGrantException.class}
    )
    public OAuth2AccessToken refreshAccessToken(String refreshTokenValue, TokenRequest tokenRequest) throws AuthenticationException {
        if (!this.supportRefreshToken) {
            throw new InvalidGrantException("Invalid refresh token: " + refreshTokenValue);
        } else {
            OAuth2RefreshToken refreshToken = this.tokenStore.readRefreshToken(refreshTokenValue);
            if (refreshToken == null) {
                throw new InvalidGrantException("Invalid refresh token: " + refreshTokenValue);
            } else {
                OAuth2Authentication authentication = this.tokenStore.readAuthenticationForRefreshToken(refreshToken);
                if (this.authenticationManager != null && !authentication.isClientOnly()) {
                    Authentication user = new PreAuthenticatedAuthenticationToken(authentication.getUserAuthentication(), "", authentication.getAuthorities());
                    user = this.authenticationManager.authenticate(user);
                    Object details = authentication.getDetails();
                    authentication = new OAuth2Authentication(authentication.getOAuth2Request(), user);
                    authentication.setDetails(details);
                }

                String clientId = authentication.getOAuth2Request().getClientId();
                if (clientId != null && clientId.equals(tokenRequest.getClientId())) {
                    this.tokenStore.removeAccessTokenUsingRefreshToken(refreshToken);
                    if (this.isExpired(refreshToken)) {
                        this.tokenStore.removeRefreshToken(refreshToken);
                        throw new InvalidTokenException("Invalid refresh token (expired): " + refreshToken);
                    } else {
                        authentication = this.createRefreshedAuthentication(authentication, tokenRequest);
                        if (!this.reuseRefreshToken) {
                            this.tokenStore.removeRefreshToken(refreshToken);
                            refreshToken = this.createRefreshToken(authentication);
                        }

                        OAuth2AccessToken accessToken = this.createAccessToken(authentication, refreshToken);
                        this.tokenStore.storeAccessToken(accessToken, authentication);
                        if (!this.reuseRefreshToken) {
                            this.tokenStore.storeRefreshToken(accessToken.getRefreshToken(), authentication);
                        }

                        return accessToken;
                    }
                } else {
                    throw new InvalidGrantException("Wrong client for this refresh token: " + refreshTokenValue);
                }
            }
        }
    }

    public OAuth2AccessToken getAccessToken(OAuth2Authentication authentication) {
        return this.tokenStore.getAccessToken(authentication);
    }

    private OAuth2Authentication createRefreshedAuthentication(OAuth2Authentication authentication, TokenRequest request) {
        Set<String> scope = request.getScope();
        OAuth2Request clientAuth = authentication.getOAuth2Request().refresh(request);
        if (scope != null && !scope.isEmpty()) {
            Set<String> originalScope = clientAuth.getScope();
            if (originalScope == null || !originalScope.containsAll(scope)) {
                throw new InvalidScopeException("Unable to narrow the scope of the client authentication to " + scope + ".", originalScope);
            }

            clientAuth = clientAuth.narrowScope(scope);
        }

        OAuth2Authentication narrowed = new OAuth2Authentication(clientAuth, authentication.getUserAuthentication());
        return narrowed;
    }

    protected boolean isExpired(OAuth2RefreshToken refreshToken) {
        if (!(refreshToken instanceof ExpiringOAuth2RefreshToken)) {
            return false;
        } else {
            ExpiringOAuth2RefreshToken expiringToken = (ExpiringOAuth2RefreshToken)refreshToken;
            return expiringToken.getExpiration() == null || System.currentTimeMillis() > expiringToken.getExpiration().getTime();
        }
    }

    public OAuth2AccessToken readAccessToken(String accessToken) {
        return this.tokenStore.readAccessToken(accessToken);
    }

    public OAuth2Authentication loadAuthentication(String accessTokenValue) throws AuthenticationException, InvalidTokenException {
        OAuth2AccessToken accessToken = this.tokenStore.readAccessToken(accessTokenValue);
        if (accessToken == null) {
            throw new InvalidTokenException("Invalid access token: " + accessTokenValue);
        } else if (accessToken.isExpired()) {
            this.tokenStore.removeAccessToken(accessToken);
            throw new InvalidTokenException("Access token expired: " + accessTokenValue);
        } else {
            OAuth2Authentication result = this.tokenStore.readAuthentication(accessToken);
            if (result == null) {
                throw new InvalidTokenException("Invalid access token: " + accessTokenValue);
            } else {
                if (this.clientDetailsService != null) {
                    String clientId = result.getOAuth2Request().getClientId();

                    try {
                        this.clientDetailsService.loadClientByClientId(clientId);
                    } catch (ClientRegistrationException var6) {
                        throw new InvalidTokenException("Client not valid: " + clientId, var6);
                    }
                }

                return result;
            }
        }
    }

    public String getClientId(String tokenValue) {
        OAuth2Authentication authentication = this.tokenStore.readAuthentication(tokenValue);
        if (authentication == null) {
            throw new InvalidTokenException("Invalid access token: " + tokenValue);
        } else {
            OAuth2Request clientAuth = authentication.getOAuth2Request();
            if (clientAuth == null) {
                throw new InvalidTokenException("Invalid access token (no client id): " + tokenValue);
            } else {
                return clientAuth.getClientId();
            }
        }
    }

    public boolean revokeToken(String tokenValue) {
        OAuth2AccessToken accessToken = this.tokenStore.readAccessToken(tokenValue);
        if (accessToken == null) {
            return false;
        } else {
            if (accessToken.getRefreshToken() != null) {
                this.tokenStore.removeRefreshToken(accessToken.getRefreshToken());
            }

            this.tokenStore.removeAccessToken(accessToken);
            return true;
        }
    }

    private OAuth2RefreshToken createRefreshToken(OAuth2Authentication authentication) {
        if (!this.isSupportRefreshToken(authentication.getOAuth2Request())) {
            return null;
        } else {
            int validitySeconds = this.getRefreshTokenValiditySeconds(authentication.getOAuth2Request());
            String value = UUID.randomUUID().toString();
            return (OAuth2RefreshToken)(validitySeconds > 0 ? new DefaultExpiringOAuth2RefreshToken(value, new Date(System.currentTimeMillis() + (long)validitySeconds * 1000L)) : new DefaultOAuth2RefreshToken(value));
        }
    }

    private OAuth2AccessToken createAccessToken(OAuth2Authentication authentication, OAuth2RefreshToken refreshToken) {
        DefaultOAuth2AccessToken token = new DefaultOAuth2AccessToken(UUID.randomUUID().toString());
        int validitySeconds = this.getAccessTokenValiditySeconds(authentication.getOAuth2Request());
        if (validitySeconds > 0) {
            token.setExpiration(new Date(System.currentTimeMillis() + (long)validitySeconds * 1000L));
        }

        token.setRefreshToken(refreshToken);
        token.setScope(authentication.getOAuth2Request().getScope());
        return (OAuth2AccessToken)(this.accessTokenEnhancer != null ? this.accessTokenEnhancer.enhance(token, authentication) : token);
    }

    protected int getAccessTokenValiditySeconds(OAuth2Request clientAuth) {
        if (this.clientDetailsService != null) {
            ClientDetails client = this.clientDetailsService.loadClientByClientId(clientAuth.getClientId());
            Integer validity = client.getAccessTokenValiditySeconds();
            if (validity != null) {
                return validity;
            }
        }

        return this.accessTokenValiditySeconds;
    }

    protected int getRefreshTokenValiditySeconds(OAuth2Request clientAuth) {
        if (this.clientDetailsService != null) {
            ClientDetails client = this.clientDetailsService.loadClientByClientId(clientAuth.getClientId());
            Integer validity = client.getRefreshTokenValiditySeconds();
            if (validity != null) {
                return validity;
            }
        }

        return this.refreshTokenValiditySeconds;
    }

    protected boolean isSupportRefreshToken(OAuth2Request clientAuth) {
        if (this.clientDetailsService != null) {
            ClientDetails client = this.clientDetailsService.loadClientByClientId(clientAuth.getClientId());
            return client.getAuthorizedGrantTypes().contains("refresh_token");
        } else {
            return this.supportRefreshToken;
        }
    }

    public void setTokenEnhancer(TokenEnhancer accessTokenEnhancer) {
        this.accessTokenEnhancer = accessTokenEnhancer;
    }

    public void setRefreshTokenValiditySeconds(int refreshTokenValiditySeconds) {
        this.refreshTokenValiditySeconds = refreshTokenValiditySeconds;
    }

    public void setAccessTokenValiditySeconds(int accessTokenValiditySeconds) {
        this.accessTokenValiditySeconds = accessTokenValiditySeconds;
    }

    public void setSupportRefreshToken(boolean supportRefreshToken) {
        this.supportRefreshToken = supportRefreshToken;
    }

    public void setReuseRefreshToken(boolean reuseRefreshToken) {
        this.reuseRefreshToken = reuseRefreshToken;
    }

    public void setTokenStore(TokenStore tokenStore) {
        this.tokenStore = tokenStore;
    }

    public void setAuthenticationManager(AuthenticationManager authenticationManager) {
        this.authenticationManager = authenticationManager;
    }

    public void setClientDetailsService(ClientDetailsService clientDetailsService) {
        this.clientDetailsService = clientDetailsService;
    }
}


 kidgrow-web/kidgrow-web-manager/src/main/resources/static/module/apiUrl.js

@@ -1,4 +1,4 @@
// var my_api_server_url = 'http://zuul.kidgrow.com/';
var my_api_server_url = 'http://192.168.2.240:8888/';
// var my_api_server_url = 'http://127.0.0.1:8888/';
//var my_api_server_url = 'http://192.168.2.240:8888/';
var my_api_server_url = 'http://127.0.0.1:8888/';


 kidgrow-web/kidgrow-web-manager/src/main/resources/static/pages/system/user.html

@@ -81,7 +81,14 @@
                { field: 'enabled', width: 100, sort: true, templet: '#user-tpl-state', title: '状态' },
                { fixed: 'right', align: 'center', toolbar: '#user-table-bar', title: '操作', width: 300 }
            ]],
            done:function(){
            done:function(res){
                if(res.code==401){
                    config.removeToken();
                    layer.msg('登录过期', {icon: 2, time: 1500}, function () {
                        location.replace('/login.html');
                    }, 1000);
                    return;
                }
                permissionsInput();
            }
        });

 pom.xml

@@ -92,6 +92,8 @@
        <docker.image.prefix>kidgrow</docker.image.prefix>
        <!--docker harbor地址-->
        <docker.repostory>182.92.99.224:8081</docker.repostory>
        <com.belerweb.pinyin4j.version>2.5.1</com.belerweb.pinyin4j.version>
        <net.coobird.thumbnailator.version>0.4.11</net.coobird.thumbnailator.version>
    </properties>

    <dependencies>
@@ -159,12 +161,12 @@
        <dependency>
            <groupId>com.belerweb</groupId>
            <artifactId>pinyin4j</artifactId>
            <version>2.5.1</version>
            <version>${com.belerweb.pinyin4j.version}</version>
        </dependency>
        <dependency>
            <groupId>net.coobird</groupId>
            <artifactId>thumbnailator</artifactId>
            <version>0.4.11</version>
            <version>${net.coobird.thumbnailator.version}</version>
        </dependency>

    </dependencies>