i

merge branch 'migration into feat/vehicle-src-75

.

internal/use-case/bpjs-plugin/member/helper.go

@@ -0,0 +1,18 @@
+package member
+
+import (
+	"fmt"
+	e "simrs-vx/internal/domain/bpjs-entities/member"
+	ibpjs "simrs-vx/internal/infra/bpjs"
+)
+
+func endpointMapper(input *e.ReadListDto) string {
+	switch input.ReferenceType {
+	case e.RTBpjs:
+		return fmt.Sprintf("%speserta/nokartu?noKartu=%s&tglpelayanan=%s", ibpjs.O.BaseUrl, input.PathValue1, input.PathValue2)
+	case e.RTNik:
+		return fmt.Sprintf("%speserta/nik?nik=%s&tglpelayanan=%s", ibpjs.O.BaseUrl, input.PathValue1, input.PathValue2)
+	default:
+		return ""
+	}
+}

internal/use-case/bpjs-plugin/member/plugin.go

@@ -0,0 +1,37 @@
+package member
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	e "simrs-vx/internal/domain/bpjs-entities/member"
+
+	"gorm.io/gorm"
+)
+
+func ReadList(input *e.ReadListDto, data *e.Response, tx *gorm.DB) error {
+	endpoint := endpointMapper(input)
+	req, err := http.NewRequest("GET", endpoint, nil)
+	if err != nil {
+		return err
+	}
+	req.Header.Set("Content-Type", "application/json")
+
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return err
+	}
+
+	if err := json.Unmarshal(body, &data); err != nil {
+		return fmt.Errorf("failed to parse response JSON: %w", err)
+	}
+
+	return nil
+}

internal/use-case/bpjs-plugin/monitoring/helper.go

@@ -0,0 +1,18 @@
+package monitoring
+
+import (
+	"fmt"
+	e "simrs-vx/internal/domain/bpjs-entities/monitoring"
+	ibpjs "simrs-vx/internal/infra/bpjs"
+)
+
+func endpointMapper(input *e.ReadListDto) string {
+	switch input.ReferenceType {
+	case e.RTHist:
+		return fmt.Sprintf("%smonitoring/history/%s?tglawal=%s&tglakhir=%s", ibpjs.O.BaseUrl, input.PathValue1, input.PathValue2, input.PathValue3)
+	case e.RTVisit:
+		return fmt.Sprintf("%smonitoring/kunjungan?tglpelayanan=%s&jnspelayanan=%s", ibpjs.O.BaseUrl, input.PathValue1, input.PathValue2)
+	default:
+		return ""
+	}
+}

internal/use-case/bpjs-plugin/monitoring/plugin.go

@@ -0,0 +1,37 @@
+package monitoring
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	e "simrs-vx/internal/domain/bpjs-entities/monitoring"
+
+	"gorm.io/gorm"
+)
+
+func ReadList(input *e.ReadListDto, data *e.Response, tx *gorm.DB) error {
+	endpoint := endpointMapper(input)
+	req, err := http.NewRequest("GET", endpoint, nil)
+	if err != nil {
+		return err
+	}
+	req.Header.Set("Content-Type", "application/json")
+
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return err
+	}
+
+	if err := json.Unmarshal(body, &data); err != nil {
+		return fmt.Errorf("failed to parse response JSON: %w", err)
+	}
+
+	return nil
+}

internal/use-case/bpjs-plugin/reference/helper.go

@@ -0,0 +1,32 @@
+package reference
+
+import (
+	"fmt"
+	e "simrs-vx/internal/domain/bpjs-entities/reference"
+	ibpjs "simrs-vx/internal/infra/bpjs"
+)
+
+func endpointMapper(input *e.ReadListDto) string {
+	switch input.ReferenceType {
+	case e.RTProvince:
+		return ibpjs.O.BaseUrl + "provinces"
+	case e.RTCities:
+		return ibpjs.O.BaseUrl + "cities/" + input.PathValue1
+	case e.RTDistrict:
+		return ibpjs.O.BaseUrl + "districts/" + input.PathValue1
+	case e.RTDiagnose:
+		return ibpjs.O.BaseUrl + "diagnosa/" + input.PathValue1
+	case e.RTDiagnosePrb:
+		return ibpjs.O.BaseUrl + "diagnosaprb"
+	case e.RTMedicinePrb:
+		return ibpjs.O.BaseUrl + "obatprb/" + input.PathValue1
+	case e.RTUnit:
+		return ibpjs.O.BaseUrl + "referensi/poli/" + input.PathValue1
+	case e.RTHealthcare:
+		return fmt.Sprintf("%sreferensi/faskes?faskes=%s&jenis-faskes=%s", ibpjs.O.BaseUrl, input.PathValue1, input.PathValue2)
+	case e.RTDoctor:
+		return fmt.Sprintf("%sreferensi/dokter-dpjp?jenis-pelayanan=%s&tgl-pelayanan=%s&kode-spesialis=%s", ibpjs.O.BaseUrl, input.PathValue1, input.PathValue2, input.PathValue3)
+	default:
+		return ""
+	}
+}

internal/use-case/bpjs-plugin/reference/plugin.go

@@ -0,0 +1,37 @@
+package reference
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	e "simrs-vx/internal/domain/bpjs-entities/reference"
+
+	"gorm.io/gorm"
+)
+
+func ReadList(input *e.ReadListDto, data *e.Response, tx *gorm.DB) error {
+	endpoint := endpointMapper(input)
+	req, err := http.NewRequest("GET", endpoint, nil)
+	if err != nil {
+		return err
+	}
+	req.Header.Set("Content-Type", "application/json")
+
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return err
+	}
+
+	if err := json.Unmarshal(body, &data); err != nil {
+		return fmt.Errorf("failed to parse response JSON: %w", err)
+	}
+
+	return nil
+}

internal/use-case/bpjs-plugin/vclaim-sep/plugin.go

@@ -0,0 +1,58 @@
+package vclaimsep
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	e "simrs-vx/internal/domain/bpjs-entities/vclaim-sep"
+
+	ibpjs "simrs-vx/internal/infra/bpjs"
+
+	"gorm.io/gorm"
+)
+
+func CreateSep(input *e.CreateDto, data *e.VclaimSep, tx *gorm.DB) error {
+	req, err := http.NewRequest("POST", ibpjs.O.BaseUrl+"/sep", bytes.NewReader(input.RequestPayload))
+	if err != nil {
+		return err
+	}
+	req.Header.Set("Content-Type", "application/json")
+
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return err
+	}
+
+	var vresp vclaimResponse
+	if err := json.Unmarshal(body, &vresp); err != nil {
+		return fmt.Errorf("failed to parse response JSON: %w", err)
+	}
+
+	msg := vresp.MetaData.Message
+
+	if err := json.Unmarshal(body, data); err != nil {
+		return fmt.Errorf("failed to unmarshal into VclaimSep: %w", err)
+	}
+
+	// Save request/response details in DTO for further use
+	input.VclaimSepHist.RequestPayload = string(input.RequestPayload)
+	input.VclaimSepHist.ResponseBody = string(body)
+	input.VclaimSepHist.Message = msg
+	input.Number = func() *string {
+		number := ""
+		if vresp.Response != nil && vresp.Response.Sep != nil {
+			number = vresp.Response.Sep.NoSep
+		}
+		return &number
+	}()
+
+	return nil
+}

internal/use-case/bpjs-plugin/vclaim-sep/tycovar.go

@@ -0,0 +1,12 @@
+package vclaimsep
+
+type vclaimResponse struct {
+	MetaData struct {
+		Message string `json:"message"`
+	} `json:"metaData"`
+	Response *struct {
+		Sep *struct {
+			NoSep string `json:"noSep"`
+		} `json:"sep"`
+	} `json:"response"`
+}

internal/use-case/bpjs-use-case/member/case.go

@@ -0,0 +1,50 @@
+package member
+
+import (
+	e "simrs-vx/internal/domain/bpjs-entities/member"
+
+	dg "github.com/karincake/apem/db-gorm-pg"
+
+	pl "simrs-vx/pkg/logger"
+	pu "simrs-vx/pkg/use-case-helper"
+
+	"gorm.io/gorm"
+)
+
+const source = "member"
+
+func ReadList(input e.ReadListDto) (*e.Response, error) {
+	var data e.Response
+	var err error
+
+	event := pl.Event{
+		Feature: "ReadList",
+		Source:  source,
+	}
+
+	// Start log
+	pl.SetLogInfo(&event, input, "started", "readList")
+
+	err = dg.I.Transaction(func(tx *gorm.DB) error {
+		mwRunner := newMiddlewareRunner(&event, tx)
+		mwRunner.setMwType(pu.MWTPre)
+		// Run pre-middleware
+		if err := mwRunner.RunReadListMiddleware(readListPreMw, &input, &data); err != nil {
+			return err
+		}
+
+		mwRunner.setMwType(pu.MWTPost)
+		// Run post-middleware
+		if err := mwRunner.RunReadListMiddleware(readListPostMw, &input, &data); err != nil {
+			return err
+		}
+
+		return nil
+	})
+
+	if err != nil {
+		return nil, err
+	}
+
+	return &data, nil
+}

internal/use-case/bpjs-use-case/member/middleware-runner.go

@@ -0,0 +1,42 @@
+package member
+
+import (
+	e "simrs-vx/internal/domain/bpjs-entities/member"
+	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,
+	}
+}
+
+func (me *middlewareRunner) RunReadListMiddleware(middlewares []readListMw, input *e.ReadListDto, data *e.Response) 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/bpjs-use-case/member/middleware.go

@@ -0,0 +1,12 @@
+package member
+
+import (
+	pm "simrs-vx/internal/use-case/bpjs-plugin/member"
+)
+
+func init() {
+	readListPreMw = append(readListPreMw,
+		readListMw{Name: "readList-member", Func: pm.ReadList},
+	)
+
+}

internal/use-case/bpjs-use-case/member/tycovar.go

@@ -0,0 +1,18 @@
+/*
+member is peserta
+*/
+package member
+
+import (
+	"gorm.io/gorm"
+
+	e "simrs-vx/internal/domain/bpjs-entities/member"
+)
+
+type readListMw struct {
+	Name string
+	Func func(input *e.ReadListDto, data *e.Response, tx *gorm.DB) error
+}
+
+var readListPreMw []readListMw  // ..
+var readListPostMw []readListMw // ..

internal/use-case/bpjs-use-case/monitoring/case.go

@@ -0,0 +1,50 @@
+package monitoring
+
+import (
+	e "simrs-vx/internal/domain/bpjs-entities/monitoring"
+
+	dg "github.com/karincake/apem/db-gorm-pg"
+
+	pl "simrs-vx/pkg/logger"
+	pu "simrs-vx/pkg/use-case-helper"
+
+	"gorm.io/gorm"
+)
+
+const source = "monitoring"
+
+func ReadList(input e.ReadListDto) (*e.Response, error) {
+	var data e.Response
+	var err error
+
+	event := pl.Event{
+		Feature: "ReadList",
+		Source:  source,
+	}
+
+	// Start log
+	pl.SetLogInfo(&event, input, "started", "readList")
+
+	err = dg.I.Transaction(func(tx *gorm.DB) error {
+		mwRunner := newMiddlewareRunner(&event, tx)
+		mwRunner.setMwType(pu.MWTPre)
+		// Run pre-middleware
+		if err := mwRunner.RunReadListMiddleware(readListPreMw, &input, &data); err != nil {
+			return err
+		}
+
+		mwRunner.setMwType(pu.MWTPost)
+		// Run post-middleware
+		if err := mwRunner.RunReadListMiddleware(readListPostMw, &input, &data); err != nil {
+			return err
+		}
+
+		return nil
+	})
+
+	if err != nil {
+		return nil, err
+	}
+
+	return &data, nil
+}

internal/use-case/bpjs-use-case/monitoring/middleware-runner.go

@@ -0,0 +1,42 @@
+package monitoring
+
+import (
+	e "simrs-vx/internal/domain/bpjs-entities/monitoring"
+	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,
+	}
+}
+
+func (me *middlewareRunner) RunReadListMiddleware(middlewares []readListMw, input *e.ReadListDto, data *e.Response) 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/bpjs-use-case/monitoring/middleware.go

@@ -0,0 +1,12 @@
+package monitoring
+
+import (
+	pm "simrs-vx/internal/use-case/bpjs-plugin/monitoring"
+)
+
+func init() {
+	readListPreMw = append(readListPreMw,
+		readListMw{Name: "readList-monitoring", Func: pm.ReadList},
+	)
+
+}

internal/use-case/bpjs-use-case/monitoring/tycovar.go

@@ -0,0 +1,18 @@
+/*
+member is peserta
+*/
+package monitoring
+
+import (
+	"gorm.io/gorm"
+
+	e "simrs-vx/internal/domain/bpjs-entities/monitoring"
+)
+
+type readListMw struct {
+	Name string
+	Func func(input *e.ReadListDto, data *e.Response, tx *gorm.DB) error
+}
+
+var readListPreMw []readListMw  // ..
+var readListPostMw []readListMw // ..

internal/use-case/bpjs-use-case/reference/case.go

