baize/convenient/entity/service.go

package entity

import (
	"git.sxidc.com/go-framework/baize/convenient/binding"
	"git.sxidc.com/go-framework/baize/convenient/binding/request"
	"git.sxidc.com/go-framework/baize/convenient/binding/response"
	"git.sxidc.com/go-framework/baize/framwork/api"
	"git.sxidc.com/go-framework/baize/framwork/domain"
	"git.sxidc.com/go-framework/baize/framwork/infrastructure"
	"git.sxidc.com/go-framework/baize/framwork/infrastructure/database"
	"git.sxidc.com/go-framework/baize/framwork/infrastructure/database/sql"
	"git.sxidc.com/go-framework/baize/framwork/tag/sql/sql_mapping"
	"git.sxidc.com/service-supports/fserr"
	"reflect"
)

func Create(tableName string, callbacks *Callbacks[string]) binding.ServiceFunc[string] {
	return func(c *api.Context, params request.Params, objects []domain.Object, i *infrastructure.Infrastructure) (string, error) {
		object := objects[0]
		if object == nil {
			return "", fserr.New("领域实体为空")
		}

		dbExecutor := i.DBExecutor()

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

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

		err = e.ForCreate()
		if err != nil {
			return callbackOnErrorReturn(callbacks, e, err, i, "")
		}

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

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

			return callbackOnErrorReturn(callbacks, e, err, i, "")
		}

		err = callbackAfterDBOperate(callbacks, e, i, dbExecutor)
		if err != nil {
			return callbackOnErrorReturn(callbacks, e, err, i, "")
		}

		return callbackOnSuccessReturn(callbacks, e, i, e.GetID())
	}
}

func Delete(tableName string, callbacks *Callbacks[any]) binding.ServiceFunc[any] {
	return func(c *api.Context, params request.Params, objects []domain.Object, i *infrastructure.Infrastructure) (any, error) {
		object := objects[0]
		if object == nil {
			return nil, fserr.New("领域实体为空")
		}

		dbExecutor := i.DBExecutor()

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

		err := e.CheckFieldID(e.DomainCNName())
		if err != nil {
			return callbackOnErrorReturn(callbacks, e, err, i, nil)
		}

		err = callbackBeforeDBOperate(callbacks, e, i, dbExecutor)
		if err != nil {
			return callbackOnErrorReturn(callbacks, e, err, i, nil)
		}

		err = database.DeleteEntity(dbExecutor, tableName, e)
		if err != nil {
			return callbackOnErrorReturn(callbacks, e, err, i, nil)
		}

		err = callbackAfterDBOperate(callbacks, e, i, dbExecutor)
		if err != nil {
			return callbackOnErrorReturn(callbacks, e, err, i, nil)
		}

		return callbackOnSuccessReturn(callbacks, e, i, nil)
	}
}

func Update(tableName string, callbacks *Callbacks[any]) binding.ServiceFunc[any] {
	return func(c *api.Context, params request.Params, objects []domain.Object, i *infrastructure.Infrastructure) (any, error) {
		object := objects[0]
		if object == nil {
			return nil, fserr.New("领域实体为空")
		}

		dbExecutor := i.DBExecutor()

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

		err := e.ForUpdate()
		if err != nil {
			return callbackOnErrorReturn(callbacks, e, err, i, nil)
		}

		exist, err := database.CheckExist(dbExecutor, &sql.CheckExistExecuteParams{
			TableName:  tableName,
			Conditions: sql.NewConditions().Equal(domain.ColumnID, e.GetID()),
		})
		if err != nil {
			return callbackOnErrorReturn(callbacks, e, err, i, nil)
		}

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

		err = callbackBeforeDBOperate(callbacks, e, i, dbExecutor)
		if err != nil {
			return callbackOnErrorReturn(callbacks, e, err, i, nil)
		}

		err = database.UpdateEntity(dbExecutor, tableName, e)
		if err != nil {
			return callbackOnErrorReturn(callbacks, e, err, i, nil)
		}

		err = callbackAfterDBOperate(callbacks, e, i, dbExecutor)
		if err != nil {
			return callbackOnErrorReturn(callbacks, e, err, i, nil)
		}

		return callbackOnSuccessReturn(callbacks, e, i, nil)
	}
}

type ConditionFieldCallback func(conditions *sql.Conditions, fieldName string, columnName string, value any) (hasDeal bool)

func Query[O any](tableName string, callbacks *Callbacks[response.InfosData[O]], conditionFieldCallback ConditionFieldCallback) binding.ServiceFunc[response.InfosData[O]] {
	return func(c *api.Context, params request.Params, objects []domain.Object, i *infrastructure.Infrastructure) (response.InfosData[O], error) {
		errResponse := response.InfosData[O]{
			Infos: make([]O, 0),
		}

		if params == nil {
			return errResponse, fserr.New("请求参数为空")
		}

		object := objects[0]
		if object == nil {
			return errResponse, fserr.New("领域实体为空")
		}

		dbExecutor := i.DBExecutor()

		queryParams, ok := params.(request.Query)
		if !ok {
			return errResponse, fserr.New("请求参数不是Query接口")
		}

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

		conditions := sql.NewConditions()

		fields, err := sql_mapping.DefaultUsage(e)
		if err != nil {
			return errResponse, 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, i, dbExecutor)
		if err != nil {
			return callbackOnErrorReturn(callbacks, e, err, i, errResponse)
		}

		results, totalCount, err := database.Query(dbExecutor, &sql.QueryExecuteParams{
			TableName:  tableName,
			Conditions: conditions,
			PageNo:     queryParams.GetPageNo(),
			PageSize:   queryParams.GetPageSize(),
		})
		if err != nil {
			return callbackOnErrorReturn(callbacks, e, err, i, errResponse)
		}

		err = callbackAfterDBOperate(callbacks, e, i, dbExecutor)
		if err != nil {
			return callbackOnErrorReturn(callbacks, e, err, i, errResponse)
		}

		infos := make([]O, 0)
		err = sql.ParseSqlResult(results, &infos)
		if err != nil {
			return callbackOnErrorReturn(callbacks, e, err, i, errResponse)
		}

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

		return callbackOnSuccessReturn(callbacks, e, i, output)
	}
}

