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

package application

import (
	"busniess-user-center/config"
	appModel "busniess-user-center/internal/models/application"
	"busniess-user-center/internal/repo"
	"busniess-user-center/pkg/redis"
	contextUtil "busniess-user-center/pkg/utils/context"
	"context"
	"fmt"

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

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

type applicationService struct {
	logger   *zap.SugaredLogger
	appRepo  repo.ApplicationRepo
	menuRepo repo.MenuRepo
	redis    *redis.Redis
	conf     *config.AppConfig
}

func NewApplicationService(i *do.Injector) (ApplicationService, error) {
	return &applicationService{
		logger:   do.MustInvoke[*zap.SugaredLogger](i),
		appRepo:  do.MustInvoke[repo.ApplicationRepo](i),
		menuRepo: do.MustInvoke[repo.MenuRepo](i),
		redis:    do.MustInvoke[*redis.Redis](i),
		conf:     do.MustInvoke[*config.AppConfig](i),
	}, nil
}

func (a *applicationService) Create(ctx context.Context, info *appModel.CreateReq) error {
	session, err := contextUtil.GetSession(ctx)
	if err != nil {
		return err
	}

	_, err = a.appRepo.GetAppByCode(ctx, info.Code)
	if err != nil && err != gorm.ErrRecordNotFound {
		return err
	}

	if err == nil {
		return fmt.Errorf("应用code:%s已经存在", info.Code)
	}

	dbApp := repo.Application{}
	err = copier.Copy(&dbApp, info)
	if err != nil {
		return err
	}

	dbApp.CreatedBy = session.Account
	return a.appRepo.CreateApplication(ctx, dbApp)
}

func (a *applicationService) ResetSecret(ctx context.Context, info *appModel.ResetSecretReq) error {
	dbApp := repo.Application{}
	err := copier.Copy(&dbApp, info)
	if err != nil {
		return err
	}

	// todo  校验权限
	return a.appRepo.ResetSecret(ctx, dbApp)
}

func (a *applicationService) Delete(ctx context.Context, req *appModel.DeleteAppReq) error {
	// todo  校验权限
	return a.appRepo.DelApp(ctx, req.Id)
}

func (a *applicationService) GetApp(ctx context.Context, req *appModel.GetAppReq) (app appModel.ApplicationInfo, err error) {
	dbApp, err := a.appRepo.GetAppByCode(ctx, req.Code)
	if err != nil && err != gorm.ErrRecordNotFound {
		return
	}

	if err == gorm.ErrRecordNotFound {
		return
	}

	app.Menus, err = a.menuRepo.GetAppMenus(ctx, dbApp.Code)
	if err != nil {
		return
	}

	err = copier.Copy(&app, dbApp)
	return
}

func (a *applicationService) Search(ctx context.Context, query *appModel.Query) (rsp appModel.List, err error) {
	query.Default()
	dbQuery := repo.Query{}
	err = copier.Copy(&dbQuery, query)
	if err != nil {
		return
	}

	dbList, err := a.appRepo.Search(ctx, dbQuery)
	if err != nil {
		return
	}

	total, err := a.appRepo.SearchCount(ctx, dbQuery)
	if err != nil {
		return
	}

	for _, item := range dbList {
		info := appModel.ApplicationInfo{}
		copier.Copy(&info, item)
		rsp.List = append(rsp.List, info)
	}

	rsp.Page = query.Page
	rsp.PageSize = query.PageSize
	rsp.Total = total

	return
}

func (a *applicationService) Menus(ctx context.Context, info *appModel.MenusReq) (rsp []appModel.Menu, err error) {
	return a.menuRepo.GetAppMenus(ctx, info.AppCode)
}

func (a *applicationService) CreateMenu(ctx context.Context, info *appModel.CreateMenuReq) error {
	// todo 校验权限
	menu := repo.Menu{}
	err := copier.Copy(&menu, info)
	if err != nil {
		return err
	}

	_, err = a.menuRepo.Create(ctx, &menu)
	return err
}

func (a *applicationService) ModifyMenu(ctx context.Context, info *appModel.ModifyMenuReq) error {
	// todo 校验权限
	dMenu, err := a.menuRepo.GetMenuById(ctx, info.Id)
	if err != nil && err != gorm.ErrRecordNotFound {
		return err
	}

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

	dMenu.Name = info.Name
	dMenu.ParentCode = info.ParentCode
	dMenu.Order = info.Order
	dMenu.Icon = info.Icon
	dMenu.Path = info.Path
	dMenu.ChildPath = info.ChildPath
	dMenu.GoFirstChild = info.GoFirstChild
	dMenu.IsShow = info.IsShow

	err = a.menuRepo.SaveMenu(ctx, &dMenu)
	return err
}

func (a *applicationService) DeleteMenu(ctx context.Context, info *appModel.DelMenuReq) error {
	// todo 校验权限
	err := a.menuRepo.DelMenuById(ctx, info.Id)
	return err
}

func (a *applicationService) Modify(ctx context.Context, info *appModel.Application) error {
	dbApp := repo.Application{}
	err := copier.Copy(&dbApp, info)
	if err != nil {
		return err
	}

	app, err := a.appRepo.GetAppByCode(ctx, info.Info.Code)
	if err != nil {
		return err
	}

	dbApp.ID = app.ID
	return a.appRepo.SaveApplication(ctx, dbApp)
}