xps-server-go/service/system/user_service.go

package system

import (
    "time"
    "xps/constant"
    "xps/datamodels"
    "xps/datasource"
    "xps/repositories/system"
    "xps/viewmodels"
)

type UserService interface {
    GetPage(m map[string]interface{}) (*viewmodels.PageResult, error)
    GetById(ocId, groupId, userId int64) (*viewmodels.UserInfo, error)
    Create(ocTypeId int64, user *viewmodels.UserInfo) error
    Update(user *viewmodels.UserInfo) error
    Delete(m map[string]interface{}) error
}

type userService struct {
    userRepo *system.UserRepo
    accountRepo *system.AccountRepo
    roleMemberRepo *system.RoleMemberRepo
    groupRepo *system.GroupRepo
    groupMemberRepo *system.GroupMemberRepo
    groupMemberPositionRepo *system.GroupMemberPositionRepo
}

func NewUserService() UserService {
    return &userService{
        userRepo: system.NewUserRepo(datasource.InstanceMaster()),
        accountRepo: system.NewAccountRepo(datasource.InstanceMaster()),
        roleMemberRepo: system.NewRoleMemberRepo(datasource.InstanceMaster()),
        groupRepo: system.NewGroupRepo(datasource.InstanceMaster()),
        groupMemberRepo: system.NewGroupMemberRepo(datasource.InstanceMaster()),
        groupMemberPositionRepo: system.NewGroupMemberPositionRepo(datasource.InstanceMaster()),
    }
}

func (s *userService) GetPage(m map[string]interface{}) (*viewmodels.PageResult, error) {
    ocId    := m["ocId"].(int64)
    groupId := m["groupId"].(int64)
    group, err := s.groupRepo.GetById(ocId, groupId)
    if err != nil {
        return nil, err
    }
    
    nodeLeft  := group.NodeLeft
    nodeRight := group.NodeRight
    m["nodeLeft"]  = nodeLeft
    m["nodeRight"] = nodeRight
    return s.userRepo.GetPage(m)
}

func (s *userService) GetById(ocId, groupId, userId int64) (*viewmodels.UserInfo, error) {
    return s.GetById(ocId, groupId, userId)
}

func (s *userService) Create(ocTypeId int64, user *viewmodels.UserInfo) error {
    ocId      := user.OcId
    userId    := ocId //管理员ID同公司ID,只有管理员可以作账号管理
    newId     := NewID()
    accountId := newId
    
    userRole := constant.ENT_USER_ROLE
    if ocTypeId == constant.OCTYPE_ADMIN {
        userRole = constant.OP_ROLE_USER
    }else if ocTypeId == constant.OCTYPE_ORG{
        userRole = constant.ORG_ROLE_USER
    }else if ocTypeId == constant.OCTYPE_ENT{
        userRole = constant.ENT_USER_ROLE
    }else if ocTypeId == constant.OCTYPE_PARTNER{
        userRole = constant.PARTNER_ROLE_USER
    }
    
    // 1.Account
    account := &datamodels.Account{
        OcId:           ocId,
        AccountId:      accountId,
        AccountName:     user.AccountName,
        Password:        "21218cca77804d2ba1922c33e0151105",
        AccountType:     0,
        AccountRealName: user.AccountRealName,
        AccountPhone:    user.AccountPhone,
        AccountLastIp:   "",
        AccountLoc:      user.AccountLoc,
        AccountIntro:    user.AccountIntro,
        AccountPhoto:    user.AccountPhoto,
        AccountAvatar:   user.AccountAvatar,
        AccountMail:     user.AccountMail,
        AccountStaffNo:  user.AccountStaffNo,
        Status:          1,
        IsFixed:         0,
        CreatedBy:       userId,
        CreatedAt:       time.Time{},
    }
    
    err := s.accountRepo.Create(account)
    if err != nil {
        return err
    }
    
    // 2. Role member
    roleMember := &datamodels.RoleMember{
        RmId     : newId,
        OcId     : ocId,
        RoleId   : int64(userRole),
        AccountId: accountId,
    }
    err = s.roleMemberRepo.Create(roleMember)
    if err != nil {
        return err
    }
    
    // 3. Group Member
    groupId := user.GroupId
    groupMember := &datamodels.GroupMember{
        GmId     : newId,
        OcId     : ocId,
        GroupId  : groupId,
        AccountId: accountId,
    }
    err = s.groupMemberRepo.Create(groupMember)
    if err != nil {
        return err
    }
    
    // 4. Group Member Position
    positionId := user.PositionId
    groupMemberPosition := &datamodels.GroupMemberPosition{
        GmpId     : newId,
        OcId      : ocId,
        GroupId   : groupId,
        AccountId : accountId,
        PositionId: positionId,
    }
    err = s.groupMemberPositionRepo.Create(groupMemberPosition)
    return err
}

func (s *userService) Update(user *viewmodels.UserInfo) error {
    ocId       := user.OcId
    accountId  := user.AccountId
    groupId    := user.GroupId
    positionId := user.PositionId
    userId     := ocId//管理员ID同公司ID,只有管理员可以作账号管理
    
    // 1. update account
    account := &datamodels.Account{
        OcId:            ocId,
        AccountId:       accountId,
        AccountName:     user.AccountName,
        AccountType:     0,
        AccountRealName: user.AccountRealName,
        AccountPhone:    user.AccountPhone,
        AccountLastIp:   "",
        AccountLoc:      user.AccountLoc,
        AccountIntro:    user.AccountIntro,
        AccountPhoto:    user.AccountPhoto,
        AccountAvatar:   user.AccountAvatar,
        AccountMail:     user.AccountMail,
        AccountStaffNo:  user.AccountStaffNo,
        Status:          user.Status,
        UpdatedBy:       userId,
        UpdatedAt:       time.Time{},
    }
    err := s.accountRepo.Update(ocId, accountId, account)
    if err == nil {
        return err
    }
    
    // 2. update group member
    gmId := user.GmId
    groupMember := &datamodels.GroupMember{
        GmId:      gmId,
        OcId:      ocId,
        GroupId:   groupId,
        AccountId: accountId,
    }
    err = s.groupMemberRepo.Update(ocId, gmId, groupMember)
    if err != nil {
        return err
    }
    
    // 3. update the group member position
    gmpId := user.GmpId
    groupMemberPosition := &datamodels.GroupMemberPosition{
        OcId:       ocId,
        GmpId:      gmpId,
        GroupId:    groupId,
        AccountId:  accountId,
        PositionId: positionId,
    }
    err = s.groupMemberPositionRepo.Update(ocId, gmpId, groupMemberPosition)
    return err
}

func (s *userService) Delete(m map[string]interface{}) error {
    err := s.accountRepo.Delete(m)
    return err
}