575 lines
20 KiB
Go
575 lines
20 KiB
Go
package logic
|
||
|
||
import (
|
||
"errors"
|
||
"fmt"
|
||
"github.com/eryajf/go-ldap-admin/config"
|
||
"github.com/eryajf/go-ldap-admin/model"
|
||
"github.com/eryajf/go-ldap-admin/public/tools"
|
||
"github.com/eryajf/go-ldap-admin/service/ildap"
|
||
"github.com/eryajf/go-ldap-admin/service/isql"
|
||
"github.com/eryajf/go-ldap-admin/svc/request"
|
||
"github.com/gin-gonic/gin"
|
||
"github.com/mozillazg/go-pinyin"
|
||
"github.com/zhaoyunxing92/dingtalk/v2"
|
||
dingreq "github.com/zhaoyunxing92/dingtalk/v2/request"
|
||
"gorm.io/gorm"
|
||
"regexp"
|
||
"strconv"
|
||
"strings"
|
||
)
|
||
|
||
type DingTalkLogic struct {
|
||
}
|
||
|
||
//通过钉钉获取部门信息
|
||
func (d *DingTalkLogic) DsyncDingTalkDepts(c *gin.Context, req interface{}) (data interface{}, rspError interface{}) {
|
||
client, err := dingtalk.NewClient(config.Conf.DingTalk.DingTalkAppKey, config.Conf.DingTalk.DingTalkAppSecret)
|
||
// 先存根部门信息到数据库和ldap，钉钉根部门id为1，ldap根部门名称为：config.Conf.DingTalk.DingTalkRootOu
|
||
r := request.DingGroupAddReq{}
|
||
r.GroupName = config.Conf.DingTalk.DingTalkRootOuName
|
||
r.GroupType = "ou"
|
||
r.ParentId = 0
|
||
r.Remark = "钉钉根部门"
|
||
r.Source = config.Conf.DingTalk.DingTalkIdSource
|
||
r.SourceDeptId = fmt.Sprintf("%s_%s", config.Conf.DingTalk.DingTalkIdSource, "1")
|
||
r.SourceDeptParentId = fmt.Sprintf("%s_%s", config.Conf.DingTalk.DingTalkIdSource, "0")
|
||
group, err := d.AddDept(&r)
|
||
if err != nil {
|
||
return nil, fmt.Sprintf("新增部门失败：部门名称为：%s,钉钉部门id为：%d,错误信息：%s", r.GroupName, r.SourceDeptId, err.Error())
|
||
}
|
||
// 获取根部门下的部门信息，进行处理
|
||
reqDept := &dingreq.DeptList{}
|
||
reqDept.DeptId = 1
|
||
reqDept.Language = "zh_CN"
|
||
err = d.GetSubDepts(client, reqDept, group.ID, r.Source)
|
||
if err != nil {
|
||
return nil, fmt.Sprintf("DsyncDingTalkDepts同步部门出错：%s", err.Error())
|
||
}
|
||
return nil, nil
|
||
}
|
||
|
||
// 通过钉钉获取部门信息，并存入数据库
|
||
func (d *DingTalkLogic) GetSubDepts(client *dingtalk.DingTalk, req *dingreq.DeptList, pgId uint, source string) error {
|
||
// 获取子部门列表
|
||
depts, err := client.GetDeptList(req)
|
||
if err != nil {
|
||
return errors.New(fmt.Sprintf("GetSubDepts获取部门列表失败：%s", err.Error()))
|
||
}
|
||
fmt.Println("GetSubDepts获取到的钉钉部门列表：", depts)
|
||
// 遍历并处理当前部门信息
|
||
for _, dept := range depts.Depts {
|
||
//先判断分组类型,默认为cn，方便应对钉钉动态调整原本没有成员的部门加入成员后，导致我们无法增加
|
||
localDept := request.DingGroupAddReq{
|
||
GroupType: "cn",
|
||
ParentId: pgId,
|
||
GroupName: dept.Name,
|
||
Remark: dept.Name,
|
||
Source: config.Conf.DingTalk.DingTalkIdSource,
|
||
SourceDeptParentId: fmt.Sprintf("%s_%d", source, dept.ParentId),
|
||
SourceDeptId: fmt.Sprintf("%s_%d", source, dept.Id),
|
||
SourceUserNum: 0,
|
||
}
|
||
//获取钉钉方，若部门存在人员信息，则设置为cn类型
|
||
//reqTemp := &dingreq.DeptUserId{}
|
||
//reqTemp.DeptId = dept.Id
|
||
//repTemp, err := client.GetDeptUserIds(reqTemp)
|
||
//if err != nil {
|
||
// return errors.New(fmt.Sprintf("GetSubDepts获取部门用户Id列表失败：%s", err.Error()))
|
||
//}
|
||
//fmt.Println("钉钉部门人员列表：", repTemp)
|
||
//if len(repTemp.UserIds) > 0 {
|
||
// localDept.GroupType = "cn"
|
||
// localDept.SourceUserNum = len(repTemp.UserIds)
|
||
//}
|
||
// 处理部门入库
|
||
deptTemp, err := d.AddDept(&localDept)
|
||
if err != nil {
|
||
return errors.New(fmt.Sprintf("GetSubDepts添加部门入库失败：%s", err.Error()))
|
||
}
|
||
// 递归调用
|
||
sub := &dingreq.DeptList{}
|
||
sub.DeptId = dept.Id
|
||
sub.Language = "zh_CN"
|
||
d.GetSubDepts(client, sub, deptTemp.ID, deptTemp.Source)
|
||
}
|
||
return nil
|
||
}
|
||
|
||
//根据现有数据库同步到的部门信息，开启用户同步
|
||
func (d DingTalkLogic) SyncDingTalkUsers(c *gin.Context, req interface{}) (data interface{}, rspError interface{}) {
|
||
client, err := dingtalk.NewClient(config.Conf.DingTalk.DingTalkAppKey, config.Conf.DingTalk.DingTalkAppSecret)
|
||
//获取数据库里面的钉钉同步过来的部门信息
|
||
r := request.GroupListAllReq{}
|
||
r.GroupType = "cn"
|
||
r.Source = config.Conf.DingTalk.DingTalkIdSource
|
||
depts, err := isql.Group.ListAll(&r)
|
||
if err != nil {
|
||
return nil, fmt.Sprintf("SyncDingTalkUsers查询本地部门列表失败：", err.Error())
|
||
}
|
||
//遍历处理部门，获取钉钉对应的用户信息
|
||
for index, dept := range depts {
|
||
fmt.Println(fmt.Sprintf("当前进行的步调为：%d,部门名称为：%s", index, dept.GroupName))
|
||
err = d.AddDeptUser(client, dept, 0)
|
||
if err != nil {
|
||
return nil, fmt.Sprintf("SyncDingTalkUsers添加部门下用户失败：", err.Error())
|
||
}
|
||
}
|
||
return nil, nil
|
||
}
|
||
|
||
//获取并处理钉钉部门下的用户信息入库
|
||
func (d DingTalkLogic) AddDeptUser(client *dingtalk.DingTalk, dept *model.Group, cursor int) error {
|
||
// 处理部门下的人员信息
|
||
deptId := strings.Split(dept.SourceDeptId, "_")
|
||
tempId, err := strconv.Atoi(deptId[1])
|
||
if err != nil {
|
||
return err
|
||
}
|
||
//方式一：获取部门下用户信息，一次100个，遍历后插入数据库，经过验证，第三方依赖包有问题
|
||
r := dingreq.DeptDetailUserInfo{}
|
||
r.DeptId = tempId
|
||
r.Language = "zh_CN"
|
||
r.Cursor = cursor
|
||
r.Size = 100
|
||
//获取钉钉部门人员信息
|
||
rep, err := client.GetDeptDetailUserInfo(&r)
|
||
fmt.Println(fmt.Sprintf("当前获取的部门名称为：%s,总用户量为：%d", dept.GroupName, len(rep.DeptDetailUsers)))
|
||
if err != nil {
|
||
return errors.New(fmt.Sprintf("AddDeptUser获取钉钉部门人员信息失败：%s", err.Error()))
|
||
}
|
||
//方式二：临时处理方案：获取部门用户id列表，遍历，挨个从钉钉获取用户信息
|
||
//dingr := dingreq.DeptUserId{}
|
||
//dingr.DeptId = tempId
|
||
//deptUserIds, err := client.GetDeptUserIds(&dingr)
|
||
//if err != nil {
|
||
// return errors.New(fmt.Sprintf("AddDeptUser通过用户部门id从钉钉获取用户id列表失败:%s", err.Error()))
|
||
//}
|
||
// 遍历并处理当前部门下的人员信息
|
||
for _, detail := range rep.DeptDetailUsers {
|
||
//for index, userId := range deptUserIds.UserIds {
|
||
// fmt.Println(fmt.Sprintf("获取到的部门用户数为：%d,正在处理的用户序号为：%d,总Ids为：", len(deptUserIds.UserIds), index))
|
||
// fmt.Println(deptUserIds.UserIds)
|
||
// userReq := dingreq.UserDetail{}
|
||
// userReq.UserId = userId
|
||
// userReq.Language = "zh_CN"
|
||
// detail, err := client.GetUserDetail(&userReq)
|
||
// if err != nil {
|
||
// return errors.New(fmt.Sprintf("AddDeptUser通过用户id从钉钉获取用户详情失败:%s", err.Error()))
|
||
// }
|
||
// 获取人员信息
|
||
fmt.Println("钉钉人员详情：", detail)
|
||
userName := ""
|
||
if detail.OrgEmail != "" {
|
||
emailstr := strings.Split(detail.OrgEmail, "@")
|
||
userName = emailstr[0]
|
||
}
|
||
if userName == "" && detail.Name != "" {
|
||
name := pinyin.LazyConvert(detail.Name, nil)
|
||
userName = strings.Join(name, "")
|
||
}
|
||
if userName == "" && detail.Mobile != "" {
|
||
userName = detail.Mobile
|
||
}
|
||
|
||
if detail.JobNumber == "" {
|
||
detail.JobNumber = userName
|
||
}
|
||
//钉钉部门ids,转换为内部部门id
|
||
sourceDeptIds := []string{}
|
||
for _, deptId := range detail.DeptIds {
|
||
sourceDeptIds = append(sourceDeptIds, fmt.Sprintf("%s_%d", config.Conf.DingTalk.DingTalkIdSource, deptId))
|
||
}
|
||
groupIds, err := isql.Group.DingTalkDeptIdsToGroupIds(sourceDeptIds)
|
||
if err != nil {
|
||
return errors.New(fmt.Sprintf("AddDeptUser转换钉钉部门id到本地分组id出错：%s", err.Error()))
|
||
}
|
||
user := request.DingUserAddReq{
|
||
Username: userName,
|
||
Password: config.Conf.DingTalk.DingTalkUserInitPassword,
|
||
Nickname: detail.Name,
|
||
GivenName: detail.Name,
|
||
Mail: detail.OrgEmail,
|
||
JobNumber: detail.JobNumber,
|
||
Mobile: detail.Mobile,
|
||
Avatar: detail.Avatar,
|
||
PostalAddress: detail.WorkPlace,
|
||
Departments: dept.GroupName,
|
||
Position: detail.Title,
|
||
Introduction: detail.Remark,
|
||
Status: 1,
|
||
DepartmentId: groupIds,
|
||
Source: config.Conf.DingTalk.DingTalkIdSource,
|
||
SourceUserId: fmt.Sprintf("%s_%s", config.Conf.DingTalk.DingTalkIdSource, detail.UserId),
|
||
SourceUnionId: fmt.Sprintf("%s_%s", config.Conf.DingTalk.DingTalkIdSource, detail.UnionId),
|
||
}
|
||
// 入库
|
||
repUser, err := d.AddUser(&user)
|
||
if err != nil {
|
||
return errors.New(fmt.Sprintf("AddDeptUser添加用户失败：%s", err.Error()))
|
||
}
|
||
fmt.Println("入库成功，用户信息为：")
|
||
fmt.Println(repUser)
|
||
}
|
||
if rep.HasMore {
|
||
err = d.AddDeptUser(client, dept, rep.NextCursor)
|
||
if err != nil {
|
||
return errors.New(fmt.Sprintf("AddDeptUser添加用户失败：%s", err.Error()))
|
||
}
|
||
}
|
||
return nil
|
||
}
|
||
|
||
// AddGroup 添加部门数据
|
||
func (d DingTalkLogic) AddDept(r *request.DingGroupAddReq) (data *model.Group, rspError error) {
|
||
// 判断部门名称是否存在
|
||
filter := tools.H{"source_dept_id": r.SourceDeptId}
|
||
dept := new(model.Group)
|
||
err := isql.Group.Find(filter, dept)
|
||
flag := errors.Is(err, gorm.ErrRecordNotFound)
|
||
fmt.Println("部门是否存在：", filter, flag)
|
||
if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
|
||
return nil, errors.New(fmt.Sprintf("AddDept添加部门失败：%s", err.Error()))
|
||
}
|
||
//分组不存在，直接创建（此处通过部门名称和第三方id来共同判定唯一，理论上不会出现重复）
|
||
if errors.Is(err, gorm.ErrRecordNotFound) {
|
||
group := model.Group{
|
||
GroupType: r.GroupType,
|
||
ParentId: r.ParentId,
|
||
GroupName: r.GroupName,
|
||
Remark: r.Remark,
|
||
Creator: "system",
|
||
Source: r.Source,
|
||
SourceDeptParentId: r.SourceDeptParentId,
|
||
SourceDeptId: r.SourceDeptId,
|
||
SourceUserNum: r.SourceUserNum,
|
||
}
|
||
pdn := ""
|
||
if group.ParentId > 0 {
|
||
pdn, err = isql.Group.GetGroupDn(r.ParentId, "")
|
||
if err != nil {
|
||
return nil, errors.New(fmt.Sprintf("AddDept获取父级部门dn失败：%s", err.Error()))
|
||
}
|
||
}
|
||
err = ildap.Group.Add(&group, pdn)
|
||
if err != nil {
|
||
return nil, tools.NewLdapError(fmt.Errorf("AddDept向LDAP创建分组失败" + err.Error()))
|
||
}
|
||
// 创建
|
||
err = isql.Group.Add(&group)
|
||
if err != nil {
|
||
return nil, tools.NewLdapError(fmt.Errorf("AddDept向MySQL创建分组失败:" + err.Error()))
|
||
}
|
||
// 默认创建分组之后，需要将admin添加到分组中
|
||
adminInfo := new(model.User)
|
||
err = isql.User.Find(tools.H{"id": 1}, adminInfo)
|
||
if err != nil {
|
||
return nil, errors.New(fmt.Sprintf("AddDept获取admin用户失败：%s", tools.NewMySqlError(err).Error()))
|
||
}
|
||
|
||
err = isql.Group.AddUserToGroup(&group, []model.User{*adminInfo})
|
||
if err != nil {
|
||
return nil, tools.NewMySqlError(fmt.Errorf("AddDept添加用户到分组失败: %s", err.Error()))
|
||
}
|
||
return &group, nil
|
||
} else { //分组存在
|
||
//判断是否名字/备注/钉钉部门ID有修改
|
||
if r.GroupName != dept.GroupName || r.Remark != dept.Remark || r.SourceDeptParentId != dept.SourceDeptParentId || r.SourceUserNum != dept.SourceUserNum {
|
||
err = d.UpdateDept(r)
|
||
if err != nil {
|
||
return nil, errors.New(fmt.Sprintf("AddDept更新部门失败：%s", err.Error()))
|
||
}
|
||
}
|
||
//处理父级部门变化
|
||
if r.SourceDeptParentId != dept.SourceDeptParentId {
|
||
// TODO 待处理父级部门变化情况
|
||
}
|
||
return dept, nil
|
||
}
|
||
}
|
||
|
||
// UpdateDept 更新部门数据
|
||
func (d DingTalkLogic) UpdateDept(r *request.DingGroupAddReq) error {
|
||
oldData := new(model.Group)
|
||
filter := tools.H{"source_dept_id": r.SourceDeptId}
|
||
err := isql.Group.Find(filter, oldData)
|
||
if err != nil {
|
||
return errors.New(fmt.Sprintf("UpdateDept获取旧的部门信息失败:%s", tools.NewMySqlError(err).Error()))
|
||
}
|
||
dept := model.Group{
|
||
Model: oldData.Model,
|
||
GroupName: r.GroupName,
|
||
Remark: r.Remark,
|
||
Creator: "system",
|
||
GroupType: oldData.GroupType,
|
||
SourceDeptId: r.SourceDeptId,
|
||
SourceDeptParentId: r.SourceDeptParentId,
|
||
SourceUserNum: r.SourceUserNum,
|
||
}
|
||
|
||
oldGroupName := oldData.GroupName
|
||
oldRemark := oldData.Remark
|
||
dn, err := isql.Group.GetGroupDn(oldData.ID, "")
|
||
if err != nil {
|
||
return errors.New(fmt.Sprintf("UpdateDept不去部门dn失败:%s", tools.NewMySqlError(err).Error()))
|
||
}
|
||
err = ildap.Group.Update(&dept, dn, oldGroupName, oldRemark)
|
||
if err != nil {
|
||
return tools.NewLdapError(fmt.Errorf("UpdateDept向LDAP更新分组失败：" + err.Error()))
|
||
}
|
||
//若配置了不允许修改分组名称，则不更新分组名称
|
||
if !config.Conf.Ldap.LdapGroupNameModify {
|
||
dept.GroupName = oldGroupName
|
||
}
|
||
err = isql.Group.Update(&dept)
|
||
if err != nil {
|
||
return tools.NewLdapError(fmt.Errorf("UpdateDept向MySQL更新分组失败:" + err.Error()))
|
||
}
|
||
return nil
|
||
}
|
||
|
||
// AddUser 添加用户数据
|
||
func (d DingTalkLogic) AddUser(r *request.DingUserAddReq) (data *model.User, rspError error) {
|
||
// 兼容处理钉钉异常人员信息，若username，mail，mobile都没有的直接跳过
|
||
if r.Username == "" && r.Mail == "" && r.Mobile == "" {
|
||
emptyData := new(model.User)
|
||
emptyData.Introduction = fmt.Sprintf("此用户：%s，username，mail，mobile皆为空，跳过入库，请手动置后台添加", r.Nickname)
|
||
emptyData.Nickname = r.Nickname
|
||
emptyData.SourceUserId = r.SourceUserId
|
||
emptyData.Source = r.Source
|
||
emptyData.GivenName = r.GivenName
|
||
return emptyData, nil
|
||
}
|
||
|
||
isExist := false
|
||
oldData := new(model.User)
|
||
if isql.User.Exist(tools.H{"source_user_id": r.SourceUserId}) {
|
||
err := isql.User.Find(tools.H{"source_user_id": r.SourceUserId}, oldData)
|
||
if err != nil {
|
||
return nil, errors.New(fmt.Sprintf("AddUser根据钉钉用户id获取用户失败：%s", err.Error()))
|
||
}
|
||
isExist = true
|
||
}
|
||
if !isExist {
|
||
if isql.User.Exist(tools.H{"source_union_id": r.SourceUnionId}) {
|
||
err := isql.User.Find(tools.H{"source_union_id": r.SourceUnionId}, oldData)
|
||
if err != nil {
|
||
return nil, errors.New(fmt.Sprintf("AddUser根据钉钉用户unionid获取用户失败：%s", err.Error()))
|
||
}
|
||
isExist = true
|
||
}
|
||
}
|
||
//if !isExist {
|
||
// if r.Mail != "" && isql.User.Exist(tools.H{"mail": r.Mail}) {
|
||
// err := isql.User.Find(tools.H{"mail": r.Mail}, oldData)
|
||
// if err != nil {
|
||
// return nil, errors.New(fmt.Sprintf("AddUser根据钉钉用户mail获取用户失败：%s", err.Error()))
|
||
// }
|
||
// isExist = true
|
||
// }
|
||
//}
|
||
if !isExist {
|
||
if isql.User.Exist(tools.H{"job_number": r.JobNumber}) {
|
||
err := isql.User.Find(tools.H{"job_number": r.JobNumber}, oldData)
|
||
if err != nil {
|
||
return nil, errors.New(fmt.Sprintf("AddUser根据钉钉用户job_number获取用户失败：%s", err.Error()))
|
||
}
|
||
isExist = true
|
||
}
|
||
}
|
||
if !isExist {
|
||
if isql.User.Exist(tools.H{"mobile": r.Mobile}) {
|
||
err := isql.User.Find(tools.H{"mobile": r.Mobile}, oldData)
|
||
if err != nil {
|
||
return nil, errors.New(fmt.Sprintf("AddUser根据钉钉用户mobile获取用户失败：%s", err.Error()))
|
||
}
|
||
isExist = true
|
||
}
|
||
}
|
||
if !isExist {
|
||
//组装用户名
|
||
//先根据钉钉唯一id获取，查看数据库中是否存在
|
||
//不存在，则根据用户名 like 用户名获取尾号最大的账号
|
||
//重新设定用户名
|
||
userData := new(model.User)
|
||
err := isql.User.FindTheSameUserName(r.Username, userData)
|
||
if err != nil && errors.Is(err, gorm.ErrRecordNotFound) {
|
||
} else {
|
||
// 找到重名用户，
|
||
re := regexp.MustCompile("[0-9]+")
|
||
num := re.FindString(userData.Username)
|
||
n := 1
|
||
if num != "" {
|
||
m, err := strconv.Atoi(num)
|
||
if err != nil {
|
||
return
|
||
}
|
||
n = m + 1
|
||
}
|
||
r.Username = fmt.Sprintf("%s%d", r.Username, n)
|
||
}
|
||
}
|
||
if isExist {
|
||
r.Username = oldData.Username
|
||
user, err := d.UpdateUser(r, oldData)
|
||
if err != nil {
|
||
return nil, errors.New(fmt.Sprintf("AddUser用户已存在，更新用户失败：%s", err.Error()))
|
||
}
|
||
return user, nil
|
||
}
|
||
// 根据角色id获取角色
|
||
r.RoleIds = []uint{2} // 默认添加为普通用户角色
|
||
roles, err := isql.Role.GetRolesByIds(r.RoleIds)
|
||
if err != nil {
|
||
return nil, tools.NewValidatorError(fmt.Errorf("AddUser根据角色ID获取角色信息失败:%s", err.Error()))
|
||
}
|
||
|
||
var reqRoleSorts []int
|
||
for _, role := range roles {
|
||
reqRoleSorts = append(reqRoleSorts, int(role.Sort))
|
||
}
|
||
deptIds := tools.SliceToString(r.DepartmentId, ",")
|
||
user := model.User{
|
||
Username: r.Username,
|
||
Password: r.Password,
|
||
Nickname: r.Nickname,
|
||
GivenName: r.GivenName,
|
||
Mail: r.Mail,
|
||
JobNumber: r.JobNumber,
|
||
Mobile: r.Mobile,
|
||
Avatar: r.Avatar,
|
||
PostalAddress: r.PostalAddress,
|
||
Departments: r.Departments,
|
||
Position: r.Position,
|
||
Introduction: r.Introduction,
|
||
Status: r.Status,
|
||
Creator: "system",
|
||
DepartmentId: deptIds,
|
||
Roles: roles,
|
||
Source: r.Source,
|
||
SourceUserId: r.SourceUserId,
|
||
SourceUnionId: r.SourceUnionId,
|
||
}
|
||
if user.Introduction == "" {
|
||
user.Introduction = r.Nickname
|
||
}
|
||
if user.JobNumber == "" {
|
||
user.JobNumber = r.Mobile
|
||
}
|
||
//先识别用户选择的部门是否是OU开头
|
||
gdns := make(map[uint]string)
|
||
for _, deptId := range r.DepartmentId {
|
||
dn, err := isql.Group.GetGroupDn(deptId, "")
|
||
if err != nil {
|
||
return nil, errors.New(fmt.Sprintf("AddUser根据用户dn信息失败:%s", err.Error()))
|
||
}
|
||
gdn := fmt.Sprintf("%s,%s", dn, config.Conf.Ldap.LdapBaseDN)
|
||
if gdn[:3] == "ou=" {
|
||
return nil, errors.New(fmt.Sprintf("AddUser不能添加用户到OU组织单元:%s", gdn))
|
||
}
|
||
gdns[deptId] = gdn
|
||
}
|
||
//先创建用户到默认分组
|
||
err = ildap.User.Add(&user)
|
||
if err != nil {
|
||
return nil, tools.NewLdapError(fmt.Errorf("AddUser向LDAP创建用户失败：" + err.Error()))
|
||
}
|
||
isExistUser := false
|
||
for deptId, gdn := range gdns {
|
||
//根据选择的部门，添加到部门内
|
||
err = ildap.Group.AddUserToGroup(gdn, fmt.Sprintf("uid=%s,%s", user.Username, config.Conf.Ldap.LdapUserDN))
|
||
if err != nil {
|
||
return nil, errors.New(fmt.Sprintf("AddUser向部门添加用户失败：%s", err.Error()))
|
||
}
|
||
if !isExistUser {
|
||
err = isql.User.Add(&user)
|
||
if err != nil {
|
||
return nil, tools.NewMySqlError(fmt.Errorf("向MySQL创建用户失败：" + err.Error()))
|
||
}
|
||
isExistUser = true
|
||
}
|
||
//根据部门分配，将用户和部门信息维护到部门关系表里面
|
||
users := []model.User{}
|
||
users = append(users, user)
|
||
depart := new(model.Group)
|
||
filter := tools.H{"id": deptId}
|
||
err = isql.Group.Find(filter, depart)
|
||
if err != nil {
|
||
return nil, tools.NewMySqlError(err)
|
||
}
|
||
err = isql.Group.AddUserToGroup(depart, users)
|
||
if err != nil {
|
||
return nil, tools.NewMySqlError(fmt.Errorf("AddUser向MySQL添加用户到分组关系失败：" + err.Error()))
|
||
}
|
||
}
|
||
return &user, nil
|
||
}
|
||
|
||
// Update 更新数据
|
||
func (d DingTalkLogic) UpdateUser(r *request.DingUserAddReq, oldData *model.User) (data *model.User, rspError error) {
|
||
deptIds := tools.SliceToString(r.DepartmentId, ",")
|
||
user := model.User{
|
||
Model: oldData.Model,
|
||
Username: r.Username,
|
||
Nickname: r.Nickname,
|
||
GivenName: r.GivenName,
|
||
Mail: r.Mail,
|
||
JobNumber: r.JobNumber,
|
||
Mobile: r.Mobile,
|
||
Avatar: r.Avatar,
|
||
PostalAddress: r.PostalAddress,
|
||
Departments: r.Departments,
|
||
Position: r.Position,
|
||
Introduction: r.Introduction,
|
||
Creator: "system",
|
||
DepartmentId: deptIds,
|
||
Source: oldData.Source,
|
||
Roles: oldData.Roles,
|
||
SourceUserId: r.SourceUserId,
|
||
SourceUnionId: r.SourceUnionId,
|
||
}
|
||
if user.Introduction == "" {
|
||
user.Introduction = r.Nickname
|
||
}
|
||
if user.PostalAddress == "" {
|
||
user.PostalAddress = "没有填写地址"
|
||
}
|
||
if user.Position == "" {
|
||
user.Position = "技术"
|
||
}
|
||
if user.JobNumber == "" {
|
||
user.JobNumber = r.Mobile
|
||
}
|
||
err := ildap.User.Update(oldData.Username, &user)
|
||
if err != nil {
|
||
return nil, tools.NewLdapError(fmt.Errorf("UpdateUser在LDAP更新用户失败：" + err.Error()))
|
||
}
|
||
|
||
// 更新用户
|
||
if !config.Conf.Ldap.LdapUserNameModify {
|
||
user.Username = oldData.Username
|
||
}
|
||
err = isql.User.Update(&user)
|
||
if err != nil {
|
||
return nil, tools.NewMySqlError(fmt.Errorf("UpdateUser在MySQL更新用户失败：" + err.Error()))
|
||
}
|
||
//判断部门信息是否有变化有变化则更新相应的数据库
|
||
oldDeptIds := tools.StringToSlice(oldData.DepartmentId, ",")
|
||
addDeptIds, removeDeptIds := tools.ArrUintCmp(oldDeptIds, r.DepartmentId)
|
||
for _, deptId := range removeDeptIds {
|
||
//从旧组中删除
|
||
err = User.RemoveUserToGroup(deptId, []uint{oldData.ID})
|
||
if err != nil {
|
||
return nil, errors.New(fmt.Sprintf("UpdateUser将用户从分组移除失败：%s", err.Error()))
|
||
}
|
||
}
|
||
for _, deptId := range addDeptIds {
|
||
//添加到新分组中
|
||
err = User.AddUserToGroup(deptId, []uint{oldData.ID})
|
||
if err != nil {
|
||
return nil, errors.New(fmt.Sprintf("UpdateUser将用户添加至分组失败：%s", err.Error()))
|
||
}
|
||
}
|
||
return &user, nil
|
||
}
|