baize/binding/service/entity_crud/service.go

package entity_crud

import (
	"git.sxidc.com/go-framework/baize/api"
	"git.sxidc.com/go-framework/baize/binding"
	"git.sxidc.com/go-framework/baize/binding/request"
	"git.sxidc.com/go-framework/baize/binding/response"
	"git.sxidc.com/go-framework/baize/domain"
	"git.sxidc.com/go-framework/baize/infrastructure"
	"git.sxidc.com/go-framework/baize/infrastructure/database"
	"git.sxidc.com/go-framework/baize/infrastructure/database/sql"
	"git.sxidc.com/go-tools/utils/strutils"
	"git.sxidc.com/service-supports/fserr"
	"git.sxidc.com/service-supports/fslog"
	"reflect"
)

func CommonEntityCreate(tableName string, dbExecutorType string, callbacks *Callbacks[string]) binding.ServiceFunc[string] {
	return func(c *api.Context, dto request.DTO, objects []domain.Object, i *infrastructure.Infrastructure) (string, error) {
		dbExecutor := i.ChooseDBExecutor(dbExecutorType)

		e, ok := objects[0].(domain.Entity)
		if !ok {
			return "", fserr.New("需要传递领域对象应该为实体")
		}

		err := e.GenerateID()
		if err != nil {
			return callbackOnError(callbacks, e, err, dbExecutor, "")
		}

		err = callbackBeforeDBOperate(callbacks, e, dbExecutor)
		if err != nil {
			return callbackOnError(callbacks, e, err, dbExecutor, "")
		}

		err = database.InsertEntity(dbExecutor, tableName, e)
		if err != nil {
			if database.IsErrorDBRecordHasExist(err) {
				err = fserr.New(e.DomainCNName() + "已存在")
			}

			return callbackOnError(callbacks, e, err, dbExecutor, "")
		}

		return callbackOnReturn(callbacks, e, dbExecutor, e.GetID())
	}
}

func CommonEntityDelete(tableName string, databaseExecutorType string, callbacks *Callbacks[any]) binding.ServiceFunc[any] {
	return func(c *api.Context, dto request.DTO, objects []domain.Object, i *infrastructure.Infrastructure) (any, error) {
		dbExecute := i.ChooseDBExecutor(databaseExecutorType)

		e, ok := objects[0].(domain.Entity)
		if !ok {
			return nil, fserr.New("需要传递领域对象应该为实体")
		}

		if strutils.IsStringEmpty(e.GetID()) {
			err := fserr.New("领域实体ID为空")
			return callbackOnError(callbacks, e, err, dbExecute, nil)
		}

		exist, err := database.CheckExist(dbExecute, &sql.CheckExistExecuteParams{
			TableName:  tableName,
			Conditions: sql.NewConditions().Equal(e.IDColumnName(), e.GetID()),
		})
		if err != nil {
			return callbackOnError(callbacks, e, err, dbExecute, nil)
		}

		if !exist {
			err := fserr.New(e.DomainCNName() + "不存在")
			return callbackOnError(callbacks, e, err, dbExecute, nil)
		}

		err = callbackBeforeDBOperate(callbacks, e, dbExecute)
		if err != nil {
			return callbackOnError(callbacks, e, err, dbExecute, nil)
		}

		err = database.DeleteEntity(dbExecute, tableName, e)
		if err != nil {
			return callbackOnError(callbacks, e, err, dbExecute, nil)
		}

		return callbackOnReturn(callbacks, e, dbExecute, nil)
	}
}

func CommonEntityUpdate(tableName string, databaseExecutorType string, callbacks *Callbacks[any]) binding.ServiceFunc[any] {
	return func(c *api.Context, dto request.DTO, objects []domain.Object, i *infrastructure.Infrastructure) (any, error) {
		dbExecute := i.ChooseDBExecutor(databaseExecutorType)

		e, ok := objects[0].(domain.Entity)
		if !ok {
			return nil, fserr.New("需要传递领域对象应该为实体")
		}

		if strutils.IsStringEmpty(e.GetID()) {
			err := fserr.New("领域实体ID为空")
			return callbackOnError(callbacks, e, err, dbExecute, nil)
		}

		exist, err := database.CheckExist(dbExecute, &sql.CheckExistExecuteParams{
			TableName:  tableName,
			Conditions: sql.NewConditions().Equal(e.IDColumnName(), e.GetID()),
		})
		if err != nil {
			return callbackOnError(callbacks, e, err, dbExecute, nil)
		}

		if !exist {
			err := fserr.New(e.DomainCNName() + "不存在")
			return callbackOnError(callbacks, e, err, dbExecute, nil)
		}

		err = callbackBeforeDBOperate(callbacks, e, dbExecute)
		if err != nil {
			return callbackOnError(callbacks, e, err, dbExecute, nil)
		}

		err = database.UpdateEntity(dbExecute, tableName, e)
		if err != nil {
			return callbackOnError(callbacks, e, err, dbExecute, nil)
		}

		return callbackOnReturn(callbacks, e, dbExecute, nil)
	}
}