@@ -0,0 +1,50 @@
+package reference
+
+import (
+	e "simrs-vx/internal/domain/bpjs-entities/reference"
+
+	dg "github.com/karincake/apem/db-gorm-pg"
+
+	pl "simrs-vx/pkg/logger"
+	pu "simrs-vx/pkg/use-case-helper"
+
+	"gorm.io/gorm"
+)
+
+const source = "reference"
+
+func ReadList(input e.ReadListDto) (*e.Response, error) {
+	var data e.Response
+	var err error
+
+	event := pl.Event{
+		Feature: "ReadList",
+		Source:  source,
+	}
+
+	// Start log
+	pl.SetLogInfo(&event, input, "started", "readList")
+
+	err = dg.I.Transaction(func(tx *gorm.DB) error {
+		mwRunner := newMiddlewareRunner(&event, tx)
+		mwRunner.setMwType(pu.MWTPre)
+		// Run pre-middleware
+		if err := mwRunner.RunReadListMiddleware(readListPreMw, &input, &data); err != nil {
+			return err
+		}
+
+		mwRunner.setMwType(pu.MWTPost)
+		// Run post-middleware
+		if err := mwRunner.RunReadListMiddleware(readListPostMw, &input, &data); err != nil {
+			return err
+		}
+
+		return nil
+	})
+
+	if err != nil {
+		return nil, err
+	}
+
+	return &data, nil
+}

internal/use-case/bpjs-use-case/reference/middleware-runner.go

@@ -0,0 +1,42 @@
+package reference
+
+import (
+	e "simrs-vx/internal/domain/bpjs-entities/reference"
+	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,
+	}
+}
+
+func (me *middlewareRunner) RunReadListMiddleware(middlewares []readListMw, input *e.ReadListDto, data *e.Response) 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/bpjs-use-case/reference/middleware.go

@@ -0,0 +1,12 @@
+package reference
+
+import (
+	pr "simrs-vx/internal/use-case/bpjs-plugin/reference"
+)
+
+func init() {
+	readListPreMw = append(readListPreMw,
+		readListMw{Name: "readList-reference", Func: pr.ReadList},
+	)
+
+}

internal/use-case/bpjs-use-case/reference/tycovar.go

@@ -0,0 +1,23 @@
+/*
+DESCRIPTION:
+A sample, part of the package that contains type, constants, and/or variables.
+
+In this sample it also provides type and variable regarding the needs of the
+middleware to separate from main use-case which has the basic CRUD
+functionality. The purpose of this is to make the code more maintainable.
+*/
+package reference
+
+import (
+	"gorm.io/gorm"
+
+	e "simrs-vx/internal/domain/bpjs-entities/reference"
+)
+
+type readListMw struct {
+	Name string
+	Func func(input *e.ReadListDto, data *e.Response, tx *gorm.DB) error
+}
+
+var readListPreMw []readListMw  // ..
+var readListPostMw []readListMw // ..

internal/use-case/bpjs-use-case/vclaim-sep-hist/case.go

@@ -0,0 +1,277 @@
+package vclaimsephist
+
+import (
+	"strconv"
+
+	e "simrs-vx/internal/domain/bpjs-entities/vclaim-sep-hist"
+
+	dg "github.com/karincake/apem/db-gorm-pg"
+	d "github.com/karincake/dodol"
+
+	pl "simrs-vx/pkg/logger"
+	pu "simrs-vx/pkg/use-case-helper"
+
+	"gorm.io/gorm"
+)
+
+const source = "vclaim-sep-hist"
+
+func Create(input e.CreateDto) (*d.Data, error) {
+	data := e.VclaimSepHist{}
+
+	event := pl.Event{
+		Feature: "Create",
+		Source:  source,
+	}
+
+	// Start log
+	pl.SetLogInfo(&event, input, "started", "create")
+
+	err := dg.I.Transaction(func(tx *gorm.DB) error {
+		mwRunner := newMiddlewareRunner(&event, tx)
+		mwRunner.setMwType(pu.MWTPre)
+		// Run pre-middleware
+		if err := mwRunner.RunCreateMiddleware(createPreMw, &input, &data); err != nil {
+			return err
+		}
+
+		if resData, err := CreateData(input, &event, tx); err != nil {
+			return err
+		} else {
+			data = *resData
+		}
+
+		mwRunner.setMwType(pu.MWTPost)
+		// Run post-middleware
+		if err := mwRunner.RunCreateMiddleware(createPostMw, &input, &data); err != nil {
+			return err
+		}
+
+		pl.SetLogInfo(&event, nil, "complete")
+
+		return nil
+	})
+
+	if err != nil {
+		return nil, err
+	}
+
+	return &d.Data{
+		Meta: d.II{
+			"source":    source,
+			"structure": "single-data",
+			"status":    "created",
+		},
+		Data: data.ToResponse(),
+	}, nil
+}
+
+func ReadList(input e.ReadListDto) (*d.Data, error) {
+	var data *e.VclaimSepHist
+	var dataList []e.VclaimSepHist
+	var metaList *e.MetaDto
+	var err error
+
+	event := pl.Event{
+		Feature: "ReadList",
+		Source:  source,
+	}
+
+	// Start log
+	pl.SetLogInfo(&event, input, "started", "readList")
+
+	err = dg.I.Transaction(func(tx *gorm.DB) error {
+		mwRunner := newMiddlewareRunner(&event, tx)
+		mwRunner.setMwType(pu.MWTPre)
+		// Run pre-middleware
+		if err := mwRunner.RunReadListMiddleware(readListPreMw, &input, data); err != nil {
+			return err
+		}
+
+		if dataList, metaList, err = ReadListData(input, &event, tx); err != nil {
+			return err
+		}
+
+		mwRunner.setMwType(pu.MWTPost)
+		// Run post-middleware
+		if err := mwRunner.RunReadListMiddleware(readListPostMw, &input, data); err != nil {
+			return err
+		}
+
+		return nil
+	})
+
+	if err != nil {
+		return nil, err
+	}
+
+	return &d.Data{
+		Meta: d.IS{
+			"source":              source,
+			"structure":           "list-data",
+			"status":              "fetched",
+			"page_number":         strconv.Itoa(metaList.PageNumber),
+			"page_size":           strconv.Itoa(metaList.PageSize),
+			"record_totalCount":   strconv.Itoa(metaList.Count),
+			"record_currentCount": strconv.Itoa(len(dataList)),
+		},
+		Data: e.ToResponseList(dataList),
+	}, nil
+}
+
+func ReadDetail(input e.ReadDetailDto) (*d.Data, error) {
+	var data *e.VclaimSepHist
+	var err error
+
+	event := pl.Event{
+		Feature: "ReadDetail",
+		Source:  source,
+	}
+
+	// Start log
+	pl.SetLogInfo(&event, input, "started", "readDetail")
+
+	err = dg.I.Transaction(func(tx *gorm.DB) error {
+		mwRunner := newMiddlewareRunner(&event, tx)
+		mwRunner.setMwType(pu.MWTPre)
+		// Run pre-middleware
+		if err := mwRunner.RunReadDetailMiddleware(readDetailPreMw, &input, data); err != nil {
+			return err
+		}
+
+		if data, err = ReadDetailData(input, &event, tx); err != nil {
+			return err
+		}
+
+		mwRunner.setMwType(pu.MWTPost)
+		// Run post-middleware
+		if err := mwRunner.RunReadDetailMiddleware(readDetailPostMw, &input, data); err != nil {
+			return err
+		}
+
+		return nil
+	})
+
+	if err != nil {
+		return nil, err
+	}
+
+	return &d.Data{
+		Meta: d.IS{
+			"source":    source,
+			"structure": "single-data",
+			"status":    "fetched",
+		},
+		Data: data.ToResponse(),
+	}, nil
+}
+
+func Update(input e.UpdateDto) (*d.Data, error) {
+	rdDto := e.ReadDetailDto{Id: input.Id}
+	var data *e.VclaimSepHist
+	var err error
+
+	event := pl.Event{
+		Feature: "Update",
+		Source:  source,
+	}
+
+	// Start log
+	pl.SetLogInfo(&event, input, "started", "update")
+
+	err = dg.I.Transaction(func(tx *gorm.DB) error {
+		pl.SetLogInfo(&event, rdDto, "started", "DBReadDetail")
+		if data, err = ReadDetailData(rdDto, &event, tx); err != nil {
+			return err
+		}
+
+		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")
+
+		mwRunner.setMwType(pu.MWTPost)
+		// Run post-middleware
+		if err := mwRunner.RunUpdateMiddleware(readDetailPostMw, &rdDto, data); err != nil {
+			return err
+		}
+
+		return nil
+	})
+
+	if err != nil {
+		return nil, err
+	}
+
+	return &d.Data{
+		Meta: d.IS{
+			"source":    source,
+			"structure": "single-data",
+			"status":    "updated",
+		},
+		Data: data.ToResponse(),
+	}, nil
+
+}
+
+func Delete(input e.DeleteDto) (*d.Data, error) {
+	rdDto := e.ReadDetailDto{Id: input.Id}
+	var data *e.VclaimSepHist
+	var err error
+
+	event := pl.Event{
+		Feature: "Delete",
+		Source:  source,
+	}
+
+	// Start log
+	pl.SetLogInfo(&event, input, "started", "delete")
+
+	err = dg.I.Transaction(func(tx *gorm.DB) error {
+		pl.SetLogInfo(&event, rdDto, "started", "DBReadDetail")
+		if data, err = ReadDetailData(rdDto, &event, tx); err != nil {
+			return err
+		}
+
+		mwRunner := newMiddlewareRunner(&event, tx)
+		mwRunner.setMwType(pu.MWTPre)
+		// Run pre-middleware
+		if err := mwRunner.RunDeleteMiddleware(readDetailPreMw, &rdDto, data); err != nil {
+			return err
+		}
+
+		if err := DeleteData(data, &event, tx); err != nil {
+			return err
+		}
+
+		mwRunner.setMwType(pu.MWTPost)
+		// Run post-middleware
+		if err := mwRunner.RunDeleteMiddleware(readDetailPostMw, &rdDto, data); err != nil {
+			return err
+		}
+
+		return nil
+	})
+
+	if err != nil {
+		return nil, err
+	}
+
+	return &d.Data{
+		Meta: d.IS{
+			"source":    source,
+			"structure": "single-data",
+			"status":    "deleted",
+		},
+		Data: data.ToResponse(),
+	}, nil
+
+}

internal/use-case/bpjs-use-case/vclaim-sep-hist/helper.go

@@ -0,0 +1,23 @@
+/*
+DESCRIPTION:
+Any functions that are used internally by the use-case
+*/
+package vclaimsephist
+
+import (
+	e "simrs-vx/internal/domain/bpjs-entities/vclaim-sep-hist"
+)
+
+func setData[T *e.CreateDto | *e.UpdateDto](input T, data *e.VclaimSepHist) {
+	var inputSrc *e.CreateDto
+	if inputT, ok := any(input).(*e.CreateDto); ok {
+		inputSrc = inputT
+	} else {
+		inputTemp := any(input).(*e.UpdateDto)
+		inputSrc = &inputTemp.CreateDto
+	}
+
+	data.RequestPayload = &inputSrc.RequestPayload
+	data.ResponseBody = &inputSrc.ResponseBody
+	data.Message = &inputSrc.Message
+}

internal/use-case/bpjs-use-case/vclaim-sep-hist/lib.go

@@ -0,0 +1,140 @@
+package vclaimsephist
+
+import (
+	e "simrs-vx/internal/domain/bpjs-entities/vclaim-sep-hist"
+
+	plh "simrs-vx/pkg/lib-helper"
+	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.CreateDto, event *pl.Event, dbx ...*gorm.DB) (*e.VclaimSepHist, error) {
+	pl.SetLogInfo(event, nil, "started", "DBCreate")
+
+	data := e.VclaimSepHist{}
+	setData(&input, &data)
+
+	var tx *gorm.DB
+	if len(dbx) > 0 {
+		tx = dbx[0]
+	} else {
+		tx = dg.I
+	}
+
+	if err := tx.Create(&data).Error; err != nil {
+		return nil, plh.HandleCreateError(input, event, err)
+	}
+
+	pl.SetLogInfo(event, nil, "complete")
+	return &data, nil
+}
+
+func ReadListData(input e.ReadListDto, event *pl.Event, dbx ...*gorm.DB) ([]e.VclaimSepHist, *e.MetaDto, error) {
+	pl.SetLogInfo(event, input, "started", "DBReadList")
+	data := []e.VclaimSepHist{}
+	pagination := gh.Pagination{}
+	count := int64(0)
+	meta := e.MetaDto{}
+
+	var tx *gorm.DB
+	if len(dbx) > 0 {
+		tx = dbx[0]
+	} else {
+		tx = dg.I
+	}
+
+	tx = tx.
+		Model(&e.VclaimSepHist{}).
+		Scopes(gh.Preload(input.Includes)).
+		Scopes(gh.Filter(input.FilterDto)).
+		Count(&count).
+		Scopes(gh.Paginate(input, &pagination)).
+		Scopes(gh.Sort(input.Sort))
+
+	if err := tx.Find(&data).Error; err != nil {
+		if err == gorm.ErrRecordNotFound {
+			return nil, &meta, nil
+		}
+		return nil, nil, plh.HandleListError(input, event, err)
+	}
+
+	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, event *pl.Event, dbx ...*gorm.DB) (*e.VclaimSepHist, error) {
+	pl.SetLogInfo(event, input, "started", "DBReadDetail")
+	data := e.VclaimSepHist{}
+
+	var tx *gorm.DB
+	if len(dbx) > 0 {
+		tx = dbx[0]
+	} else {
+		tx = dg.I
+	}
+
+	if err := tx.First(&data, input.Id).Error; err != nil {
+		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.UpdateDto, data *e.VclaimSepHist, event *pl.Event, dbx ...*gorm.DB) error {
+	pl.SetLogInfo(event, data, "started", "DBUpdate")
+	setData(&input, data)
+
+	var tx *gorm.DB
+	if len(dbx) > 0 {
+		tx = dbx[0]
+	} else {
+		tx = dg.I
+	}
+
+	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(data *e.VclaimSepHist, event *pl.Event, dbx ...*gorm.DB) error {
+	pl.SetLogInfo(event, data, "started", "DBDelete")
+	var tx *gorm.DB
+	if len(dbx) > 0 {
+		tx = dbx[0]
+	} else {
+		tx = dg.I
+	}
+
+	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/bpjs-use-case/vclaim-sep-hist/middleware-runner.go

@@ -0,0 +1,103 @@
+package vclaimsephist
+
+import (
+	e "simrs-vx/internal/domain/bpjs-entities/vclaim-sep-hist"
+	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.VclaimSepHist) 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.VclaimSepHist) 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.VclaimSepHist) 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.VclaimSepHist) 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.VclaimSepHist) 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/bpjs-use-case/vclaim-sep-hist/middleware.go

