OperationService/application/service/mini_page_config.go

package service

import (
	"ecos/application/domain/mini_page_config"
	"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 miniPageConfigService = &MiniPageConfigService{}

type MiniPageConfigService struct{}

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

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

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

	entity_crud.BindSimple[mini_page_config.Info](v1Binder, &entity_crud.Simple[mini_page_config.Info]{
		Entity:             &mini_page_config.Entity{},
		Schema:             dbSchema,
		CreateJsonBody:     &mini_page_config.CreateMiniPageConfigJsonBody{},
		DeleteQueryParams:  &mini_page_config.DeleteMiniPageConfigQueryParams{},
		UpdateJsonBody:     &mini_page_config.UpdateMiniPageConfigJsonBody{},
		QueryQueryParams:   &mini_page_config.GetMiniPageConfigsQueryParams{},
		GetByIDQueryParams: &mini_page_config.GetMiniPageConfigQueryParams{},
	},
		entity_crud.WithQueryFormCustomConditionFunc[mini_page_config.Info](func(c *api.Context, params request.Params, e entity.Entity, i *infrastructure.Infrastructure) (*entity_crud.CustomCondition, error) {
			requestParams, err := request.ToConcrete[*mini_page_config.GetMiniPageConfigsQueryParams](params)
			if err != nil {
				return nil, err
			}
			conditions := sql.NewConditions()
			if strutils.IsStringNotEmpty(requestParams.PageCode) {
				conditions.Equal(mini_page_config.ColumnPageCode, requestParams.PageCode)
			}
			return &entity_crud.CustomCondition{
				Conditions: conditions,
				OrderBy:    mini_page_config.ColumnSortOrder,
			}, nil
		}),
	)

	binding.PutBind(v1Binder, &binding.SimpleBindItem[any]{
		Path:             "/miniPageConfig/enabledOrDisable",
		SendResponseFunc: response.SendMsgResponse,
		RequestParams:    &mini_page_config.EnabledOrDisableJsonBody{},
		ServiceFunc: func(c *api.Context, params request.Params, objects []domain.Object, i *infrastructure.Infrastructure) (any, error) {
			requestParams, err := request.ToConcrete[*mini_page_config.EnabledOrDisableJsonBody](params)
			if err != nil {
				return nil, err
			}
			err = database.Transaction(i.DBExecutor(), func(tx database.Executor) error {
				err = database.Update(tx, &sql.UpdateExecuteParams{
					TableName:  domain.TableName(dbSchema, &mini_page_config.Entity{}),
					Conditions: sql.NewConditions().Equal(entity.ColumnID, requestParams.ID),
					TableRow:   sql.NewTableRow().Add(mini_page_config.ColumnIsEnabled, requestParams.IsEnabled),
				})
				if requestParams.IsEnabled == Enabled {
					err = database.Update(tx, &sql.UpdateExecuteParams{
						TableName:  domain.TableName(dbSchema, &mini_page_config.Entity{}),
						Conditions: sql.NewConditions().Not(entity.ColumnID, requestParams.ID),
						TableRow:   sql.NewTableRow().Add(mini_page_config.ColumnIsEnabled, Disable),
					})
					if err != nil {
						return err
					}
				}
				return nil
			})
			return nil, nil
		},
	})

}

func (svc *MiniPageConfigService) queryByKeyFields(e *mini_page_config.Entity, dbExecutor database.Executor) (*mini_page_config.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(mini_page_config.Entity)
	err = sql.ParseSqlResult(result, existEntity)
	if err != nil {
		return nil, err
	}

	return existEntity, nil
}

func (svc *MiniPageConfigService) checkExistByKeyFields(e *mini_page_config.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
}