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

package service

import (
	"time"
	"xps/cmd/constant"
	"xps/cmd/datasource"
	"xps/pkg/base"
	"xps/pkg/system/datamodel"
	"xps/pkg/system/repository"
	"xps/pkg/system/viewmodel"
	"xps/pkg/utils"
)

type UserService interface {
	GetList(m map[string]interface{}) ([]viewmodel.UserInfo, error)
	GetPage(m map[string]interface{}) (*base.PageResult, error)
	GetById(ocId, groupId, userId int64) (*viewmodel.UserInfo, error)
	Create(ocTypeId int64, user *viewmodel.UserInfo) error
	Update(user *viewmodel.UserInfo) error
	UpdatePassword(ocId, userId int64, pwd string) error
	ResetPassword(ocId, userId int64) error
	ChangeStatus(ocId, userId, status int64) error
	Delete(m map[string]interface{}) error
	IsUserNameExist(ocId int64, accountName string) (bool, error)
	IsUserPhoneExist(ocId int64, accountPhone string) (bool, error)
	IsStaffNoExist(ocId int64, staffNo string) (bool, error)
	IsEmailExist(ocId int64, staffNo string) (bool, error)
	SelectUser(ocId int64) ([]viewmodel.UserSelectVo, error)
}

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

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

func (s *userService) GetList(m map[string]interface{}) ([]viewmodel.UserInfo, 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.GetList(m)
}

func (s *userService) GetPage(m map[string]interface{}) (*base.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) (*viewmodel.UserInfo, error) {
	return s.userRepo.GetById(ocId, groupId, userId)
}

func (s *userService) Create(ocTypeId int64, user *viewmodel.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 := &datamodel.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 := &datamodel.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 := &datamodel.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 := &datamodel.GroupMemberPosition{
		GmpId:      newId,
		OcId:       ocId,
		GroupId:    groupId,
		AccountId:  accountId,
		PositionId: positionId,
	}
	err = s.groupMemberPositionRepo.Create(groupMemberPosition)
	return err
}

func (s *userService) Update(user *viewmodel.UserInfo) error {
	ocId := user.OcId
	accountId := user.AccountId
	groupId := user.GroupId
	positionId := user.PositionId
	userId := ocId //管理员ID同公司ID,只有管理员可以作账号管理

	// 1. update account
	account := &datamodel.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 := &datamodel.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 := &datamodel.GroupMemberPosition{
		OcId:       ocId,
		GmpId:      gmpId,
		GroupId:    groupId,
		AccountId:  accountId,
		PositionId: positionId,
	}
	err = s.groupMemberPositionRepo.Update(ocId, gmpId, groupMemberPosition)
	return err
}

func (s *userService) UpdatePassword(ocId, userId int64, pwd string) error {
	hashedPwd := utils.GetMD5String(pwd)
	data := &datamodel.Account{
		Password: hashedPwd,
	}
	return s.accountRepo.Update(ocId, userId, data)
}

func (s *userService) ResetPassword(ocId, userId int64) error {
	pwd := utils.GetMD5String("888888")
	data := &datamodel.Account{
		Password: pwd,
	}
	return s.accountRepo.Update(ocId, userId, data)
}

func (s *userService) ChangeStatus(ocId, userId, status int64) error {
	data := &datamodel.Account{
		Status: status,
	}
	return s.accountRepo.Update(ocId, userId, data)
}

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

func (s *userService) IsUserNameExist(ocId int64, accountName string) (bool, error) {
	return s.accountRepo.IsUserNameExist(ocId, accountName)
}

func (s *userService) IsUserPhoneExist(ocId int64, accountPhone string) (bool, error) {
	return s.accountRepo.IsUserPhoneExist(ocId, accountPhone)
}

func (s *userService) IsStaffNoExist(ocId int64, staffNo string) (bool, error) {
	return s.accountRepo.IsStaffNoExist(ocId, staffNo)
}

func (s *userService) IsEmailExist(ocId int64, email string) (bool, error) {
	return s.accountRepo.IsEmailExist(ocId, email)
}

func (s *userService) SelectUser(ocId int64) ([]viewmodel.UserSelectVo, error) {
	m := make(map[string]interface{}, 0)
	m["ocId"] = ocId
	memberList, err := s.groupMemberPositionRepo.GetList(m)
	if err != nil {
		return nil, err
	}

	voList := make([]viewmodel.UserSelectVo, 0)
	itemList := make([]viewmodel.UserSelectItemVo, 0)
	positionId := int64(0)
	for _, member := range memberList {
		item := viewmodel.UserSelectItemVo{
			Name:         member.AccountName,
			Value:        member.AccountId,
			AccountId:    member.AccountId,
			AccountName:  member.AccountName,
			PositionId:   member.PositionId,
			PositionName: member.PositionName,
			GroupId:      member.GroupId,
			GroupName:    member.GroupName,
		}
		itemList = append(itemList, item)

		if positionId != 0 && positionId != member.PositionId {
			vo := viewmodel.UserSelectVo{
				Name:     member.PositionName,
				Children: itemList,
			}
			itemList = make([]viewmodel.UserSelectItemVo, 0)
			voList = append(voList, vo)
		}
		positionId = member.PositionId
	}

	return voList, nil
}