func GetByID[O any](tableName string, callbacks *Callbacks[O]) binding.ServiceFunc[O] {
	return func(c *api.Context, params request.Params, objects []domain.Object, i *infrastructure.Infrastructure) (O, error) {
		var outputZero O

		outputZeroValue := reflect.New(reflect.TypeOf(outputZero)).Elem()
		if outputZeroValue.Kind() == reflect.Pointer {
			outputZeroValue.Set(reflect.New(outputZeroValue.Type().Elem()))
		}

		outputZero = outputZeroValue.Interface().(O)

		object := objects[0]
		if object == nil {
			return outputZero, fserr.New("领域实体为空")
		}

		dbExecutor := i.DBExecutor()

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

		err := e.CheckFieldID(e.DomainCNName())
		if err != nil {
			return callbackOnErrorReturn(callbacks, e, err, i, outputZero)
		}

		err = callbackBeforeDBOperate(callbacks, e, i, dbExecutor)
		if err != nil {
			return callbackOnErrorReturn(callbacks, e, err, i, outputZero)
		}

		result, err := database.QueryOne(dbExecutor, &sql.QueryOneExecuteParams{
			TableName:  tableName,
			Conditions: sql.NewConditions().Equal(domain.ColumnID, e.GetID()),
		})
		if err != nil {
			return callbackOnErrorReturn(callbacks, e, err, i, outputZero)
		}

		err = callbackAfterDBOperate(callbacks, e, i, dbExecutor)
		if err != nil {
			return callbackOnErrorReturn(callbacks, e, err, i, 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 callbackOnErrorReturn(callbacks, e, err, i, outputZero)
		}

		return callbackOnSuccessReturn(callbacks, e, i, info)
	}
}

func CreateTx(tableName string, callbacks *Callbacks[string]) binding.ServiceFunc[string] {
	return func(c *api.Context, params request.Params, objects []domain.Object, i *infrastructure.Infrastructure) (string, error) {
		object := objects[0]
		if object == nil {
			return "", fserr.New("领域实体为空")
		}

		dbExecutor := i.DBExecutor()

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

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

		err = e.ForCreate()
		if err != nil {
			return callbackOnErrorReturn(callbacks, e, err, i, "")
		}

		err = database.Transaction(dbExecutor, func(tx database.Executor) error {
			err = callbackBeforeDBOperate(callbacks, e, i, tx)
			if err != nil {
				return err
			}

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

				return err
			}

			err = callbackAfterDBOperate(callbacks, e, i, tx)
			if err != nil {
				return err
			}

			return nil
		})
		if err != nil {
			return callbackOnErrorReturn(callbacks, e, err, i, "")
		}

		return callbackOnSuccessReturn(callbacks, e, i, e.GetID())
	}
}

func DeleteTx(tableName string, callbacks *Callbacks[any]) binding.ServiceFunc[any] {
	return func(c *api.Context, params request.Params, objects []domain.Object, i *infrastructure.Infrastructure) (any, error) {
		object := objects[0]
		if object == nil {
			return nil, fserr.New("领域实体为空")
		}

		dbExecutor := i.DBExecutor()

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

		err := e.CheckFieldID(e.DomainCNName())
		if err != nil {
			return callbackOnErrorReturn(callbacks, e, err, i, nil)
		}

		err = database.Transaction(dbExecutor, func(tx database.Executor) error {
			err = callbackBeforeDBOperate(callbacks, e, i, tx)
			if err != nil {
				return err
			}

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

			err = callbackAfterDBOperate(callbacks, e, i, tx)
			if err != nil {
				return err
			}

			return nil
		})
		if err != nil {
			return callbackOnErrorReturn(callbacks, e, err, i, nil)
		}

		return callbackOnSuccessReturn(callbacks, e, i, nil)
	}
}

func UpdateTx(tableName string, callbacks *Callbacks[any]) binding.ServiceFunc[any] {
	return func(c *api.Context, params request.Params, objects []domain.Object, i *infrastructure.Infrastructure) (any, error) {
		object := objects[0]
		if object == nil {
			return nil, fserr.New("领域实体为空")
		}

		dbExecutor := i.DBExecutor()

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

		err := e.CheckFieldID(e.DomainCNName())
		if err != nil {
			return callbackOnErrorReturn(callbacks, e, err, i, nil)
		}

		exist, err := database.CheckExist(dbExecutor, &sql.CheckExistExecuteParams{
			TableName:  tableName,
			Conditions: sql.NewConditions().Equal(domain.ColumnID, e.GetID()),
		})
		if err != nil {
			return callbackOnErrorReturn(callbacks, e, err, i, nil)
		}

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

		err = database.Transaction(dbExecutor, func(tx database.Executor) error {
			err = callbackBeforeDBOperate(callbacks, e, i, tx)
			if err != nil {
				return err
			}

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

			err = callbackAfterDBOperate(callbacks, e, i, tx)
			if err != nil {
				return err
			}

			return nil
		})
		if err != nil {
			return callbackOnErrorReturn(callbacks, e, err, i, nil)
		}

		return callbackOnSuccessReturn(callbacks, e, i, nil)
	}
}