baize/convenient/entity_crud/service_callbacks.go

package entity_crud

import (
	"git.sxidc.com/go-framework/baize/framework/binding/response"
	"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-tools/utils/reflectutils"
)

type CreateCallbacks struct {
	Prepare         func(e entity.Entity, i *infrastructure.Infrastructure) (map[string]any, error)
	Before          func(e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error
	After           func(e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error
	OnSuccessReturn func(e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, id string) (string, error)
	OnErrorReturn   func(e entity.Entity, prepared map[string]any, err error, i *infrastructure.Infrastructure) (string, error)
}

func callbackPrepareCreate(callbacks *CreateCallbacks, e entity.Entity, i *infrastructure.Infrastructure) (map[string]any, error) {
	if callbacks == nil {
		return make(map[string]any), nil
	}

	if callbacks.Prepare == nil {
		return make(map[string]any), nil
	}

	return callbacks.Prepare(e, i)
}

func callbackBeforeCreate(callbacks *CreateCallbacks, e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error {
	if callbacks == nil {
		return nil
	}

	if callbacks.Before == nil {
		return nil
	}

	return callbacks.Before(e, prepared, i, tx)
}

func callbackAfterCreate(callbacks *CreateCallbacks, e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, dbExecutor database.Executor) error {
	if callbacks == nil {
		return nil
	}

	if callbacks.After == nil {
		return nil
	}

	return callbacks.After(e, prepared, i, dbExecutor)
}

func callbackOnCreateSuccessReturn(callbacks *CreateCallbacks, e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, id string) (string, error) {
	if callbacks == nil {
		return id, nil
	}

	if callbacks.OnSuccessReturn == nil {
		return id, nil
	}

	return callbacks.OnSuccessReturn(e, prepared, i, id)
}

func callbackOnCreateErrorReturn(callbacks *CreateCallbacks, e entity.Entity, prepared map[string]any, err error, i *infrastructure.Infrastructure) (string, error) {
	if callbacks == nil {
		return "", err
	}

	if callbacks.OnErrorReturn == nil {
		return "", err
	}

	return callbacks.OnErrorReturn(e, prepared, err, i)
}

type DeleteCallbacks struct {
	Prepare         func(e entity.Entity, i *infrastructure.Infrastructure) (map[string]any, error)
	Before          func(e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error
	After           func(e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error
	OnSuccessReturn func(e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure) error
	OnErrorReturn   func(e entity.Entity, prepared map[string]any, err error, i *infrastructure.Infrastructure) error
}

func callbackPrepareDelete(callbacks *DeleteCallbacks, e entity.Entity, i *infrastructure.Infrastructure) (map[string]any, error) {
	if callbacks == nil {
		return make(map[string]any), nil
	}

	if callbacks.Prepare == nil {
		return make(map[string]any), nil
	}

	return callbacks.Prepare(e, i)
}

func callbackBeforeDelete(callbacks *DeleteCallbacks, e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error {
	if callbacks == nil {
		return nil
	}

	if callbacks.Before == nil {
		return nil
	}

	return callbacks.Before(e, prepared, i, tx)
}

func callbackAfterDelete(callbacks *DeleteCallbacks, e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, dbExecutor database.Executor) error {
	if callbacks == nil {
		return nil
	}

	if callbacks.After == nil {
		return nil
	}

	return callbacks.After(e, prepared, i, dbExecutor)
}

func callbackOnDeleteSuccessReturn(callbacks *DeleteCallbacks, e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure) error {
	if callbacks == nil {
		return nil
	}

	if callbacks.OnSuccessReturn == nil {
		return nil
	}

	return callbacks.OnSuccessReturn(e, prepared, i)
}

func callbackOnDeleteErrorReturn(callbacks *DeleteCallbacks, e entity.Entity, prepared map[string]any, err error, i *infrastructure.Infrastructure) error {
	if callbacks == nil {
		return err
	}

	if callbacks.OnErrorReturn == nil {
		return err
	}

	return callbacks.OnErrorReturn(e, prepared, err, i)
}

type UpdateCallbacks struct {
	Prepare         func(e entity.Entity, i *infrastructure.Infrastructure) (map[string]any, error)
	Before          func(e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error
	After           func(e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error
	OnSuccessReturn func(e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure) error
	OnErrorReturn   func(e entity.Entity, prepared map[string]any, err error, i *infrastructure.Infrastructure) error
}

func callbackPrepareUpdate(callbacks *UpdateCallbacks, e entity.Entity, i *infrastructure.Infrastructure) (map[string]any, error) {
	if callbacks == nil {
		return make(map[string]any), nil
	}

	if callbacks.Prepare == nil {
		return make(map[string]any), nil
	}

	return callbacks.Prepare(e, i)
}

func callbackBeforeUpdate(callbacks *UpdateCallbacks, e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error {
	if callbacks == nil {
		return nil
	}

	if callbacks.Before == nil {
		return nil
	}

	return callbacks.Before(e, prepared, i, tx)
}

func callbackAfterUpdate(callbacks *UpdateCallbacks, e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, dbExecutor database.Executor) error {
	if callbacks == nil {
		return nil
	}

	if callbacks.After == nil {
		return nil
	}

	return callbacks.After(e, prepared, i, dbExecutor)
}

func callbackOnUpdateSuccessReturn(callbacks *UpdateCallbacks, e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure) error {
	if callbacks == nil {
		return nil
	}

	if callbacks.OnSuccessReturn == nil {
		return nil
	}

	return callbacks.OnSuccessReturn(e, prepared, i)
}

func callbackOnUpdateErrorReturn(callbacks *UpdateCallbacks, e entity.Entity, prepared map[string]any, err error, i *infrastructure.Infrastructure) error {
	if callbacks == nil {
		return err
	}

	if callbacks.OnErrorReturn == nil {
		return err
	}

	return callbacks.OnErrorReturn(e, prepared, err, i)
}

type QueryCallbacks[O any] struct {
	Before          func(e entity.Entity, i *infrastructure.Infrastructure) error
	After           func(e entity.Entity, i *infrastructure.Infrastructure) error
	OnSuccessReturn func(e entity.Entity, i *infrastructure.Infrastructure, output response.InfosData[O]) (response.InfosData[O], error)
	OnErrorReturn   func(e entity.Entity, err error, i *infrastructure.Infrastructure) (response.InfosData[O], error)
}

func callbackBeforeQuery[O any](callbacks *QueryCallbacks[O], e entity.Entity, i *infrastructure.Infrastructure) error {
	if callbacks == nil {
		return nil
	}

	if callbacks.Before == nil {
		return nil
	}

	return callbacks.Before(e, i)
}

func callbackAfterQuery[O any](callbacks *QueryCallbacks[O], e entity.Entity, i *infrastructure.Infrastructure) error {
	if callbacks == nil {
		return nil
	}

	if callbacks.After == nil {
		return nil
	}

	return callbacks.After(e, i)
}

func callbackOnQuerySuccessReturn[O any](callbacks *QueryCallbacks[O], e entity.Entity, i *infrastructure.Infrastructure, output response.InfosData[O]) (response.InfosData[O], error) {
	if callbacks == nil {
		return output, nil
	}

	if callbacks.OnSuccessReturn == nil {
		return output, nil
	}

	return callbacks.OnSuccessReturn(e, i, output)
}

func callbackOnQueryErrorReturn[O any](callbacks *QueryCallbacks[O], e entity.Entity, err error, i *infrastructure.Infrastructure) (response.InfosData[O], error) {
	if callbacks == nil {
		return response.InfosData[O]{
			Infos: make([]O, 0),
		}, err
	}

	if callbacks.OnErrorReturn == nil {
		return response.InfosData[O]{
			Infos: make([]O, 0),
		}, err
	}

	return callbacks.OnErrorReturn(e, err, i)
}

type QueryByIDCallbacks[O any] struct {
	Before          func(e entity.Entity, i *infrastructure.Infrastructure) error
	After           func(e entity.Entity, i *infrastructure.Infrastructure) error
	OnSuccessReturn func(e entity.Entity, i *infrastructure.Infrastructure, output O) (O, error)
	OnErrorReturn   func(e entity.Entity, err error, i *infrastructure.Infrastructure) (O, error)
}

func callbackBeforeQueryByID[O any](callbacks *QueryByIDCallbacks[O], e entity.Entity, i *infrastructure.Infrastructure) error {
	if callbacks == nil {
		return nil
	}

	if callbacks.Before == nil {
		return nil
	}

	return callbacks.Before(e, i)
}

func callbackAfterQueryByID[O any](callbacks *QueryByIDCallbacks[O], e entity.Entity, i *infrastructure.Infrastructure) error {
	if callbacks == nil {
		return nil
	}

	if callbacks.After == nil {
		return nil
	}

	return callbacks.After(e, i)
}

func callbackOnQueryByIDSuccessReturn[O any](callbacks *QueryByIDCallbacks[O], e entity.Entity, i *infrastructure.Infrastructure, output O) (O, error) {
	if callbacks == nil {
		return output, nil
	}

	if callbacks.OnSuccessReturn == nil {
		return output, nil
	}

	return callbacks.OnSuccessReturn(e, i, output)
}

func callbackOnQueryByIDErrorReturn[O any](callbacks *QueryByIDCallbacks[O], e entity.Entity, err error, i *infrastructure.Infrastructure) (O, error) {
	if callbacks == nil {
		return reflectutils.Zero[O](), err
	}

	if callbacks.OnErrorReturn == nil {
		return reflectutils.Zero[O](), err
	}

	return callbacks.OnErrorReturn(e, err, i)
}