xps-server-g5/pkg/system/service/oc_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"
)

type OcService interface {
	GetList(m map[string]interface{}) ([]viewmodel.OcInfo, error)
	GetPage(m map[string]interface{}) (*base.PageResult, error)
	GetById(ocId int64) (*viewmodel.OcInfo, error)
	Create(d *datamodel.Oc) error
	Update(d *datamodel.Oc) error
	Delete(m map[string]interface{}) error

	GetAdmin(ocId int64) (*viewmodel.OcAdminInfo, error)
	CreateAdmin(d *viewmodel.OcAdminInfo) error
	UpdateAdmin(d *viewmodel.OcAdminInfo) error
	ResetAdminPwd(ocId, accountId int64) error

	UpdateStatus(ocId, status int64) error
	UpdateLicStatus(ocId, status int64) error
}

type ocService struct {
	ocRepo                  *repository.OcRepo
	groupCatRepo            *repository.GroupCatRepo
	groupRepo               *repository.GroupRepo
	accountRepo             *repository.AccountRepo
	positionRepo            *repository.PositionRepo
	groupMemberRepo         *repository.GroupMemberRepo
	groupMemberPositionRepo *repository.GroupMemberPositionRepo
	roleMemberRepo          *repository.RoleMemberRepo
}

func NewOcService() OcService {
	return &ocService{
		ocRepo: repository.NewOcRepo(datasource.InstanceMaster()),
	}
}

func (s *ocService) GetList(m map[string]interface{}) ([]viewmodel.OcInfo, error) {
	return s.ocRepo.GetList(m)
}

func (s *ocService) GetPage(m map[string]interface{}) (*base.PageResult, error) {
	return s.ocRepo.GetPage(m)
}

func (s *ocService) GetById(ocId int64) (*viewmodel.OcInfo, error) {
	return s.ocRepo.GetById(ocId)
}

func (s *ocService) Create(o *datamodel.Oc) error {
	ocId := NewID()
	ocName := o.OcName
	userId := o.CreatedBy

	// 1.Create OC
	o.OcId = ocId
	o.RootId = ocId
	o.ParentId = 0
	o.GroupId = ocId
	o.NodeLeft = 1
	o.NodeRight = 2
	o.NodeLevel = 1
	o.IsLeaf = 1
	o.Status = 1
	o.CreatedAt = time.Now()
	err1 := s.ocRepo.Create(o)
	if err1 != nil {
		return err1
	}

	// 2.Group Cat
	groupCat := &datamodel.GroupCat{
		OcId:          ocId,
		GroupCatId:    ocId,
		GroupCatTitle: "公司",
		IsFixed:       1,
		GroupCatDesc:  "公司",
		CreatedAt:     time.Now(),
		CreatedBy:     userId,
	}
	err2 := s.groupCatRepo.Create(groupCat)
	if err2 != nil {
		return err1
	}

	// 3.Group
	group := &datamodel.Group{
		OcId:       ocId,
		GroupId:    ocId,
		GroupName:  ocName,
		GroupCatId: ocId,
		NodeLeft:   1,
		NodeRight:  2,
		NodeLevel:  1,
		RootId:     ocId,
		ParentId:   0,
		IsFixed:    1,
		IsLeaf:     1,
		GroupCode:  "",
		GroupPath:  "",
		CreatedBy:  userId,
		CreatedAt:  time.Now(),
	}
	err3 := s.groupRepo.Create(group)
	if err3 != nil {
		return err3
	}

	return nil
}

func (s *ocService) Update(o *datamodel.Oc) error {
	ocId := o.OcId
	ocName := o.OcName
	userId := o.UpdatedBy

	// 1. Update OC
	o.UpdatedAt = time.Now()
	err1 := s.ocRepo.Update(o)
	if err1 != nil {
		return err1
	}

	// 2.Group
	group := &datamodel.Group{
		OcId:      ocId,
		GroupId:   ocId,
		GroupName: ocName,
		UpdatedAt: time.Now(),
		UpdatedBy: userId,
	}
	err2 := s.groupRepo.Update(group)
	if err2 != nil {
		return err2
	}
	return nil
}