func CommonEntityQuery[O any](tableName string, databaseExecutorType string, callbacks *Callbacks[*response.InfosData[O]], conditionFieldCallback domain.ConditionFieldCallback) binding.ServiceFunc[*response.InfosData[O]] {
	return func(c *api.Context, dto request.DTO, objects []domain.Object, i *infrastructure.Infrastructure) (*response.InfosData[O], error) {
		dbExecute := i.ChooseDBExecutor(databaseExecutorType)

		queryDTO, ok := dto.(request.Query)
		if !ok {
			return &response.InfosData[O]{}, fserr.New("DTO不是Query")
		}

		e, ok := objects[0].(domain.Entity)
		if !ok {
			return &response.InfosData[O]{}, fserr.New("需要传递领域对象应该为实体")
		}

		conditions, err := e.QueryDBConditions(conditionFieldCallback)
		if err != nil {
			return callbackOnError(callbacks, e, err, dbExecute, &response.InfosData[O]{})
		}

		err = callbackBeforeDBOperate(callbacks, e, dbExecute)
		if err != nil {
			return callbackOnError(callbacks, e, err, dbExecute, &response.InfosData[O]{})
		}

		results, totalCount, err := database.Query(dbExecute, &sql.QueryExecuteParams{
			TableName:  tableName,
			Conditions: conditions,
			PageNo:     queryDTO.GetPageNo(),
			PageSize:   queryDTO.GetPageSize(),
		})
		if err != nil {
			return callbackOnError(callbacks, e, err, dbExecute, &response.InfosData[O]{})
		}

		infos := make([]O, 0)
		err = sql.ParseSqlResult(results, &infos)
		if err != nil {
			return callbackOnError(callbacks, e, err, dbExecute, &response.InfosData[O]{})
		}

		output := &response.InfosData[O]{
			Infos:      infos,
			TotalCount: totalCount,
			PageNo:     queryDTO.GetPageNo(),
		}

		return callbackOnReturn(callbacks, e, dbExecute, output)
	}
}

func CommonEntityQueryByID[O any](tableName string, databaseExecutorType string, callbacks *Callbacks[O]) binding.ServiceFunc[O] {
	return func(c *api.Context, dto request.DTO, objects []domain.Object, i *infrastructure.Infrastructure) (O, error) {
		var outputZero O
		outputZeroValue := reflect.Zero(reflect.TypeOf(outputZero))
		if outputZeroValue.Kind() != reflect.Pointer {
			fslog.Error("建议在QueryByID时使用指针类型作为输出，以方便对查询结果进行后处理")
		}

		outputZeroValue.Set(reflect.New(outputZeroValue.Type().Elem()))

		dbExecute := i.ChooseDBExecutor(databaseExecutorType)

		e, ok := objects[0].(domain.Entity)
		if !ok {
			return outputZero, fserr.New("需要传递领域对象应该为实体")
		}

		if strutils.IsStringEmpty(e.GetID()) {
			err := fserr.New("领域实体ID为空")
			return callbackOnError(callbacks, e, err, dbExecute, nil)
		}

		err := callbackBeforeDBOperate(callbacks, e, dbExecute)
		if err != nil {
			return callbackOnError(callbacks, e, err, dbExecute, outputZero)
		}

		result, err := database.QueryOne(dbExecute, &sql.QueryOneExecuteParams{
			TableName:  tableName,
			Conditions: sql.NewConditions().Equal(e.IDColumnName(), e.GetID()),
		})
		if err != nil {
			return callbackOnError(callbacks, e, err, dbExecute, outputZero)
		}

		var info O
		var infoPointer any

		infoPointer = &info
		if outputZeroValue.Kind() == reflect.Pointer {
			infoPointer = info
		}

		err = sql.ParseSqlResult(result, infoPointer)
		if err != nil {
			return callbackOnError(callbacks, e, err, dbExecute, outputZero)
		}

		return callbackOnReturn(callbacks, e, dbExecute, info)
	}
}