munawwirul_jamal/simrsx-be
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor : adjust use case after mw refactored

Browse Source
This commit is contained in:
dpurbosakti
2025-08-22 15:18:25 +07:00
parent 7a032ff518
commit a4a0a4f672
49 changed files with 2331 additions and 2304 deletions
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

internal/use-case/main-use-case/user/case.go
+55 -114
View File
@@ -18,8 +18,6 @@ const source = "user"
func Create(input e.CreateDto) (*d.Data, error) {
data := e.User{}
setCreate(input, &data)
event := pl.Event{
Feature: "Create",
Source: source,
@@ -29,31 +27,22 @@ func Create(input e.CreateDto) (*d.Data, error) {
pl.SetLogInfo(&event, input, "started", "create")
err := dg.I.Transaction(func(tx *gorm.DB) error {
executor := newMiddlewareExecutor(&event, tx)
executor.setMwtype(pu.MWTPre)
// Execute pre-middleware
if err := executor.ExecuteCreateMiddleware(createPreMw, &input, &data); err != nil {
mwRunner := newMiddlewareRunner(&event, tx)
mwRunner.setMwType(pu.MWTPre)
// Run pre-middleware
if err := mwRunner.RunCreateMiddleware(createPreMw, &input, &data); err != nil {
return err
}
pl.SetLogInfo(&event, data, "started", "DBCreate")
_, err := CreateData(&data, tx)
if err != nil {
event.Status = "failed"
event.ErrInfo = pl.ErrorInfo{
Code: "data-create-fail",
Detail: "Database insert failed",
Raw: err,
}
return pl.SetLogError(event, data)
if resData, err := CreateData(input, &event, tx); err != nil {
return err
} else {
data = *resData
}
pl.SetLogInfo(&event, nil, "complete")
executor.setMwtype(pu.MWTPost)
// Execute post-middleware
if err := executor.ExecuteCreateMiddleware(createPostMw, &input, &data); err != nil {
mwRunner.setMwType(pu.MWTPost)
// Run post-middleware
if err := mwRunner.RunCreateMiddleware(createPostMw, &input, &data); err != nil {
return err
}
@@ -91,31 +80,20 @@ func ReadList(input e.ReadListDto) (*d.Data, error) {
pl.SetLogInfo(&event, input, "started", "readList")
err = dg.I.Transaction(func(tx *gorm.DB) error {
executor := newMiddlewareExecutor(&event, tx)
executor.setMwtype(pu.MWTPre)
// Execute pre-middleware
if err := executor.ExecuteReadListMiddleware(readListPreMw, &input, data); err != nil {
mwRunner := newMiddlewareRunner(&event, tx)
mwRunner.setMwType(pu.MWTPre)
// Run pre-middleware
if err := mwRunner.RunReadListMiddleware(readListPreMw, &input, data); err != nil {
return err
}
pl.SetLogInfo(&event, input, "started", "DBReadList")
dataList, metaList, err = ReadListData(input, tx)
if err != nil {
event.Status = "failed"
event.ErrInfo = pl.ErrorInfo{
Code: "data-read-list-fail",
Detail: "Database read list failed",
Raw: err,
}
return pl.SetLogError(event, input)
if dataList, metaList, err = ReadListData(input, &event, tx); err != nil {
return err
}
pl.SetLogInfo(&event, nil, "complete")
executor.setMwtype(pu.MWTPost)
// Execute post-middleware
if err := executor.ExecuteReadListMiddleware(readListPostMw, &input, data); err != nil {
mwRunner.setMwType(pu.MWTPost)
// Run post-middleware
if err := mwRunner.RunReadListMiddleware(readListPostMw, &input, data); err != nil {
return err
}
@@ -152,23 +130,20 @@ func ReadDetail(input e.ReadDetailDto) (*d.Data, error) {
pl.SetLogInfo(&event, input, "started", "readDetail")
err = dg.I.Transaction(func(tx *gorm.DB) error {
executor := newMiddlewareExecutor(&event, tx)
executor.setMwtype(pu.MWTPre)
// Execute pre-middleware
if err := executor.ExecuteReadDetailMiddleware(readDetailPreMw, &input, data); err != nil {
mwRunner := newMiddlewareRunner(&event, tx)
mwRunner.setMwType(pu.MWTPre)
// Run pre-middleware
if err := mwRunner.RunReadDetailMiddleware(readDetailPreMw, &input, data); err != nil {
return err
}
pl.SetLogInfo(&event, input, "started", "DBReadDetail")
data, err = ReadDetailData(input, tx)
if processedErr := pu.HandleReadError(err, &event, source, input.Id, data); processedErr != nil {
return processedErr
if data, err = ReadDetailData(input, &event, tx); err != nil {
return err
}
executor.setMwtype(pu.MWTPost)
// Execute post-middleware
if err := executor.ExecuteReadDetailMiddleware(readDetailPostMw, &input, data); err != nil {
mwRunner.setMwType(pu.MWTPost)
// Run post-middleware
if err := mwRunner.RunReadDetailMiddleware(readDetailPostMw, &input, data); err != nil {
return err
}
@@ -185,7 +160,7 @@ func ReadDetail(input e.ReadDetailDto) (*d.Data, error) {
"structure": "single-data",
"status": "fetched",
},
Data: pu.SafeToResponse(data),
Data: data.ToResponse(),
}, nil
}
@@ -204,49 +179,26 @@ func Update(input e.UpdateDto) (*d.Data, error) {
err = dg.I.Transaction(func(tx *gorm.DB) error {
pl.SetLogInfo(&event, rdDto, "started", "DBReadDetail")
data, err = ReadDetailData(rdDto, tx)
if processedErr := pu.HandleReadError(err, &event, source, input.Id, data); processedErr != nil {
return processedErr
}
pl.SetLogInfo(&event, input, "started", "setUpdate")
err = setUpdate(input, data)
if err != nil {
event.Status = "failed"
event.ErrInfo = pl.ErrorInfo{
Code: "set-update-fail",
Detail: "Set update data failed",
Raw: err,
}
return pl.SetLogError(event, input)
}
pl.SetLogInfo(&event, nil, "complete")
executor := newMiddlewareExecutor(&event, tx)
executor.setMwtype(pu.MWTPre)
// Execute pre-middleware
if err := executor.ExecuteUpdateMiddleware(readDetailPreMw, &rdDto, data); err != nil {
if data, err = ReadDetailData(rdDto, &event, tx); err != nil {
return err
}
pl.SetLogInfo(&event, data, "started", "DBUpdate")
if err := UpdateData(*data, tx); err != nil {
event.Status = "failed"
event.ErrInfo = pl.ErrorInfo{
Code: "data-update-fail",
Detail: "Database update failed",
Raw: err,
}
return pl.SetLogError(event, data)
mwRunner := newMiddlewareRunner(&event, tx)
mwRunner.setMwType(pu.MWTPre)
// Run pre-middleware
if err := mwRunner.RunUpdateMiddleware(readDetailPreMw, &rdDto, data); err != nil {
return err
}
if err := UpdateData(input, data, &event, tx); err != nil {
return err
}
pl.SetLogInfo(&event, nil, "complete")
executor.setMwtype(pu.MWTPost)
// Execute post-middleware
if err := executor.ExecuteUpdateMiddleware(readDetailPostMw, &rdDto, data); err != nil {
mwRunner.setMwType(pu.MWTPost)
// Run post-middleware
if err := mwRunner.RunUpdateMiddleware(readDetailPostMw, &rdDto, data); err != nil {
return err
}
@@ -283,35 +235,24 @@ func Delete(input e.DeleteDto) (*d.Data, error) {
err = dg.I.Transaction(func(tx *gorm.DB) error {
pl.SetLogInfo(&event, rdDto, "started", "DBReadDetail")
data, err = ReadDetailData(rdDto, tx)
if processedErr := pu.HandleReadError(err, &event, source, input.Id, data); processedErr != nil {
return processedErr
}
executor := newMiddlewareExecutor(&event, tx)
executor.setMwtype(pu.MWTPre)
// Execute pre-middleware
if err := executor.ExecuteDeleteMiddleware(readDetailPreMw, &rdDto, data); err != nil {
if data, err = ReadDetailData(rdDto, &event, tx); err != nil {
return err
}
pl.SetLogInfo(&event, data, "started", "DBDelete")
if err := DeleteData(data, tx); err != nil {
event.Status = "failed"
event.ErrInfo = pl.ErrorInfo{
Code: "data-delete-fail",
Detail: "Database delete failed",
Raw: err,
}
return pl.SetLogError(event, data)
mwRunner := newMiddlewareRunner(&event, tx)
mwRunner.setMwType(pu.MWTPre)
// Run pre-middleware
if err := mwRunner.RunDeleteMiddleware(readDetailPreMw, &rdDto, data); err != nil {
return err
}
pl.SetLogInfo(&event, nil, "complete")
if err := DeleteData(data, &event, tx); err != nil {
return err
}
executor.setMwtype(pu.MWTPost)
// Execute post-middleware
if err := executor.ExecuteDeleteMiddleware(readDetailPostMw, &rdDto, data); err != nil {
mwRunner.setMwType(pu.MWTPost)
// Run post-middleware
if err := mwRunner.RunDeleteMiddleware(readDetailPostMw, &rdDto, data); err != nil {
return err
}
internal/use-case/main-use-case/user/helper.go
+1 -106
View File
@@ -5,13 +5,9 @@ Any functions that are used internally by the use-case
package user
import (
"fmt"
e "simrs-vx/internal/domain/main-entities/user"
pl "simrs-vx/pkg/logger"
p "simrs-vx/pkg/password"
"gorm.io/gorm"
)
func setCreate(src e.CreateDto, dst *e.User) error {
@@ -27,109 +23,8 @@ func setCreate(src e.CreateDto, dst *e.User) error {
return nil
}
func setUpdate(src e.UpdateDto, dst *e.User) error {
func setUpdate(src e.UpdateDto, dst *e.User) {
dst.Name = src.Name
dst.Status_Code = src.Status_Code
return nil
}
// executeCreateMiddleware executes create middleware (pre or post)
func executeCreateMiddleware(middlewares []createMw, input *e.CreateDto, data *e.User, tx *gorm.DB, event *pl.Event, mwType string) error {
for i := range middlewares {
mwName := fmt.Sprintf("%s[%d]", mwType, i)
pl.SetLogInfo(event, data, "started", mwName)
if err := middlewares[i](input, data, tx); err != nil {
event.Status = "failed"
event.ErrInfo = pl.ErrorInfo{
Code: getMiddlewareErrorCode(mwType),
Detail: fmt.Sprintf("%s middleware %s failed", getMiddlewareTypeLabel(mwType), mwName),
Raw: err,
}
return pl.SetLogError(*event, data)
}
pl.SetLogInfo(event, nil, "complete")
}
return nil
}
// executeReadListMiddleware executes read list middleware (pre or post)
func executeReadListMiddleware(middlewares []readListMw, input *e.ReadListDto, data *e.User, tx *gorm.DB, event *pl.Event, mwType string) error {
for i := range middlewares {
mwName := fmt.Sprintf("%s[%d]", mwType, i)
pl.SetLogInfo(event, input, "started", mwName)
if err := middlewares[i](input, data, tx); err != nil {
event.Status = "failed"
event.ErrInfo = pl.ErrorInfo{
Code: getMiddlewareErrorCode(mwType),
Detail: fmt.Sprintf("%s middleware %s failed", getMiddlewareTypeLabel(mwType), mwName),
Raw: err,
}
return pl.SetLogError(*event, input)
}
pl.SetLogInfo(event, nil, "complete")
}
return nil
}
// executeReadDetailMiddleware executes read detail middleware (pre or post)
func executeReadDetailMiddleware(middlewares []readDetailMw, input *e.ReadDetailDto, data *e.User, tx *gorm.DB, event *pl.Event, mwType string) error {
for i := range middlewares {
mwName := fmt.Sprintf("%s[%d]", mwType, i)
// Use data for logging if available, otherwise use input
logData := interface{}(input)
if data != nil {
logData = data
}
pl.SetLogInfo(event, logData, "started", mwName)
if err := middlewares[i](input, data, tx); err != nil {
event.Status = "failed"
event.ErrInfo = pl.ErrorInfo{
Code: getMiddlewareErrorCode(mwType),
Detail: fmt.Sprintf("%s middleware %s failed", getMiddlewareTypeLabel(mwType), mwName),
Raw: err,
}
return pl.SetLogError(*event, logData)
}
pl.SetLogInfo(event, nil, "complete")
}
return nil
}
// Helper functions to determine error codes and labels based on middleware type
func getMiddlewareErrorCode(mwType string) string {
if containsString(mwType, "Pre") {
return "MW_PRE_FAILED"
}
return "MW_POST_FAILED"
}
func getMiddlewareTypeLabel(mwType string) string {
if containsString(mwType, "Pre") {
return "Pre"
}
return "Post"
}
func containsString(str, substr string) bool {
return len(str) >= len(substr) && str[len(str)-len(substr):] != substr &&
(len(str) == len(substr) || str[len(str)-len(substr)-1:len(str)-len(substr)] != substr) &&
func() bool {
for i := 0; i <= len(str)-len(substr); i++ {
if str[i:i+len(substr)] == substr {
return true
}
}
return false
}()
}
internal/use-case/main-use-case/user/lib.go
+65 -14
View File
@@ -2,13 +2,20 @@ package user
import (
e "simrs-vx/internal/domain/main-entities/user"
pl "simrs-vx/pkg/logger"
pu "simrs-vx/pkg/use-case-helper"
dg "github.com/karincake/apem/db-gorm-pg"
gh "github.com/karincake/getuk"
"gorm.io/gorm"
)
func CreateData(input *e.User, dbx ...*gorm.DB) (*e.User, error) {
func CreateData(input e.CreateDto, event *pl.Event, dbx ...*gorm.DB) (*e.User, error) {
pl.SetLogInfo(event, nil, "started", "DBCreate")
data := e.User{}
setCreate(input, &data)
var tx *gorm.DB
if len(dbx) > 0 {
tx = dbx[0]
@@ -16,14 +23,22 @@ func CreateData(input *e.User, dbx ...*gorm.DB) (*e.User, error) {
tx = dg.I
}
if err := tx.Create(&input).Error; err != nil {
return nil, err
if err := tx.Create(&data).Error; err != nil {
event.Status = "failed"
event.ErrInfo = pl.ErrorInfo{
Code: "data-create-fail",
Detail: "Database insert failed",
Raw: err,
}
return nil, pl.SetLogError(event, input)
}
return input, nil
pl.SetLogInfo(event, nil, "complete")
return &data, nil
}
func ReadListData(input e.ReadListDto, dbx ...*gorm.DB) ([]e.User, *e.MetaDto, error) {
func ReadListData(input e.ReadListDto, event *pl.Event, dbx ...*gorm.DB) ([]e.User, *e.MetaDto, error) {
pl.SetLogInfo(event, input, "started", "DBReadList")
data := []e.User{}
pagination := gh.Pagination{}
count := int64(0)
@@ -38,8 +53,6 @@ func ReadListData(input e.ReadListDto, dbx ...*gorm.DB) ([]e.User, *e.MetaDto, e
tx = tx.
Model(&e.User{}).
// Joins("Patient"). // if needed
// Preload("Patient"). // if needed
Scopes(gh.Filter(input)).
Count(&count).
Scopes(gh.Paginate(input, &pagination)).
@@ -49,16 +62,25 @@ func ReadListData(input e.ReadListDto, dbx ...*gorm.DB) ([]e.User, *e.MetaDto, e
if err == gorm.ErrRecordNotFound {
return nil, &meta, nil
}
return nil, nil, err
event.Status = "failed"
event.ErrInfo = pl.ErrorInfo{
Code: "data-create-fail",
Detail: "Database insert failed",
Raw: err,
}
return nil, nil, pl.SetLogError(event, input)
}
meta.Count = int(count)
meta.PageNumber = pagination.PageNumber
meta.PageSize = pagination.PageSize
pl.SetLogInfo(event, nil, "complete")
return data, &meta, nil
}
func ReadDetailData(input e.ReadDetailDto, dbx ...*gorm.DB) (*e.User, error) {
func ReadDetailData(input e.ReadDetailDto, event *pl.Event, dbx ...*gorm.DB) (*e.User, error) {
pl.SetLogInfo(event, input, "started", "DBReadDetail")
data := e.User{}
var tx *gorm.DB
@@ -69,13 +91,19 @@ func ReadDetailData(input e.ReadDetailDto, dbx ...*gorm.DB) (*e.User, error) {
}
if err := tx.First(&data, input.Id).Error; err != nil {
return nil, err
if processedErr := pu.HandleReadError(err, event, source, input.Id, data); processedErr != nil {
return nil, processedErr
}
}
pl.SetLogInfo(event, nil, "complete")
return &data, nil
}
func UpdateData(input e.User, dbx ...*gorm.DB) error {
func UpdateData(input e.UpdateDto, data *e.User, event *pl.Event, dbx ...*gorm.DB) error {
pl.SetLogInfo(event, data, "started", "DBUpdate")
setUpdate(input, data)
var tx *gorm.DB
if len(dbx) > 0 {
tx = dbx[0]
@@ -83,10 +111,22 @@ func UpdateData(input e.User, dbx ...*gorm.DB) error {
tx = dg.I
}
return tx.Save(&input).Error
if err := tx.Save(&data).Error; err != nil {
event.Status = "failed"
event.ErrInfo = pl.ErrorInfo{
Code: "data-update-fail",
Detail: "Database update failed",
Raw: err,
}
return pl.SetLogError(event, input)
}
pl.SetLogInfo(event, nil, "complete")
return nil
}
func DeleteData(input *e.User, dbx ...*gorm.DB) error {
func DeleteData(data *e.User, event *pl.Event, dbx ...*gorm.DB) error {
pl.SetLogInfo(event, data, "started", "DBDelete")
var tx *gorm.DB
if len(dbx) > 0 {
tx = dbx[0]
@@ -94,5 +134,16 @@ func DeleteData(input *e.User, dbx ...*gorm.DB) error {
tx = dg.I
}
return tx.Delete(input).Error
if err := tx.Delete(&data).Error; err != nil {
event.Status = "failed"
event.ErrInfo = pl.ErrorInfo{
Code: "data-delete-fail",
Detail: "Database delete failed",
Raw: err,
}
return pl.SetLogError(event, data)
}
pl.SetLogInfo(event, nil, "complete")
return nil
}
internal/use-case/main-use-case/user/middleware-runner.go
+103
View File
@@ -0,0 +1,103 @@
package user
import (
e "simrs-vx/internal/domain/main-entities/user"
pl "simrs-vx/pkg/logger"
pu "simrs-vx/pkg/use-case-helper"
"gorm.io/gorm"
)
type middlewareRunner struct {
Event *pl.Event
Tx *gorm.DB
MwType pu.MWType
}
// NewMiddlewareExecutor creates a new middleware executor
func newMiddlewareRunner(event *pl.Event, tx *gorm.DB) *middlewareRunner {
return &middlewareRunner{
Event: event,
Tx: tx,
}
}
// ExecuteCreateMiddleware executes create middleware
func (me *middlewareRunner) RunCreateMiddleware(middlewares []createMw, input *e.CreateDto, data *e.User) error {
for _, middleware := range middlewares {
logData := pu.GetLogData(input, data)
pl.SetLogInfo(me.Event, logData, "started", middleware.Name)
if err := middleware.Func(input, data, me.Tx); err != nil {
return pu.HandleMiddlewareError(me.Event, string(me.MwType), middleware.Name, logData, err)
}
pl.SetLogInfo(me.Event, nil, "complete")
}
return nil
}
func (me *middlewareRunner) RunReadListMiddleware(middlewares []readListMw, input *e.ReadListDto, data *e.User) error {
for _, middleware := range middlewares {
logData := pu.GetLogData(input, data)
pl.SetLogInfo(me.Event, logData, "started", middleware.Name)
if err := middleware.Func(input, data, me.Tx); err != nil {
return pu.HandleMiddlewareError(me.Event, string(me.MwType), middleware.Name, logData, err)
}
pl.SetLogInfo(me.Event, nil, "complete")
}
return nil
}
func (me *middlewareRunner) RunReadDetailMiddleware(middlewares []readDetailMw, input *e.ReadDetailDto, data *e.User) error {
for _, middleware := range middlewares {
logData := pu.GetLogData(input, data)
pl.SetLogInfo(me.Event, logData, "started", middleware.Name)
if err := middleware.Func(input, data, me.Tx); err != nil {
return pu.HandleMiddlewareError(me.Event, string(me.MwType), middleware.Name, logData, err)
}
pl.SetLogInfo(me.Event, nil, "complete")
}
return nil
}
func (me *middlewareRunner) RunUpdateMiddleware(middlewares []readDetailMw, input *e.ReadDetailDto, data *e.User) error {
for _, middleware := range middlewares {
logData := pu.GetLogData(input, data)
pl.SetLogInfo(me.Event, logData, "started", middleware.Name)
if err := middleware.Func(input, data, me.Tx); err != nil {
return pu.HandleMiddlewareError(me.Event, string(me.MwType), middleware.Name, logData, err)
}
pl.SetLogInfo(me.Event, nil, "complete")
}
return nil
}
func (me *middlewareRunner) RunDeleteMiddleware(middlewares []readDetailMw, input *e.ReadDetailDto, data *e.User) error {
for _, middleware := range middlewares {
logData := pu.GetLogData(input, data)
pl.SetLogInfo(me.Event, logData, "started", middleware.Name)
if err := middleware.Func(input, data, me.Tx); err != nil {
return pu.HandleMiddlewareError(me.Event, string(me.MwType), middleware.Name, logData, err)
}
pl.SetLogInfo(me.Event, nil, "complete")
}
return nil
}
func (me *middlewareRunner) setMwType(mwType pu.MWType) {
me.MwType = mwType
}
internal/use-case/main-use-case/user/middleware.go
+5 -155
View File
@@ -1,159 +1,9 @@
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"
)
// example of middleware
// func init() {
// createPreMw = append(createPreMw, pm.ModifInput)
// createPreMw = append(createPreMw, pm.CheckData)
// createPreMw = append(createPreMw,
// CreateMw{Name: "modif-input", Func: pm.ModifInput},
// CreateMw{Name: "check-data", Func: 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
}
internal/use-case/main-use-case/user/tycovar.go
+17 -5
View File
@@ -14,11 +14,23 @@ import (
e "simrs-vx/internal/domain/main-entities/user"
)
type createMw func(input *e.CreateDto, data *e.User, tx *gorm.DB) error
type readListMw func(input *e.ReadListDto, data *e.User, tx *gorm.DB) error
type readDetailMw func(input *e.ReadDetailDto, data *e.User, tx *gorm.DB) error
type updateMw func(input *e.ReadDetailDto, data *e.User, tx *gorm.DB) error
type deleteMw func(input *e.ReadDetailDto, data *e.User, tx *gorm.DB) error
type createMw struct {
Name string
Func func(input *e.CreateDto, data *e.User, tx *gorm.DB) error
}
type readListMw struct {
Name string
Func func(input *e.ReadListDto, data *e.User, tx *gorm.DB) error
}
type readDetailMw struct {
Name string
Func func(input *e.ReadDetailDto, data *e.User, tx *gorm.DB) error
}
type UpdateMw = readDetailMw
type DeleteMw = readDetailMw
var createPreMw []createMw // preprocess middleware
var createPostMw []createMw // postprocess middleware