454 lines
12 KiB
Go
454 lines
12 KiB
Go
package service
|
|
|
|
import (
|
|
"crypto/md5"
|
|
"encoding/hex"
|
|
"errors"
|
|
"github.com/gin-gonic/gin"
|
|
"github.com/google/uuid"
|
|
"hospital-admin-api/api/dao"
|
|
"hospital-admin-api/api/model"
|
|
"hospital-admin-api/api/requests"
|
|
"hospital-admin-api/global"
|
|
"regexp"
|
|
"strconv"
|
|
)
|
|
|
|
type UserService struct {
|
|
}
|
|
|
|
// AddUser 新增用户
|
|
func (r *UserService) AddUser(c *gin.Context, AddUserRequest requests.AddUser) (bool, error) {
|
|
// 当前登陆用户id
|
|
loginUserId := c.GetInt64("UserId")
|
|
if loginUserId == 0 {
|
|
return false, errors.New("新增失败")
|
|
}
|
|
|
|
loginRoleId := c.GetInt64("RoleId")
|
|
if loginRoleId == 0 {
|
|
return false, errors.New("新增失败")
|
|
}
|
|
|
|
// 获取当前登陆用户角色数据
|
|
adminRoleDao := dao.AdminRoleDao{}
|
|
|
|
adminUserDao := dao.AdminUserDao{}
|
|
AdminDeptDao := dao.AdminDeptDao{}
|
|
AdminPostDao := dao.AdminPostDao{}
|
|
|
|
// 检测账号名
|
|
AdminUser, err := adminUserDao.GetAdminUserFirstByAccess(AddUserRequest.Access)
|
|
if AdminUser != nil {
|
|
return false, errors.New("账号名重复")
|
|
}
|
|
|
|
// 检测手机号
|
|
AdminUser, err = adminUserDao.GetAdminUserFirstByPhone(AddUserRequest.Phone)
|
|
if AdminUser != nil {
|
|
return false, errors.New("手机号重复")
|
|
}
|
|
|
|
// 检测角色
|
|
roleID, err := strconv.ParseInt(AddUserRequest.RoleID, 10, 64)
|
|
if err != nil {
|
|
return false, errors.New("角色错误")
|
|
}
|
|
|
|
adminRole, err := adminRoleDao.GetAdminRoleFirstById(roleID)
|
|
if err != nil || adminRole == nil {
|
|
return false, errors.New("角色错误")
|
|
}
|
|
|
|
// 检测部门
|
|
deptID, err := strconv.ParseInt(AddUserRequest.DeptID, 10, 64)
|
|
if err != nil {
|
|
return false, errors.New("部门错误")
|
|
}
|
|
|
|
adminDept, err := AdminDeptDao.GetAdminDeptById(deptID)
|
|
if err != nil || adminDept == nil {
|
|
return false, errors.New("部门错误")
|
|
}
|
|
|
|
// 检测岗位
|
|
postID, err := strconv.ParseInt(AddUserRequest.PostID, 10, 64)
|
|
if err != nil {
|
|
return false, errors.New("岗位错误")
|
|
}
|
|
|
|
adminPost, err := AdminPostDao.GetAdminPostById(postID)
|
|
if err != nil || adminPost == nil {
|
|
return false, errors.New("岗位错误")
|
|
}
|
|
|
|
// 处理密码
|
|
salt := uuid.New().String()
|
|
password := md5.Sum([]byte(AddUserRequest.Password + salt))
|
|
// 将哈希值转换为16进制字符串
|
|
passwordString := hex.EncodeToString(password[:])
|
|
|
|
// 开始事务
|
|
tx := global.Db.Begin()
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
tx.Rollback()
|
|
}
|
|
}()
|
|
|
|
// 新增用户
|
|
AdminUserModel := &model.AdminUser{
|
|
Access: AddUserRequest.Access,
|
|
Password: passwordString,
|
|
Salt: salt,
|
|
Status: AddUserRequest.Status,
|
|
IsDeleted: AddUserRequest.IsDeleted,
|
|
IsDisabled: AddUserRequest.IsDisabled,
|
|
NickName: AddUserRequest.NickName,
|
|
Phone: AddUserRequest.Phone,
|
|
Avatar: AddUserRequest.Avatar,
|
|
Sex: AddUserRequest.Sex,
|
|
Email: AddUserRequest.Email,
|
|
RoleID: roleID,
|
|
DeptID: deptID,
|
|
PostID: postID,
|
|
CreateBy: loginUserId,
|
|
}
|
|
|
|
adminUser, _ := adminUserDao.AddAdminUser(tx, AdminUserModel)
|
|
if adminUser == nil {
|
|
tx.Rollback()
|
|
return false, errors.New("新增失败")
|
|
}
|
|
|
|
tx.Commit()
|
|
|
|
return true, nil
|
|
}
|
|
|
|
// DeleteUser 删除用户-批量
|
|
func (r *UserService) DeleteUser(c *gin.Context, DeleteUserRequest requests.DeleteUser) (bool, error) {
|
|
// 获取当前登陆用户数据
|
|
userId := c.GetInt64("UserId")
|
|
if userId == 0 {
|
|
return false, errors.New("数据错误")
|
|
}
|
|
|
|
AdminUserDao := dao.AdminUserDao{}
|
|
adminUser, err := AdminUserDao.GetAdminUserFirstById(userId)
|
|
if err != nil || adminUser == nil {
|
|
return false, errors.New("用户数据错误")
|
|
}
|
|
|
|
// 获取当前登陆用户角色数据
|
|
roleId := c.GetInt64("RoleId")
|
|
if roleId == 0 {
|
|
return false, errors.New("数据错误")
|
|
}
|
|
|
|
// 开始事务
|
|
tx := global.Db.Begin()
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
tx.Rollback()
|
|
}
|
|
}()
|
|
|
|
for _, v := range DeleteUserRequest.UserIds {
|
|
// 将字符串转换为int64类型
|
|
v, err := strconv.ParseInt(v, 10, 64)
|
|
if err != nil {
|
|
tx.Rollback()
|
|
return false, errors.New("菜单错误")
|
|
}
|
|
|
|
if v == adminUser.UserID {
|
|
tx.Rollback()
|
|
return false, errors.New("非法操作，请勿删除自己")
|
|
}
|
|
|
|
// 检测删除用户
|
|
adminUser, err := AdminUserDao.GetAdminUserFirstById(userId)
|
|
if err != nil || adminUser == nil {
|
|
tx.Rollback()
|
|
return false, errors.New("删除失败")
|
|
}
|
|
|
|
// 删除用户
|
|
err = AdminUserDao.DeleteAdminUserById(tx, v)
|
|
if err != nil {
|
|
tx.Rollback()
|
|
return false, errors.New("删除失败")
|
|
}
|
|
}
|
|
|
|
tx.Commit()
|
|
|
|
return true, nil
|
|
}
|
|
|
|
// PutUser 修改用户
|
|
func (r *UserService) PutUser(c *gin.Context, requestUserId int64, putUserRequest requests.PutUser) (bool, error) {
|
|
// 获取当前登陆用户数据
|
|
loginUserId := c.GetInt64("UserId")
|
|
if loginUserId == 0 {
|
|
return false, errors.New("数据错误")
|
|
}
|
|
|
|
adminUserDao := dao.AdminUserDao{}
|
|
loginAdminUser, err := adminUserDao.GetAdminUserFirstById(loginUserId)
|
|
if err != nil || loginAdminUser == nil {
|
|
return false, errors.New("用户数据错误")
|
|
}
|
|
|
|
if loginUserId == requestUserId && putUserRequest.IsDisabled == 1 {
|
|
return false, errors.New("不可把自己置为禁用")
|
|
}
|
|
|
|
if loginUserId == requestUserId && putUserRequest.IsDeleted == 1 {
|
|
return false, errors.New("不可把自己置为删除")
|
|
}
|
|
|
|
// 获取需修改用户数据
|
|
adminUser, err := adminUserDao.GetAdminUserFirstById(requestUserId)
|
|
if err != nil || adminUser == nil {
|
|
return false, errors.New("用户数据错误")
|
|
}
|
|
|
|
// 获取当前登陆用户角色数据
|
|
loginRoleId := c.GetInt64("RoleId")
|
|
if loginRoleId == 0 {
|
|
return false, errors.New("数据错误")
|
|
}
|
|
|
|
adminRoleDao := dao.AdminRoleDao{}
|
|
adminRole, err := adminRoleDao.GetAdminRoleFirstById(loginRoleId)
|
|
if err != nil || adminRole == nil {
|
|
return false, errors.New("非法操作")
|
|
}
|
|
|
|
if adminRole.IsAdmin == 0 && loginUserId != requestUserId {
|
|
return false, errors.New("普通用户只可修改自己的用户数据")
|
|
}
|
|
|
|
if putUserRequest.Access != adminUser.Access {
|
|
// 检测账号名
|
|
res, err := adminUserDao.GetAdminUserFirstByAccess(putUserRequest.Access)
|
|
if res != nil && err != nil {
|
|
return false, errors.New("账号名重复")
|
|
}
|
|
}
|
|
|
|
if putUserRequest.Phone != adminUser.Phone {
|
|
// 检测手机号
|
|
res, err := adminUserDao.GetAdminUserFirstByPhone(putUserRequest.Phone)
|
|
if res != nil || err != nil {
|
|
return false, errors.New("手机号重复")
|
|
}
|
|
}
|
|
|
|
// 检测角色
|
|
if putUserRequest.RoleID == "" {
|
|
return false, errors.New("角色错误")
|
|
}
|
|
roleID, err := strconv.ParseInt(putUserRequest.RoleID, 10, 64)
|
|
if err != nil {
|
|
return false, errors.New("角色错误")
|
|
}
|
|
|
|
if roleID != adminUser.RoleID {
|
|
res, err := adminRoleDao.GetAdminRoleFirstById(roleID)
|
|
if err != nil || res == nil {
|
|
return false, errors.New("角色错误")
|
|
}
|
|
}
|
|
|
|
// 检测部门
|
|
deptID, err := strconv.ParseInt(putUserRequest.DeptID, 10, 64)
|
|
if err != nil {
|
|
return false, errors.New("部门错误")
|
|
}
|
|
|
|
if deptID != adminUser.DeptID {
|
|
adminDeptDao := dao.AdminDeptDao{}
|
|
res, err := adminDeptDao.GetAdminDeptById(deptID)
|
|
if err != nil || res == nil {
|
|
return false, errors.New("部门错误")
|
|
}
|
|
}
|
|
|
|
// 检测岗位
|
|
postID, err := strconv.ParseInt(putUserRequest.PostID, 10, 64)
|
|
if err != nil {
|
|
return false, errors.New("岗位错误")
|
|
}
|
|
|
|
if postID != adminUser.PostID {
|
|
adminPostDao := dao.AdminPostDao{}
|
|
res, err := adminPostDao.GetAdminPostById(postID)
|
|
if err != nil || res == nil {
|
|
return false, errors.New("岗位错误")
|
|
}
|
|
}
|
|
|
|
// 开始事务
|
|
tx := global.Db.Begin()
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
tx.Rollback()
|
|
}
|
|
}()
|
|
|
|
// 修改角色
|
|
data := make(map[string]interface{})
|
|
data["access"] = putUserRequest.Access
|
|
data["is_deleted"] = putUserRequest.IsDeleted
|
|
data["is_disabled"] = putUserRequest.IsDisabled
|
|
data["nick_name"] = putUserRequest.NickName
|
|
data["phone"] = putUserRequest.Phone
|
|
data["avatar"] = putUserRequest.Avatar
|
|
data["sex"] = putUserRequest.Sex
|
|
data["email"] = putUserRequest.Email
|
|
data["role_id"] = roleID
|
|
data["dept_id"] = deptID
|
|
data["post_id"] = postID
|
|
data["update_by"] = loginUserId
|
|
err = adminUserDao.EditAdminUserById(tx, requestUserId, data)
|
|
if err != nil {
|
|
tx.Rollback()
|
|
return false, errors.New("修改失败")
|
|
}
|
|
|
|
tx.Commit()
|
|
|
|
return true, nil
|
|
}
|
|
|
|
// PutUserPassword 修改用户密码
|
|
func (r *UserService) PutUserPassword(requestUserId int64, putUserPasswordRequest requests.PutUserPassword) (bool, error) {
|
|
adminUserDao := dao.AdminUserDao{}
|
|
|
|
// 获取需修改用户数据
|
|
adminUser, err := adminUserDao.GetAdminUserFirstById(requestUserId)
|
|
if err != nil || adminUser == nil {
|
|
return false, errors.New("用户数据错误")
|
|
}
|
|
|
|
// 加密旧密码
|
|
newPassword := md5.Sum([]byte(putUserPasswordRequest.NewPassword + adminUser.Salt))
|
|
// 将哈希值转换为16进制字符串
|
|
newPasswordString := hex.EncodeToString(newPassword[:])
|
|
|
|
// 检测密码是否相同
|
|
if adminUser.Password == newPasswordString {
|
|
return false, errors.New("新密码请不要和原密码相同")
|
|
}
|
|
|
|
// 检测旧密码是否正确
|
|
// 检测用户密码
|
|
password := md5.Sum([]byte(putUserPasswordRequest.Password + adminUser.Salt))
|
|
// 将哈希值转换为16进制字符串
|
|
passwordString := hex.EncodeToString(password[:])
|
|
|
|
if passwordString != adminUser.Password {
|
|
return false, errors.New("原密码错误，请重新输入")
|
|
}
|
|
|
|
// 密码校验
|
|
if len(putUserPasswordRequest.NewPassword) < 8 {
|
|
return false, errors.New("密码小于8位数")
|
|
}
|
|
|
|
num := `[0-9]{1}`
|
|
a_z := `[a-z]{1}`
|
|
A_Z := `[A-Z]{1}`
|
|
symbol := `[!@#.~$%^&*()+|_]{1}`
|
|
if b, err := regexp.MatchString(num, putUserPasswordRequest.NewPassword); !b || err != nil {
|
|
return false, errors.New("密码强度必须为字⺟⼤⼩写+数字+符号")
|
|
}
|
|
if b, err := regexp.MatchString(a_z, putUserPasswordRequest.NewPassword); !b || err != nil {
|
|
return false, errors.New("密码强度必须为字⺟⼤⼩写+数字+符号")
|
|
}
|
|
if b, err := regexp.MatchString(A_Z, putUserPasswordRequest.NewPassword); !b || err != nil {
|
|
return false, errors.New("密码强度必须为字⺟⼤⼩写+数字+符号")
|
|
}
|
|
if b, err := regexp.MatchString(symbol, putUserPasswordRequest.NewPassword); !b || err != nil {
|
|
return false, errors.New("密码强度必须为字⺟⼤⼩写+数字+符号")
|
|
}
|
|
|
|
// 开始事务
|
|
tx := global.Db.Begin()
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
tx.Rollback()
|
|
}
|
|
}()
|
|
|
|
// 修改角色
|
|
data := make(map[string]interface{})
|
|
data["password"] = newPasswordString
|
|
err = adminUserDao.EditAdminUserById(tx, requestUserId, data)
|
|
if err != nil {
|
|
tx.Rollback()
|
|
return false, errors.New("修改失败")
|
|
}
|
|
|
|
tx.Commit()
|
|
|
|
return true, nil
|
|
}
|
|
|
|
// GetUserCardNum 获取用户身份证号
|
|
func (r *UserService) GetUserCardNum(userId, familyId int64) (string, error) {
|
|
var cardNum string
|
|
|
|
// 获取用户数据
|
|
userDao := dao.UserDao{}
|
|
user, err := userDao.GetUserById(userId)
|
|
if err != nil || user == nil {
|
|
return "", errors.New("用户错误")
|
|
}
|
|
|
|
// 判断用户类型
|
|
if user.UserType == 1 {
|
|
// 患者
|
|
if familyId == 0 {
|
|
return "", errors.New("获取失败")
|
|
}
|
|
|
|
patientFamilyDao := dao.PatientFamilyDao{}
|
|
patientFamily, err := patientFamilyDao.GetPatientFamilyById(familyId)
|
|
if err != nil || patientFamily == nil {
|
|
return "", errors.New("获取失败")
|
|
}
|
|
|
|
cardNum = patientFamily.IdNumber
|
|
} else if user.UserType == 2 {
|
|
// 医生
|
|
userDoctorInfoDao := dao.UserDoctorInfoDao{}
|
|
userDoctorInfo, err := userDoctorInfoDao.GetUserDoctorInfoByUserId(userId)
|
|
if err != nil || userDoctorInfo == nil {
|
|
return "", errors.New("获取失败")
|
|
}
|
|
|
|
cardNum = userDoctorInfo.CardNum
|
|
} else if user.UserType == 3 {
|
|
// 药师
|
|
cardNum = "暂时未做"
|
|
}
|
|
|
|
return cardNum, nil
|
|
}
|
|
|
|
// GetUserBankNumByDoctorId 获取银行卡号
|
|
func (r *UserService) GetUserBankNumByDoctorId(doctorId int64) (string, error) {
|
|
// 获取用户数据
|
|
doctorBankCardDao := dao.DoctorBankCardDao{}
|
|
doctorBankCard, err := doctorBankCardDao.GetDoctorBankCardByDoctorId(doctorId)
|
|
if err != nil || doctorBankCard == nil {
|
|
return "", errors.New("错误数据")
|
|
}
|
|
|
|
return doctorBankCard.BankCardCode, nil
|
|
}
|