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-framework/baize/tag/sql/sql_mapping"
	"git.sxidc.com/go-tools/utils/strutils"
	"git.sxidc.com/service-supports/fserr"
	"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 := sql.NewConditions()

		fields, err := sql_mapping.DefaultUsage(e)
		if err != nil {
			return response.InfosData[O]{}, err
		}

		for _, field := range fields {
			hasDeal := false
			if conditionFieldCallback != nil {
				hasDeal = conditionFieldCallback(conditions, field.FieldName, field.ColumnName, field.Value)
			}

			if !hasDeal {
				fieldValue := reflect.ValueOf(field.Value)
				if !fieldValue.IsZero() {
					conditions.Equal(field.ColumnName, field.Value)
				}
			}
		}

		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 {
			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, outputZero)
		}

		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)
	}
}