func (s *ocService) Delete(m map[string]interface{}) error {
	return s.ocRepo.Delete(m)
}

func (s *ocService) GetAdmin(ocId int64) (*viewmodel.OcAdminInfo, error) {
	return s.ocRepo.GetAdmin(ocId)
}

func (s *ocService) CreateAdmin(a *viewmodel.OcAdminInfo) error {
	ocId := a.OcId
	adminId := ocId
	userId := a.CreatedBy

	//1.Account
	account := &datamodel.Account{
		OcId:          ocId,
		AccountId:     adminId,
		AccountName:   a.AdminName,
		Password:      "21218cca77804d2ba1922c33e0151105",
		AccountPhone:  a.AdminPhone,
		AccountType:   0,
		AccountAvatar: "",
		IsFixed:       1,
		Status:        1,
		CreatedBy:     userId,
		CreatedAt:     time.Now(),
	}
	err1 := s.accountRepo.Create(account)
	if err1 != nil {
		return err1
	}

	//2.OC Admin
	oc := &datamodel.Oc{
		OcId:    ocId,
		AdminId: adminId,
	}
	err2 := s.ocRepo.Update(oc)
	if err2 != nil {
		return err2
	}

	//3.Role Member
	roleMember := &datamodel.RoleMember{
		OcId:      ocId,
		RmId:      ocId,
		RoleId:    constant.ENT_ROLE_ADMIN,
		AccountId: adminId,
	}
	err3 := s.roleMemberRepo.Create(roleMember)
	if err3 != nil {
		return err3
	}

	//4.Position
	position := &datamodel.Position{
		OcId:         ocId,
		PositionId:   ocId,
		PositionName: "管理员",
		PositionDesc: "管理员",
		IsFixed:      1,
		CreatedAt:    time.Now(),
		CreatedBy:    userId,
	}
	err4 := s.positionRepo.Create(position)
	if err4 != nil {
		return err4
	}

	//5.Group Member
	groupMember := &datamodel.GroupMember{
		OcId:      ocId,
		GmId:      ocId,
		GroupId:   ocId,
		AccountId: adminId,
		IsFixed:   1,
	}
	err5 := s.groupMemberRepo.Create(groupMember)
	if err5 != nil {
		return err5
	}

	//6.Group Member Position
	groupMemberPosition := &datamodel.GroupMemberPosition{
		OcId:       ocId,
		GmpId:      ocId,
		GroupId:    ocId,
		AccountId:  adminId,
		PositionId: ocId,
		IsFixed:    1,
	}
	err6 := s.groupMemberPositionRepo.Create(groupMemberPosition)
	return err6
}

func (s *ocService) UpdateAdmin(a *viewmodel.OcAdminInfo) error {
	ocId := a.OcId
	adminId := a.AdminId
	userId := a.UpdatedBy

	//1. Account
	account := &datamodel.Account{
		OcId:         ocId,
		AccountId:    adminId,
		AccountName:  a.AdminName,
		AccountPhone: a.AdminPhone,
		UpdatedBy:    userId,
		UpdatedAt:    time.Now(),
	}
	return s.accountRepo.Update(ocId, adminId, account)
}

func (s *ocService) ResetAdminPwd(ocId, accountId int64) error {
	//1. Account
	account := &datamodel.Account{
		OcId:      ocId,
		AccountId: accountId,
		Password:  "21218cca77804d2ba1922c33e0151105",
	}
	return s.accountRepo.Update(ocId, accountId, account)
}

func (s *ocService) UpdateStatus(ocId, status int64) error {
	oc := &datamodel.Oc{
		OcId:   ocId,
		Status: status,
	}
	return s.ocRepo.Update(oc)
}

func (s *ocService) UpdateLicStatus(ocId, status int64) error {
	oc := &datamodel.Oc{
		OcId:  ocId,
		IfLic: status,
	}
	return s.ocRepo.Update(oc)
}