InformationManageService/application/service/banner.go

package service

import (
	"erpims/application/domain/banner"
	"erpims/oss"
	"git.sxidc.com/go-framework/baize/convenient/entity_crud"
	"git.sxidc.com/go-framework/baize/framework/binding"
	"git.sxidc.com/go-framework/baize/framework/core/api"
	"git.sxidc.com/go-framework/baize/framework/core/api/request"
	"git.sxidc.com/go-framework/baize/framework/core/api/response"
	"git.sxidc.com/go-framework/baize/framework/core/application"
	"git.sxidc.com/go-framework/baize/framework/core/domain"
	"git.sxidc.com/go-framework/baize/framework/core/domain/entity"
	"git.sxidc.com/go-framework/baize/framework/core/infrastructure"
	"git.sxidc.com/go-framework/baize/framework/core/infrastructure/database"
	"git.sxidc.com/go-framework/baize/framework/core/infrastructure/database/sql"
	"git.sxidc.com/go-tools/utils/strutils"
	"github.com/pkg/errors"
)

var bannerService = &BannerService{}

type BannerService struct{}

func (svc *BannerService) Init(appInstance *application.App) error {
	svc.v1(appInstance)
	return nil
}

func (svc *BannerService) Destroy() error {
	return nil
}

func (svc *BannerService) v1(appInstance *application.App) {
	v1Binder := binding.NewBinder(appInstance.ChooseRouter(api.RouterPrefix, "v1"),
		appInstance.Infrastructure())

	entity_crud.BindSimple[banner.Info](v1Binder,
		&entity_crud.Simple[banner.Info]{
			Entity:             &banner.Entity{},
			Schema:             dbSchema,
			CreateJsonBody:     &banner.CreateBannerJsonBody{},
			DeleteQueryParams:  &banner.DeleteBannerQueryParams{},
			UpdateJsonBody:     &banner.UpdateBannerJsonBody{},
			QueryQueryParams:   &banner.GetBannersQueryParams{},
			GetByIDQueryParams: &banner.GetBannerQueryParams{},
		},
		entity_crud.WithCreateTx(),
		entity_crud.WithCreateCallbacks(&entity_crud.CreateCallbacks{
			Before: func(c *api.Context, params request.Params, e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error {
				requestParams, err := request.ToConcrete[*banner.CreateBannerJsonBody](params)
				if err != nil {
					return err
				}
				info, err := domain.ToConcrete[*banner.Entity](e)
				if err != nil {
					return err
				}

				//图片处理
				if strutils.IsStringNotEmpty(requestParams.PicUrl) {
					newPicture, err := oss.MultipleFileMv(requestParams.PicUrl)
					if err != nil {
						return err
					}
					info.PicUrl = newPicture
				}

				return nil
			},
		}),
		entity_crud.WithUpdateTx(),
		entity_crud.WithUpdateCallbacks(&entity_crud.UpdateCallbacks{
			Before: func(c *api.Context, params request.Params, e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error {
				requestParams, err := request.ToConcrete[*banner.UpdateBannerJsonBody](params)
				info, err := domain.ToConcrete[*banner.Entity](e)
				if err != nil {
					return err
				}

				if strutils.IsStringNotEmpty(requestParams.PicUrl) {
					newPicture, err := oss.MultipleFileMv(requestParams.PicUrl)
					if err != nil {
						return err
					}
					info.PicUrl = newPicture
				}
				return nil
			},
		}),
		entity_crud.WithQueryCallbacks(&entity_crud.QueryCallbacks[banner.Info]{
			OnSuccessReturn: func(c *api.Context, params request.Params, e entity.Entity, i *infrastructure.Infrastructure, output response.InfosData[banner.Info]) (response.InfosData[banner.Info], error) {
				for i2 := range output.Infos {
					item := &output.Infos[i2]
					if strutils.IsStringNotEmpty(item.PicUrlStr) {
						fileObjects, err := oss.MultipleFileUrl(item.PicUrlStr)
						if err != nil {
							return output, err
						}
						item.PicUrl = fileObjects
					}
				}
				return output, nil
			},
		}),
		entity_crud.WithGetByIDCallbacks(&entity_crud.GetByIDCallbacks[banner.Info]{
			OnSuccessReturn: func(c *api.Context, params request.Params, e entity.Entity, i *infrastructure.Infrastructure, output banner.Info) (banner.Info, error) {
				if strutils.IsStringNotEmpty(output.PicUrlStr) {
					fileObjects, err := oss.MultipleFileUrl(output.PicUrlStr)
					if err != nil {
						return output, err
					}
					output.PicUrl = fileObjects
				}

				return output, nil
			},
		}),
		entity_crud.WithQueryOrderBy[banner.Info](entity.ColumnCreatedTime+" desc"),
		entity_crud.WithQueryConditionFieldCallback[banner.Info](func(conditions *sql.Conditions, fieldName string, columnName string, value any) (hasDeal bool, err error) {
			switch fieldName {
			case banner.FieldTitle:
				conditions.Like(columnName, "%"+value.(string)+"%")
				return true, nil
			case banner.ColumnPageUrl:
				conditions.Like(columnName, "%"+value.(string)+"%")
				return true, nil
			default:
				return false, nil
			}
		}))
}

func (svc *BannerService) queryByKeyFields(e *banner.Entity, dbExecutor database.Executor) (*banner.Entity, error) {
	result, err := database.QueryOne(dbExecutor, &sql.QueryOneExecuteParams{
		TableName:  domain.TableName(dbSchema, e),
		Conditions: sql.NewConditions().Equal(entity.ColumnID, e.ID),
	})
	if err != nil {
		if database.IsErrorDBRecordNotExist(err) {
			return nil, errors.New(e.DomainCNName() + "不存在")
		}

		return nil, err
	}

	existEntity := new(banner.Entity)
	err = sql.ParseSqlResult(result, existEntity)
	if err != nil {
		return nil, err
	}

	return existEntity, nil
}

func (svc *BannerService) checkExistByKeyFields(e *banner.Entity, dbExecutor database.Executor) error {
	exist, err := database.CheckExist(dbExecutor, &sql.CheckExistExecuteParams{
		TableName:  domain.TableName(dbSchema, e),
		Conditions: sql.NewConditions().Equal(entity.ColumnID, e.ID),
	})
	if err != nil {
		return err
	}

	if !exist {
		return errors.New(e.DomainCNName() + "不存在")
	}

	return nil
}