@@ -0,0 +1,9 @@
+package vclaimsephist
+
+// example of middleware
+// func init() {
+// 	createPreMw = append(createPreMw,
+// 		CreateMw{Name: "modif-input", Func: pm.ModifInput},
+// 		CreateMw{Name: "check-data", Func: pm.CheckData},
+// 	)
+// }

internal/use-case/bpjs-use-case/vclaim-sep-hist/tycovar.go

@@ -0,0 +1,44 @@
+/*
+DESCRIPTION:
+A sample, part of the package that contains type, constants, and/or variables.
+
+In this sample it also provides type and variable regarding the needs of the
+middleware to separate from main use-case which has the basic CRUD
+functionality. The purpose of this is to make the code more maintainable.
+*/
+package vclaimsephist
+
+import (
+	"gorm.io/gorm"
+
+	e "simrs-vx/internal/domain/bpjs-entities/vclaim-sep-hist"
+)
+
+type createMw struct {
+	Name string
+	Func func(input *e.CreateDto, data *e.VclaimSepHist, tx *gorm.DB) error
+}
+
+type readListMw struct {
+	Name string
+	Func func(input *e.ReadListDto, data *e.VclaimSepHist, tx *gorm.DB) error
+}
+
+type readDetailMw struct {
+	Name string
+	Func func(input *e.ReadDetailDto, data *e.VclaimSepHist, tx *gorm.DB) error
+}
+
+type UpdateMw = readDetailMw
+type DeleteMw = readDetailMw
+
+var createPreMw []createMw      // preprocess middleware
+var createPostMw []createMw     // postprocess middleware
+var readListPreMw []readListMw  // ..
+var readListPostMw []readListMw // ..
+var readDetailPreMw []readDetailMw
+var readDetailPostMw []readDetailMw
+var updatePreMw []readDetailMw
+var updatePostMw []readDetailMw
+var deletePreMw []readDetailMw
+var deletePostMw []readDetailMw

internal/use-case/bpjs-use-case/vclaim-sep-print/case.go

@@ -0,0 +1,277 @@
+package vclaimsepprint
+
+import (
+	"strconv"
+
+	e "simrs-vx/internal/domain/bpjs-entities/vclaim-sep-print"
+
+	dg "github.com/karincake/apem/db-gorm-pg"
+	d "github.com/karincake/dodol"
+
+	pl "simrs-vx/pkg/logger"
+	pu "simrs-vx/pkg/use-case-helper"
+
+	"gorm.io/gorm"
+)
+
+const source = "vclaim-sep-print"
+
+func Create(input e.CreateDto) (*d.Data, error) {
+	data := e.VclaimSepPrint{}
+
+	event := pl.Event{
+		Feature: "Create",
+		Source:  source,
+	}
+
+	// Start log
+	pl.SetLogInfo(&event, input, "started", "create")
+
+	err := dg.I.Transaction(func(tx *gorm.DB) error {
+		mwRunner := newMiddlewareRunner(&event, tx)
+		mwRunner.setMwType(pu.MWTPre)
+		// Run pre-middleware
+		if err := mwRunner.RunCreateMiddleware(createPreMw, &input, &data); err != nil {
+			return err
+		}
+
+		if resData, err := CreateData(input, &event, tx); err != nil {
+			return err
+		} else {
+			data = *resData
+		}
+
+		mwRunner.setMwType(pu.MWTPost)
+		// Run post-middleware
+		if err := mwRunner.RunCreateMiddleware(createPostMw, &input, &data); err != nil {
+			return err
+		}
+
+		pl.SetLogInfo(&event, nil, "complete")
+
+		return nil
+	})
+
+	if err != nil {
+		return nil, err
+	}
+
+	return &d.Data{
+		Meta: d.II{
+			"source":    source,
+			"structure": "single-data",
+			"status":    "created",
+		},
+		Data: data.ToResponse(),
+	}, nil
+}
+
+func ReadList(input e.ReadListDto) (*d.Data, error) {
+	var data *e.VclaimSepPrint
+	var dataList []e.VclaimSepPrint
+	var metaList *e.MetaDto
+	var err error
+
+	event := pl.Event{
+		Feature: "ReadList",
+		Source:  source,
+	}
+
+	// Start log
+	pl.SetLogInfo(&event, input, "started", "readList")
+
+	err = dg.I.Transaction(func(tx *gorm.DB) error {
+		mwRunner := newMiddlewareRunner(&event, tx)
+		mwRunner.setMwType(pu.MWTPre)
+		// Run pre-middleware
+		if err := mwRunner.RunReadListMiddleware(readListPreMw, &input, data); err != nil {
+			return err
+		}
+
+		if dataList, metaList, err = ReadListData(input, &event, tx); err != nil {
+			return err
+		}
+
+		mwRunner.setMwType(pu.MWTPost)
+		// Run post-middleware
+		if err := mwRunner.RunReadListMiddleware(readListPostMw, &input, data); err != nil {
+			return err
+		}
+
+		return nil
+	})
+
+	if err != nil {
+		return nil, err
+	}
+
+	return &d.Data{
+		Meta: d.IS{
+			"source":              source,
+			"structure":           "list-data",
+			"status":              "fetched",
+			"page_number":         strconv.Itoa(metaList.PageNumber),
+			"page_size":           strconv.Itoa(metaList.PageSize),
+			"record_totalCount":   strconv.Itoa(metaList.Count),
+			"record_currentCount": strconv.Itoa(len(dataList)),
+		},
+		Data: e.ToResponseList(dataList),
+	}, nil
+}
+
+func ReadDetail(input e.ReadDetailDto) (*d.Data, error) {
+	var data *e.VclaimSepPrint
+	var err error
+
+	event := pl.Event{
+		Feature: "ReadDetail",
+		Source:  source,
+	}
+
+	// Start log
+	pl.SetLogInfo(&event, input, "started", "readDetail")
+
+	err = dg.I.Transaction(func(tx *gorm.DB) error {
+		mwRunner := newMiddlewareRunner(&event, tx)
+		mwRunner.setMwType(pu.MWTPre)
+		// Run pre-middleware
+		if err := mwRunner.RunReadDetailMiddleware(readDetailPreMw, &input, data); err != nil {
+			return err
+		}
+
+		if data, err = ReadDetailData(input, &event, tx); err != nil {
+			return err
+		}
+
+		mwRunner.setMwType(pu.MWTPost)
+		// Run post-middleware
+		if err := mwRunner.RunReadDetailMiddleware(readDetailPostMw, &input, data); err != nil {
+			return err
+		}
+
+		return nil
+	})
+
+	if err != nil {
+		return nil, err
+	}
+
+	return &d.Data{
+		Meta: d.IS{
+			"source":    source,
+			"structure": "single-data",
+			"status":    "fetched",
+		},
+		Data: data.ToResponse(),
+	}, nil
+}
+
+func Update(input e.UpdateDto) (*d.Data, error) {
+	rdDto := e.ReadDetailDto{Id: input.Id}
+	var data *e.VclaimSepPrint
+	var err error
+
+	event := pl.Event{
+		Feature: "Update",
+		Source:  source,
+	}
+
+	// Start log
+	pl.SetLogInfo(&event, input, "started", "update")
+
+	err = dg.I.Transaction(func(tx *gorm.DB) error {
+		pl.SetLogInfo(&event, rdDto, "started", "DBReadDetail")
+		if data, err = ReadDetailData(rdDto, &event, tx); err != nil {
+			return err
+		}
+
+		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")
+
+		mwRunner.setMwType(pu.MWTPost)
+		// Run post-middleware
+		if err := mwRunner.RunUpdateMiddleware(readDetailPostMw, &rdDto, data); err != nil {
+			return err
+		}
+
+		return nil
+	})
+
+	if err != nil {
+		return nil, err
+	}
+
+	return &d.Data{
+		Meta: d.IS{
+			"source":    source,
+			"structure": "single-data",
+			"status":    "updated",
+		},
+		Data: data.ToResponse(),
+	}, nil
+
+}
+
+func Delete(input e.DeleteDto) (*d.Data, error) {
+	rdDto := e.ReadDetailDto{Id: input.Id}
+	var data *e.VclaimSepPrint
+	var err error
+
+	event := pl.Event{
+		Feature: "Delete",
+		Source:  source,
+	}
+
+	// Start log
+	pl.SetLogInfo(&event, input, "started", "delete")
+
+	err = dg.I.Transaction(func(tx *gorm.DB) error {
+		pl.SetLogInfo(&event, rdDto, "started", "DBReadDetail")
+		if data, err = ReadDetailData(rdDto, &event, tx); err != nil {
+			return err
+		}
+
+		mwRunner := newMiddlewareRunner(&event, tx)
+		mwRunner.setMwType(pu.MWTPre)
+		// Run pre-middleware
+		if err := mwRunner.RunDeleteMiddleware(readDetailPreMw, &rdDto, data); err != nil {
+			return err
+		}
+
+		if err := DeleteData(data, &event, tx); err != nil {
+			return err
+		}
+
+		mwRunner.setMwType(pu.MWTPost)
+		// Run post-middleware
+		if err := mwRunner.RunDeleteMiddleware(readDetailPostMw, &rdDto, data); err != nil {
+			return err
+		}
+
+		return nil
+	})
+
+	if err != nil {
+		return nil, err
+	}
+
+	return &d.Data{
+		Meta: d.IS{
+			"source":    source,
+			"structure": "single-data",
+			"status":    "deleted",
+		},
+		Data: data.ToResponse(),
+	}, nil
+
+}

internal/use-case/bpjs-use-case/vclaim-sep-print/helper.go

@@ -0,0 +1,21 @@
+/*
+DESCRIPTION:
+Any functions that are used internally by the use-case
+*/
+package vclaimsepprint
+
+import (
+	e "simrs-vx/internal/domain/bpjs-entities/vclaim-sep-print"
+)
+
+func setData[T *e.CreateDto | *e.UpdateDto](input T, data *e.VclaimSepPrint) {
+	var inputSrc *e.CreateDto
+	if inputT, ok := any(input).(*e.CreateDto); ok {
+		inputSrc = inputT
+	} else {
+		inputTemp := any(input).(*e.UpdateDto)
+		inputSrc = &inputTemp.CreateDto
+	}
+
+	data.VclaimSep_Number = inputSrc.VclaimSep_Number
+}

internal/use-case/bpjs-use-case/vclaim-sep-print/lib.go

@@ -0,0 +1,148 @@
+package vclaimsepprint
+
+import (
+	e "simrs-vx/internal/domain/bpjs-entities/vclaim-sep-print"
+
+	plh "simrs-vx/pkg/lib-helper"
+	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.CreateDto, event *pl.Event, dbx ...*gorm.DB) (*e.VclaimSepPrint, error) {
+	pl.SetLogInfo(event, nil, "started", "DBCreate")
+
+	data := e.VclaimSepPrint{}
+	var maxCounter uint
+
+	var tx *gorm.DB
+	if len(dbx) > 0 {
+		tx = dbx[0]
+	} else {
+		tx = dg.I
+	}
+
+	err := tx.Model(&data).
+		Where("VclaimSep_Number = ?", input.VclaimSep_Number).
+		Select("COALESCE(MAX(Counter), 0)").
+		Scan(&maxCounter).Error
+	if err != nil {
+		return nil, err
+	}
+
+	if err := tx.Create(&data).Error; err != nil {
+		return nil, plh.HandleCreateError(input, event, err)
+	}
+
+	pl.SetLogInfo(event, nil, "complete")
+	return &data, nil
+}
+
+func ReadListData(input e.ReadListDto, event *pl.Event, dbx ...*gorm.DB) ([]e.VclaimSepPrint, *e.MetaDto, error) {
+	pl.SetLogInfo(event, input, "started", "DBReadList")
+	data := []e.VclaimSepPrint{}
+	pagination := gh.Pagination{}
+	count := int64(0)
+	meta := e.MetaDto{}
+
+	var tx *gorm.DB
+	if len(dbx) > 0 {
+		tx = dbx[0]
+	} else {
+		tx = dg.I
+	}
+
+	tx = tx.
+		Model(&e.VclaimSepPrint{}).
+		Scopes(gh.Preload(input.Includes)).
+		Scopes(gh.Filter(input.FilterDto)).
+		Count(&count).
+		Scopes(gh.Paginate(input, &pagination)).
+		Scopes(gh.Sort(input.Sort))
+
+	if err := tx.Find(&data).Error; err != nil {
+		if err == gorm.ErrRecordNotFound {
+			return nil, &meta, nil
+		}
+		return nil, nil, plh.HandleListError(input, event, err)
+	}
+
+	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, event *pl.Event, dbx ...*gorm.DB) (*e.VclaimSepPrint, error) {
+	pl.SetLogInfo(event, input, "started", "DBReadDetail")
+	data := e.VclaimSepPrint{}
+
+	var tx *gorm.DB
+	if len(dbx) > 0 {
+		tx = dbx[0]
+	} else {
+		tx = dg.I
+	}
+
+	if err := tx.First(&data, input.Id).Error; err != nil {
+		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.UpdateDto, data *e.VclaimSepPrint, event *pl.Event, dbx ...*gorm.DB) error {
+	pl.SetLogInfo(event, data, "started", "DBUpdate")
+	setData(&input, data)
+
+	var tx *gorm.DB
+	if len(dbx) > 0 {
+		tx = dbx[0]
+	} else {
+		tx = dg.I
+	}
+
+	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(data *e.VclaimSepPrint, event *pl.Event, dbx ...*gorm.DB) error {
+	pl.SetLogInfo(event, data, "started", "DBDelete")
+	var tx *gorm.DB
+	if len(dbx) > 0 {
+		tx = dbx[0]
+	} else {
+		tx = dg.I
+	}
+
+	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/bpjs-use-case/vclaim-sep-print/middleware-runner.go

@@ -0,0 +1,103 @@
+package vclaimsepprint
+
+import (
+	e "simrs-vx/internal/domain/bpjs-entities/vclaim-sep-print"
+	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.VclaimSepPrint) 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.VclaimSepPrint) 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.VclaimSepPrint) 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.VclaimSepPrint) 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.VclaimSepPrint) 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/bpjs-use-case/vclaim-sep-print/middleware.go

