busniess-user-center/internal/service/organization/organization.go

package organization

import (
	"busniess-user-center/config"
	orgModel "busniess-user-center/internal/models/organization"
	userModel "busniess-user-center/internal/models/user"
	"busniess-user-center/internal/repo"
	"busniess-user-center/internal/service/util"
	"busniess-user-center/pkg/redis"
	"context"
	"encoding/json"
	"fmt"

	"busniess-user-center/internal/service/user"

	"github.com/jinzhu/copier"
	"github.com/samber/do"
	"go.uber.org/zap"
	"gorm.io/gorm"
)

func init() {
	do.Provide(nil, NewOrganizationService)
}

type organizationService struct {
	logger      *zap.SugaredLogger
	orgRepo     repo.OrganizationRepo
	redis       *redis.Redis
	conf        *config.AppConfig
	userService user.UserService
}

func NewOrganizationService(i *do.Injector) (OrganizationService, error) {
	return &organizationService{
		logger:      do.MustInvoke[*zap.SugaredLogger](i),
		orgRepo:     do.MustInvoke[repo.OrganizationRepo](i),
		redis:       do.MustInvoke[*redis.Redis](i),
		conf:        do.MustInvoke[*config.AppConfig](i),
		userService: do.MustInvoke[user.UserService](i),
	}, nil
}

func (o *organizationService) CreateOrganization(ctx context.Context, info *orgModel.CreateOrgReq) error {
	if info.ParentId > 0 {
		if exist, err := o.orgRepo.ExistOrgId(ctx, info.ParentId); err != nil {
			return err
		} else if !exist {
			return fmt.Errorf("父组织%d不存在", info.ParentId)
		}
	}

	leader := "[]"
	if len(info.Leaders) > 0 {
		if err := o.verfyUsers(ctx, info.Leaders); err != nil {
			return err
		}

		leaderByte, _ := json.Marshal(info.Leaders)
		leader = string(leaderByte)
	}

	dbOrg := repo.Organization{
		Name:     info.Name,
		ParentID: info.ParentId,
		Sort:     uint(info.Sort),
		Status:   int(repo.OrganizationEnableStatus),
		Leaders:  leader,
	}

	_, err := o.orgRepo.Create(ctx, dbOrg)

	return err
}

func (o *organizationService) SaveOrganization(ctx context.Context, info *orgModel.SaveOrgReq) error {
	dbOrg, err := o.orgRepo.GetById(ctx, info.Id)
	if err != nil && err != gorm.ErrRecordNotFound {
		return err
	}

	if err == gorm.ErrRecordNotFound {
		return fmt.Errorf("组织不存在")
	}

	newOrg := repo.Organization{}
	copier.Copy(&newOrg, dbOrg)
	newOrg.Name = info.Name
	newOrg.Sort = uint(info.Sort)

	if info.ParentId > 0 {
		if exist, err := o.orgRepo.ExistOrgId(ctx, info.ParentId); err != nil {
			return err
		} else if !exist {
			return fmt.Errorf("父组织%d不存在", info.ParentId)
		}

		newOrg.ParentID = info.ParentId
	}

	if len(info.Leaders) > 0 {
		if err := o.verfyUsers(ctx, info.Leaders); err != nil {
			return err
		}

		leaderByte, _ := json.Marshal(info.Leaders)
		newOrg.Leaders = string(leaderByte)
	}

	err = o.orgRepo.Save(ctx, newOrg)
	return err
}

func (o *organizationService) DelOrganization(ctx context.Context, info *orgModel.DelOrgReq) error {
	// todo 判断权限
	// todo 判断组织下面有没有成员
	// todo 删除组织授权和相应的用户
	return o.orgRepo.DelById(ctx, info.Id)
}

func (o *organizationService) Organization(ctx context.Context, info *orgModel.GetOrgReq) (org orgModel.Organization, err error) {
	dbOrg, err := o.orgRepo.GetById(ctx, info.Id)
	if err != nil && err != gorm.ErrRecordNotFound {
		return
	}

	if err == gorm.ErrRecordNotFound {
		err = fmt.Errorf("组织不存在")
		return
	}

	copier.Copy(&org, dbOrg)
	if len(dbOrg.Leaders) > 0 {
		json.Unmarshal([]byte(dbOrg.Leaders), &org.Leaders)
	}

	return
}

func (o *organizationService) MoveOrganization(ctx context.Context, info *orgModel.MoveOrgReq) error {
	// todo 判断权限
	dbOrg, err := o.orgRepo.GetById(ctx, info.Id)
	if err != nil && err != gorm.ErrRecordNotFound {
		return err
	}

	if err == gorm.ErrRecordNotFound {
		return fmt.Errorf("组织%d不存在", info.Id)
	}

	if dbOrg.ID == info.DestId || dbOrg.ParentID == info.DestId {
		return nil
	}

	_, err = o.orgRepo.GetById(ctx, info.DestId)
	if err != nil && err != gorm.ErrRecordNotFound {
		return err
	}

	if err != gorm.ErrRecordNotFound {
		return fmt.Errorf("目标组织%d不存在", info.DestId)
	}

	dbOrg.ParentID = info.DestId
	return o.orgRepo.Save(ctx, dbOrg)
}

func (o *organizationService) OrganizationTree(ctx context.Context) (orgModel.OrgTree, error) {
	dbOrgs, err := o.orgRepo.GetOrgs(ctx)
	if err != nil {
		return nil, err
	}

	tree := util.GetOrgTree(dbOrgs)
	return tree, nil
}

func (o *organizationService) DisableOrganization(ctx context.Context, info *orgModel.DisableOrgReq) error {
	// todo 判断有没有权限
	// 判断是否成员
	return o.orgRepo.SetStatus(ctx, info.Id, repo.OrganizationDisableStatus)
}

func (o *organizationService) EnableOrganization(ctx context.Context, info *orgModel.EnableOrgReq) error {
	// todo 判断有没有权限
	return o.orgRepo.SetStatus(ctx, info.Id, repo.OrganizationEnableStatus)
}

func (o *organizationService) AddUser(ctx context.Context, info *orgModel.AddUsersReq) error {
	org, err := o.orgRepo.GetById(ctx, info.OrgId)
	if err != nil && err != gorm.ErrRecordNotFound {
		return err
	}

	if err == gorm.ErrRecordNotFound {
		return fmt.Errorf("组织%d不存在", info.OrgId)
	}

	o.orgRepo.Create()
	return nil
}

func (o *organizationService) RemoveUser(ctx context.Context, info *orgModel.RemoveUsersReq) error {
	return nil
}

func (o *organizationService) SearchOrgUsers(ctx context.Context, query *orgModel.SearchOrgUserReq) ([]userModel.UserInfo, error) {
	return nil, nil
}