CodeThinkerGo Viewer

code_thinker_go/test_files/handler.go.bak
1package main
2
3import (
4    "context"
5    "encoding/json"
6    "fmt"
7    "sync"
8    "time"
9
10    "code.byted.org/LarkDataIntelligence/user_service/domain/user_service/cache"
11    "code.byted.org/LarkDataIntelligence/user_service/domain/user_service/constants"
12
13    "code.byted.org/LarkDataIntelligence/common/c360base"
14
15    "code.byted.org/LarkDataIntelligence/user_service/domain/user_service/handler/store"
16
17    "code.byted.org/LarkDataIntelligence/user_service/config/user_service/config"
18
19    "code.byted.org/LarkDataIntelligence/kiteclient/kitex_gen/biz_permission"
20    "code.byted.org/LarkDataIntelligence/kiteclient/kitex_gen/biz_permission/bizpermission"
21    accountTeamHandler "code.byted.org/LarkDataIntelligence/user_service/domain/user_service/account_team/handler"
22    chatHandler "code.byted.org/LarkDataIntelligence/user_service/domain/user_service/chat/handler"
23    "code.byted.org/LarkDataIntelligence/user_service/domain/user_service/handler/auth"
24    bizUserHandler "code.byted.org/LarkDataIntelligence/user_service/domain/user_service/handler/biz_user"
25    authConfigHandler "code.byted.org/LarkDataIntelligence/user_service/domain/user_service/handler/config"
26    userProfileHandler "code.byted.org/LarkDataIntelligence/user_service/domain/user_service/user_profile/handler"
27    "code.byted.org/LarkDataIntelligence/user_service/utils"
28
29    "code.byted.org/LarkDataIntelligence/user_service/domain/user_service/datasource"
30    B "code.byted.org/LarkDataIntelligence/user_service/domain/user_service/datasource/base"
31    "code.byted.org/LarkDataIntelligence/user_service/domain/user_service/model"
32    us "code.byted.org/LarkDataIntelligence/user_service/domain/user_service/user"
33    "code.byted.org/LarkDataIntelligence/user_service/kitex_gen/base"
34    "code.byted.org/LarkDataIntelligence/user_service/kitex_gen/user_service"
35    "github.com/sirupsen/logrus"
36    "golang.org/x/sync/errgroup"
37)
38
39// UserServiceImpl implements the last service interface defined in the IDL.
40type UserServiceImpl struct {
41    userProfileHandler *userProfileHandler.UserProfileHandler
42    accountTeamHandler *accountTeamHandler.AccountTeamHandler
43    userAuthHandler    *auth.UserAuthHandler
44    userStoreHandler   *store.UserStoreHandler
45    authConfigHandler  *authConfigHandler.AuthConfigHandler
46    bizUserHandler     *bizUserHandler.BizUserProxyHandler
47    chatHandler        *chatHandler.ChatHandler
48    cacheService       *cache.UserCacheService
49}
50
51func NewUserService(
52    userProfileHandler *userProfileHandler.UserProfileHandler,
53    accountTeamHandler *accountTeamHandler.AccountTeamHandler,
54    userAuthHandler *auth.UserAuthHandler,
55    userStoreHandler *store.UserStoreHandler,
56    authConfigHandler *authConfigHandler.AuthConfigHandler,
57    bizUserHandler *bizUserHandler.BizUserProxyHandler,
58    chatHandler *chatHandler.ChatHandler,
59    cacheService *cache.UserCacheService,
60) (*UserServiceImpl, error) {
61    return &UserServiceImpl{
62        userProfileHandler: userProfileHandler,
63        accountTeamHandler: accountTeamHandler,
64        userAuthHandler:    userAuthHandler,
65        userStoreHandler:   userStoreHandler,
66        authConfigHandler:  authConfigHandler,
67        bizUserHandler:     bizUserHandler,
68        chatHandler:        chatHandler,
69        cacheService:       cacheService,
70    }, nil
71}
72
73// CreateUser implements the UserServiceImpl interface.
74func (s *UserServiceImpl) CreateUser(ctx context.Context, req *user_service.CreateUserRequest) (resp *user_service.CommonCreateResponse, err error) {
75    resp = &user_service.CommonCreateResponse{}
76    userFromPeople := &B.User{}
77    usersFromPeople, err := datasource.GetUserDataSourceService().MGetUsersByEmails(ctx, []string{req.User.Email})
78    if err != nil {
79        resp.BaseResp = &base.BaseResp{
80            StatusMessage: err.Error(),
81        }
82        return
83    }
84    if len(usersFromPeople) > 0 {
85        logrus.Infof("usersFromPeople: %v", usersFromPeople)
86        userFromPeople = usersFromPeople[0]
87    }
88    u := model.User{
89        UserKey:      req.User.UserKey,
90        Name:         userFromPeople.Name,
91        Email:        req.User.Email,
92        DepartmentID: userFromPeople.Department.ID,
93        NickName:     req.User.NickName,
94        EmployeeID:   req.User.EmployeeID,
95        EmployeeCode: req.User.EmployeeCode,
96        Avatar:       req.User.Avatar,
97    }
98    // Create Department if not exist
99    departmentFromPeople := userFromPeople.Department
100    department := model.DepartmentModel.GetByDepartmentID(ctx, departmentFromPeople.ID)
101    if department.NotExist() {
102        d := model.Department{
103            DepartmentID:       departmentFromPeople.ID,
104            DepartmentName:     departmentFromPeople.Name,
105            DepartmentParentID: "",
106        }
107        if err = d.Create(ctx, &d); err != nil {
108            return resp, err
109        }
110    }
111
112    if err := u.Create(ctx, &u); err != nil {
113        return resp, err
114    }
115
116    resp.Success = true
117    return
118}
119
120// CreateLarkGroup implements the UserServiceImpl interface.
121func (s *UserServiceImpl) CreateLarkGroup(ctx context.Context, req *user_service.CreateLarkGroupRequest) (resp *user_service.CommonCreateResponse, err error) {
122    resp = &user_service.CommonCreateResponse{}
123    group := req.Group
124    larkGroup := model.LarkGroup{
125        TagID:        group.TagID,
126        TagValue:     group.TagValue,
127        DepartmentID: group.DepartmentID,
128        ChatID:       group.ChatID,
129    }
130    if err := model.LarkGroupModel.Create(ctx, &larkGroup); err != nil {
131        return resp, err
132    }
133    resp.Success = true
134    return
135}
136
137// CreateUserTag implements the UserServiceImpl interface.
138func (s *UserServiceImpl) CreateUserTag(ctx context.Context, req *user_service.CreateUserTagRequest) (resp *user_service.CommonCreateResponse, err error) {
139    resp = &user_service.CommonCreateResponse{}
140    tag := req.Tag
141    userTag := model.UserTag{
142        UserKey:  tag.UserKey,
143        TagID:    tag.TagID,
144        TagValue: tag.TagValue,
145    }
146    if err := model.UserTagModel.Create(ctx, &userTag); err != nil {
147        return resp, err
148    }
149    resp.Success = true
150    return
151}
152
153// CreateBizUserTag implements the UserServiceImpl interface.
154func (s *UserServiceImpl) CreateBizUserTag(ctx context.Context, req *user_service.CreateBizUserTagRequest) (resp *user_service.CommonCreateResponse, err error) {
155    resp = &user_service.CommonCreateResponse{}
156    tag := req.Tag
157    bizUserTag := model.BizUserTag{
158        BizKey:   tag.BizKey,
159        UserKey:  tag.UserKey,
160        TagID:    tag.TagID,
161        TagValue: tag.TagValue,
162    }
163    if err := model.BizUserTagModel.Create(ctx, &bizUserTag); err != nil {
164        return resp, err
165    }
166    resp.Success = true
167    return
168}
169
170// CreateBizUser implements the UserServiceImpl interface.
171func (s *UserServiceImpl) CreateBizUser(ctx context.Context, req *user_service.CreateBizUserRequest) (resp *user_service.CommonCreateResponse, err error) {
172    resp = &user_service.CommonCreateResponse{}
173    bizUser := model.BizUser{
174        BizKey:       req.User.BizKey,
175        UserKey:      req.User.UserKey,
176        DepartmentID: req.User.DepartmentID,
177        LeaderKey:    req.User.LeaderKey,
178        OpenID:       req.User.OpenID,
179        LarkID:       req.User.LarkID,
180    }
181    if err := model.BizUserModel.Create(ctx, &bizUser); err != nil {
182        return resp, err
183    }
184    resp.Success = true
185    return
186}
187
188// CreateDepartment implements the UserServiceImpl interface.
189func (s *UserServiceImpl) CreateDepartment(ctx context.Context, req *user_service.CreateDepartmentRequest) (resp *user_service.CommonCreateResponse, err error) {
190    resp = &user_service.CommonCreateResponse{}
191    data := req.Department
192    department := model.Department{
193        DepartmentID:       data.DepartmentID,
194        DepartmentName:     data.DepartmentName,
195        DepartmentParentID: data.DepartmentParentID,
196    }
197    if err := model.DepartmentModel.Create(ctx, &department); err != nil {
198        return resp, err
199    }
200    resp.Success = true
201    return
202}
203
204// CreateBiz implements the UserServiceImpl interface.
205func (s *UserServiceImpl) CreateBiz(ctx context.Context, req *user_service.CreateBizRequest) (resp *user_service.CommonCreateResponse, err error) {
206    resp = &user_service.CommonCreateResponse{}
207    data := req.Biz
208    biz := model.Biz{
209        Model:   model.Model{},
210        BizKey:  data.BizKey,
211        BizName: data.BizName,
212    }
213    if err := model.BizModel.Create(ctx, &biz); err != nil {
214        return resp, err
215    }
216    resp.Success = true
217    return
218}
219
220// MGetUser implements the UserServiceImpl interface.
221func (s *UserServiceImpl) MGetUser(ctx context.Context, req *user_service.MGetUserRequest) (resp *user_service.MGetUserResponse, err error) {
222    resp = user_service.NewMGetUserResponse()
223    if req.FromDatasource && req.QueryFilter == "email" {
224        dsUsers, err := datasource.GetUserDataSourceService().MGetUsersByEmails(ctx, req.Values)
225        if err != nil {
226            return nil, err
227        }
228
229        departmentName := func(name string, need bool) string {
230            if need {
231                return name
232            }
233
234            return ""
235        }
236
237        for _, dsUser := range dsUsers {
238            resp.Users = append(resp.Users, &user_service.User{
239                Email:          dsUser.Email,
240                DepartmentName: departmentName(dsUser.Department.Name, req.WithDepartment),
241            })
242        }
243
244        return resp, nil
245    }
246
247    users := make([]*model.User, 0)
248    filters := map[string]interface{}{
249        req.QueryFilter: req.Values,
250    }
251    q := model.WhereCond{
252        FuzzyQuery: nil,
253        ExactQuery: nil,
254        Filters:    filters,
255    }
256    if err = model.UserModel.Gets(ctx, &q, &users); err != nil {
257        logrus.WithContext(ctx).Error(err)
258        return nil, err
259    }
260    // get department info
261    departmentIDs := make([]string, 0)
262    for _, u := range users {
263        departmentIDs = append(departmentIDs, u.DepartmentID)
264    }
265    departmentMap, err := model.DepartmentModel.MGetByDepartmentID(ctx, departmentIDs)
266    if err != nil {
267        resp.BaseResp.StatusMessage = "missing parameter"
268        return
269    }
270
271    for _, user := range users {
272        resp.Users = append(resp.Users, &user_service.User{
273            UserKey:        user.UserKey,
274            Email:          user.Email,
275            LeaderKey:      user.LeaderKey,
276            DepartmentName: departmentMap[user.DepartmentID].DepartmentName,
277            IsExtern:       false,
278            Name:           user.Name,
279            NickName:       user.NickName,
280            EmployeeID:     user.EmployeeID,
281            EmployeeCode:   user.EmployeeCode,
282            Avatar:         user.Avatar,
283            DepartmentID:   user.DepartmentID,
284        })
285    }
286
287    return
288}
289
290// GetUsersByLeader implements the UserServiceImpl interface.
291func (s *UserServiceImpl) GetUsersByLeader(ctx context.Context, req *user_service.GetUsersByLeaderRequest) (resp *user_service.GetUsersByLeaderResponse, err error) {
292    resp = &user_service.GetUsersByLeaderResponse{}
293    if req.BizKey != "" {
294        users := make([]*model.BizUser, 0)
295        q := model.WhereCond{
296            FuzzyQuery: nil,
297            ExactQuery: map[string]interface{}{
298                "biz_key":    req.BizKey,
299                "leader_key": req.LeaderUserKey,
300            },
301            Filters: nil,
302        }
303        if err = model.BizUserModel.Gets(ctx, &q, &users); err != nil {
304            logrus.WithContext(ctx).Error(err)
305        }
306        for _, u := range users {
307            var email string
308            if err = u.Self(u).Select(ctx, "email", &email); err != nil {
309                logrus.WithContext(ctx).Error(err)
310            }
311            resp.Users = append(resp.Users, &user_service.User{
312                UserKey:   u.UserKey,
313                Email:     email, // TODO 是否需要再去user表获取Email
314                LeaderKey: u.LeaderKey,
315            })
316        }
317    } else {
318        users := make([]*model.User, 0)
319        q := model.WhereCond{
320            FuzzyQuery: nil,
321            ExactQuery: map[string]interface{}{
322                "leader_key": req.LeaderUserKey,
323            },
324            Filters: nil,
325        }
326        if err = model.UserModel.Gets(ctx, &q, &users); err != nil {
327            logrus.WithContext(ctx).Error(err)
328        }
329        for _, u := range users {
330            resp.Users = append(resp.Users, &user_service.User{
331                UserKey:   u.UserKey,
332                Email:     u.Email,
333                LeaderKey: u.LeaderKey,
334            })
335        }
336    }
337
338    return
339}
340
341// MCheckUserRelation implements the UserServiceImpl interface.
342func (s *UserServiceImpl) MCheckUserRelation(ctx context.Context, req *user_service.MCheckUserRelationRequest) (resp *user_service.MCheckUserRelationResponse, err error) {
343    // TODO 增加缓存|并查集实现
344    items := req.McheckUserRelationItems
345    resp = &user_service.MCheckUserRelationResponse{
346        BaseResp: base.NewBaseResp(),
347    }
348    // deep == 0 make no sense, at lease the value is 1
349    if req.Deep == 0 {
350        req.Deep = 1
351    }
352
353    for _, item := range items {
354        var r user_service.RelationValue = utils.OtherRelation
355        // if biz_key exist, find in bzi_user
356        if req.BizKey != nil {
357            r = user_service.RelationValue(us.CheckRelationshipInBizUser(ctx, int(req.Deep), *req.BizKey, item.UserKey, item.TargetUserKey))
358        }
359        if r == utils.OtherRelation {
360            r = user_service.RelationValue(us.CheckRelationshipInUser(ctx, int(req.Deep), item.UserKey, item.TargetUserKey))
361        }
362        resp.Relations = append(resp.Relations, &user_service.RelationResult_{
363            Item:     item,
364            Relation: r,
365        })
366    }
367    return
368}
369
370// DeleteUser implements the UserServiceImpl interface.
371func (s *UserServiceImpl) DeleteUser(ctx context.Context, req *user_service.DeleteUserRequest) (resp *user_service.CommonDeleteResponse, err error) {
372    // TODO 自动拼装DeleteRequest中的参数 封装一个根据request来进行删除的通用delete方法
373    resp = &user_service.CommonDeleteResponse{
374        BaseResp: &base.BaseResp{},
375    }
376    if req.UserKey == "" {
377        resp.BaseResp.StatusMessage = "missing parameter"
378        resp.Success = false
379        return
380    }
381    q, err := model.BuildQuery(model.ExactQuery, []string{"user_key"}, req.UserKey)
382    if err != nil {
383        resp.Success = false
384        return
385    }
386    success := model.UserModel.DeleteBy(ctx, q, &model.User{})
387    resp.Success = success
388    return
389}
390
391// DeleteBizUser implements the UserServiceImpl interface.
392func (s *UserServiceImpl) DeleteBizUser(ctx context.Context, req *user_service.DeleteBizUserRequest) (resp *user_service.CommonDeleteResponse, err error) {
393    resp = &user_service.CommonDeleteResponse{
394        BaseResp: &base.BaseResp{},
395    }
396    if req.UserKey == "" || req.BizKey == "" {
397        resp.BaseResp.StatusMessage = "missing parameter"
398        resp.Success = false
399        return
400    }
401    q, err := model.BuildQuery(model.ExactQuery, []string{"user_key", "biz_key"}, req.UserKey, req.BizKey)
402    if err != nil {
403        resp.Success = false
404        return
405    }
406    success := model.BizUserModel.DeleteBy(ctx, q, &model.BizUser{})
407    resp.Success = success
408    return
409}
410
411// DeleteLarkGroup implements the UserServiceImpl interface.
412func (s *UserServiceImpl) DeleteLarkGroup(ctx context.Context, req *user_service.DeleteLarkGroupRequest) (resp *user_service.CommonDeleteResponse, err error) {
413    resp = &user_service.CommonDeleteResponse{
414        BaseResp: &base.BaseResp{},
415    }
416    if req.ChatID == "" {
417        resp.BaseResp.StatusMessage = "missing parameter"
418        resp.Success = false
419        return
420    }
421    q, err := model.BuildQuery(model.ExactQuery, []string{"chat_id"}, req.ChatID)
422    if err != nil {
423        resp.Success = false
424        return
425    }
426    success := model.LarkGroupModel.DeleteBy(ctx, q, &model.LarkGroup{})
427    resp.Success = success
428    return
429}
430
431// DeleteDepartmentGroup implements the UserServiceImpl interface.
432func (s *UserServiceImpl) DeleteDepartmentGroup(ctx context.Context, req *user_service.DeleteDepartmentRequest) (resp *user_service.CommonDeleteResponse, err error) {
433    resp = &user_service.CommonDeleteResponse{
434        BaseResp: &base.BaseResp{},
435    }
436    if req.DepartmentID == "" {
437        resp.BaseResp.StatusMessage = "missing parameter"
438        resp.Success = false
439        return
440    }
441    q, err := model.BuildQuery(model.ExactQuery, []string{"department_id"}, req.DepartmentID)
442    if err != nil {
443        resp.Success = false
444        return
445    }
446    success := model.DepartmentModel.DeleteBy(ctx, q, &model.Department{})
447    resp.Success = success
448    return
449}
450
451// DeleteUserTag implements the UserServiceImpl interface.
452func (s *UserServiceImpl) DeleteUserTag(ctx context.Context, req *user_service.DeleteUserTagRequest) (resp *user_service.CommonDeleteResponse, err error) {
453    resp = &user_service.CommonDeleteResponse{
454        BaseResp: &base.BaseResp{},
455    }
456    if req.UserKey == "" || req.TagID == "" {
457        resp.BaseResp.StatusMessage = "missing parameter"
458        resp.Success = false
459        return
460    }
461    q, err := model.BuildQuery(model.ExactQuery, []string{"user_key", "tag_id"}, req.UserKey, req.TagID)
462    if err != nil {
463        resp.Success = false
464        return
465    }
466    success := model.UserTagModel.DeleteBy(ctx, q, &model.UserTag{})
467    resp.Success = success
468    return
469}
470
471// DeleteBizUserTag implements the UserServiceImpl interface.
472func (s *UserServiceImpl) DeleteBizUserTag(ctx context.Context, req *user_service.DeleteBizUserTagRequest) (resp *user_service.CommonDeleteResponse, err error) {
473    resp = &user_service.CommonDeleteResponse{
474        BaseResp: &base.BaseResp{},
475    }
476    if req.UserKey == "" || req.BizKey == "" || req.TagID == "" {
477        resp.BaseResp.StatusMessage = "missing parameter"
478        resp.Success = false
479        return
480    }
481    q, err := model.BuildQuery(model.ExactQuery, []string{"user_key", "tag_id", "biz_key"}, req.UserKey, req.TagID, req.BizKey)
482    if err != nil {
483        resp.Success = false
484        return
485    }
486    success := model.BizUserTagModel.DeleteBy(ctx, q, &model.BizUserTag{})
487    resp.Success = success
488    return
489}
490
491// DeleteBiz implements the UserServiceImpl interface.
492func (s *UserServiceImpl) DeleteBiz(ctx context.Context, req *user_service.DeleteBizRequest) (resp *user_service.CommonDeleteResponse, err error) {
493    resp = &user_service.CommonDeleteResponse{
494        BaseResp: &base.BaseResp{},
495    }
496    if req.BizKey == "" {
497        resp.BaseResp.StatusMessage = "missing parameter"
498        resp.Success = false
499        return
500    }
501    q, err := model.BuildQuery(model.ExactQuery, []string{"biz_key"}, req.BizKey)
502    if err != nil {
503        resp.Success = false
504        return
505    }
506    success := model.BizModel.DeleteBy(ctx, q, &model.Biz{})
507    resp.Success = success
508    return
509}
510
511// EmailToUserKey implements the UserServiceImpl interface. if the email not exist, it will not returned
512func (s *UserServiceImpl) EmailToUserKey(ctx context.Context, req *user_service.EmailToUserKeyResquest) (resp *user_service.EmailToUserKeyResponse, err error) {
513    users, err := model.UserModel.GetByEmails(ctx, req.Emails)
514    if err != nil {
515        logrus.Errorf("EmailToUserKey: %v", err)
516        return nil, err
517    }
518    resp = user_service.NewEmailToUserKeyResponse()
519    userKeyMap := make(map[string]string)
520    // if the email not exist, it will not returned
521    for _, u := range users {
522        userKeyMap[u.Email] = u.UserKey
523    }
524    resp.UserkeyMap = userKeyMap
525    return
526}
527
528// GetBizUser implements the UserServiceImpl interface.
529func (s *UserServiceImpl) GetBizUser(ctx context.Context, req *user_service.GetBizUserRequest) (resp *user_service.GetBizUserResponse, err error) {
530    resp = user_service.NewGetBizUserResponse()
531    resp.User = user_service.NewCombinedUser()
532    user, err := model.GetUserByBizKey(ctx, req.BizKey, req.QueryFilter, req.QueryFilterValue)
533    if err != nil {
534        return nil, err
535    }
536
537    resp.User.User = &user_service.User{
538        UserKey: user.UserKey,
539        Email:   user.Email,
540        Name:    user.Name,
541        Avatar:  user.Avatar,
542    }
543    resp.User.BizUser = &user_service.BizUser{
544        UserKey: user.UserKey,
545    }
546
547    return
548}
549
550// GetUser implements the UserServiceImpl interface.
551func (s *UserServiceImpl) GetUser(ctx context.Context, req *user_service.GetUserRequest) (resp *user_service.GetUserResponse, err error) {
552    var dsUsers []*B.User
553    resp = user_service.NewGetUserResponse()
554
555    if req.GetEmail() != "" {
556        dsUsers, err = datasource.GetUserDataSourceService().MGetUsersByEmails(ctx, []string{req.Email})
557        if err != nil {
558            return nil, err
559        }
560    } else {
561        dsUsers, err = datasource.GetUserDataSourceService().MGetUsersByEmployNumbers(ctx, []int64{req.GetEmployeeNumber()})
562        if err != nil {
563            return nil, err
564        }
565    }
566
567    if len(dsUsers) == 0 {
568        return resp, nil
569    }
570
571    dsUser := dsUsers[0]
572
573    resp.Email = dsUser.Email
574    resp.Name = dsUser.Name
575    resp.DepartmentName = dsUser.Department.Name
576    resp.LeaderName = dsUser.Leader.Name
577    resp.LeaderEmail = dsUser.Leader.Email
578    return resp, nil
579}
580
581// GetUsers implements the UserServiceImpl interface.
582func (s *UserServiceImpl) GetUsers(ctx context.Context, req *user_service.GetUsersRequest) (resp *user_service.GetUsersResponse, err error) {
583    log := logrus.WithContext(ctx).WithField("method", "GetUsers")
584    var dsUsers []*B.User
585    if len(req.GetEmails()) != 0 {
586        /* 待数据全后，走缓存获取
587        if !req.IsSetC360Base() || req.C360Base.TenantKey == "" || req.C360Base.NamespaceID == "" {
588            log.Errorf("c360base not set")
589            return nil, fmt.Errorf("c360base not set")
590        }
591        reqUserByEmails := &user_service.MGetUsersByEmailsForPluginRequest{
592            Emails:   req.Emails,
593            C360Base: req.C360Base,
594        }
595        respUserByEmails, err := s.MGetUsersByEmailsForPlugin(ctx, reqUserByEmails)
596        if err != nil { // 如果查询email失败，直接请求people
597            log.Errorf("get userinfo by emails failed. [%s]", err.Error())
598        } else {
599            userKeyEmailMap := make(map[string]string, 0)
600            for _, userInfo := range respUserByEmails.Users {
601                if userInfo != nil {
602                    userKeyEmailMap[userInfo.UserKey] = userInfo.Email
603                }
604            }
605            userProfiles, err := s.userProfileHandler.MGetPeopleInfoFromProfile(ctx, userKeyEmailMap, req.C360Base.TenantKey)
606            if err != nil {
607                log.Errorf("get people info failed. [%s]", err.Error())
608            } else {
609                resp = user_service.NewGetUsersResponse()
610                resp.Users = userProfiles
611                log.Infof("get users from profile")
612                return resp, nil
613            }
614        }
615        */
616
617        dsUsers, err = datasource.GetUserDataSourceService().MGetUsersByEmails(ctx, req.GetEmails())
618        if err != nil {
619            return nil, err
620        }
621
622    } else {
623        dsUsers, err = datasource.GetUserDataSourceService().MGetUsersByEmployNumbers(ctx, req.GetEmployeeNumbers())
624        if err != nil {
625            return nil, err
626        }
627    }
628
629    resp = user_service.NewGetUsersResponse()
630    resp.Users = map[string]*user_service.GetUsersItem{}
631
632    if len(dsUsers) == 0 {
633        return resp, nil
634    }
635
636    for _, user := range dsUsers {
637        resp.Users[user.Email] = &user_service.GetUsersItem{
638            Name:           user.Name,
639            Email:          user.Email,
640            DepartmentName: user.Department.Name,
641            LeaderName:     user.Leader.Name,
642            LeaderEmail:    user.Leader.Email,
643            Terminated:     user.Terminated,
644        }
645    }
646    log.Infof("get users from people")
647    return
648}
649
650// MGetUserByLeader implements the UserServiceImpl interface.
651func (s *UserServiceImpl) MGetUserByLeader(ctx context.Context, req *user_service.MGetUserByLeaderRequest) (resp *user_service.MGetUserByLeaderResponse, err error) {
652    log := logrus.WithContext(ctx).WithField("method", "MGetUserByLeader")
653    resp = user_service.NewMGetUserByLeaderResponse()
654
655    dsUsers, err := datasource.GetUserDataSourceService().MGetUsersByEmails(ctx, []string{req.GetEmail()})
656    if err != nil {
657        return nil, err
658    }
659
660    if len(dsUsers) == 0 {
661        log.Error("not found user")
662        return resp, nil
663    }
664
665    users, err := datasource.GetUserDataSourceService().MGetUsersByLeaderId(ctx, dsUsers[0].ID)
666    if err != nil {
667        return nil, err
668    }
669
670    for _, user := range users {
671        if user.Terminated {
672            continue
673        }
674
675        resp.Users = append(resp.Users, &user_service.GetUsersItem{
676            Name:           user.Name,
677            Email:          user.Email,
678            DepartmentName: user.Department.Name,
679            LeaderName:     user.Leader.Name,
680            LeaderEmail:    user.Leader.Email,
681        })
682    }
683
684    return resp, nil
685}
686
687// MGetUserTimeLine implements the UserServiceImpl interface.
688func (s *UserServiceImpl) MGetUserTimeLine(ctx context.Context, req *user_service.MGetUserTimeLineRequest) (resp *user_service.MGetUserTimeLineResponse, err error) {
689    resp = user_service.NewMGetUserTimeLineResponse()
690
691    res, err := datasource.GetUserDataSourceService().MGetUserTimeLine(ctx, req.GetEmails())
692    if err != nil {
693        return nil, err
694    }
695    userTimeLineMap := map[string][]*user_service.TimelineItem{}
696
697    for key, value := range res {
698        items := make([]*user_service.TimelineItem, 0)
699        for _, v := range value {
700            t := time.Time(v.TimelineCreateTime)
701            items = append(items, &user_service.TimelineItem{
702                TimelineMessage: &user_service.TimelineMessage{
703                    Terminated:     v.Terminated,
704                    Name:           v.Name,
705                    Email:          v.Email,
706                    DepartmentName: v.DepartmentName,
707                    LeaderName:     v.LeaderName,
708                },
709                TimelineCreateTime: t.String(),
710                DepartmentId:       v.DepartmentId,
711            })
712        }
713
714        userTimeLineMap[key] = items
715    }
716
717    resp.TimelineItemsMap = userTimeLineMap
718    return
719}
720
721// GetUserInfoByUserServiceCode implements the UserServiceImpl interface.
722func (s *UserServiceImpl) GetUserInfoByUserServiceCode(ctx context.Context, req *user_service.GetUserInfoRequest) (*user_service.GetUserInfoResponse, error) {
723    log := logrus.WithContext(ctx).WithField("method", "GetUserInfoByUserServiceCode")
724    resp := &user_service.GetUserInfoResponse{}
725    userInfo, err := us.GetUserInfoByUserServiceToken(ctx, req.UserServiceToken, req.AuthPlatform, req.BizKey)
726    if err != nil {
727        log.Errorf("get userinfo failed. %s", err.Error())
728        return nil, err
729    }
730    resp.UserInfo = userInfo
731    return resp, nil
732}
733
734// AuthUser implements the UserServiceImpl interface.
735func (s *UserServiceImpl) AuthUser(ctx context.Context, req *user_service.AuthUserRequest) (*user_service.AuthUserResponse, error) {
736    //log := logrus.WithContext(ctx).WithField("method", "AuthUser")
737    resp := &user_service.AuthUserResponse{}
738
739    return resp, nil
740}
741
742// GetLarkIDByEmail implements the UserServiceImpl interface.
743func (s *UserServiceImpl) GetLarkIDByEmail(ctx context.Context, req *user_service.GetLarkIDByEmailRequest) (*user_service.GetLarkIDByEmailResponse, error) {
744    log := logrus.WithContext(ctx).WithField("method", "GetLarkIDByEmail")
745    resp := &user_service.GetLarkIDByEmailResponse{}
746    larkIdMap, err := us.GetLarkIdByEmail(c360base.MustNewC360Context(ctx, req.C360Base.TenantKey, req.C360Base.NamespaceID), req.Emails)
747    if err != nil {
748        log.Errorf("err: %s", err.Error())
749        return nil, err
750    }
751    resp.LarkIdMap = larkIdMap
752    data, _ := json.Marshal(config.GetTagMapConfig())
753    logrus.Infof("tags:  %s", data)
754    return resp, nil
755}
756
757// AccountTeamListMember implements the UserServiceImpl interface. AccountTeam列表拉取
758func (s *UserServiceImpl) AccountTeamListMember(ctx context.Context, req *user_service.AccountTeamListMemberRequest) (*user_service.AccountTeamListMemberResponse, error) {
759    log := logrus.WithContext(ctx).WithField("method", "AccountTeamListMember")
760    if !req.IsSetC360Base() || req.C360Base.TenantKey == "" || req.C360Base.NamespaceID == "" {
761        log.Errorf("c360base not set")
762    }
763    resp := &user_service.AccountTeamListMemberResponse{
764        AccountTeamMembers: map[string][]*user_service.AccountTeamMember{},
765    }
766    teamMembers, err := s.accountTeamHandler.GetAccountTeamMembers(ctx, req)
767    if err != nil {
768        log.Errorf("err: %s", err.Error())
769        return nil, err
770    }
771    for accountId, team := range teamMembers {
772        resp.AccountTeamMembers[accountId] = team.AccountTeamMembers
773    }
774    return resp, nil
775}
776
777// AccountTeamApplyMember implements the UserServiceImpl interface. AccountTeam成员增加
778func (s *UserServiceImpl) AccountTeamApplyMember(ctx context.Context, req *user_service.AccountTeamApplyMemberRequest) (*user_service.AccountTeamApplyMemberResponse, error) {
779    log := logrus.WithContext(ctx).WithField("method", "AccountTeamApplyMember")
780    if !req.IsSetC360Base() || req.C360Base.TenantKey == "" || req.C360Base.NamespaceID == "" {
781        log.Errorf("c360base not set")
782    }
783    resp := &user_service.AccountTeamApplyMemberResponse{}
784    applyRet, err := s.accountTeamHandler.ApplyAccountTeamMembers(ctx, req)
785    if err != nil {
786        log.Errorf("err: %s", err.Error())
787        return nil, err
788    }
789    resp.Code = applyRet
790    resp.Message = "submit apply ok"
791    return resp, nil
792}
793
794// AccountTeamAddMember implements the UserServiceImpl interface. AccountTeam成员增加
795func (s *UserServiceImpl) AccountTeamAddMember(ctx context.Context, req *user_service.AccountTeamAddMemberRequest) (*user_service.AccountTeamAddMemberResponse, error) {
796    log := logrus.WithContext(ctx).WithField("method", "AccountTeamAddMember")
797    if !req.IsSetC360Base() || req.C360Base.TenantKey == "" || req.C360Base.NamespaceID == "" {
798        log.Errorf("c360base not set")
799    }
800    resp := &user_service.AccountTeamAddMemberResponse{}
801    _, err := s.accountTeamHandler.AddAccountTeamMembers(ctx, req)
802    if err != nil {
803        log.Errorf("err: %s", err.Error())
804        return nil, err
805    }
806    resp.Code = 0
807    resp.Message = "add member ok"
808    return resp, nil
809}
810
811// AccountTeamDelMember implements the UserServiceImpl interface. AccountTeam成员删除
812func (s *UserServiceImpl) AccountTeamDelMember(ctx context.Context, req *user_service.AccountTeamDelMemberRequest) (*user_service.AccountTeamDelMemberResponse, error) {
813    log := logrus.WithContext(ctx).WithField("method", "AccountTeamAddMember")
814    if !req.IsSetC360Base() || req.C360Base.TenantKey == "" || req.C360Base.NamespaceID == "" {
815        log.Errorf("c360base not set")
816    }
817    resp := &user_service.AccountTeamDelMemberResponse{}
818    _, err := s.accountTeamHandler.DelAccountTeamMembers(ctx, req)
819    if err != nil {
820        log.Errorf("err: %s", err.Error())
821        return nil, err
822    }
823    resp.Code = 0
824    resp.Message = "del member ok"
825    return resp, nil
826}
827
828// AccountTeamMemberGetAccess implements the UserServiceImpl interface. AccountTeam成员检查
829func (s *UserServiceImpl) AccountTeamMemberGetAccess(ctx context.Context, req *user_service.AccountTeamMemberAccessRequest) (*user_service.AccountTeamMemberAccessResponse, error) {
830    log := logrus.WithContext(ctx).WithField("method", "AccountTeamAddMember")
831    if !req.IsSetC360Base() || req.C360Base.TenantKey == "" || req.C360Base.NamespaceID == "" {
832        log.Errorf("c360base not set")
833    }
834    resp := &user_service.AccountTeamMemberAccessResponse{}
835    teamMemberAccess, err := s.accountTeamHandler.GetAccountTeamMemberAccess(ctx, req)
836    if err != nil {
837        log.Errorf("err: %s", err.Error())
838        return nil, err
839    }
840    resp.AccountTeamAccess = teamMemberAccess
841    return resp, nil
842}
843
844// MGetSfUser implements the UserServiceImpl interface. AccountTeam获取成员
845func (s *UserServiceImpl) MGetSfUser(ctx context.Context, req *user_service.MGetSfUserRequest) (*user_service.MGetSfUserResponse, error) {
846    log := logrus.WithContext(ctx).WithField("method", "AccountTeamAddMember")
847    if !req.IsSetC360Base() || req.C360Base.TenantKey == "" || req.C360Base.NamespaceID == "" {
848        log.Errorf("c360base not set")
849    }
850    resp := &user_service.MGetSfUserResponse{}
851    teamMembers, err := s.accountTeamHandler.MGetSfUser(ctx, req)
852    if err != nil {
853        log.Errorf("err: %s", err.Error())
854        return nil, err
855    }
856    resp.Users = teamMembers
857    return resp, nil
858}
859
860func (s *UserServiceImpl) ApprovalCallback(ctx context.Context, req *user_service.ApprovalCallbackRequest) (*user_service.ApprovalCallbackResponse, error) {
861    log := logrus.WithContext(ctx).WithField("method", "ApprovalCallback")
862    if !req.IsSetC360Base() || req.C360Base.TenantKey == "" || req.C360Base.NamespaceID == "" {
863        log.Errorf("c360base not set")
864    }
865    resp := &user_service.ApprovalCallbackResponse{}
866    log.Infof("callback raw data: %s", req.EventRawData)
867    err := s.accountTeamHandler.ApprovalCallback(ctx, req)
868    if err != nil {
869        log.Errorf("err: %s", err.Error())
870        return nil, err
871    }
872    resp.Code = 200
873    resp.Message = "event handled success"
874    return resp, nil
875}
876
877func (s *UserServiceImpl) AccountTeamRemoveMemberApply(ctx context.Context, req *user_service.AccountTeamRemoveMemberApplyRequest) (*user_service.AccountTeamRemoveMemberApplyResponse, error) {
878    log := logrus.WithContext(ctx).WithField("method", "AccountTeamRemoveMemberApply")
879    if !req.IsSetC360Base() || req.C360Base.TenantKey == "" || req.C360Base.NamespaceID == "" {
880        log.Errorf("c360base not set")
881    }
882    resp := &user_service.AccountTeamRemoveMemberApplyResponse{}
883    err := s.accountTeamHandler.AccountTeamRemoveMemberApply(ctx, req)
884    if err != nil {
885        log.Errorf("err: %s", err.Error())
886        return nil, err
887    }
888    resp.Code = 200
889    resp.Message = "remove apply success"
890    return resp, nil
891}
892
893func (s *UserServiceImpl) MGetAccountTeamMember(ctx context.Context, req *user_service.MGetAccountTeamMemberRequest) (*user_service.MGetAccountTeamMemberResponse, error) {
894    log := logrus.WithContext(ctx).WithField("method", "MGetAccountTeamMember")
895    if !req.IsSetC360Base() || req.C360Base.TenantKey == "" || req.C360Base.NamespaceID == "" {
896        log.Errorf("c360base not set")
897    }
898    resp := &user_service.MGetAccountTeamMemberResponse{}
899    accountTeamMembers, err := s.accountTeamHandler.MGetAccountTeamMember(ctx, req.C360Base, req.MemberIDs)
900    if err != nil {
901        log.Errorf("err: %s", err.Error())
902        return nil, err
903    }
904    resp.MemberList = accountTeamMembers
905    return resp, nil
906}
907
908// GetAccessibleBiz implements the UserServiceImpl interface.
909func (s *UserServiceImpl) GetAccessibleBiz(ctx context.Context, req *user_service.GetAccessibleBizRequest) (resp *user_service.GetAccessibleBizResponse, err error) {
910
911    clients := make(map[string]bizpermission.Client)
912    for _, u := range config.GetUnitConfig().Units {
913        if u.TenantKey == req.TenantKey {
914            client, err := bizpermission.NewClient(u.BizPermissionPSM)
915            if err != nil {
916                return nil, err
917            }
918            clients[u.Key] = client
919        }
920    }
921
922    var units []*user_service.BizInfo
923    var mutex sync.Mutex
924    var eg errgroup.Group
925    for _, u := range config.GetUnitConfig().Units {
926        if u.TenantKey != req.TenantKey {
927            continue
928        }
929        unit := u
930        eg.Go(func() error {
931            client := clients[unit.Key]
932            resp, err := client.CheckAccess(ctx, &biz_permission.CheckAccessRequest{
933                UserKey:        req.Email,
934                ApplicationKey: unit.ApplicationKey,
935                ResourceKeys:   []string{unit.TargetPermKey},
936            })
937            if err != nil {
938                return err
939            }
940
941            if detail := resp.Resources[unit.TargetPermKey]; detail != nil && detail.Accessible {
942                mutex.Lock()
943                units = append(units, &user_service.BizInfo{
944                    BizKey: unit.Key,
945                    Name:   unit.Name,
946                })
947                mutex.Unlock()
948            }
949            return nil
950        })
951    }
952
953    if err := eg.Wait(); err != nil {
954        return nil, err
955    }
956
957    return &user_service.GetAccessibleBizResponse{
958        AccessibleBizs: units,
959    }, nil
960}
961
962// SetFPTLoginInfo implements the UserServiceImpl interface.
963func (s *UserServiceImpl) SetFPTLoginInfo(ctx context.Context, req *user_service.SetFPTLoginInfoRequest) (resp *user_service.SetFPTLoginInfoResponse, err error) {
964    return s.userAuthHandler.SetFPTLoginInfo(ctx, req)
965}
966
967// GetFPTUserInfo implements the UserServiceImpl interface.
968func (s *UserServiceImpl) GetFPTUserInfo(ctx context.Context, req *user_service.GetFPTUserInfoRequest) (resp *user_service.GetFPTUserInfoResponse, err error) {
969    return s.userAuthHandler.GetFPTUserInfo(ctx, req)
970}
971
972// GetFPTAccessToken implements the UserServiceImpl interface.
973func (s *UserServiceImpl) GetFPTAccessToken(ctx context.Context, req *user_service.GetFPTAccessTokenRequest) (resp *user_service.GetFPTAccessTokenResponse, err error) {
974    return s.userAuthHandler.GetFPTAccessToken(ctx, req)
975}
976
977// LogoutAction implements the UserServiceImpl interface.
978func (s *UserServiceImpl) LogoutAction(ctx context.Context, req *user_service.LogoutActionRequest) (resp *user_service.LogoutActionResponse, err error) {
979    return s.userAuthHandler.LogoutAction(ctx, req)
980}
981
982// SetOPPLoginInfo implements the UserServiceImpl interface.
983func (s *UserServiceImpl) SetOPPLoginInfo(ctx context.Context, req *user_service.SetOPPLoginInfoRequest) (resp *user_service.SetOPPLoginInfoResponse, err error) {
984    // 中心登录没有相关检查，需要控制一下，目前没有开放平台中心登录，走的还是callback
985    return s.userAuthHandler.SetOPPLoginInfoWithNamespaceCheck(ctx, req)
986}
987
988// GetOPPUserInfo implements the UserServiceImpl interface.
989func (s *UserServiceImpl) GetOPPUserInfo(ctx context.Context, req *user_service.GetOPPUserInfoRequest) (resp *user_service.GetOPPUserInfoResponse, err error) {
990    return s.userAuthHandler.GetOPPUserInfo(ctx, req)
991}
992
993// GetOPPLoginInfo implements the UserServiceImpl interface.
994func (s *UserServiceImpl) GetOPPLoginInfo(ctx context.Context, req *user_service.GetOPPLoginInfoRequest) (resp *user_service.GetOPPLoginInfoResponse, err error) {
995    return s.userAuthHandler.GetOPPLoginInfo(ctx, req)
996}
997
998// GetOPPAccessToken implements the UserServiceImpl interface.
999func (s *UserServiceImpl) GetOPPAccessToken(ctx context.Context, req *user_service.GetOPPAccessTokenRequest) (resp *user_service.GetOPPAccessTokenResponse, err error) {
1000    return s.userAuthHandler.GetOPPAccessToken(ctx, req)
1001}
1002
1003// SetOPPRefreshTokenInfo implements the UserServiceImpl interface.
1004func (s *UserServiceImpl) SetOPPRefreshTokenInfo(ctx context.Context, req *user_service.SetOPPRefreshTokenInfoRequest) (resp *user_service.SetOPPRefreshTokenInfoResponse, err error) {
1005    return s.userAuthHandler.SetOPPRefreshTokenInfo(ctx, req)
1006}
1007
1008// Put implements the UserServiceImpl interface.
1009func (s *UserServiceImpl) Put(ctx context.Context, req *user_service.StorePutRequest) (resp *user_service.StorePutResponse, err error) {
1010    return s.userStoreHandler.Put(ctx, req)
1011}
1012
1013// Get implements the UserServiceImpl interface.
1014func (s *UserServiceImpl) Get(ctx context.Context, req *user_service.StoreGetRequest) (resp *user_service.StoreGetResponse, err error) {
1015    return s.userStoreHandler.Get(ctx, req)
1016}
1017
1018// OpenPlatformAuthCallback implements the UserServiceImpl interface. // 登录后的callback
1019func (s *UserServiceImpl) OpenPlatformAuthCallback(ctx context.Context, req *user_service.OpenPlatformAuthCallbackRequest) (resp *user_service.OpenPlatformAuthCallbackResponse, err error) {
1020    return s.userAuthHandler.OpenPlatformAuthCallback(ctx, req)
1021}
1022
1023// OpenMiniAuthCallback implements the UserServiceImpl interface.
1024func (s *UserServiceImpl) OpenMiniAuthCallback(ctx context.Context, req *user_service.OpenMiniAuthCallbackRequest) (resp *user_service.OpenMiniAuthCallbackResponse, err error) {
1025    return s.userAuthHandler.OpenMiniAuthCallback(ctx, req)
1026}
1027
1028// GetNamespaceByID implements the UserServiceImpl interface.
1029func (s *UserServiceImpl) GetNamespaceByID(ctx context.Context, req *user_service.GetNamespaceByIDRequest) (*user_service.GetNamespaceByIDResponse, error) {
1030    return s.authConfigHandler.GetNamespaceByID(ctx, req)
1031}
1032
1033// GetNamespaceByURI implements the UserServiceImpl interface.支持老域名
1034func (s *UserServiceImpl) GetNamespaceByURI(ctx context.Context, req *user_service.GetNamespaceByURIRequest) (*user_service.GetNamespaceByURIResponse, error) {
1035    return s.authConfigHandler.GetNamespaceByURI(ctx, req)
1036}
1037
1038// GetNamespaceByCode implements the UserServiceImpl interface.支持老域名
1039func (s *UserServiceImpl) GetNamespaceByCode(ctx context.Context, req *user_service.GetNamespaceByCodeRequest) (*user_service.GetNamespaceByCodeResponse, error) {
1040    return s.authConfigHandler.GetNamespaceByCode(ctx, req)
1041}
1042
1043// GetNamespacesByTenantKey implements the UserServiceImpl interface.支持老域名
1044func (s *UserServiceImpl) GetNamespacesByTenantKey(ctx context.Context, req *user_service.GetNamespacesByTenantKeyRequest) (*user_service.GetNamespacesByTenantKeyResponse, error) {
1045    return s.authConfigHandler.GetNamespacesByTenantKey(ctx, req)
1046}
1047
1048// GetAppInfoByAppKey implements the UserServiceImpl interface.支持老域名
1049func (s *UserServiceImpl) GetAppInfoByAppKey(ctx context.Context, req *user_service.GetAppInfoByAppKeyRequest) (*user_service.GetAppInfoByAppKeyResponse, error) {
1050    return s.authConfigHandler.GetAppInfoByAppKey(ctx, req)
1051}
1052
1053// GetUserByOpenID implements the UserServiceImpl interface.支持老域名
1054func (s *UserServiceImpl) GetUserByOpenID(ctx context.Context, req *user_service.GetUserByOpenIDRequest) (*user_service.GetUserByOpenIDResponse, error) {
1055    log := logrus.WithContext(ctx).WithField("method", "GetUserByOpenID")
1056    if len(req.OpenID) == 0 {
1057        log.Errorf("input openid empty")
1058        return &user_service.GetUserByOpenIDResponse{}, nil
1059    }
1060
1061    if !config.EnableUserCache() {
1062        return s.bizUserHandler.GetUserByOpenID(ctx, req)
1063    }
1064
1065    ts := time.Now()
1066    defer func() {
1067        log.WithField("hdl", "GetUserByOpenID").WithField("cost", time.Now().Sub(ts).Milliseconds()).Infof("GetUserByOpenID[%s]", req.OpenID)
1068    }()
1069    userInfo, expired, err := s.cacheService.GetUser(ctx, req.C360Base, req.OpenID)
1070    if err != nil {
1071        log.WithError(err).Errorf("get from cache failed")
1072        return nil, err
1073    }
1074    if userInfo == nil { // 为空则同步获取
1075        getResp, err := s.bizUserHandler.GetUserByOpenID(ctx, req)
1076        if err != nil {
1077            log.WithError(err).Errorf("get user by openid failed. [%s]", req.OpenID)
1078            return nil, err
1079        }
1080        if getResp == nil || getResp.User == nil {
1081            log.Errorf("get user by openid nil [%s]", req.OpenID)
1082            return nil, fmt.Errorf("ret is nil")
1083        }
1084        s.cacheService.SetUser(ctx, req.C360Base, req.OpenID, getResp.User)
1085        return getResp, nil
1086    }
1087
1088    if expired { // 过期的异步获取
1089        go func() {
1090            defer func() {
1091                errRecover := recover()
1092                if errRecover != nil {
1093                    log.Errorf("panic err")
1094                }
1095            }()
1096
1097            getResp, err := s.bizUserHandler.GetUserByOpenID(ctx, req)
1098            if err != nil {
1099                log.WithError(err).Errorf("get user by openid failed. [%s]", req.OpenID)
1100                return
1101            }
1102            if getResp == nil || getResp.User == nil {
1103                log.Errorf("get user by openid nil [%s]", req.OpenID)
1104                return
1105            }
1106            s.cacheService.SetUser(ctx, req.C360Base, req.OpenID, getResp.User)
1107        }()
1108    }
1109
1110    respOpenID := &user_service.GetUserByOpenIDResponse{}
1111    respOpenID.User = userInfo
1112    return respOpenID, nil
1113}
1114
1115// MGetUsersByOpenIDs implements the UserServiceImpl interface.支持老域名
1116func (s *UserServiceImpl) MGetUsersByOpenIDs(ctx context.Context, req *user_service.MGetUsersByOpenIDsRequest) (*user_service.MGetUsersByOpenIDsResponse, error) {
1117    log := logrus.WithContext(ctx).WithField("method", "MGetUsersByOpenIDs")
1118
1119    if len(req.OpenIDs) == 0 {
1120        log.Errorf("input openids empty")
1121        return &user_service.MGetUsersByOpenIDsResponse{}, nil
1122    }
1123    if !config.EnableUserCache() {
1124        return s.bizUserHandler.MGetUsersByOpenIDs(ctx, req)
1125    }
1126
1127    ts := time.Now()
1128    defer func() {
1129        log.WithField("hdl", "MGetUsersByOpenIDs").WithField("cost", time.Now().Sub(ts).Milliseconds()).Infof("MGetUsersByOpenIDs[%+v]", req.OpenIDs)
1130    }()
1131
1132    userInfos, newKeys, expiredKeys, err := s.cacheService.MGetUser(ctx, req.C360Base, constants.IDKeyOpenId, req.OpenIDs)
1133    if err != nil {
1134        log.WithError(err).Errorf("mget from cache failed")
1135        return nil, err
1136    }
1137
1138    if newKeys != nil && len(newKeys) > 0 { // 处理需要新获取的用户走同步获取
1139        log.Infof("mget new user by newKeys [%+v]", newKeys)
1140        newKeysReq := &user_service.MGetUsersByOpenIDsRequest{
1141            OpenIDs:  newKeys,
1142            C360Base: req.C360Base,
1143        }
1144        newKeysResp, err := s.bizUserHandler.MGetUsersByOpenIDs(ctx, newKeysReq)
1145        if err != nil {
1146            log.WithError(err).Errorf("mget new user by openids failed [%+v]", newKeys)
1147        }
1148        if newKeysResp != nil && newKeysResp.Users != nil && len(newKeysResp.Users) > 0 {
1149            userInfos = append(userInfos, newKeysResp.Users...)
1150            s.cacheService.MSetUser(ctx, req.C360Base, constants.IDKeyOpenId, newKeysResp.Users) //存储新获得后的值
1151        }
1152    }
1153
1154    if expiredKeys != nil && len(expiredKeys) > 0 { // 需要刷新的走异步刷新
1155        go func() {
1156            defer func() {
1157                errRecover := recover()
1158                if errRecover != nil {
1159                    log.Errorf("panic err")
1160                }
1161            }()
1162
1163            log.Infof("mget expired user by exipreKeys [%+v]", expiredKeys)
1164
1165            toFreshReq := &user_service.MGetUsersByOpenIDsRequest{
1166                OpenIDs:  expiredKeys,
1167                C360Base: req.C360Base,
1168            }
1169            toFreshResp, err := s.bizUserHandler.MGetUsersByOpenIDs(ctx, toFreshReq)
1170            if err != nil {
1171                log.WithError(err).Errorf("mget expired user by openids failed [%+v]", expiredKeys)
1172            }
1173
1174            if toFreshResp != nil && toFreshResp.Users != nil && len(toFreshResp.Users) > 0 {
1175                s.cacheService.MSetUser(ctx, req.C360Base, constants.IDKeyOpenId, toFreshResp.Users) //存储刷新后的值
1176            }
1177        }()
1178    }
1179    respUser := &user_service.MGetUsersByOpenIDsResponse{}
1180    respUser.Users = userInfos
1181    return respUser, nil
1182}
1183
1184// GetUserByUserKey implements the UserServiceImpl interface.支持老域名
1185func (s *UserServiceImpl) GetUserByUserKey(ctx context.Context, req *user_service.GetUserByUserKeyRequest) (*user_service.GetUserByUserKeyResponse, error) {
1186    log := logrus.WithContext(ctx).WithField("method", "GetUserByUserKey")
1187
1188    if len(req.UserKey) == 0 {
1189        log.Errorf("input userkey empty")
1190        return &user_service.GetUserByUserKeyResponse{}, nil
1191    }
1192    if !config.EnableUserCache() {
1193        return s.bizUserHandler.GetUserByUserKey(ctx, req)
1194    }
1195
1196    ts := time.Now()
1197    defer func() {
1198        log.WithField("hdl", "GetUserByUserKey").WithField("cost", time.Now().Sub(ts).Milliseconds()).Infof("GetUserByUserKey[%s]", req.UserKey)
1199    }()
1200    userInfo, expired, err := s.cacheService.GetUser(ctx, req.C360Base, req.UserKey)
1201    if err != nil {
1202        log.WithError(err).Errorf("get from cache failed")
1203        return nil, err
1204    }
1205    if userInfo == nil { // 为空则同步获取
1206        getResp, err := s.bizUserHandler.GetUserByUserKey(ctx, req)
1207        if err != nil {
1208            log.WithError(err).Errorf("get user by userkey failed. [%s]", req.UserKey)
1209            return nil, err
1210        }
1211        if getResp == nil || getResp.User == nil {
1212            log.Errorf("get user by userkey nil [%s]", req.UserKey)
1213            return nil, fmt.Errorf("ret is nil")
1214        }
1215        s.cacheService.SetUser(ctx, req.C360Base, req.UserKey, getResp.User)
1216        return getResp, nil
1217    }
1218
1219    if expired { // 过期的异步获取
1220        go func() {
1221            defer func() {
1222                errRecover := recover()
1223                if errRecover != nil {
1224                    log.Errorf("panic err")
1225                }
1226            }()
1227
1228            getResp, err := s.bizUserHandler.GetUserByUserKey(ctx, req)
1229            if err != nil {
1230                log.WithError(err).Errorf("get user by userkey failed. [%s]", req.UserKey)
1231                return
1232            }
1233            if getResp == nil || getResp.User == nil {
1234                log.Errorf("get user by userkey nil [%s]", req.UserKey)
1235                return
1236            }
1237            s.cacheService.SetUser(ctx, req.C360Base, req.UserKey, getResp.User)
1238        }()
1239    }
1240
1241    respUserKey := &user_service.GetUserByUserKeyResponse{}
1242    respUserKey.User = userInfo
1243    return respUserKey, nil
1244}
1245
1246// MGetUsersByUserKeys implements the UserServiceImpl interface.支持老域名
1247func (s *UserServiceImpl) MGetUsersByUserKeys(ctx context.Context, req *user_service.MGetUsersByUserKeysRequest) (*user_service.MGetUsersByUserKeysResponse, error) {
1248    log := logrus.WithContext(ctx).WithField("method", "MGetUsersByUserKeys")
1249
1250    if len(req.UserKeyList) == 0 {
1251        log.Errorf("input userkey list empty")
1252        return &user_service.MGetUsersByUserKeysResponse{}, nil
1253    }
1254    if !config.EnableUserCache() {
1255        return s.bizUserHandler.MGetUsersByUserKeys(ctx, req)
1256    }
1257
1258    ts := time.Now()
1259    defer func() {
1260        log.WithField("hdl", "MGetUsersByUserKeys").WithField("cost", time.Now().Sub(ts).Milliseconds()).Infof("MGetUsersByUserKeys[%+v]", req.UserKeyList)
1261    }()
1262
1263    userInfos, newKeys, expiredKeys, err := s.cacheService.MGetUser(ctx, req.C360Base, constants.IDKeyUserKey, req.UserKeyList)
1264    if err != nil {
1265        log.WithError(err).Errorf("mget from cache failed")
1266        return nil, err
1267    }
1268
1269    if newKeys != nil && len(newKeys) > 0 { // 处理需要新获取的用户走同步获取
1270        log.Infof("mget new user by newKeys [%+v]", newKeys)
1271        newKeysReq := &user_service.MGetUsersByUserKeysRequest{
1272            UserKeyList: newKeys,
1273            C360Base:    req.C360Base,
1274        }
1275        newKeysResp, err := s.bizUserHandler.MGetUsersByUserKeys(ctx, newKeysReq)
1276        if err != nil {
1277            log.WithError(err).Warnf("mget new user by userkey failed [%+v]", newKeys)
1278        }
1279        if newKeysResp != nil && newKeysResp.Users != nil && len(newKeysResp.Users) > 0 {
1280            userInfos = append(userInfos, newKeysResp.Users...)
1281            s.cacheService.MSetUser(ctx, req.C360Base, constants.IDKeyUserKey, newKeysResp.Users) //存储新获得后的值
1282        }
1283    }
1284
1285    if expiredKeys != nil && len(expiredKeys) > 0 { // 需要刷新的走异步刷新
1286        go func() {
1287            defer func() {
1288                errRecover := recover()
1289                if errRecover != nil {
1290                    log.Errorf("panic err")
1291                }
1292            }()
1293
1294            log.Infof("mget expired user by exipreKeys [%+v]", expiredKeys)
1295
1296            toFreshReq := &user_service.MGetUsersByUserKeysRequest{
1297                UserKeyList: expiredKeys,
1298                C360Base:    req.C360Base,
1299            }
1300            toFreshResp, err := s.bizUserHandler.MGetUsersByUserKeys(ctx, toFreshReq)
1301            if err != nil {
1302                log.WithError(err).Errorf("mget expired user by userkey failed [%+v]", expiredKeys)
1303            }
1304
1305            if toFreshResp != nil && toFreshResp.Users != nil && len(toFreshResp.Users) > 0 {
1306                s.cacheService.MSetUser(ctx, req.C360Base, constants.IDKeyUserKey, toFreshResp.Users) //存储刷新后的值
1307            }
1308        }()
1309    }
1310    respUser := &user_service.MGetUsersByUserKeysResponse{}
1311    respUser.Users = userInfos
1312    return respUser, nil
1313}
1314
1315// ListUserIDs
1316func (s *UserServiceImpl) ListUserIDs(ctx context.Context, req *user_service.ListUsersRequest) (*user_service.ListUsersResponse, error) {
1317    return s.bizUserHandler.ListUserIDs(ctx, req)
1318}
1319
1320// GetUserByEmailForPlugin implements the UserServiceImpl interface.支持老域名
1321func (s *UserServiceImpl) GetUserByEmailForPlugin(ctx context.Context, req *user_service.GetUserByEmailForPluginRequest) (*user_service.GetUserByEmailForPluginResponse, error) {
1322    log := logrus.WithContext(ctx).WithField("method", "GetUserByEmailForPlugin")
1323
1324    if len(req.Email) == 0 {
1325        log.Errorf("input email empty")
1326        return &user_service.GetUserByEmailForPluginResponse{}, nil
1327    }
1328    if !config.EnableUserCache() {
1329        return s.bizUserHandler.GetUserByEmailForPlugin(ctx, req)
1330    }
1331
1332    ts := time.Now()
1333    defer func() {
1334        log.WithField("hdl", "GetUserByEmailForPlugin").WithField("cost", time.Now().Sub(ts).Milliseconds()).Infof("GetUserByEmailForPlugin[%s]", req.Email)
1335    }()
1336    userInfo, expired, err := s.cacheService.GetUser(ctx, req.C360Base, req.Email)
1337    if err != nil {
1338        log.WithError(err).Errorf("get from cache failed")
1339        return nil, err
1340    }
1341    if userInfo == nil { // 为空则同步获取
1342        getResp, err := s.bizUserHandler.GetUserByEmailForPlugin(ctx, req)
1343        if err != nil {
1344            log.WithError(err).Errorf("get user by email failed. [%s]", req.Email)
1345            return nil, err
1346        }
1347        if getResp == nil || getResp.User == nil {
1348            log.Errorf("get user by email nil [%s]", req.Email)
1349            return nil, fmt.Errorf("ret is nil")
1350        }
1351        s.cacheService.SetUser(ctx, req.C360Base, req.Email, getResp.User)
1352        return getResp, nil
1353    }
1354
1355    if expired { // 过期的异步获取
1356        go func() {
1357            defer func() {
1358                errRecover := recover()
1359                if errRecover != nil {
1360                    log.Errorf("panic err")
1361                }
1362            }()
1363
1364            getResp, err := s.bizUserHandler.GetUserByEmailForPlugin(ctx, req)
1365            if err != nil {
1366                log.WithError(err).Errorf("get user by email failed. [%s]", req.Email)
1367                return
1368            }
1369            if getResp == nil || getResp.User == nil {
1370                log.Errorf("get user by email nil [%s]", req.Email)
1371                return
1372            }
1373            s.cacheService.SetUser(ctx, req.C360Base, req.Email, getResp.User)
1374        }()
1375    }
1376
1377    resp := &user_service.GetUserByEmailForPluginResponse{}
1378    resp.User = userInfo
1379    return resp, nil
1380}
1381
1382// MGetUsersByEmailsForPlugin implements the UserServiceImpl interface.支持老域名
1383func (s *UserServiceImpl) MGetUsersByEmailsForPlugin(ctx context.Context, req *user_service.MGetUsersByEmailsForPluginRequest) (*user_service.MGetUsersByEmailsForPluginResponse, error) {
1384    log := logrus.WithContext(ctx).WithField("method", "MGetUsersByEmailsForPlugin")
1385
1386    if len(req.Emails) == 0 {
1387        log.Errorf("input emails empty")
1388        return &user_service.MGetUsersByEmailsForPluginResponse{}, nil
1389    }
1390
1391    if !config.EnableUserCache() {
1392        return s.bizUserHandler.MGetUsersByEmailsForPlugin(ctx, req)
1393    }
1394
1395    ts := time.Now()
1396    defer func() {
1397        log.WithField("hdl", "MGetUsersByEmailsForPlugin").WithField("cost", time.Now().Sub(ts).Milliseconds()).Infof("MGetUsersByEmailsForPlugin[%d]", len(req.Emails))
1398    }()
1399
1400    userInfos, newKeys, expiredKeys, err := s.cacheService.MGetUser(ctx, req.C360Base, constants.IDKeyEmail, req.Emails)
1401    if err != nil {
1402        log.WithError(err).Errorf("mget from cache failed")
1403        return nil, err
1404    }
1405
1406    if newKeys != nil && len(newKeys) > 0 { // 处理需要新获取的用户走同步获取
1407        log.Infof("mget new user by newKeys [%+v]", newKeys)
1408        newKeysReq := &user_service.MGetUsersByEmailsForPluginRequest{
1409            Emails:   newKeys,
1410            C360Base: req.C360Base,
1411        }
1412        newKeysResp, err := s.bizUserHandler.MGetUsersByEmailsForPlugin(ctx, newKeysReq)
1413        if err != nil {
1414            log.WithError(err).Errorf("mget new user by email failed [%+v]", newKeys)
1415        }
1416        if newKeysResp != nil && newKeysResp.Users != nil && len(newKeysResp.Users) > 0 {
1417            userInfos = append(userInfos, newKeysResp.Users...)
1418            s.cacheService.MSetUser(ctx, req.C360Base, constants.IDKeyEmail, newKeysResp.Users) //存储新获得后的值
1419        }
1420    }
1421
1422    if expiredKeys != nil && len(expiredKeys) > 0 { // 需要刷新的走异步刷新
1423        go func() {
1424            defer func() {
1425                errRecover := recover()
1426                if errRecover != nil {
1427                    log.Errorf("panic err")
1428                }
1429            }()
1430
1431            log.Infof("mget expired user by exipreKeys [%d]", len(expiredKeys))
1432
1433            toFreshReq := &user_service.MGetUsersByEmailsForPluginRequest{
1434                Emails:   expiredKeys,
1435                C360Base: req.C360Base,
1436            }
1437            toFreshResp, err := s.bizUserHandler.MGetUsersByEmailsForPlugin(ctx, toFreshReq)
1438            if err != nil {
1439                log.WithError(err).Errorf("mget expired user by email failed [%+v]", expiredKeys)
1440            }
1441
1442            if toFreshResp != nil && toFreshResp.Users != nil && len(toFreshResp.Users) > 0 {
1443                s.cacheService.MSetUser(ctx, req.C360Base, constants.IDKeyEmail, toFreshResp.Users) //存储刷新后的值
1444            }
1445        }()
1446    }
1447
1448    respUser := &user_service.MGetUsersByEmailsForPluginResponse{}
1449    respUser.Users = userInfos
1450
1451    return respUser, nil
1452}
1453
1454// GetUserProfile implements the UserServiceImpl interface. 获取profile
1455func (s *UserServiceImpl) GetUserProfile(ctx context.Context, req *user_service.GetUserProfileRequest) (*user_service.GetUserProfileResponse, error) {
1456    return s.bizUserHandler.GetUserProfile(ctx, req)
1457}
1458
1459// SearchUsersAndChats implements the UserServiceImpl interface.
1460func (s *UserServiceImpl) SearchUsersAndChats(ctx context.Context, req *user_service.SearchUsersAndChatsRequest) (resp *user_service.SearchUsersAndChatsResponse, err error) {
1461    return s.chatHandler.SearchUsersAndChats(ctx, req)
1462}
1463
1464// GetUserKeysByLeaderKey implements the UserServiceImpl interface.
1465func (s *UserServiceImpl) GetUserKeysByLeaderKey(ctx context.Context, req *user_service.GetUserKeysByLeaderKeyRequest) (resp *user_service.GetUserKeysByLeaderKeyResponse, err error) {
1466    log := logrus.WithContext(ctx).WithField("method", "GetUserKeysByLeaderKey")
1467    reqUser := &user_service.GetUserByUserKeyRequest{
1468        UserKey:  req.LeaderUserKey,
1469        C360Base: req.C360Base,
1470    }
1471    userInfo, err := s.GetUserByUserKey(ctx, reqUser)
1472    if err != nil {
1473        log.WithError(err).Errorf("Get user by userKey failed. [%s]", req.LeaderUserKey)
1474        return nil, err
1475    }
1476    return s.bizUserHandler.GetUserKeysByLeaderKey(ctx, userInfo.User, req.C360Base, req.Page)
1477}
1478
1479// GetAppTokenInfo implements the UserServiceImpl interface.
1480func (s *UserServiceImpl) GetAppTokenInfo(ctx context.Context, req *user_service.GetAppTokenInfoRequest) (resp *user_service.GetAppTokenInfoResponse, err error) {
1481    return s.userAuthHandler.GetAppTokenInfo(ctx, req)
1482}
1483
1484// GetUserBySFID implements the UserServiceImpl interface.
1485func (s *UserServiceImpl) GetUserBySFID(ctx context.Context, req *user_service.GetUserBySFIDRequest) (resp *user_service.GetUserBySFIDResponse, err error) {
1486    log := logrus.WithContext(ctx).WithField("method", "GetUserBySFID")
1487
1488    if len(req.SFID) == 0 {
1489        log.Errorf("input sfid empty")
1490        return &user_service.GetUserBySFIDResponse{}, nil
1491    }
1492
1493    if !config.EnableUserCache() {
1494        return s.bizUserHandler.GetUserBySFID(ctx, req)
1495    }
1496
1497    ts := time.Now()
1498    defer func() {
1499        log.WithField("hdl", "GetUserBySFID").WithField("cost", time.Now().Sub(ts).Milliseconds()).Infof("GetUserBySFID[%s]", req.SFID)
1500    }()
1501    userInfo, expired, err := s.cacheService.GetUser(ctx, req.C360Base, req.SFID)
1502    if err != nil {
1503        log.WithError(err).Errorf("get from cache failed")
1504        return nil, err
1505    }
1506    if userInfo == nil { // 为空则同步获取
1507        getResp, err := s.bizUserHandler.GetUserBySFID(ctx, req)
1508        if err != nil {
1509            log.WithError(err).Errorf("get user by sfid failed. [%s]", req.SFID)
1510            return nil, err
1511        }
1512        if getResp == nil || getResp.User == nil {
1513            log.Errorf("get user by sfid nil [%s]", req.SFID)
1514            return nil, fmt.Errorf("ret is nil")
1515        }
1516        s.cacheService.SetUser(ctx, req.C360Base, req.SFID, getResp.User)
1517        return getResp, nil
1518    }
1519
1520    if expired { // 过期的异步获取
1521        go func() {
1522            defer func() {
1523                errRecover := recover()
1524                if errRecover != nil {
1525                    log.Errorf("panic err")
1526                }
1527            }()
1528
1529            getResp, err := s.bizUserHandler.GetUserBySFID(ctx, req)
1530            if err != nil {
1531                log.WithError(err).Errorf("get user by sfid failed. [%s]", req.SFID)
1532                return
1533            }
1534            if getResp == nil || getResp.User == nil {
1535                log.Errorf("get user by sfid nil [%s]", req.SFID)
1536                return
1537            }
1538            s.cacheService.SetUser(ctx, req.C360Base, req.SFID, getResp.User)
1539        }()
1540    }
1541
1542    respSFID := &user_service.GetUserBySFIDResponse{}
1543    respSFID.User = userInfo
1544    return respSFID, nil
1545}
1546
1547// MGetUsersBySFIDs implements the UserServiceImpl interface.
1548func (s *UserServiceImpl) MGetUsersBySFIDs(ctx context.Context, req *user_service.MGetUsersBySFIDsRequest) (resp *user_service.MGetUsersBySFIDsResponse, err error) {
1549    log := logrus.WithContext(ctx).WithField("method", "MGetUsersBySFIDs")
1550    if len(req.SFIDList) == 0 {
1551        log.Errorf("input sfids empty")
1552        return &user_service.MGetUsersBySFIDsResponse{}, nil
1553    }
1554
1555    if !config.EnableUserCache() {
1556        return s.bizUserHandler.MGetUsersBySFIDs(ctx, req)
1557    }
1558
1559    ts := time.Now()
1560    defer func() {
1561        log.WithField("hdl", "MGetUsersBySFIDs").WithField("cost", time.Now().Sub(ts).Milliseconds()).Infof("MGetUsersBySFIDs[%+v]", req.SFIDList)
1562    }()
1563
1564    userInfos, newKeys, expiredKeys, err := s.cacheService.MGetUser(ctx, req.C360Base, constants.IDKeySFIDKey, req.SFIDList)
1565    if err != nil {
1566        log.WithError(err).Errorf("mget from cache failed")
1567        return nil, err
1568    }
1569
1570    if newKeys != nil && len(newKeys) > 0 { // 处理需要新获取的用户走同步获取
1571        newKeysReq := &user_service.MGetUsersBySFIDsRequest{
1572            SFIDList: newKeys,
1573            C360Base: req.C360Base,
1574        }
1575        newKeysResp, err := s.bizUserHandler.MGetUsersBySFIDs(ctx, newKeysReq)
1576        if err != nil {
1577            log.WithError(err).Errorf("mget new user by sfid failed [%+v]", newKeys)
1578        }
1579        if newKeysResp != nil && newKeysResp.Users != nil && len(newKeysResp.Users) > 0 {
1580            userInfos = append(userInfos, newKeysResp.Users...)
1581            s.cacheService.MSetUser(ctx, req.C360Base, constants.IDKeySFIDKey, newKeysResp.Users) //存储新获得后的值
1582        }
1583    }
1584
1585    if expiredKeys != nil && len(expiredKeys) > 0 { // 需要刷新的走异步刷新
1586        go func() {
1587            defer func() {
1588                errRecover := recover()
1589                if errRecover != nil {
1590                    log.Errorf("panic err")
1591                }
1592            }()
1593
1594            toFreshReq := &user_service.MGetUsersBySFIDsRequest{
1595                SFIDList: expiredKeys,
1596                C360Base: req.C360Base,
1597            }
1598            toFreshResp, err := s.bizUserHandler.MGetUsersBySFIDs(ctx, toFreshReq)
1599            if err != nil {
1600                log.WithError(err).Errorf("mget expired user by sfid failed [%+v]", expiredKeys)
1601            }
1602
1603            if toFreshResp != nil && toFreshResp.Users != nil && len(toFreshResp.Users) > 0 {
1604                s.cacheService.MSetUser(ctx, req.C360Base, constants.IDKeySFIDKey, toFreshResp.Users) //存储刷新后的值
1605            }
1606        }()
1607    }
1608    respSFIDs := &user_service.MGetUsersBySFIDsResponse{}
1609    respSFIDs.Users = userInfos
1610
1611    return respSFIDs, nil
1612}
1613
1614// MigrateUser implements the UserServiceImpl interface.
1615func (s *UserServiceImpl) MigrateUser(ctx context.Context, req *user_service.MigrateUserRequest) (resp *user_service.MigrateUserResponse, err error) {
1616    return s.bizUserHandler.MigrateUser(ctx, req)
1617}
1618
CodeThinker, Enjoy your reading code