@@ -0,0 +1,9 @@
+package vclaimsepprint
+
+// example of middleware
+// func init() {
+// 	createPreMw = append(createPreMw,
+// 		CreateMw{Name: "modif-input", Func: pm.ModifInput},
+// 		CreateMw{Name: "check-data", Func: pm.CheckData},
+// 	)
+// }

internal/use-case/bpjs-use-case/vclaim-sep-print/tycovar.go

@@ -0,0 +1,44 @@
+/*
+DESCRIPTION:
+A sample, part of the package that contains type, constants, and/or variables.
+
+In this sample it also provides type and variable regarding the needs of the
+middleware to separate from main use-case which has the basic CRUD
+functionality. The purpose of this is to make the code more maintainable.
+*/
+package vclaimsepprint
+
+import (
+	"gorm.io/gorm"
+
+	e "simrs-vx/internal/domain/bpjs-entities/vclaim-sep-print"
+)
+
+type createMw struct {
+	Name string
+	Func func(input *e.CreateDto, data *e.VclaimSepPrint, tx *gorm.DB) error
+}
+
+type readListMw struct {
+	Name string
+	Func func(input *e.ReadListDto, data *e.VclaimSepPrint, tx *gorm.DB) error
+}
+
+type readDetailMw struct {
+	Name string
+	Func func(input *e.ReadDetailDto, data *e.VclaimSepPrint, tx *gorm.DB) error
+}
+
+type UpdateMw = readDetailMw
+type DeleteMw = readDetailMw
+
+var createPreMw []createMw      // preprocess middleware
+var createPostMw []createMw     // postprocess middleware
+var readListPreMw []readListMw  // ..
+var readListPostMw []readListMw // ..
+var readDetailPreMw []readDetailMw
+var readDetailPostMw []readDetailMw
+var updatePreMw []readDetailMw
+var updatePostMw []readDetailMw
+var deletePreMw []readDetailMw
+var deletePostMw []readDetailMw

internal/use-case/bpjs-use-case/vclaim-sep/case.go

@@ -0,0 +1,288 @@
+package vclaimsep
+
+import (
+	"strconv"
+
+	e "simrs-vx/internal/domain/bpjs-entities/vclaim-sep"
+	// evsh "simrs-vx/internal/domain/bpjs-entities/vclaim-sep-hist"
+
+	uvsh "simrs-vx/internal/use-case/bpjs-use-case/vclaim-sep-hist"
+
+	dg "github.com/karincake/apem/db-gorm-pg"
+	d "github.com/karincake/dodol"
+
+	pl "simrs-vx/pkg/logger"
+	pu "simrs-vx/pkg/use-case-helper"
+
+	"gorm.io/gorm"
+)
+
+const source = "vclaim-sep"
+
+func Create(input e.CreateDto) (*d.Data, error) {
+	data := e.VclaimSep{}
+
+	event := pl.Event{
+		Feature: "Create",
+		Source:  source,
+	}
+
+	// Start log
+	pl.SetLogInfo(&event, input, "started", "create")
+
+	err := dg.I.Transaction(func(tx *gorm.DB) error {
+		mwRunner := newMiddlewareRunner(&event, tx)
+		mwRunner.setMwType(pu.MWTPre)
+		// Run pre-middleware
+		if err := mwRunner.RunCreateMiddleware(createPreMw, &input, &data); err != nil {
+			return err
+		}
+
+		if _, err := uvsh.CreateData(input.VclaimSepHist, &event, tx); err != nil {
+			return err
+		}
+
+		if !input.IsMessageSuccess() {
+			return nil
+		}
+
+		if resData, err := CreateData(input, &event, tx); err != nil {
+			return err
+		} else {
+			data = *resData
+		}
+
+		mwRunner.setMwType(pu.MWTPost)
+		// Run post-middleware
+		if err := mwRunner.RunCreateMiddleware(createPostMw, &input, &data); err != nil {
+			return err
+		}
+
+		pl.SetLogInfo(&event, nil, "complete")
+
+		return nil
+	})
+
+	if err != nil {
+		return nil, err
+	}
+
+	return &d.Data{
+		Meta: d.II{
+			"source":    source,
+			"structure": "single-data",
+			"status":    "created",
+		},
+		Data: data.ToResponse(),
+	}, nil
+}
+
+func ReadList(input e.ReadListDto) (*d.Data, error) {
+	var data *e.VclaimSep
+	var dataList []e.VclaimSep
+	var metaList *e.MetaDto
+	var err error
+
+	event := pl.Event{
+		Feature: "ReadList",
+		Source:  source,
+	}
+
+	// Start log
+	pl.SetLogInfo(&event, input, "started", "readList")
+
+	err = dg.I.Transaction(func(tx *gorm.DB) error {
+		mwRunner := newMiddlewareRunner(&event, tx)
+		mwRunner.setMwType(pu.MWTPre)
+		// Run pre-middleware
+		if err := mwRunner.RunReadListMiddleware(readListPreMw, &input, data); err != nil {
+			return err
+		}
+
+		if dataList, metaList, err = ReadListData(input, &event, tx); err != nil {
+			return err
+		}
+
+		mwRunner.setMwType(pu.MWTPost)
+		// Run post-middleware
+		if err := mwRunner.RunReadListMiddleware(readListPostMw, &input, data); err != nil {
+			return err
+		}
+
+		return nil
+	})
+
+	if err != nil {
+		return nil, err
+	}
+
+	return &d.Data{
+		Meta: d.IS{
+			"source":              source,
+			"structure":           "list-data",
+			"status":              "fetched",
+			"page_number":         strconv.Itoa(metaList.PageNumber),
+			"page_size":           strconv.Itoa(metaList.PageSize),
+			"record_totalCount":   strconv.Itoa(metaList.Count),
+			"record_currentCount": strconv.Itoa(len(dataList)),
+		},
+		Data: e.ToResponseList(dataList),
+	}, nil
+}
+
+func ReadDetail(input e.ReadDetailDto) (*d.Data, error) {
+	var data *e.VclaimSep
+	var err error
+
+	event := pl.Event{
+		Feature: "ReadDetail",
+		Source:  source,
+	}
+
+	// Start log
+	pl.SetLogInfo(&event, input, "started", "readDetail")
+
+	err = dg.I.Transaction(func(tx *gorm.DB) error {
+		mwRunner := newMiddlewareRunner(&event, tx)
+		mwRunner.setMwType(pu.MWTPre)
+		// Run pre-middleware
+		if err := mwRunner.RunReadDetailMiddleware(readDetailPreMw, &input, data); err != nil {
+			return err
+		}
+
+		if data, err = ReadDetailData(input, &event, tx); err != nil {
+			return err
+		}
+
+		mwRunner.setMwType(pu.MWTPost)
+		// Run post-middleware
+		if err := mwRunner.RunReadDetailMiddleware(readDetailPostMw, &input, data); err != nil {
+			return err
+		}
+
+		return nil
+	})
+
+	if err != nil {
+		return nil, err
+	}
+
+	return &d.Data{
+		Meta: d.IS{
+			"source":    source,
+			"structure": "single-data",
+			"status":    "fetched",
+		},
+		Data: data.ToResponse(),
+	}, nil
+}
+
+func Update(input e.UpdateDto) (*d.Data, error) {
+	rdDto := e.ReadDetailDto{Number: input.Number}
+	var data *e.VclaimSep
+	var err error
+
+	event := pl.Event{
+		Feature: "Update",
+		Source:  source,
+	}
+
+	// Start log
+	pl.SetLogInfo(&event, input, "started", "update")
+
+	err = dg.I.Transaction(func(tx *gorm.DB) error {
+		pl.SetLogInfo(&event, rdDto, "started", "DBReadDetail")
+		if data, err = ReadDetailData(rdDto, &event, tx); err != nil {
+			return err
+		}
+
+		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")
+
+		mwRunner.setMwType(pu.MWTPost)
+		// Run post-middleware
+		if err := mwRunner.RunUpdateMiddleware(readDetailPostMw, &rdDto, data); err != nil {
+			return err
+		}
+
+		return nil
+	})
+
+	if err != nil {
+		return nil, err
+	}
+
+	return &d.Data{
+		Meta: d.IS{
+			"source":    source,
+			"structure": "single-data",
+			"status":    "updated",
+		},
+		Data: data.ToResponse(),
+	}, nil
+
+}
+
+func Delete(input e.DeleteDto) (*d.Data, error) {
+	rdDto := e.ReadDetailDto{Number: input.Number}
+	var data *e.VclaimSep
+	var err error
+
+	event := pl.Event{
+		Feature: "Delete",
+		Source:  source,
+	}
+
+	// Start log
+	pl.SetLogInfo(&event, input, "started", "delete")
+
+	err = dg.I.Transaction(func(tx *gorm.DB) error {
+		pl.SetLogInfo(&event, rdDto, "started", "DBReadDetail")
+		if data, err = ReadDetailData(rdDto, &event, tx); err != nil {
+			return err
+		}
+
+		mwRunner := newMiddlewareRunner(&event, tx)
+		mwRunner.setMwType(pu.MWTPre)
+		// Run pre-middleware
+		if err := mwRunner.RunDeleteMiddleware(readDetailPreMw, &rdDto, data); err != nil {
+			return err
+		}
+
+		if err := DeleteData(data, &event, tx); err != nil {
+			return err
+		}
+
+		mwRunner.setMwType(pu.MWTPost)
+		// Run post-middleware
+		if err := mwRunner.RunDeleteMiddleware(readDetailPostMw, &rdDto, data); err != nil {
+			return err
+		}
+
+		return nil
+	})
+
+	if err != nil {
+		return nil, err
+	}
+
+	return &d.Data{
+		Meta: d.IS{
+			"source":    source,
+			"structure": "single-data",
+			"status":    "deleted",
+		},
+		Data: data.ToResponse(),
+	}, nil
+
+}

internal/use-case/bpjs-use-case/vclaim-sep/helper.go

@@ -0,0 +1,22 @@
+/*
+DESCRIPTION:
+Any functions that are used internally by the use-case
+*/
+package vclaimsep
+
+import (
+	e "simrs-vx/internal/domain/bpjs-entities/vclaim-sep"
+)
+
+func setData[T *e.CreateDto | *e.UpdateDto](input T, data *e.VclaimSep) {
+	var inputSrc *e.CreateDto
+	if inputT, ok := any(input).(*e.CreateDto); ok {
+		inputSrc = inputT
+	} else {
+		inputTemp := any(input).(*e.UpdateDto)
+		inputSrc = &inputTemp.CreateDto
+	}
+
+	data.Encounter_Id = inputSrc.Encounter_Id
+	data.Number = inputSrc.Number
+}

internal/use-case/bpjs-use-case/vclaim-sep/lib.go

