simrsx-be/internal/use-case/main-use-case/user/middleware.go

package user

// pm "simrs-vx/internal/use-case/plugin/modifier"

import (
	"fmt"
	e "simrs-vx/internal/domain/main-entities/user"
	pl "simrs-vx/pkg/logger"
	pu "simrs-vx/pkg/use-case-helper"

	"gorm.io/gorm"
)

// func init() {
// createPreMw = append(createPreMw, pm.ModifInput)
// createPreMw = append(createPreMw, pm.CheckData)
// }

type middlewareExecutor struct {
	Event  *pl.Event
	Tx     *gorm.DB
	MwType pu.MWType
}

// NewMiddlewareExecutor creates a new middleware executor
func newMiddlewareExecutor(event *pl.Event, tx *gorm.DB) *middlewareExecutor {
	return &middlewareExecutor{
		Event: event,
		Tx:    tx,
	}
}

// ExecuteCreateMiddleware executes create middleware
func (me *middlewareExecutor) ExecuteCreateMiddleware(middlewares []createMw, input *e.CreateDto, data *e.User) error {
	for i, middleware := range middlewares {
		mwName := fmt.Sprintf("%s[%d]", me.MwType, i)

		pl.SetLogInfo(me.Event, data, "started", mwName)

		if err := middleware(input, data, me.Tx); err != nil {
			me.Event.Status = "failed"
			me.Event.ErrInfo = pl.ErrorInfo{
				Code:   pu.GetMiddlewareErrorCode(me.MwType),
				Detail: fmt.Sprintf("%s middleware %s failed", me.MwType, mwName),
				Raw:    err,
			}
			return pl.SetLogError(*me.Event, data)
		}

		pl.SetLogInfo(me.Event, nil, "complete")
	}
	return nil
}

func (me *middlewareExecutor) ExecuteReadListMiddleware(middlewares []readListMw, input *e.ReadListDto, data *e.User) error {
	for i, middleware := range middlewares {
		mwName := fmt.Sprintf("%s[%d]", me.MwType, i)

		pl.SetLogInfo(me.Event, input, "started", mwName)

		if err := middleware(input, data, me.Tx); err != nil {
			me.Event.Status = "failed"
			me.Event.ErrInfo = pl.ErrorInfo{
				Code:   pu.GetMiddlewareErrorCode(me.MwType),
				Detail: fmt.Sprintf("%s middleware %s failed", me.MwType, mwName),
				Raw:    err,
			}
			return pl.SetLogError(*me.Event, input)
		}

		pl.SetLogInfo(me.Event, nil, "complete")
	}
	return nil
}

func (me *middlewareExecutor) ExecuteReadDetailMiddleware(middlewares []readDetailMw, input *e.ReadDetailDto, data *e.User) error {
	for i, middleware := range middlewares {
		mwName := fmt.Sprintf("%s[%d]", me.MwType, i)

		// Use data for logging if available, otherwise use input
		logData := interface{}(input)
		if data != nil {
			logData = data
		}

		pl.SetLogInfo(me.Event, logData, "started", mwName)

		if err := middleware(input, data, me.Tx); err != nil {
			me.Event.Status = "failed"
			me.Event.ErrInfo = pl.ErrorInfo{
				Code:   pu.GetMiddlewareErrorCode(me.MwType),
				Detail: fmt.Sprintf("%s middleware %s failed", me.MwType, mwName),
				Raw:    err,
			}
			return pl.SetLogError(*me.Event, logData)
		}

		pl.SetLogInfo(me.Event, nil, "complete")
	}
	return nil
}

func (me *middlewareExecutor) ExecuteUpdateMiddleware(middlewares []readDetailMw, input *e.ReadDetailDto, data *e.User) error {
	for i, middleware := range middlewares {
		mwName := fmt.Sprintf("%s[%d]", me.MwType, i)

		// Use data for logging if available, otherwise use input
		logData := interface{}(input)
		if data != nil {
			logData = data
		}

		pl.SetLogInfo(me.Event, logData, "started", mwName)

		if err := middleware(input, data, me.Tx); err != nil {
			me.Event.Status = "failed"
			me.Event.ErrInfo = pl.ErrorInfo{
				Code:   pu.GetMiddlewareErrorCode(me.MwType),
				Detail: fmt.Sprintf("%s middleware %s failed", me.MwType, mwName),
				Raw:    err,
			}
			return pl.SetLogError(*me.Event, logData)
		}

		pl.SetLogInfo(me.Event, nil, "complete")
	}
	return nil
}

func (me *middlewareExecutor) ExecuteDeleteMiddleware(middlewares []readDetailMw, input *e.ReadDetailDto, data *e.User) error {
	for i, middleware := range middlewares {
		mwName := fmt.Sprintf("%s[%d]", me.MwType, i)

		// Use data for logging if available, otherwise use input
		logData := interface{}(input)
		if data != nil {
			logData = data
		}

		pl.SetLogInfo(me.Event, logData, "started", mwName)

		if err := middleware(input, data, me.Tx); err != nil {
			me.Event.Status = "failed"
			me.Event.ErrInfo = pl.ErrorInfo{
				Code:   pu.GetMiddlewareErrorCode(me.MwType),
				Detail: fmt.Sprintf("%s middleware %s failed", me.MwType, mwName),
				Raw:    err,
			}
			return pl.SetLogError(*me.Event, logData)
		}

		pl.SetLogInfo(me.Event, nil, "complete")
	}
	return nil
}

func (me *middlewareExecutor) setMwtype(mwType pu.MWType) {
	me.MwType = mwType
}