@@ -0,0 +1,147 @@
+package vclaimsep
+
+import (
+	e "simrs-vx/internal/domain/bpjs-entities/vclaim-sep"
+
+	plh "simrs-vx/pkg/lib-helper"
+	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.CreateDto, event *pl.Event, dbx ...*gorm.DB) (*e.VclaimSep, error) {
+	pl.SetLogInfo(event, nil, "started", "DBCreate")
+
+	data := e.VclaimSep{}
+	setData(&input, &data)
+
+	var tx *gorm.DB
+	if len(dbx) > 0 {
+		tx = dbx[0]
+	} else {
+		tx = dg.I
+	}
+
+	if err := tx.Create(&data).Error; err != nil {
+		return nil, plh.HandleCreateError(input, event, err)
+	}
+
+	pl.SetLogInfo(event, nil, "complete")
+	return &data, nil
+}
+
+func ReadListData(input e.ReadListDto, event *pl.Event, dbx ...*gorm.DB) ([]e.VclaimSep, *e.MetaDto, error) {
+	pl.SetLogInfo(event, input, "started", "DBReadList")
+	data := []e.VclaimSep{}
+	pagination := gh.Pagination{}
+	count := int64(0)
+	meta := e.MetaDto{}
+
+	var tx *gorm.DB
+	if len(dbx) > 0 {
+		tx = dbx[0]
+	} else {
+		tx = dg.I
+	}
+
+	tx = tx.
+		Model(&e.VclaimSep{}).
+		Scopes(gh.Preload(input.Includes)).
+		Scopes(gh.Filter(input.FilterDto)).
+		Count(&count).
+		Scopes(gh.Paginate(input, &pagination)).
+		Scopes(gh.Sort(input.Sort))
+
+	if err := tx.Find(&data).Error; err != nil {
+		if err == gorm.ErrRecordNotFound {
+			return nil, &meta, nil
+		}
+		return nil, nil, plh.HandleListError(input, event, err)
+	}
+
+	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, event *pl.Event, dbx ...*gorm.DB) (*e.VclaimSep, error) {
+	pl.SetLogInfo(event, input, "started", "DBReadDetail")
+	data := e.VclaimSep{}
+
+	var tx *gorm.DB
+	if len(dbx) > 0 {
+		tx = dbx[0]
+	} else {
+		tx = dg.I
+	}
+
+	if input.Number != nil {
+		tx = tx.Where("\"Number\" = ?", *input.Number)
+	}
+	if input.Id != 0 {
+		tx = tx.Where("\"Id\" = ?", input.Id)
+	}
+
+	if err := tx.First(&data).Error; err != nil {
+		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.UpdateDto, data *e.VclaimSep, event *pl.Event, dbx ...*gorm.DB) error {
+	pl.SetLogInfo(event, data, "started", "DBUpdate")
+	setData(&input, data)
+
+	var tx *gorm.DB
+	if len(dbx) > 0 {
+		tx = dbx[0]
+	} else {
+		tx = dg.I
+	}
+
+	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(data *e.VclaimSep, event *pl.Event, dbx ...*gorm.DB) error {
+	pl.SetLogInfo(event, data, "started", "DBDelete")
+	var tx *gorm.DB
+	if len(dbx) > 0 {
+		tx = dbx[0]
+	} else {
+		tx = dg.I
+	}
+
+	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/bpjs-use-case/vclaim-sep/middleware-runner.go

@@ -0,0 +1,103 @@
+package vclaimsep
+
+import (
+	e "simrs-vx/internal/domain/bpjs-entities/vclaim-sep"
+	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.VclaimSep) 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.VclaimSep) 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.VclaimSep) 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.VclaimSep) 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.VclaimSep) 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/bpjs-use-case/vclaim-sep/middleware.go

@@ -0,0 +1,13 @@
+package vclaimsep
+
+import (
+	pvs "simrs-vx/internal/use-case/bpjs-plugin/vclaim-sep"
+)
+
+// example of middleware
+func init() {
+	createPreMw = append(createPreMw,
+		createMw{Name: "create-sep", Func: pvs.CreateSep},
+	)
+
+}

internal/use-case/bpjs-use-case/vclaim-sep/tycovar.go

@@ -0,0 +1,44 @@
+/*
+DESCRIPTION:
+A sample, part of the package that contains type, constants, and/or variables.
+
+In this sample it also provides type and variable regarding the needs of the
+middleware to separate from main use-case which has the basic CRUD
+functionality. The purpose of this is to make the code more maintainable.
+*/
+package vclaimsep
+
+import (
+	"gorm.io/gorm"
+
+	e "simrs-vx/internal/domain/bpjs-entities/vclaim-sep"
+)
+
+type createMw struct {
+	Name string
+	Func func(input *e.CreateDto, data *e.VclaimSep, tx *gorm.DB) error
+}
+
+type readListMw struct {
+	Name string
+	Func func(input *e.ReadListDto, data *e.VclaimSep, tx *gorm.DB) error
+}
+
+type readDetailMw struct {
+	Name string
+	Func func(input *e.ReadDetailDto, data *e.VclaimSep, tx *gorm.DB) error
+}
+
+type UpdateMw = readDetailMw
+type DeleteMw = readDetailMw
+
+var createPreMw []createMw      // preprocess middleware
+var createPostMw []createMw     // postprocess middleware
+var readListPreMw []readListMw  // ..
+var readListPostMw []readListMw // ..
+var readDetailPreMw []readDetailMw
+var readDetailPostMw []readDetailMw
+var updatePreMw []readDetailMw
+var updatePostMw []readDetailMw
+var deletePreMw []readDetailMw
+var deletePostMw []readDetailMw

internal/use-case/main-use-case/authentication/case.go

@@ -10,13 +10,19 @@ import (
 	"github.com/golang-jwt/jwt"
 	"github.com/google/uuid"
 
+	"simrs-vx/internal/domain/main-entities/intern"
 	eu "simrs-vx/internal/domain/main-entities/user"
-	erc "simrs-vx/internal/domain/references/common"
 
 	pa "simrs-vx/pkg/auth-helper"
 	el "simrs-vx/pkg/logger"
 	p "simrs-vx/pkg/password"
 
+	ed "simrs-vx/internal/domain/main-entities/doctor"
+	ee "simrs-vx/internal/domain/main-entities/employee"
+	en "simrs-vx/internal/domain/main-entities/nurse"
+	erc "simrs-vx/internal/domain/references/common"
+	erg "simrs-vx/internal/domain/references/organization"
+
 	a "github.com/karincake/apem"
 	dg "github.com/karincake/apem/db-gorm-pg"
 	ms "github.com/karincake/apem/ms-redis"
@@ -72,11 +78,6 @@ func GenToken(input eu.LoginDto) (*d.Data, error) {
 		return nil, d.FieldErrors{"authentication": d.FieldError{Code: "auth-login-unverified", Message: el.GenMessage("auth-login-unverified")}}
 	}
 
-	userDivisionPositions, err := getDivisionPosition(user.Id)
-	if err != nil {
-		return nil, d.FieldErrors{"authentication": d.FieldError{Code: "auth-getData-failed", Message: el.GenMessage("auth-getData-failed")}}
-	}
-
 	// Access token prep
 	id, err := uuid.NewRandom()
 	if err != nil {
@@ -90,19 +91,94 @@ func GenToken(input eu.LoginDto) (*d.Data, error) {
 	atExpires := time.Now().Add(duration).Unix()
 	atSecretKey := authCfg.AtSecretKey
 
-	// Creating Access Token
+	// Create Claim
 	atClaims := jwt.MapClaims{}
 	atClaims["user_id"] = user.Id
 	atClaims["user_name"] = user.Name
-	atClaims["user_position_code"] = user.Position_Code
-	atClaims["exp"] = atExpires
+	atClaims["user_contractPosition_code"] = user.ContractPosition_Code
 	atClaims["uuid"] = aUuid
-	atClaims["user_division_positions"] = userDivisionPositions
+	atClaims["exp"] = atExpires
+
+	// Create output
+	outputData := d.II{
+		"user_id":                    strconv.Itoa(int(user.Id)),
+		"user_name":                  user.Name,
+		"user_contractPosition_code": user.ContractPosition_Code,
+	}
+
+	// extra
+	role := []string{}
+	switch user.ContractPosition_Code {
+	case erg.CSCEmp:
+		// employee
+		employee := ee.Employee{}
+		dg.I.Where("\"User_Id\" = ?", user.Id).First(&employee)
+		if employee.Id == 0 {
+			return nil, d.FieldErrors{"authentication": d.FieldError{Code: "auth-noEmployee", Message: el.GenMessage("auth-noEmployee")}}
+		}
+		atClaims["employee_id"] = employee.Id
+		outputData["employee_id"] = employee.Id
+		role = append(role, "emp-"+string(*employee.Position_Code))
+
+		if employee.Division_Code != nil {
+			atClaims["employee_division_code"] = employee.Division_Code
+			outputData["employee_division_code"] = employee.Division_Code
+		}
+
+		// employee position
+		if employee.Id > 0 && employee.Position_Code != nil {
+			switch *employee.Position_Code {
+			case erg.EPCDoc:
+				doctor := ed.Doctor{}
+				dg.I.Where("\"Employee_Id\" = ?", employee.Id).First(&doctor)
+				if doctor.Id == 0 {
+					return nil, d.FieldErrors{"authentication": d.FieldError{Code: "auth-noDoctor", Message: el.GenMessage("auth-noDoctor")}}
+				}
+				atClaims["doctor_id"] = doctor.Id
+				outputData["doctor_id"] = doctor.Id
+
+				// specialist
+				if doctor.Specialist_Id != nil {
+					atClaims["specialist_id"] = doctor.Specialist_Id
+					outputData["specialist_id"] = doctor.Specialist_Id
+				}
+				if doctor.Subspecialist_Id != nil {
+					atClaims["subspecialist_id"] = doctor.Subspecialist_Id
+					outputData["subspecialist_id"] = doctor.Subspecialist_Id
+				}
+			case erg.EPCNur:
+				nurse := en.Nurse{}
+				dg.I.Where("\"Employee_Id\" = ?", employee.Id).First(&nurse)
+				if nurse.Id == 0 {
+					return nil, d.FieldErrors{"authentication": d.FieldError{Code: "auth-noNurse", Message: el.GenMessage("auth-noNurse")}}
+				}
+				atClaims["nurse_id"] = nurse.Id
+				outputData["nurse_id"] = nurse.Id
+			}
+			// division position
+			divsionPositions, err := getDivisionPosition(employee.Id)
+			if err != nil {
+				return nil, d.FieldErrors{"authentication": d.FieldError{Code: "auth-getData-failed", Message: el.GenMessage("auth-getData-failed")}}
+			}
+			role = append(role, divsionPositions...)
+			// atClaims["division_positions"] = divsionPositions
+			// outputData["division_positions"] = divsionPositions
+		}
+	case erg.CSCInt:
+		intern := intern.Intern{}
+		dg.I.Where("\"User_Id\" = ?", user.Id).First(&intern)
+		role = append(role, "int-"+string(*intern.Position_Code))
+	}
+	atClaims["roles"] = role
+	outputData["roles"] = role
+
+	// Generate jwt
 	at := jwt.NewWithClaims(jwt.SigningMethodHS256, atClaims)
 	ats, err := at.SignedString([]byte(atSecretKey))
 	if err != nil {
 		return nil, d.FieldErrors{"user": d.FieldError{Code: "token-sign-err", Message: el.GenMessage("token-sign-err")}}
 	}
+	outputData["accessToken"] = ats
 
 	// Save to redis
 	now := time.Now()
@@ -125,13 +201,7 @@ func GenToken(input eu.LoginDto) (*d.Data, error) {
 			"structure": "single-data",
 			"status":    "verified",
 		},
-		Data: d.II{
-			"user_id":                 strconv.Itoa(int(user.Id)),
-			"user_name":               user.Name,
-			"user_position_code":      user.Position_Code,
-			"accessToken":             ats,
-			"user_division_positions": userDivisionPositions,
-		},
+		Data: outputData,
 	}, nil
 }
 
@@ -186,41 +256,41 @@ func ExtractToken(r *http.Request, tokenType TokenType) (data *pa.AuthInfo, err
 			return nil, d.FieldError{Code: "token-unidentified", Message: el.GenMessage("token-unidentified")}
 		}
 		user_name := fmt.Sprintf("%v", claims["user_name"])
+		// user_email := ""
+		// if v, exist := claims["user_email"]; exist && v != nil {
+		// 	user_email = v.(string)
+		// }
+		// ref_id := 0
+		// if v, exist := claims["user_ref_id"]; exist && v != nil {
+		// 	tmp := v.(float64)
+		// 	ref_id = int(tmp)
+		// }
+		// position_code := ""
+		// if v, exist := claims["user_position_code"]; exist && v != nil {
+		// 	position_code = v.(string)
+		// }
+		// data = &AuthInfo{
+		// 	Uuid:      accessUuid,
+		// 	User_Id:   int(user_id),
+		// 	User_Name: user_name,
+		// User_Email:         user_email,
+		// User_Ref_Id:        ref_id,
+		// User_Position_Code: position_code,
+		contractPosition_code := ""
+		if v, exist := claims["contractPosition_code"]; exist && v != nil {
+			contractPosition_code = v.(string)
+		}
+		employee_position_code := ""
+		if v, exist := claims["employee_position_code"]; exist && v != nil {
+			employee_position_code = v.(string)
+		}
 
-		var userDivisionPositions []pa.DivisionPosition
-		raw := claims["user_division_positions"]
-		if raw == nil {
-			fmt.Println("No user_division_positions found in claims")
-		} else {
-			list, ok := raw.([]interface{})
-			if !ok {
-				fmt.Printf("user_division_positions is not []interface{}, but %T\n", raw)
-			} else {
-				fmt.Printf("Found %d division positions\n", len(list))
-				for i, item := range list {
-					if m, ok := item.(map[string]interface{}); ok {
-						fmt.Printf("Item %d: %v\n", i, m)
-						dp := pa.DivisionPosition{
-							Division_Code:         fmt.Sprintf("%v", m["division_code"]),
-							DivisionPosition_Code: fmt.Sprintf("%v", m["divisionPosition_code"]),
-						}
-						userDivisionPositions = append(userDivisionPositions, dp)
-					} else {
-						fmt.Printf("Item %d not map[string]interface{} but %T\n", i, item)
-					}
-				}
-			}
-		}
-		position_code := ""
-		if v, exist := claims["user_position_code"]; exist && v != nil {
-			position_code = v.(string)
-		}
 		data = &pa.AuthInfo{
-			Uuid:                   accessUuid,
-			User_Id:                uint(user_id),
-			User_Name:              user_name,
-			User_Position_Code:     position_code,
-			User_DivisionPositions: userDivisionPositions,
+			Uuid:                       accessUuid,
+			User_Id:                    uint(user_id),
+			User_Name:                  user_name,
+			User_ContractPosition_code: contractPosition_code,
+			Employee_Position_Code:     &employee_position_code,
 		}
 		return
 	}

internal/use-case/main-use-case/authentication/helper.go

@@ -1,11 +1,7 @@
 package authentication
 
 import (
-	"errors"
 	edp "simrs-vx/internal/domain/main-entities/division-position"
-	ee "simrs-vx/internal/domain/main-entities/employee"
-
-	pa "simrs-vx/pkg/auth-helper"
 
 	dg "github.com/karincake/apem/db-gorm-pg"
 	"gorm.io/gorm"
@@ -27,21 +23,21 @@ func getDocName(id uint) string {
 	return "authentication"
 }
 
-func getDivisionPosition(user_id uint) ([]pa.DivisionPosition, error) {
-	var result []pa.DivisionPosition
+func getDivisionPosition(employee_id uint) ([]string, error) {
+	var result []string
 
-	var employee ee.Employee
-	if err := dg.I.Where("\"User_Id\" = ?", user_id).First(&employee).Error; err != nil {
-		if err == gorm.ErrRecordNotFound {
-			return result, nil
-		}
-		return result, errors.New("no employee found")
-	}
+	// var employee ee.Employee
+	// if err := dg.I.Where("\"Employee_Id\" = ?", employee_id).First(&employee).Error; err != nil {
+	// 	if err == gorm.ErrRecordNotFound {
+	// 		return result, nil
+	// 	}
+	// 	return result, errors.New("no employee found")
+	// }
 
 	var divisionPositions []edp.DivisionPosition
 	err := dg.I.
 		Preload("Division").
-		Where("\"Employee_Id\" = ?", employee.Id).
+		Where("\"Employee_Id\" = ?", employee_id).
 		Find(&divisionPositions).Error
 	if err != nil {
 		if err == gorm.ErrRecordNotFound {
@@ -51,15 +47,9 @@ func getDivisionPosition(user_id uint) ([]pa.DivisionPosition, error) {
 	}
 
 	for _, dp := range divisionPositions {
-		result = append(result, pa.DivisionPosition{
-			Division_Code: func() string {
-				if dp.Division != nil {
-					return dp.Division.Code
-				}
-				return ""
-			}(),
-			DivisionPosition_Code: dp.Code,
-		})
+		if dp.Division != nil {
+			result = append(result, "div-"+dp.Division.Code+"-"+dp.Code)
+		}
 	}
 
 	return result, nil

internal/use-case/main-use-case/encounter/case.go

@@ -7,12 +7,14 @@ import (
 	ea "simrs-vx/internal/domain/main-entities/ambulatory"
 	ec "simrs-vx/internal/domain/main-entities/chemo"
 	ee "simrs-vx/internal/domain/main-entities/emergency"
+	eem "simrs-vx/internal/domain/main-entities/employee"
 	e "simrs-vx/internal/domain/main-entities/encounter"
 	ei "simrs-vx/internal/domain/main-entities/inpatient"
 
 	ua "simrs-vx/internal/use-case/main-use-case/ambulatory"
 	uc "simrs-vx/internal/use-case/main-use-case/chemo"
 	ue "simrs-vx/internal/use-case/main-use-case/emergency"
+	uem "simrs-vx/internal/use-case/main-use-case/employee"
 	ui "simrs-vx/internal/use-case/main-use-case/inpatient"
 
 	erc "simrs-vx/internal/domain/references/common"
@@ -48,6 +50,12 @@ func Create(input e.CreateDto) (*d.Data, error) {
 			return err
 		}
 
+		if emp, err := uem.ReadDetailData(eem.ReadDetailDto{User_Id: &input.AuthInfo.User_Id}, &event, tx); err != nil {
+			return err
+		} else {
+			input.Adm_Employee_Id = &emp.Id
+		}
+
 		if resData, err := CreateData(input, &event, tx); err != nil {
 			return err
 		} else {

internal/use-case/main-use-case/encounter/helper.go

@@ -9,8 +9,10 @@ import (
 	"fmt"
 	"strings"
 
-	e "simrs-vx/internal/domain/main-entities/encounter"
-	es "simrs-vx/internal/domain/main-entities/soapi"
+	"gorm.io/gorm"
+
+	pl "simrs-vx/pkg/logger"
+	pu "simrs-vx/pkg/use-case-helper"
 
 	edo "simrs-vx/internal/domain/main-entities/device-order"
 	emo "simrs-vx/internal/domain/main-entities/material-order"
@@ -23,6 +25,7 @@ import (
 	epi "simrs-vx/internal/domain/main-entities/prescription-item"
 
 	// udo "simrs-vx/internal/use-case/main-use-case/device-order"
+	es "simrs-vx/internal/domain/main-entities/soapi"
 	um "simrs-vx/internal/use-case/main-use-case/medication"
 	umei "simrs-vx/internal/use-case/main-use-case/medication-item"
 	umi "simrs-vx/internal/use-case/main-use-case/medicine-mix"
@@ -30,13 +33,9 @@ import (
 	up "simrs-vx/internal/use-case/main-use-case/prescription"
 	upi "simrs-vx/internal/use-case/main-use-case/prescription-item"
 
-	pl "simrs-vx/pkg/logger"
-	pu "simrs-vx/pkg/use-case-helper"
-
+	e "simrs-vx/internal/domain/main-entities/encounter"
 	erc "simrs-vx/internal/domain/references/common"
-	ero "simrs-vx/internal/domain/references/organization"
-
-	"gorm.io/gorm"
+	erg "simrs-vx/internal/domain/references/organization"
 )
 
 func setData[T *e.CreateDto | *e.UpdateDto](input T, data *e.Encounter) {
@@ -55,7 +54,13 @@ func setData[T *e.CreateDto | *e.UpdateDto](input T, data *e.Encounter) {
 	data.Specialist_Id = inputSrc.Specialist_Id
 	data.Subspecialist_Id = inputSrc.Subspecialist_Id
 	data.VisitDate = inputSrc.VisitDate
+	data.PaymentMethod_Code = inputSrc.PaymentMethod_Code
+	data.InsuranceCompany_Id = inputSrc.InsuranceCompany_Id
+	data.Member_Number = inputSrc.Member_Number
+	data.Ref_Number = inputSrc.Ref_Number
+	data.Trx_Number = inputSrc.Trx_Number
 	data.Appointment_Doctor_Id = inputSrc.Appointment_Doctor_Id
+	data.Adm_Employee_Id = inputSrc.Adm_Employee_Id
 	data.Responsible_Doctor_Id = inputSrc.Responsible_Doctor_Id
 	data.RefSource_Name = inputSrc.RefSource_Name
 	data.Appointment_Id = inputSrc.Appointment_Id
@@ -108,7 +113,7 @@ func checkSoapiByDocExists(encounter_id uint, event *pl.Event, tx *gorm.DB) erro
 	}
 
 	for _, s := range soapies {
-		if s.Employee != nil && s.Employee.User != nil && s.Employee.User.Position_Code == ero.UPCDoc {
+		if s.Employee != nil && *s.Employee.Position_Code == erg.EPCDoc {
 			return nil
 		}
 	}

internal/use-case/main-use-case/encounter/lib.go

@@ -81,7 +81,7 @@ func ReadDetailData(input e.ReadDetailDto, event *pl.Event, dbx ...*gorm.DB) (*e
 		tx = dg.I
 	}
 
-	if err := tx.First(&data, input.Id).Error; err != nil {
+	if err := tx.Scopes(gh.Preload(input.Includes)).First(&data, input.Id).Error; err != nil {
 		if processedErr := pu.HandleReadError(err, event, source, input.Id, data); processedErr != nil {
 			return nil, processedErr
 		}

internal/use-case/main-use-case/medical-action-src/case.go

@@ -34,6 +34,9 @@ func Create(input e.CreateDto) (*d.Data, error) {
 			return err
 		}
 
+		if err := createItem(&input, &event, tx); err != nil {
+			return err
+		}
 		if resData, err := CreateData(input, &event, tx); err != nil {
 			return err
 		} else {

internal/use-case/main-use-case/medical-action-src/helper.go

@@ -5,7 +5,17 @@ Any functions that are used internally by the use-case
 package medicalactionsrc
 
 import (
+	ei "simrs-vx/internal/domain/main-entities/item"
 	e "simrs-vx/internal/domain/main-entities/medical-action-src"
+
+	ero "simrs-vx/internal/domain/references/organization"
+
+	ui "simrs-vx/internal/use-case/main-use-case/item"
+
+	pl "simrs-vx/pkg/logger"
+	pu "simrs-vx/pkg/use-case-helper"
+
+	"gorm.io/gorm"
 )
 
 func setData[T *e.CreateDto | *e.UpdateDto](input T, data *e.MedicalActionSrc) {
@@ -19,5 +29,21 @@ func setData[T *e.CreateDto | *e.UpdateDto](input T, data *e.MedicalActionSrc) {
 
 	data.Code = inputSrc.Code
 	data.Name = inputSrc.Name
+	data.Type_Code = inputSrc.Type_Code
 	data.Item_Id = inputSrc.Item_Id
 }
+
+func createItem(input *e.CreateDto, event *pl.Event, tx *gorm.DB) error {
+	itemCreate := ei.CreateDto{
+		Code:           pu.AddPrefix("medAct-", input.Code),
+		Name:           input.Name,
+		ItemGroup_Code: ero.ITGCMedAct,
+	}
+	item, err := ui.CreateData(itemCreate, event, tx)
+	if err != nil {
+		return err
+	}
+
+	input.Item_Id = &item.Id
+	return nil
+}

internal/use-case/main-use-case/patient/case.go

@@ -9,6 +9,7 @@ import (
 	upe "simrs-vx/internal/use-case/main-use-case/person"
 	upa "simrs-vx/internal/use-case/main-use-case/person-address"
 	upc "simrs-vx/internal/use-case/main-use-case/person-contact"
+	upi "simrs-vx/internal/use-case/main-use-case/person-insurance"
 	upr "simrs-vx/internal/use-case/main-use-case/person-relative"
 
 	ere "simrs-vx/internal/domain/references/encounter"
@@ -47,6 +48,7 @@ func Create(input e.CreateDto) (*d.Data, error) {
 		} else {
 			input.Person_Id = person_id
 		}
+
 		for idx := range input.PersonAddresses {
 			input.PersonAddresses[idx].Person_Id = *input.Person_Id
 		}
@@ -68,6 +70,13 @@ func Create(input e.CreateDto) (*d.Data, error) {
 			return err
 		}
 
+		for idx := range input.PersonInsurances {
+			input.PersonInsurances[idx].Person_Id = *input.Person_Id
+		}
+		if err := upi.CreateOrUpdateBatch(input.PersonInsurances, &event, tx); err != nil {
+			return err
+		}
+
 		if resData, err := CreateData(input, &event, tx); err != nil {
 			return err
 		} else {
@@ -252,6 +261,13 @@ func Update(input e.UpdateDto) (*d.Data, error) {
 			return err
 		}
 
+		for idx := range input.PersonInsurances {
+			input.PersonInsurances[idx].Person_Id = *input.Person_Id
+		}
+		if err := upi.CreateOrUpdateBatch(input.PersonInsurances, &event, tx); err != nil {
+			return err
+		}
+
 		if err := UpdateData(input, data, &event, tx); err != nil {
 			return err
 		}

internal/use-case/main-use-case/patient/lib.go

@@ -91,7 +91,8 @@ func ReadDetailData(input e.ReadDetailDto, event *pl.Event, dbx ...*gorm.DB) (*e
 		Preload("Person.Contacts").
 		Preload("Person.Relatives.Village.District.Regency.Province").
 		Preload("Person.Addresses.Village.District.Regency.Province").
-		Preload("Person.Addresses.PostalRegion.Village.District.Regency.Province")
+		Preload("Person.Addresses.PostalRegion.Village.District.Regency.Province").
+		Preload("Person.Insurances.InsuranceCompany")
 
 	if err := tx.First(&data, input.Id).Error; err != nil {
 		if processedErr := pu.HandleReadError(err, event, source, input.Id, data); processedErr != nil {
@@ -157,6 +158,7 @@ func SearchData(input e.SearchDto, event *pl.Event, dbx ...*gorm.DB) (*e.Patient
 	pl.SetLogInfo(event, input, "started", "DBSearch")
 
 	var patient e.Patient
+	var err error
 
 	var tx *gorm.DB
 	if len(dbx) > 0 {
@@ -167,15 +169,25 @@ func SearchData(input e.SearchDto, event *pl.Event, dbx ...*gorm.DB) (*e.Patient
 
 	// Preload associations for complete data
 	tx = tx.Preload(clause.Associations)
-	tx = tx.Preload("Person.Addresses")
-	tx = tx.Preload("Person.Contacts")
-	tx = tx.Preload("Person.Relatives")
+	tx = tx.Preload("Person.Addresses").
+		Preload("Person.Contacts").
+		Preload("Person.Relatives").
+		Preload("Person.Insurances")
 
-	// Search by patient number OR person's resident identity number (exact match)
-	err := tx.Joins("JOIN \"Person\" ON \"Patient\".\"Person_Id\" = \"Person\".\"Id\"").
-		Where("\"Patient\".\"Number\" = ? OR \"Person\".\"ResidentIdentityNumber\" = ?",
-			input.Search, input.Search).
-		First(&patient).Error
+	switch input.Mode {
+	case e.SMIdent:
+		// Search by patient number OR person's resident identity number (exact match) OR person's name (partial match)
+		err = tx.Joins("JOIN \"Person\" ON \"Patient\".\"Person_Id\" = \"Person\".\"Id\"").
+			Where("\"Patient\".\"Number\" = ? OR \"Person\".\"ResidentIdentityNumber\" = ? OR \"Person\".\"Name\" ILIKE ?",
+				input.Search, input.Search, "%"+input.Search+"%").
+			First(&patient).Error
+	case e.SMNik:
+		// Search by patient person's resident identity number (exact match)
+		err = tx.Joins("JOIN \"Person\" ON \"Patient\".\"Person_Id\" = \"Person\".\"Id\"").
+			Where("\"Person\".\"ResidentIdentityNumber\" = ?",
+				input.Search).
+			First(&patient).Error
+	}
 
 	if err != nil {
 		if processedErr := pu.HandleSearchError(err, event, source, input.Search, patient); processedErr != nil {

internal/use-case/main-use-case/person-insurance/case.go

@@ -0,0 +1,276 @@
+package personinsurance
+
+import (
+	e "simrs-vx/internal/domain/main-entities/person-insurance"
+	"strconv"
+
+	dg "github.com/karincake/apem/db-gorm-pg"
+	d "github.com/karincake/dodol"
+
+	pl "simrs-vx/pkg/logger"
+	pu "simrs-vx/pkg/use-case-helper"
+
+	"gorm.io/gorm"
+)
+
+const source = "person-insurance"
+
+func Create(input e.CreateDto) (*d.Data, error) {
+	data := e.PersonInsurance{}
+
+	event := pl.Event{
+		Feature: "Create",
+		Source:  source,
+	}
+
+	// Start log
+	pl.SetLogInfo(&event, input, "started", "create")
+
+	err := dg.I.Transaction(func(tx *gorm.DB) error {
+		mwRunner := newMiddlewareRunner(&event, tx)
+		mwRunner.setMwType(pu.MWTPre)
+		// Run pre-middleware
+		if err := mwRunner.RunCreateMiddleware(createPreMw, &input, &data); err != nil {
+			return err
+		}
+
+		if resData, err := CreateData(input, &event, tx); err != nil {
+			return err
+		} else {
+			data = *resData
+		}
+
+		mwRunner.setMwType(pu.MWTPost)
+		// Run post-middleware
+		if err := mwRunner.RunCreateMiddleware(createPostMw, &input, &data); err != nil {
+			return err
+		}
+
+		pl.SetLogInfo(&event, nil, "complete")
+
+		return nil
+	})
+
+	if err != nil {
+		return nil, err
+	}
+
+	return &d.Data{
+		Meta: d.II{
+			"source":    source,
+			"structure": "single-data",
+			"status":    "created",
+		},
+		Data: data.ToResponse(),
+	}, nil
+}
+
+func ReadList(input e.ReadListDto) (*d.Data, error) {
+	var data *e.PersonInsurance
+	var dataList []e.PersonInsurance
+	var metaList *e.MetaDto
+	var err error
+
+	event := pl.Event{
+		Feature: "ReadList",
+		Source:  source,
+	}
+
+	// Start log
+	pl.SetLogInfo(&event, input, "started", "readList")
+
+	err = dg.I.Transaction(func(tx *gorm.DB) error {
+		mwRunner := newMiddlewareRunner(&event, tx)
+		mwRunner.setMwType(pu.MWTPre)
+		// Run pre-middleware
+		if err := mwRunner.RunReadListMiddleware(readListPreMw, &input, data); err != nil {
+			return err
+		}
+
+		if dataList, metaList, err = ReadListData(input, &event, tx); err != nil {
+			return err
+		}
+
+		mwRunner.setMwType(pu.MWTPost)
+		// Run post-middleware
+		if err := mwRunner.RunReadListMiddleware(readListPostMw, &input, data); err != nil {
+			return err
+		}
+
+		return nil
+	})
+
+	if err != nil {
+		return nil, err
+	}
+
+	return &d.Data{
+		Meta: d.IS{
+			"source":              source,
+			"structure":           "list-data",
+			"status":              "fetched",
+			"page_number":         strconv.Itoa(metaList.PageNumber),
+			"page_size":           strconv.Itoa(metaList.PageSize),
+			"record_totalCount":   strconv.Itoa(metaList.Count),
+			"record_currentCount": strconv.Itoa(len(dataList)),
+		},
+		Data: e.ToResponseList(dataList),
+	}, nil
+}
+
+func ReadDetail(input e.ReadDetailDto) (*d.Data, error) {
+	var data *e.PersonInsurance
+	var err error
+
+	event := pl.Event{
+		Feature: "ReadDetail",
+		Source:  source,
+	}
+
+	// Start log
+	pl.SetLogInfo(&event, input, "started", "readDetail")
+
+	err = dg.I.Transaction(func(tx *gorm.DB) error {
+		mwRunner := newMiddlewareRunner(&event, tx)
+		mwRunner.setMwType(pu.MWTPre)
+		// Run pre-middleware
+		if err := mwRunner.RunReadDetailMiddleware(readDetailPreMw, &input, data); err != nil {
+			return err
+		}
+
+		if data, err = ReadDetailData(input, &event, tx); err != nil {
+			return err
+		}
+
+		mwRunner.setMwType(pu.MWTPost)
+		// Run post-middleware
+		if err := mwRunner.RunReadDetailMiddleware(readDetailPostMw, &input, data); err != nil {
+			return err
+		}
+
+		return nil
+	})
+
+	if err != nil {
+		return nil, err
+	}
+
+	return &d.Data{
+		Meta: d.IS{
+			"source":    source,
+			"structure": "single-data",
+			"status":    "fetched",
+		},
+		Data: data.ToResponse(),
+	}, nil
+}
+
+func Update(input e.UpdateDto) (*d.Data, error) {
+	rdDto := e.ReadDetailDto{Id: input.Id}
+	var data *e.PersonInsurance
+	var err error
+
+	event := pl.Event{
+		Feature: "Update",
+		Source:  source,
+	}
+
+	// Start log
+	pl.SetLogInfo(&event, input, "started", "update")
+
+	err = dg.I.Transaction(func(tx *gorm.DB) error {
+		pl.SetLogInfo(&event, rdDto, "started", "DBReadDetail")
+		if data, err = ReadDetailData(rdDto, &event, tx); err != nil {
+			return err
+		}
+
+		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")
+
+		mwRunner.setMwType(pu.MWTPost)
+		// Run post-middleware
+		if err := mwRunner.RunUpdateMiddleware(readDetailPostMw, &rdDto, data); err != nil {
+			return err
+		}
+
+		return nil
+	})
+
+	if err != nil {
+		return nil, err
+	}
+
+	return &d.Data{
+		Meta: d.IS{
+			"source":    source,
+			"structure": "single-data",
+			"status":    "updated",
+		},
+		Data: data.ToResponse(),
+	}, nil
+
+}
+
+func Delete(input e.DeleteDto) (*d.Data, error) {
+	rdDto := e.ReadDetailDto{Id: input.Id}
+	var data *e.PersonInsurance
+	var err error
+
+	event := pl.Event{
+		Feature: "Delete",
+		Source:  source,
+	}
+
+	// Start log
+	pl.SetLogInfo(&event, input, "started", "delete")
+
+	err = dg.I.Transaction(func(tx *gorm.DB) error {
+		pl.SetLogInfo(&event, rdDto, "started", "DBReadDetail")
+		if data, err = ReadDetailData(rdDto, &event, tx); err != nil {
+			return err
+		}
+
+		mwRunner := newMiddlewareRunner(&event, tx)
+		mwRunner.setMwType(pu.MWTPre)
+		// Run pre-middleware
+		if err := mwRunner.RunDeleteMiddleware(readDetailPreMw, &rdDto, data); err != nil {
+			return err
+		}
+
+		if err := DeleteData(data, &event, tx); err != nil {
+			return err
+		}
+
+		mwRunner.setMwType(pu.MWTPost)
+		// Run post-middleware
+		if err := mwRunner.RunDeleteMiddleware(readDetailPostMw, &rdDto, data); err != nil {
+			return err
+		}
+
+		return nil
+	})
+
+	if err != nil {
+		return nil, err
+	}
+
+	return &d.Data{
+		Meta: d.IS{
+			"source":    source,
+			"structure": "single-data",
+			"status":    "deleted",
+		},
+		Data: data.ToResponse(),
+	}, nil
+
+}

internal/use-case/main-use-case/person-insurance/helper.go

@@ -0,0 +1,24 @@
+/*
+DESCRIPTION:
+Any functions that are used internally by the use-case
+*/
+package personinsurance
+
+import (
+	e "simrs-vx/internal/domain/main-entities/person-insurance"
+)
+
+func setData[T *e.CreateDto | *e.UpdateDto](input T, data *e.PersonInsurance) {
+	var inputSrc *e.CreateDto
+	if inputT, ok := any(input).(*e.CreateDto); ok {
+		inputSrc = inputT
+	} else {
+		inputTemp := any(input).(*e.UpdateDto)
+		inputSrc = &inputTemp.CreateDto
+	}
+
+	data.Person_Id = &inputSrc.Person_Id
+	data.InsuranceCompany_Id = inputSrc.InsuranceCompany_Id
+	data.Ref_Number = inputSrc.Ref_Number
+	data.DefaultStatus = inputSrc.DefaultStatus
+}

internal/use-case/main-use-case/person-insurance/lib.go

@@ -0,0 +1,193 @@
+package personinsurance
+
+import (
+	e "simrs-vx/internal/domain/main-entities/person-insurance"
+
+	plh "simrs-vx/pkg/lib-helper"
+	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.CreateDto, event *pl.Event, dbx ...*gorm.DB) (*e.PersonInsurance, error) {
+	pl.SetLogInfo(event, nil, "started", "DBCreate")
+
+	data := e.PersonInsurance{}
+	setData(&input, &data)
+
+	var tx *gorm.DB
+	if len(dbx) > 0 {
+		tx = dbx[0]
+	} else {
+		tx = dg.I
+	}
+
+	if err := tx.Create(&data).Error; err != nil {
+		return nil, plh.HandleCreateError(input, event, err)
+	}
+
+	pl.SetLogInfo(event, nil, "complete")
+	return &data, nil
+}
+
+func ReadListData(input e.ReadListDto, event *pl.Event, dbx ...*gorm.DB) ([]e.PersonInsurance, *e.MetaDto, error) {
+	pl.SetLogInfo(event, input, "started", "DBReadList")
+	data := []e.PersonInsurance{}
+	pagination := gh.Pagination{}
+	count := int64(0)
+	meta := e.MetaDto{}
+
+	var tx *gorm.DB
+	if len(dbx) > 0 {
+		tx = dbx[0]
+	} else {
+		tx = dg.I
+	}
+
+	tx = tx.
+		Model(&e.PersonInsurance{}).
+		Scopes(gh.Filter(input)).
+		Count(&count).
+		Scopes(gh.Paginate(input, &pagination)).
+		Order("\"CreatedAt\" DESC")
+
+	if err := tx.Find(&data).Error; err != nil {
+		if err == gorm.ErrRecordNotFound {
+			return nil, &meta, nil
+		}
+		event.Status = "failed"
+		event.ErrInfo = pl.ErrorInfo{
+			Code:   "data-get-fail",
+			Detail: "Database get 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, event *pl.Event, dbx ...*gorm.DB) (*e.PersonInsurance, error) {
+	pl.SetLogInfo(event, input, "started", "DBReadDetail")
+	data := e.PersonInsurance{}
+
+	var tx *gorm.DB
+	if len(dbx) > 0 {
+		tx = dbx[0]
+	} else {
+		tx = dg.I
+	}
+
+	if err := tx.First(&data, input.Id).Error; err != nil {
+		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.UpdateDto, data *e.PersonInsurance, event *pl.Event, dbx ...*gorm.DB) error {
+	pl.SetLogInfo(event, data, "started", "DBUpdate")
+	setData(&input, data)
+
+	var tx *gorm.DB
+	if len(dbx) > 0 {
+		tx = dbx[0]
+	} else {
+		tx = dg.I
+	}
+
+	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(data *e.PersonInsurance, event *pl.Event, dbx ...*gorm.DB) error {
+	pl.SetLogInfo(event, data, "started", "DBDelete")
+	var tx *gorm.DB
+	if len(dbx) > 0 {
+		tx = dbx[0]
+	} else {
+		tx = dg.I
+	}
+
+	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
+}
+
+func CreateOrUpdateBatch(input []e.UpdateDto, event *pl.Event, tx ...*gorm.DB) error {
+	var data = make([]e.PersonInsurance, len(input))
+	var dbx *gorm.DB
+	if len(tx) > 0 {
+		dbx = tx[0]
+	} else {
+		dbx = dg.I
+	}
+
+	for idx := range input {
+		if input[idx].Id > 0 {
+			if err := dbx.Where("\"Id\" = ? AND \"Person_Id\" = ?", input[idx].Id, input[idx].Person_Id).First(&data[idx]).Error; err == nil {
+				setData(&input[idx], &data[idx])
+				if err := dbx.Save(&data[idx]).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)
+				}
+			} else if err != gorm.ErrRecordNotFound {
+				event.Status = "failed"
+				event.ErrInfo = pl.ErrorInfo{
+					Code:   "data-get-fail",
+					Detail: "Database get failed",
+					Raw:    err,
+				}
+				return pl.SetLogError(event, input)
+			}
+			continue
+		}
+		setData(&input[idx], &data[idx])
+		if err := dbx.Create(&data[idx]).Error; err != nil {
+			event.Status = "failed"
+			event.ErrInfo = pl.ErrorInfo{
+				Code:   "data-create-fail",
+				Detail: "Database insert failed",
+				Raw:    err,
+			}
+			return pl.SetLogError(event, input)
+		}
+	}
+
+	return nil
+}

internal/use-case/main-use-case/person-insurance/middleware-runner.go

@@ -0,0 +1,103 @@
+package personinsurance
+
+import (
+	e "simrs-vx/internal/domain/main-entities/person-insurance"
+	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.PersonInsurance) 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.PersonInsurance) 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.PersonInsurance) 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.PersonInsurance) 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.PersonInsurance) 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/person-insurance/middleware.go

@@ -0,0 +1,9 @@
+package personinsurance
+
+// example of middleware
+// func init() {
+// 	createPreMw = append(createPreMw,
+// 		CreateMw{Name: "modif-input", Func: pm.ModifInput},
+// 		CreateMw{Name: "check-data", Func: pm.CheckData},
+// 	)
+// }

internal/use-case/main-use-case/person-insurance/tycovar.go

@@ -0,0 +1,44 @@
+/*
+DESCRIPTION:
+A sample, part of the package that contains type, constants, and/or variables.
+
+In this sample it also provides type and variable regarding the needs of the
+middleware to separate from main use-case which has the basic CRUD
+functionality. The purpose of this is to make the code more maintainable.
+*/
+package personinsurance
+
+import (
+	"gorm.io/gorm"
+
+	e "simrs-vx/internal/domain/main-entities/person-insurance"
+)
+
+type createMw struct {
+	Name string
+	Func func(input *e.CreateDto, data *e.PersonInsurance, tx *gorm.DB) error
+}
+
+type readListMw struct {
+	Name string
+	Func func(input *e.ReadListDto, data *e.PersonInsurance, tx *gorm.DB) error
+}
+
+type readDetailMw struct {
+	Name string
+	Func func(input *e.ReadDetailDto, data *e.PersonInsurance, tx *gorm.DB) error
+}
+
+type UpdateMw = readDetailMw
+type DeleteMw = readDetailMw
+
+var createPreMw []createMw      // preprocess middleware
+var createPostMw []createMw     // postprocess middleware
+var readListPreMw []readListMw  // ..
+var readListPostMw []readListMw // ..
+var readDetailPreMw []readDetailMw
+var readDetailPostMw []readDetailMw
+var updatePreMw []readDetailMw
+var updatePostMw []readDetailMw
+var deletePreMw []readDetailMw
+var deletePostMw []readDetailMw

internal/use-case/main-use-case/user/case.go

@@ -9,7 +9,6 @@ import (
 	ed "simrs-vx/internal/domain/main-entities/doctor"
 	ee "simrs-vx/internal/domain/main-entities/employee"
 	el "simrs-vx/internal/domain/main-entities/laborant"
-	em "simrs-vx/internal/domain/main-entities/midwife"
 	en "simrs-vx/internal/domain/main-entities/nurse"
 	et "simrs-vx/internal/domain/main-entities/nutritionist"
 	ep "simrs-vx/internal/domain/main-entities/pharmacist"
@@ -19,7 +18,6 @@ import (
 	ud "simrs-vx/internal/use-case/main-use-case/doctor"
 	ue "simrs-vx/internal/use-case/main-use-case/employee"
 	ul "simrs-vx/internal/use-case/main-use-case/laborant"
-	um "simrs-vx/internal/use-case/main-use-case/midwife"
 	un "simrs-vx/internal/use-case/main-use-case/nurse"
 	ut "simrs-vx/internal/use-case/main-use-case/nutritionist"
 	upe "simrs-vx/internal/use-case/main-use-case/person"
@@ -85,7 +83,7 @@ func Create(input e.CreateDto) (*d.Data, error) {
 			data = *resData
 		}
 
-		if input.Position_Code == ero.UPCInt {
+		if input.ContractPosition_Code == ero.CSCInt {
 			createInt := esi.CreateDto{
 				Person_Id:        input.Person_Id,
 				Specialist_Id:    input.Specialist_Id,
@@ -105,8 +103,8 @@ func Create(input e.CreateDto) (*d.Data, error) {
 			return err
 		}
 
-		switch input.Position_Code {
-		case ero.UPCDoc:
+		switch input.Employee.Position_Code {
+		case ero.EPCDoc:
 			createDoc := ed.CreateDto{
 				Employee_Id:      &employeeData.Id,
 				IHS_Number:       input.IHS_Number,
@@ -118,7 +116,7 @@ func Create(input e.CreateDto) (*d.Data, error) {
 			if _, err := ud.CreateData(createDoc, &event, tx); err != nil {
 				return err
 			}
-		case ero.UPCNur:
+		case ero.EPCNur:
 			createNurse := en.CreateDto{
 				Employee_Id: &employeeData.Id,
 				IHS_Number:  input.IHS_Number,
@@ -128,7 +126,7 @@ func Create(input e.CreateDto) (*d.Data, error) {
 			if _, err := un.CreateData(createNurse, &event, tx); err != nil {
 				return err
 			}
-		case ero.UPCNut:
+		case ero.EPCNut:
 			createNutritionist := et.CreateDto{
 				Employee_Id: &employeeData.Id,
 				IHS_Number:  input.IHS_Number,
@@ -136,7 +134,7 @@ func Create(input e.CreateDto) (*d.Data, error) {
 			if _, err := ut.CreateData(createNutritionist, &event, tx); err != nil {
 				return err
 			}
-		case ero.UPCPha:
+		case ero.EPCPha:
 			createPharmacist := ep.CreateDto{
 				Employee_Id: &employeeData.Id,
 				IHS_Number:  input.IHS_Number,
@@ -144,7 +142,7 @@ func Create(input e.CreateDto) (*d.Data, error) {
 			if _, err := up.CreateData(createPharmacist, &event, tx); err != nil {
 				return err
 			}
-		case ero.UPCLab:
+		case ero.EPCLab:
 			createLaborant := el.CreateDto{
 				Employee_Id: &employeeData.Id,
 				IHS_Number:  input.IHS_Number,
@@ -152,16 +150,6 @@ func Create(input e.CreateDto) (*d.Data, error) {
 			if _, err := ul.CreateData(createLaborant, &event, tx); err != nil {
 				return err
 			}
-		case ero.UPCMwi:
-			createMidwife := em.CreateDto{
-				Employee_Id: &employeeData.Id,
-				IHS_Number:  input.IHS_Number,
-			}
-			if _, err := um.CreateData(em.CreateDto(createMidwife), &event, tx); err != nil {
-				return err
-			}
-		case ero.UPCReg, ero.UPCHur, ero.UPCGea, ero.UPCMan:
-			// do nothing
 		default:
 			return errors.New("invalid employee position")
 		}
@@ -317,7 +305,7 @@ func Update(input e.UpdateDto) (*d.Data, error) {
 			return err
 		}
 
-		person_id, err := getPersonIdByUserId(data.Id, input.Position_Code, &event, tx)
+		person_id, err := getPersonIdByUserId(data.Id, input.ContractPosition_Code, &event, tx)
 		if err != nil {
 			return err
 		} else {
@@ -348,7 +336,7 @@ func Update(input e.UpdateDto) (*d.Data, error) {
 			return err
 		}
 
-		if input.Position_Code == ero.UPCInt {
+		if input.ContractPosition_Code == ero.CSCInt {
 			readInt := esi.ReadDetailDto{User_Id: &data.Id}
 			readIntData, err := usi.ReadDetailData(readInt, &event, tx)
 			if err != nil {
@@ -384,8 +372,8 @@ func Update(input e.UpdateDto) (*d.Data, error) {
 			return err
 		}
 
-		switch input.Position_Code {
-		case ero.UPCDoc:
+		switch input.Employee.Position_Code {
+		case ero.EPCDoc:
 			readDoc := ed.ReadDetailDto{Employee_Id: &employeeData.Id}
 			readDocData, err := ud.ReadDetailData(readDoc, &event, tx)
 			if err != nil {
@@ -407,7 +395,7 @@ func Update(input e.UpdateDto) (*d.Data, error) {
 			if _, err := ud.CreateData(createDoc, &event, tx); err != nil {
 				return err
 			}
-		case ero.UPCNur:
+		case ero.EPCNur:
 			readNur := en.ReadDetailDto{Employee_Id: &employeeData.Id}
 			readNurData, err := un.ReadDetailData(readNur, &event, tx)
 			if err != nil {
@@ -427,7 +415,7 @@ func Update(input e.UpdateDto) (*d.Data, error) {
 			if _, err := un.CreateData(createNur, &event, tx); err != nil {
 				return err
 			}
-		case ero.UPCNut:
+		case ero.EPCNut:
 			readNut := et.ReadDetailDto{Employee_Id: &employeeData.Id}
 			readNutData, err := ut.ReadDetailData(readNut, &event, tx)
 			if err != nil {
@@ -447,7 +435,7 @@ func Update(input e.UpdateDto) (*d.Data, error) {
 			if _, err := ut.CreateData(createNut, &event, tx); err != nil {
 				return err
 			}
-		case ero.UPCPha:
+		case ero.EPCPha:
 			readPha := ep.ReadDetailDto{Employee_Id: &employeeData.Id}
 			readPhaData, err := up.ReadDetailData(readPha, &event, tx)
 			if err != nil {
@@ -467,7 +455,7 @@ func Update(input e.UpdateDto) (*d.Data, error) {
 			if _, err := up.CreateData(createPha, &event, tx); err != nil {
 				return err
 			}
-		case ero.UPCLab:
+		case ero.EPCLab:
 			readLab := el.ReadDetailDto{Employee_Id: &employeeData.Id}
 			readLabData, err := ul.ReadDetailData(readLab, &event, tx)
 			if err != nil {
@@ -487,28 +475,6 @@ func Update(input e.UpdateDto) (*d.Data, error) {
 			if _, err := ul.CreateData(createLab, &event, tx); err != nil {
 				return err
 			}
-		case ero.UPCMwi:
-			readMidwife := em.ReadDetailDto{Employee_Id: &employeeData.Id}
-			readMidwifeData, err := um.ReadDetailData(readMidwife, &event, tx)
-			if err != nil {
-				return err
-			}
-			createMidwife := em.CreateDto{
-				Employee_Id: &employeeData.Id,
-				IHS_Number:  input.IHS_Number,
-			}
-			if readMidwifeData != nil {
-				if err := um.UpdateData(em.UpdateDto{CreateDto: createMidwife}, readMidwifeData, &event, tx); err != nil {
-					return err
-				}
-				return nil
-			}
-
-			if _, err := um.CreateData(createMidwife, &event, tx); err != nil {
-				return err
-			}
-		case ero.UPCReg, ero.UPCHur, ero.UPCGea, ero.UPCMan:
-			// do nothing
 		default:
 			return errors.New("invalid employee position")
 		}

internal/use-case/main-use-case/user/helper.go

@@ -6,19 +6,19 @@ package user
 
 import (
 	"errors"
-	ee "simrs-vx/internal/domain/main-entities/employee"
-	esi "simrs-vx/internal/domain/main-entities/specialist-intern"
-	e "simrs-vx/internal/domain/main-entities/user"
 
-	ue "simrs-vx/internal/use-case/main-use-case/employee"
-	usi "simrs-vx/internal/use-case/main-use-case/specialist-intern"
-
-	ero "simrs-vx/internal/domain/references/organization"
+	"gorm.io/gorm"
 
 	pl "simrs-vx/pkg/logger"
 	p "simrs-vx/pkg/password"
 
-	"gorm.io/gorm"
+	ue "simrs-vx/internal/use-case/main-use-case/employee"
+	usi "simrs-vx/internal/use-case/main-use-case/specialist-intern"
+
+	ee "simrs-vx/internal/domain/main-entities/employee"
+	esi "simrs-vx/internal/domain/main-entities/specialist-intern"
+	e "simrs-vx/internal/domain/main-entities/user"
+	erg "simrs-vx/internal/domain/references/organization"
 )
 
 func setCreate(src e.CreateDto, dst *e.User) error {
@@ -30,15 +30,14 @@ func setCreate(src e.CreateDto, dst *e.User) error {
 	dst.Name = src.Name
 	dst.Password = pass
 	dst.Status_Code = src.Status_Code
-	dst.Position_Code = src.Position_Code
+	dst.ContractPosition_Code = src.ContractPosition_Code
 
 	return nil
 }
 
 func setUpdate(src e.UpdateDto, dst *e.User) {
 	dst.Status_Code = src.Status_Code
-	dst.Position_Code = src.Position_Code
-
+	dst.ContractPosition_Code = src.ContractPosition_Code
 }
 
 func setDataEmployeeUpdate(src e.EmployeUpdateDto) ee.UpdateDto {
@@ -54,9 +53,10 @@ func setDataEmployeeUpdate(src e.EmployeUpdateDto) ee.UpdateDto {
 	}
 }
 
-func getPersonIdByUserId(userId uint, positionCode ero.UserPosisitionCode, event *pl.Event, tx *gorm.DB) (*uint, error) {
+func getPersonIdByUserId(userId uint, positionCode erg.ContractPositionCode, event *pl.Event, tx *gorm.DB) (*uint, error) {
 	pl.SetLogInfo(event, nil, "started", "DBGetPersonIdByUserId")
-	if positionCode == ero.UPCInt {
+	if positionCode == erg.CSCEmp {
+	} else if positionCode == erg.CSCInt {
 		specInt, err := usi.ReadDetailData(esi.ReadDetailDto{User_Id: &userId}, event, tx)
 		if err != nil {
 			return nil, err