Merge pull request #149 from dikstub-rssa/feat/sync-installation

Feat/sync installation

cmd/main-api/config.yml-example

@@ -66,4 +66,8 @@ corsCfg:
   allowedMethod: 
 
 bpjsCfg:
-  baseUrl:
+  baseUrl:
+  
+syncUrlCfg:
+      host:
+      prefix: new-to-old

cmd/main-sync-api/config.yml-example

@@ -1,41 +0,0 @@
-appCfg: 
-  fullName: SIMRS Sync
-  codeName: simrs-sync
-  version: 0.1.0
-  env: development
-  lang: en
-
-dbCfg:
-  dsn: 
-  maxOpenConns: 5
-  maxIdleConns: 5
-  maxIdleTime: 100
-
-multiDbCfg: 
-  dbs :
-    - name: simrs_sync
-      dsn: 
-      maxOpenConns: 5
-      maxIdleConns: 5
-      maxIdleTime: 100 
-
-httpCfg: 
-  host: 127.0.0.1
-  port: 8003
-
-loggerCfg: 
-  hideTime: true
-  hideLevel: true
-
-langCfg: 
-  active: en
-  path: ../../assets/language/en
-  fileName: data.json
-
-corsCfg: 
-  allowedOrigin: 
-  allowedMethod: GET, POST, PUT, PATCH, DELETE, OPTIONS
-
-syncUrlCfg:
-  target:
-  host:

cmd/main-sync-api/main.go

@@ -1,15 +0,0 @@
-package main
-
-import (
-	a "github.com/karincake/apem"
-
-	h "simrs-vx/internal/interface/main-sync-handler"
-
-	d "github.com/karincake/apem/db-gorm-pg"
-
-	l "github.com/karincake/apem/logger-zerolog"
-)
-
-func main() {
-	a.Run(h.SetRoutes(), &l.O, &d.O)
-}

cmd/simgos-sync-api/config.yml-example

@@ -34,8 +34,4 @@ langCfg:
 
 corsCfg: 
   allowedOrigin: 
-  allowedMethod: GET, POST, PUT, PATCH, DELETE, OPTIONS
-
-syncUrlCfg:
-  target:
-  host:
+  allowedMethod: GET, POST, PUT, PATCH, DELETE, OPTIONS

cmd/simgos-sync-migration/Makefile

@@ -0,0 +1,18 @@
+# Makefile for Atlas migrations
+
+# Default environment
+ENV ?= gorm
+
+.PHONY: diff apply hash
+
+## Generate a new migration diff
+diff:
+	atlas migrate diff --env $(ENV)
+
+## Apply migrations to the database
+apply:
+	atlas migrate apply --env $(ENV)
+
+## Calculate the schema hash
+hash:
+	atlas migrate hash

cmd/simgos-sync-migration/README-ATLAS.MD

@@ -0,0 +1,59 @@
+# Database Migration with Atlas
+
+This project uses [Atlas](https://atlasgo.io/) for database schema management and migrations.
+
+## 📋 Prerequisites
+
+1. **Download and Install Atlas CLI**  
+   Run the following command in PowerShell or Git Bash:
+
+   ```sh
+   curl -sSf https://atlasgo.sh | sh
+   ```
+    Verify installation:
+
+    ```sh
+    atlas version
+    ```
+
+2. Install GORM Provider
+    Run inside your Go project:
+
+    ```sh
+    go get -u ariga.io/atlas-provider-gorm
+    ```
+
+3. Create atlas.hcl configuration file
+   Just create an atlas.hcl file in your project root as example given at atlas.hcl.example
+4. Create migrations folder
+    ```sh
+    mkdir migrations
+    ```
+5. Usage
+You can use the provided Makefile for common commands:
+
+    Generate a migration diff
+    ```sh
+    make diff
+    ```
+
+    Apply migrations
+    ```sh
+    make apply
+    ```
+
+    Compute schema hash
+    ```sh
+    make hash
+    ```
+
+    If you don’t have make installed, you can run the Atlas commands directly:
+    ```sh
+    atlas migrate diff --env gorm
+    ```
+    ```sh
+    atlas migrate apply --env gorm
+    ```
+    ```sh
+    atlas migrate hash
+    ```

cmd/simgos-sync-migration/atlas.hcl.example

@@ -0,0 +1,22 @@
+data "external_schema" "gorm" {
+  program = [
+    "go",
+    "run",
+    "-mod=mod",
+    ".",
+  ]
+}
+
+env "gorm" {
+  src = data.external_schema.gorm.url
+  dev = "" // dsn db to check the diff
+  migration {
+    dir = "file://migrations"
+  }
+  url = "" // dsn db to apply
+  format {
+    migrate {
+      diff = "{{ sql . \"  \" }}"
+    }
+  }
+}

cmd/simgos-sync-migration/migration.go

@@ -0,0 +1,9 @@
+package main
+
+import (
+	m "simrs-vx/internal/interface/migration"
+)
+
+func main() {
+	m.Migrate(m.SimgosSync)
+}

cmd/simgos-sync-migration/migrations/20251113035508.sql

@@ -0,0 +1,36 @@
+-- Create "InstallationLink" table
+CREATE TABLE "public"."InstallationLink" (
+  "Id" bigserial NOT NULL,
+  "CreatedAt" timestamptz NULL,
+  "UpdatedAt" timestamptz NULL,
+  "DeletedAt" timestamptz NULL,
+  "Simx_Id" bigint NULL,
+  "Simgos_Id" bigint NULL,
+  PRIMARY KEY ("Id"),
+  CONSTRAINT "uni_InstallationLink_Simgos_Id" UNIQUE ("Simgos_Id"),
+  CONSTRAINT "uni_InstallationLink_Simx_Id" UNIQUE ("Simx_Id")
+);
+-- Create "InstallationSimgosLog" table
+CREATE TABLE "public"."InstallationSimgosLog" (
+  "Id" bigserial NOT NULL,
+  "CreatedAt" timestamptz NULL,
+  "UpdatedAt" timestamptz NULL,
+  "DeletedAt" timestamptz NULL,
+  "Value" text NULL,
+  "Date" timestamptz NULL,
+  "Status" text NULL,
+  "ErrMessage" text NULL,
+  PRIMARY KEY ("Id")
+);
+-- Create "InstallationSimxLog" table
+CREATE TABLE "public"."InstallationSimxLog" (
+  "Id" bigserial NOT NULL,
+  "CreatedAt" timestamptz NULL,
+  "UpdatedAt" timestamptz NULL,
+  "DeletedAt" timestamptz NULL,
+  "Value" text NULL,
+  "Date" timestamptz NULL,
+  "Status" text NULL,
+  "ErrMessage" text NULL,
+  PRIMARY KEY ("Id")
+);

cmd/simgos-sync-migration/migrations/atlas.sum

@@ -0,0 +1,2 @@
+h1:8jMmMBxSEls9jaOUrpQQV0wUPlORRwJWd5g9742Z2fQ=
+20251113035508.sql h1:rjDlu6yDdy5xv6nrCOr7NialrLSLT23pzduYNq29Hf0=

internal/domain/main-entities/installation/dto.go

@@ -8,6 +8,7 @@ import (
 )
 
 type CreateDto struct {
+	Id                  *uint                  `json:"id"`
 	Code                *string                `json:"code" validate:"maxLength=10"`
 	Name                string                 `json:"name" validate:"maxLength=50"`
 	EncounterClass_Code ere.EncounterClassCode `json:"encounterClass_code" validate:"maxLength=10"`

internal/domain/references/common/common.go

@@ -16,6 +16,7 @@ type (
 	DataVerifiedCode     string
 	CrudCode             string
 	DataApprovalCode     string
+	ProcessStatusCode    string
 )
 
 const (
@@ -102,6 +103,9 @@ const (
 	DACNew      DataApprovalCode = "new"
 	DACApproved DataApprovalCode = "approved"
 	DACRejected DataApprovalCode = "rejected"
+
+	PSCSuccess ProcessStatusCode = "success"
+	PSCFailed  ProcessStatusCode = "failed"
 )
 
 func GetDayCodes() map[DayCode]string {

internal/domain/simgos-entities/installation/entity.go

@@ -0,0 +1,12 @@
+package installation
+
+type MInstalasi struct {
+	No_Instalasi      uint   `json:"no_instalasi" gorm:"primaryKey;autoIncrement;column:no_instalasi"`
+	Nama_Instalasi    string `json:"nama_instalasi" gorm:"column:nama_instalasi"`
+	Status_Rawat_Inap uint   `json:"status_rawat_inap" gorm:"column:status_rawat_inap"`
+	St_Aktif          uint   `json:"st_aktif" gorm:"column:st_aktif"`
+}
+
+func (MInstalasi) TableName() string {
+	return "m_instalasi"
+}

internal/domain/sync-entities/installation/entity.go

@@ -0,0 +1,29 @@
+package installation
+
+import (
+	ecore "simrs-vx/internal/domain/base-entities/core"
+	erc "simrs-vx/internal/domain/references/common"
+	"time"
+)
+
+type InstallationLink struct {
+	ecore.Main
+	Simx_Id   uint `json:"simx_id" gorm:"unique"`
+	Simgos_Id uint `json:"simgos_id" gorm:"unique"`
+}
+
+type InstallationSimxLog struct {
+	ecore.Main
+	Value      *string               `json:"value"`
+	Date       *time.Time            `json:"date"`
+	Status     erc.ProcessStatusCode `json:"status"`
+	ErrMessage *string               `json:"errMessage"`
+}
+
+type InstallationSimgosLog struct {
+	ecore.Main
+	Value      *string               `json:"value"`
+	Date       *time.Time            `json:"date"`
+	Status     erc.ProcessStatusCode `json:"status"`
+	ErrMessage *string               `json:"errMessage"`
+}

internal/domain/sync-entities/log/dto.go

@@ -0,0 +1,12 @@
+package log
+
+import (
+	erc "simrs-vx/internal/domain/references/common"
+)
+
+type SimxLogDto struct {
+	Payload    any          `json:"payload"`
+	IsSuccess  bool         `json:"isSuccess"`
+	ErrMessage *string      `json:"errMessage"`
+	Method     erc.CrudCode `json:"method"`
+}

internal/infra/simgos-db/simgos-db.go

@@ -0,0 +1,9 @@
+package simgos_db
+
+import (
+	dg "github.com/karincake/apem/db-gorm-pg"
+)
+
+func SetInstance() {
+	I = dg.IS["simrs"]
+}

internal/infra/simgos-db/tycovar.go

@@ -0,0 +1,5 @@
+package simgos_db
+
+import "gorm.io/gorm"
+
+var I *gorm.DB

internal/infra/sync-cfg/sync-cfg.go

@@ -7,8 +7,9 @@ import (
 
 func SetConfig() {
 	a.ParseSingleCfg(&O)
-	if O.Host == "" || O.Target == "" {
-		panic("sync url config host or target empty")
+
+	if O.Host == "" || O.Prefix == "" {
+		panic("config sync host and prefix empty")
 	}
 	lo.I.Println("sync url config loaded, status: DONE!!")
 }

internal/infra/sync-cfg/tycovar.go

@@ -3,6 +3,6 @@ package synccfg
 var O SyncUrlCfg = SyncUrlCfg{}
 
 type SyncUrlCfg struct {
-	Target string `yaml:"target"`
+	Prefix string `yaml:"prefix"`
 	Host   string `yaml:"host"`
 }

internal/interface/main-handler/main-handler.go

@@ -60,6 +60,7 @@ import (
 	gs "simrs-vx/internal/infra/gorm-setting"
 	minio "simrs-vx/internal/infra/minio"
 	ssdb "simrs-vx/internal/infra/ss-db"
+	simgossync "simrs-vx/internal/infra/sync-cfg"
 
 	/******************** pkg ********************/
 	cmw "simrs-vx/pkg/cors-manager-mw"
@@ -129,6 +130,7 @@ func SetRoutes() http.Handler {
 	a.RegisterExtCall(mh.I.SetClient)
 	a.RegisterExtCall(ibpjs.SetConfig)
 	a.RegisterExtCall(validation.RegisterValidation)
+	a.RegisterExtCall(simgossync.SetConfig)
 
 	r := http.NewServeMux()
 

internal/interface/main-sync-handler/main-sync-handler.go

@@ -1,36 +0,0 @@
-package mainsynchandler
-
-import (
-	"net/http"
-
-	/******************** infra ********************/
-	gs "simrs-vx/internal/infra/gorm-setting"
-	synccfg "simrs-vx/internal/infra/sync-cfg"
-
-	/******************** pkg ********************/
-	cmw "simrs-vx/pkg/cors-manager-mw"
-	lh "simrs-vx/pkg/lang-helper"
-	handlerlogger "simrs-vx/pkg/middleware/handler-logger"
-	zlc "simrs-vx/pkg/zerolog-ctx"
-
-	/******************** external ********************/
-	a "github.com/karincake/apem"
-
-	/******************** internal ********************/
-	"simrs-vx/internal/interface/main-handler/home"
-)
-
-func SetRoutes() http.Handler {
-	///
-	a.RegisterExtCall(gs.Adjust)
-	a.RegisterExtCall(zlc.Adjust)
-	a.RegisterExtCall(lh.Populate)
-	a.RegisterExtCall(synccfg.SetConfig)
-
-	r := http.NewServeMux()
-
-	/******************** Main ********************/
-	r.HandleFunc("/", home.Home)
-
-	return cmw.SetCors(handlerlogger.SetLog(r))
-}

internal/interface/migration/migration.go

@@ -31,6 +31,8 @@ func getEntities(input string) []any {
 		return getMainEntities()
 	case "satusehat":
 		return getSatuSehatEntities()
+	case "simgossync":
+		return getSimgosSyncEntities()
 	}
 	return nil
 }

internal/interface/migration/simgossync-entities.go

@@ -0,0 +1,14 @@
+package migration
+
+import (
+	/************** Source ***************/
+	installation "simrs-vx/internal/domain/sync-entities/installation"
+)
+
+func getSimgosSyncEntities() []any {
+	return []any{
+		&installation.InstallationLink{},
+		&installation.InstallationSimxLog{},
+		&installation.InstallationSimgosLog{},
+	}
+}

internal/interface/migration/tycovar.go

@@ -2,6 +2,7 @@
 package migration
 
 const (
-	Main      = "main"
-	SatuSehat = "satusehat"
+	Main       = "main"
+	SatuSehat  = "satusehat"
+	SimgosSync = "simgossync"
 )

internal/interface/simgos-sync-handler/installation/handler.go

@@ -0,0 +1,69 @@
+package installation
+
+import (
+	"net/http"
+	"strconv"
+
+	rw "github.com/karincake/risoles"
+	// ua "github.com/karincake/tumpeng/auth/svc"
+
+	e "simrs-vx/internal/domain/main-entities/installation"
+	esync "simrs-vx/internal/domain/sync-entities/log"
+	u "simrs-vx/internal/use-case/simgos-sync-use-case/installation"
+)
+
+type myBase struct{}
+
+var O myBase
+
+func (obj myBase) Create(w http.ResponseWriter, r *http.Request) {
+	dto := e.CreateDto{}
+	if res := rw.ValidateStructByIOR(w, r.Body, &dto); !res {
+		return
+	}
+	res, err := u.Create(dto)
+	rw.DataResponse(w, res, err)
+}
+
+func (obj myBase) CreateLog(w http.ResponseWriter, r *http.Request) {
+	dto := esync.SimxLogDto{}
+	if res := rw.ValidateStructByIOR(w, r.Body, &dto); !res {
+		return
+	}
+	res, err := u.CreateSimxLog(dto)
+	rw.DataResponse(w, res, err)
+}
+
+func (obj myBase) Update(w http.ResponseWriter, r *http.Request) {
+	id := rw.ValidateString(w, "id", r.PathValue("id"))
+	if id == "" {
+		return
+	}
+
+	dto := e.UpdateDto{}
+	if res := rw.ValidateStructByIOR(w, r.Body, &dto); !res {
+		return
+	}
+
+	val, _ := strconv.ParseUint(id, 10, 16)
+	valUint := uint16(val)
+	dto.Id = &valUint
+
+	res, err := u.Update(dto)
+	rw.DataResponse(w, res, err)
+}
+
+func (obj myBase) Delete(w http.ResponseWriter, r *http.Request) {
+	id := rw.ValidateString(w, "id", r.PathValue("id"))
+	if id == "" {
+		return
+	}
+
+	dto := e.DeleteDto{}
+	val, _ := strconv.ParseUint(id, 10, 16)
+	valUint := uint16(val)
+	dto.Id = &valUint
+
+	res, err := u.Delete(dto)
+	rw.DataResponse(w, res, err)
+}

internal/interface/simgos-sync-handler/simgos-sync-handler.go

@@ -5,8 +5,7 @@ import (
 
 	/******************** infra ********************/
 	gs "simrs-vx/internal/infra/gorm-setting"
-	synccfg "simrs-vx/internal/infra/sync-cfg"
-
+	simgosdb "simrs-vx/internal/infra/simgos-db"
 	/******************** pkg ********************/
 	cmw "simrs-vx/pkg/cors-manager-mw"
 	lh "simrs-vx/pkg/lang-helper"
@@ -15,9 +14,11 @@ import (
 
 	/******************** external ********************/
 	a "github.com/karincake/apem"
+	hk "github.com/karincake/hongkue"
 
 	/******************** internal ********************/
 	"simrs-vx/internal/interface/main-handler/home"
+	installation "simrs-vx/internal/interface/simgos-sync-handler/installation"
 )
 
 func SetRoutes() http.Handler {
@@ -25,12 +26,20 @@ func SetRoutes() http.Handler {
 	a.RegisterExtCall(gs.Adjust)
 	a.RegisterExtCall(zlc.Adjust)
 	a.RegisterExtCall(lh.Populate)
-	a.RegisterExtCall(synccfg.SetConfig)
+	a.RegisterExtCall(simgosdb.SetInstance)
 
 	r := http.NewServeMux()
 
 	/******************** Main ********************/
 	r.HandleFunc("/", home.Home)
 
+	/******************** Source ******************/
+	hk.GroupRoutes("/new-to-old/v1/installation", r, hk.MapHandlerFunc{
+		"POST /":       installation.O.Create,
+		"POST /log":    installation.O.CreateLog,
+		"PATCH /{id}":  installation.O.Update,
+		"DELETE /{id}": installation.O.Delete,
+	})
+
 	return cmw.SetCors(handlerlogger.SetLog(r))
 }

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

@@ -1,7 +1,7 @@
 package installation
 
 import (
-	e "simrs-vx/internal/domain/main-entities/installation"
+	erc "simrs-vx/internal/domain/references/common"
 	"strconv"
 
 	dg "github.com/karincake/apem/db-gorm-pg"
@@ -11,6 +11,9 @@ import (
 	pu "simrs-vx/pkg/use-case-helper"
 
 	"gorm.io/gorm"
+
+	e "simrs-vx/internal/domain/main-entities/installation"
+	esync "simrs-vx/internal/domain/sync-entities/log"
 )
 
 const source = "installation"
@@ -25,36 +28,32 @@ func Create(input e.CreateDto) (*d.Data, error) {
 
 	// Start log
 	pl.SetLogInfo(&event, input, "started", "create")
+	mwRunner := newMiddlewareRunner(&event)
 
 	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
+			id := uint(data.Id)
+			input.Id = &id
 		}
 
-		mwRunner.setMwType(pu.MWTPost)
-		// Run post-middleware
-		if err := mwRunner.RunCreateMiddleware(createPostMw, &input, &data); err != nil {
+		mwRunner.setMwType(pu.MWTPre)
+		// Run pre-middleware
+		if err := mwRunner.RunCreateMiddleware(createPreMw, &input); err != nil {
 			return err
 		}
 
-		pl.SetLogInfo(&event, nil, "complete")
-
 		return nil
 	})
 
-	if err != nil {
+	if err = runLogMiddleware(err, input, mwRunner); err != nil {
 		return nil, err
 	}
 
+	pl.SetLogInfo(&event, nil, "complete")
+
 	return &d.Data{
 		Meta: d.II{
 			"source":    source,
@@ -66,7 +65,6 @@ func Create(input e.CreateDto) (*d.Data, error) {
 }
 
 func ReadList(input e.ReadListDto) (*d.Data, error) {
-	var data *e.Installation
 	var dataList []e.Installation
 	var metaList *e.MetaDto
 	var err error
@@ -80,23 +78,11 @@ func ReadList(input e.ReadListDto) (*d.Data, error) {
 	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
 	})
 
@@ -131,23 +117,11 @@ func ReadDetail(input e.ReadDetailDto) (*d.Data, error) {
 	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
 	})
 
@@ -177,6 +151,7 @@ func Update(input e.UpdateDto) (*d.Data, error) {
 
 	// Start log
 	pl.SetLogInfo(&event, input, "started", "update")
+	mwRunner := newMiddlewareRunner(&event)
 
 	err = dg.I.Transaction(func(tx *gorm.DB) error {
 		pl.SetLogInfo(&event, rdDto, "started", "DBReadDetail")
@@ -184,32 +159,26 @@ func Update(input e.UpdateDto) (*d.Data, error) {
 			return err
 		}
 
-		mwRunner := newMiddlewareRunner(&event, tx)
-		mwRunner.setMwType(pu.MWTPre)
-		// Run pre-middleware
-		if err := mwRunner.RunUpdateMiddleware(readDetailPreMw, &rdDto, data); err != nil {
-			return err
-		}
-
+		input.Id = &data.Id
 		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 {
+		mwRunner.setMwType(pu.MWTPre)
+		// Run pre-middleware
+		if err := mwRunner.RunUpdateMiddleware(updatePreMw, &input); err != nil {
 			return err
 		}
 
 		return nil
 	})
 
-	if err != nil {
+	if err = runLogMiddleware(err, input, mwRunner); err != nil {
 		return nil, err
 	}
 
+	pl.SetLogInfo(&event, nil, "complete")
+
 	return &d.Data{
 		Meta: d.IS{
 			"source":    source,
@@ -233,6 +202,7 @@ func Delete(input e.DeleteDto) (*d.Data, error) {
 
 	// Start log
 	pl.SetLogInfo(&event, input, "started", "delete")
+	mwRunner := newMiddlewareRunner(&event)
 
 	err = dg.I.Transaction(func(tx *gorm.DB) error {
 		pl.SetLogInfo(&event, rdDto, "started", "DBReadDetail")
@@ -240,30 +210,26 @@ func Delete(input e.DeleteDto) (*d.Data, error) {
 			return err
 		}
 
-		mwRunner := newMiddlewareRunner(&event, tx)
-		mwRunner.setMwType(pu.MWTPre)
-		// Run pre-middleware
-		if err := mwRunner.RunDeleteMiddleware(readDetailPreMw, &rdDto, data); err != nil {
-			return err
-		}
-
+		input.Id = &data.Id
 		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 {
+		mwRunner.setMwType(pu.MWTPre)
+		// Run pre-middleware
+		if err := mwRunner.RunDeleteMiddleware(deletePreMw, &input); err != nil {
 			return err
 		}
 
 		return nil
 	})
 
-	if err != nil {
+	if err = runLogMiddleware(err, input, mwRunner); err != nil {
 		return nil, err
 	}
 
+	pl.SetLogInfo(&event, nil, "complete")
+
 	return &d.Data{
 		Meta: d.IS{
 			"source":    source,
@@ -274,3 +240,32 @@ func Delete(input e.DeleteDto) (*d.Data, error) {
 	}, nil
 
 }
+
+func runLogMiddleware(err error, input any, mwRunner *middlewareRunner) error {
+	var errMsg string
+	inputLog := esync.SimxLogDto{
+		Payload: input,
+		Method:  erc.CCCreate,
+	}
+
+	if err != nil {
+		// Run log-middleware
+		errMsg = err.Error()
+		inputLog.ErrMessage = &errMsg
+		inputLog.IsSuccess = false
+
+		// create log failed
+		if errMiddleware := mwRunner.RunCreateLogMiddleware(createSimxLogMw, &inputLog); errMiddleware != nil {
+			return errMiddleware
+		}
+		return err
+	}
+
+	// create log success
+	inputLog.IsSuccess = true
+	if err = mwRunner.RunCreateLogMiddleware(createSimxLogMw, &inputLog); err != nil {
+		return err
+	}
+
+	return nil
+}

internal/use-case/main-use-case/installation/middleware-runner.go

@@ -1,11 +1,13 @@
 package installation
 
 import (
-	e "simrs-vx/internal/domain/main-entities/installation"
 	pl "simrs-vx/pkg/logger"
 	pu "simrs-vx/pkg/use-case-helper"
 
 	"gorm.io/gorm"
+
+	e "simrs-vx/internal/domain/main-entities/installation"
+	esync "simrs-vx/internal/domain/sync-entities/log"
 )
 
 type middlewareRunner struct {
@@ -15,21 +17,36 @@ type middlewareRunner struct {
 }
 
 // NewMiddlewareExecutor creates a new middleware executor
-func newMiddlewareRunner(event *pl.Event, tx *gorm.DB) *middlewareRunner {
+func newMiddlewareRunner(event *pl.Event) *middlewareRunner {
 	return &middlewareRunner{
 		Event: event,
-		Tx:    tx,
 	}
 }
 
 // ExecuteCreateMiddleware executes create middleware
-func (me *middlewareRunner) RunCreateMiddleware(middlewares []createMw, input *e.CreateDto, data *e.Installation) error {
+func (me *middlewareRunner) RunCreateMiddleware(middlewares []createMw, input *e.CreateDto) error {
 	for _, middleware := range middlewares {
-		logData := pu.GetLogData(input, data)
+		logData := pu.GetLogData(input, nil)
 
 		pl.SetLogInfo(me.Event, logData, "started", middleware.Name)
 
-		if err := middleware.Func(input, data, me.Tx); err != nil {
+		if err := middleware.Func(input); err != nil {
+			return pu.HandleMiddlewareError(me.Event, string(me.MwType), middleware.Name, logData, err)
+		}
+
+		pl.SetLogInfo(me.Event, nil, "complete")
+	}
+	return nil
+}
+
+// ExecuteCreateMiddleware executes create middleware
+func (me *middlewareRunner) RunCreateLogMiddleware(middlewares []createLogMw, input *esync.SimxLogDto) error {
+	for _, middleware := range middlewares {
+		logData := pu.GetLogData(input, nil)
+
+		pl.SetLogInfo(me.Event, logData, "started", middleware.Name)
+
+		if err := middleware.Func(input); err != nil {
 			return pu.HandleMiddlewareError(me.Event, string(me.MwType), middleware.Name, logData, err)
 		}
 
@@ -68,13 +85,13 @@ func (me *middlewareRunner) RunReadDetailMiddleware(middlewares []readDetailMw,
 	return nil
 }
 
-func (me *middlewareRunner) RunUpdateMiddleware(middlewares []readDetailMw, input *e.ReadDetailDto, data *e.Installation) error {
+func (me *middlewareRunner) RunUpdateMiddleware(middlewares []UpdateMw, input *e.UpdateDto) error {
 	for _, middleware := range middlewares {
-		logData := pu.GetLogData(input, data)
+		logData := pu.GetLogData(input, nil)
 
 		pl.SetLogInfo(me.Event, logData, "started", middleware.Name)
 
-		if err := middleware.Func(input, data, me.Tx); err != nil {
+		if err := middleware.Func(input); err != nil {
 			return pu.HandleMiddlewareError(me.Event, string(me.MwType), middleware.Name, logData, err)
 		}
 
@@ -83,13 +100,13 @@ func (me *middlewareRunner) RunUpdateMiddleware(middlewares []readDetailMw, inpu
 	return nil
 }
 
-func (me *middlewareRunner) RunDeleteMiddleware(middlewares []readDetailMw, input *e.ReadDetailDto, data *e.Installation) error {
+func (me *middlewareRunner) RunDeleteMiddleware(middlewares []DeleteMw, input *e.DeleteDto) error {
 	for _, middleware := range middlewares {
-		logData := pu.GetLogData(input, data)
+		logData := pu.GetLogData(input, nil)
 
 		pl.SetLogInfo(me.Event, logData, "started", middleware.Name)
 
-		if err := middleware.Func(input, data, me.Tx); err != nil {
+		if err := middleware.Func(input); err != nil {
 			return pu.HandleMiddlewareError(me.Event, string(me.MwType), middleware.Name, logData, err)
 		}
 

internal/use-case/main-use-case/installation/middleware.go

@@ -1,9 +1,22 @@
 package installation
 
+import (
+	plugin "simrs-vx/internal/use-case/simgos-sync-plugin/installation"
+)
+
 // example of middleware
-// func init() {
-// 	createPreMw = append(createPreMw,
-// 		CreateMw{Name: "modif-input", Func: pm.ModifInput},
-// 		CreateMw{Name: "check-data", Func: pm.CheckData},
-// 	)
-// }
+func init() {
+	createPreMw = append(createPreMw,
+		createMw{Name: "create-installation", Func: plugin.Create},
+	)
+
+	createSimxLogMw = append(createSimxLogMw,
+		createLogMw{Name: "create-log", Func: plugin.CreateLog},
+	)
+
+	updatePreMw = append(updatePreMw,
+		updateMw{Name: "update-installation", Func: plugin.Update})
+
+	deletePreMw = append(deletePreMw,
+		deleteMw{Name: "delete-installation", Func: plugin.Delete})
+}

internal/use-case/main-use-case/installation/tycovar.go

@@ -12,11 +12,27 @@ import (
 	"gorm.io/gorm"
 
 	e "simrs-vx/internal/domain/main-entities/installation"
+	elog "simrs-vx/internal/domain/sync-entities/log"
 )
 
 type createMw struct {
 	Name string
-	Func func(input *e.CreateDto, data *e.Installation, tx *gorm.DB) error
+	Func func(input *e.CreateDto) error
+}
+
+type createLogMw struct {
+	Name string
+	Func func(input *elog.SimxLogDto) error
+}
+
+type updateMw struct {
+	Name string
+	Func func(input *e.UpdateDto) error
+}
+
+type deleteMw struct {
+	Name string
+	Func func(input *e.DeleteDto) error
 }
 
 type readListMw struct {
@@ -29,16 +45,17 @@ type readDetailMw struct {
 	Func func(input *e.ReadDetailDto, data *e.Installation, tx *gorm.DB) error
 }
 
-type UpdateMw = readDetailMw
-type DeleteMw = readDetailMw
+type UpdateMw = updateMw
+type DeleteMw = deleteMw
 
-var createPreMw []createMw      // preprocess middleware
-var createPostMw []createMw     // postprocess middleware
+var createPreMw []createMw  // preprocess middleware
+var createPostMw []createMw // postprocess middleware
+var createSimxLogMw []createLogMw
 var readListPreMw []readListMw  // ..
 var readListPostMw []readListMw // ..
 var readDetailPreMw []readDetailMw
 var readDetailPostMw []readDetailMw
-var updatePreMw []readDetailMw
+var updatePreMw []updateMw
 var updatePostMw []readDetailMw
-var deletePreMw []readDetailMw
+var deletePreMw []deleteMw
 var deletePostMw []readDetailMw

internal/use-case/simgos-sync-plugin/installation/plugin.go

@@ -0,0 +1,153 @@
+package installation
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+
+	sync "simrs-vx/internal/infra/sync-cfg"
+
+	e "simrs-vx/internal/domain/main-entities/installation"
+	elog "simrs-vx/internal/domain/sync-entities/log"
+)
+
+func Create(input *e.CreateDto) error {
+	endpoint := getPrefixEndpoint()
+
+	jsonData, err := json.Marshal(input)
+	if err != nil {
+		return fmt.Errorf("failed to encode JSON: %w", err)
+	}
+
+	req, err := http.NewRequest("POST", endpoint, bytes.NewReader(jsonData))
+	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()
+
+	if resp.StatusCode != http.StatusOK {
+		return fmt.Errorf(resp.Status)
+	}
+
+	_, err = io.ReadAll(resp.Body)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func CreateLog(input *elog.SimxLogDto) error {
+	prefixEndpoint := getPrefixEndpoint()
+	endpoint := prefixEndpoint + "/log"
+
+	jsonData, err := json.Marshal(input)
+	if err != nil {
+		return fmt.Errorf("failed to encode JSON: %w", err)
+	}
+
+	req, err := http.NewRequest("POST", endpoint, bytes.NewReader(jsonData))
+	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()
+
+	if resp.StatusCode != http.StatusOK {
+		return fmt.Errorf(resp.Status)
+	}
+
+	_, err = io.ReadAll(resp.Body)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func Update(input *e.UpdateDto) error {
+	prefixEndpoint := getPrefixEndpoint()
+	endpoint := fmt.Sprintf("%s/%v", prefixEndpoint, *input.Id)
+
+	jsonData, err := json.Marshal(input)
+	if err != nil {
+		return fmt.Errorf("failed to encode JSON: %w", err)
+	}
+
+	req, err := http.NewRequest("PATCH", endpoint, bytes.NewReader(jsonData))
+	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()
+
+	if resp.StatusCode != http.StatusOK {
+		return fmt.Errorf(resp.Status)
+	}
+
+	_, err = io.ReadAll(resp.Body)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func Delete(input *e.DeleteDto) error {
+	prefixEndpoint := getPrefixEndpoint()
+	endpoint := fmt.Sprintf("%s/%v", prefixEndpoint, *input.Id)
+
+	jsonData, err := json.Marshal(input)
+	if err != nil {
+		return fmt.Errorf("failed to encode JSON: %w", err)
+	}
+
+	req, err := http.NewRequest("DELETE", endpoint, bytes.NewReader(jsonData))
+	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()
+
+	if resp.StatusCode != http.StatusOK {
+		return fmt.Errorf(resp.Status)
+	}
+
+	_, err = io.ReadAll(resp.Body)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func getPrefixEndpoint() string {
+	return fmt.Sprintf("%s%s/v1/installation", sync.O.Host, sync.O.Prefix)
+}

internal/use-case/simgos-sync-use-case/installation/case.go

@@ -0,0 +1,255 @@
+package installation
+
+import (
+	"errors"
+	esimgos "simrs-vx/internal/domain/simgos-entities/installation"
+	esync "simrs-vx/internal/domain/sync-entities/log"
+
+	dg "github.com/karincake/apem/db-gorm-pg"
+	d "github.com/karincake/dodol"
+
+	pl "simrs-vx/pkg/logger"
+
+	"gorm.io/gorm"
+
+	e "simrs-vx/internal/domain/main-entities/installation"
+)
+
+const source = "installation"
+
+func Create(input e.CreateDto) (*d.Data, error) {
+	var (
+		txSync   = dg.I.Begin()
+		txSimgos = dg.IS["simrs"].Begin()
+	)
+
+	event := pl.Event{
+		Feature: "Create",
+		Source:  source,
+	}
+
+	// Start log
+	pl.SetLogInfo(&event, input, "started", "create")
+
+	// STEP 1: Insert to simgos
+	sgData, err := CreateSimgosData(input, &event, txSimgos)
+	if err != nil {
+		return nil, err
+	}
+
+	// STEP 2: Insert to Link
+	if err = CreateLinkData(*input.Id, sgData.No_Instalasi, &event, txSync); err != nil {
+		txSimgos.Rollback()
+		return nil, err
+	}
+
+	// STEP 3: Commit two trx
+	if err = txSimgos.Commit().Error; err != nil {
+		txSimgos.Rollback()
+		txSync.Rollback()
+		return nil, err
+	}
+
+	if err = txSync.Commit().Error; err != nil {
+		// STEP 4: Rollback Partial
+		go func() {
+			_ = DeleteSimgosData(sgData, &event)
+		}()
+		return nil, err
+	}
+
+	pl.SetLogInfo(&event, nil, "complete")
+
+	return &d.Data{
+		Meta: d.II{
+			"source":    source,
+			"structure": "single-data",
+			"status":    "created",
+		},
+	}, nil
+}
+
+func CreateSimxLog(input esync.SimxLogDto) (*d.Data, error) {
+	event := pl.Event{
+		Feature: "Create",
+		Source:  source,
+	}
+
+	// Start log
+	pl.SetLogInfo(&event, input, "started", "create")
+
+	err := dg.I.Transaction(func(tx *gorm.DB) error {
+		// InsertSimxLog
+		if err := CreateLogData(input, &event, tx); err != nil {
+			return err
+		}
+
+		pl.SetLogInfo(&event, nil, "complete")
+
+		return nil
+	})
+
+	if err != nil {
+		return nil, err
+	}
+
+	pl.SetLogInfo(&event, nil, "complete")
+
+	return &d.Data{
+		Meta: d.II{
+			"source":    source,
+			"structure": "single-data",
+			"status":    "created",
+		},
+	}, nil
+}
+
+func Update(input e.UpdateDto) (*d.Data, error) {
+	var (
+		txSync   = dg.I.Begin()
+		txSimgos = dg.IS["simrs"].Begin()
+		sgData   *esimgos.MInstalasi
+		err      error
+	)
+
+	event := pl.Event{
+		Feature: "Update",
+		Source:  source,
+	}
+
+	// Start log
+	pl.SetLogInfo(&event, input, "started", "update")
+
+	// STEP 1: Get Installation Link
+	syncLink, errGetLink := ReadDetailLinkData(*input.Id, &event)
+	if errGetLink != nil {
+		if !errors.Is(err, gorm.ErrRecordNotFound) {
+			return nil, err
+		}
+	}
+
+	if errGetLink != nil && errors.Is(errGetLink, gorm.ErrRecordNotFound) {
+		// STEP 2.1: Insert to simgos
+		sgData, err = CreateSimgosData(input.CreateDto, &event, txSimgos)
+		if err != nil {
+			return nil, err
+		}
+
+		// STEP 2.2: Insert to Link
+		simxId := uint(*input.Id)
+		if err = CreateLinkData(simxId, sgData.No_Instalasi, &event, txSync); err != nil {
+			txSimgos.Rollback()
+			return nil, err
+		}
+	} else {
+		// Step 3.1: Update Simgos
+		err = UpdateSimgosData(input, syncLink, &event, txSimgos)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	// STEP 4: Commit two trx
+	if err = txSimgos.Commit().Error; err != nil {
+		txSimgos.Rollback()
+		txSync.Rollback()
+		return nil, err
+	}
+
+	if errGetLink != nil {
+		if err = txSync.Commit().Error; err != nil {
+			// STEP 5.1: Rollback Partial
+			go func() {
+				_ = DeleteSimgosData(sgData, &event)
+			}()
+			return nil, err
+		}
+	}
+
+	pl.SetLogInfo(&event, nil, "complete")
+
+	return &d.Data{
+		Meta: d.IS{
+			"source":    source,
+			"structure": "single-data",
+			"status":    "updated",
+		},
+	}, nil
+}
+
+func Delete(input e.DeleteDto) (*d.Data, error) {
+	var (
+		txSync   = dg.I.Begin()
+		txSimgos = dg.IS["simrs"].Begin()
+		sgData   *esimgos.MInstalasi
+		err      error
+	)
+
+	event := pl.Event{
+		Feature: "Delete",
+		Source:  source,
+	}
+
+	// Start log
+	pl.SetLogInfo(&event, input, "started", "delete")
+
+	// STEP 1: Get Installation Link
+	syncLink, errGetLink := ReadDetailLinkData(*input.Id, &event)
+	if errGetLink != nil {
+		if !errors.Is(err, gorm.ErrRecordNotFound) {
+			return nil, err
+		}
+	}
+
+	if errGetLink == nil {
+		// STEP 2: Get Simgos
+		sgData, err = ReadDetailSimgosData(uint16(syncLink.Simgos_Id), &event)
+		if err != nil {
+			return nil, err
+		}
+
+		// STEP 3: Delete M_Instalation Simgos
+		err = DeleteSimgosData(sgData, &event, txSimgos)
+		if err != nil {
+			return nil, err
+		}
+
+		// STEP 4: Delete Installation Link
+		err = DeleteLinkData(syncLink, &event, txSync)
+		if err != nil {
+			txSimgos.Rollback()
+			return nil, err
+		}
+
+		// STEP 4: Commit two trx
+		if err = txSimgos.Commit().Error; err != nil {
+			txSimgos.Rollback()
+			txSync.Rollback()
+			return nil, err
+		}
+
+		if err = txSync.Commit().Error; err != nil {
+			// STEP 5: Rollback Partial
+			go func() {
+				inputRollback := e.UpdateDto{
+					CreateDto: e.CreateDto{
+						Name: sgData.Nama_Instalasi,
+					},
+				}
+				_ = UpdateSimgosData(inputRollback, syncLink, &event)
+			}()
+			return nil, err
+		}
+	}
+
+	pl.SetLogInfo(&event, nil, "complete")
+
+	return &d.Data{
+		Meta: d.IS{
+			"source":    source,
+			"structure": "single-data",
+			"status":    "deleted",
+		},
+	}, nil
+
+}

internal/use-case/simgos-sync-use-case/installation/helper.go

@@ -0,0 +1,58 @@
+/*
+DESCRIPTION:
+Any functions that are used internally by the use-case
+*/
+package installation
+
+import (
+	"encoding/json"
+	e "simrs-vx/internal/domain/main-entities/installation"
+	erc "simrs-vx/internal/domain/references/common"
+	esimgos "simrs-vx/internal/domain/simgos-entities/installation"
+	esync "simrs-vx/internal/domain/sync-entities/installation"
+	"simrs-vx/internal/domain/sync-entities/log"
+)
+
+func setDataSimgos[T *e.CreateDto | *e.UpdateDto](input T) (data esimgos.MInstalasi) {
+	var inputSrc *e.CreateDto
+	if inputT, ok := any(input).(*e.CreateDto); ok {
+		inputSrc = inputT
+	} else {
+		inputTemp := any(input).(*e.UpdateDto)
+		inputSrc = &inputTemp.CreateDto
+	}
+
+	data.Nama_Instalasi = inputSrc.Name
+	data.Status_Rawat_Inap = 0
+	data.St_Aktif = 1
+
+	return
+}
+
+func setDataSimxLog(input *log.SimxLogDto) (data esync.InstallationSimxLog) {
+	// encode to JSON
+	jsonData, _ := json.MarshalIndent(input.Payload, "", "  ")
+	jsonString := string(jsonData)
+
+	var status erc.ProcessStatusCode
+	if input.IsSuccess {
+		status = erc.PSCSuccess
+	} else {
+		status = erc.PSCFailed
+		if input.ErrMessage != nil {
+			data.ErrMessage = input.ErrMessage
+		}
+	}
+
+	data.Value = &jsonString
+	data.Date = &now
+	data.Status = status
+
+	return
+}
+
+func setDataSimxLink(simxId, simgosId uint) (data esync.InstallationLink) {
+	data.Simx_Id = simxId
+	data.Simgos_Id = simgosId
+	return
+}

internal/use-case/simgos-sync-use-case/installation/lib.go

@@ -0,0 +1,184 @@
+package installation
+
+import (
+	esynclog "simrs-vx/internal/domain/sync-entities/log"
+	plh "simrs-vx/pkg/lib-helper"
+	pl "simrs-vx/pkg/logger"
+	"time"
+
+	dg "github.com/karincake/apem/db-gorm-pg"
+	"gorm.io/gorm"
+
+	e "simrs-vx/internal/domain/main-entities/installation"
+	esimgos "simrs-vx/internal/domain/simgos-entities/installation"
+	esync "simrs-vx/internal/domain/sync-entities/installation"
+)
+
+var now = time.Now()
+
+func CreateSimgosData(input e.CreateDto, event *pl.Event, dbx ...*gorm.DB) (*esimgos.MInstalasi, error) {
+	pl.SetLogInfo(event, nil, "started", "DBCreate")
+
+	data := setDataSimgos(&input)
+
+	var tx *gorm.DB
+	if len(dbx) > 0 {
+		tx = dbx[0]
+	} else {
+		tx = dg.IS["simrs"]
+	}
+
+	if err := tx.Create(&data).Error; err != nil {
+		return nil, plh.HandleCreateError(input, event, err)
+	}
+
+	pl.SetLogInfo(event, nil, "complete")
+	return &data, nil
+}
+
+func ReadDetailSimgosData(simgosId uint16, event *pl.Event) (*esimgos.MInstalasi, error) {
+	pl.SetLogInfo(event, simgosId, "started", "DBReadDetail")
+	data := esimgos.MInstalasi{}
+
+	var tx = dg.IS["simrs"]
+
+	if err := tx.
+		Where("\"no_instalasi\" = ?", simgosId).
+		First(&data).Error; err != nil {
+		return nil, err
+	}
+
+	pl.SetLogInfo(event, nil, "complete")
+	return &data, nil
+}
+
+func UpdateSimgosData(input e.UpdateDto, dataSimgos *esync.InstallationLink, event *pl.Event, dbx ...*gorm.DB) error {
+	pl.SetLogInfo(event, input, "started", "DBUpdate")
+
+	data := setDataSimgos(&input)
+	data.No_Instalasi = dataSimgos.Simgos_Id
+
+	var tx *gorm.DB
+	if len(dbx) > 0 {
+		tx = dbx[0]
+	} else {
+		tx = dg.IS["simrs"]
+	}
+
+	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 DeleteSimgosData(data *esimgos.MInstalasi, 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.IS["simrs"]
+	}
+
+	data.St_Aktif = 0
+
+	if err := tx.Save(&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 CreateLinkData(simxId, simgosId uint, event *pl.Event, dbx ...*gorm.DB) error {
+	pl.SetLogInfo(event, nil, "started", "DBCreate")
+	data := setDataSimxLink(simxId, simgosId)
+
+	var tx *gorm.DB
+	if len(dbx) > 0 {
+		tx = dbx[0]
+	} else {
+		tx = dg.I
+	}
+
+	if err := tx.Create(&data).Error; err != nil {
+		return plh.HandleCreateError(data, event, err)
+	}
+
+	pl.SetLogInfo(event, nil, "complete")
+	return nil
+}
+
+func ReadDetailLinkData(simxId uint16, event *pl.Event) (*esync.InstallationLink, error) {
+	pl.SetLogInfo(event, simxId, "started", "DBReadDetail")
+	data := esync.InstallationLink{}
+
+	var tx = dg.I
+
+	if err := tx.
+		Where("\"Simx_Id\" = ?", simxId).
+		First(&data).Error; err != nil {
+		return nil, err
+	}
+
+	pl.SetLogInfo(event, nil, "complete")
+	return &data, nil
+}
+
+func DeleteLinkData(data *esync.InstallationLink, 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 CreateLogData(input esynclog.SimxLogDto, event *pl.Event, dbx ...*gorm.DB) error {
+	pl.SetLogInfo(event, nil, "started", "DBCreate")
+	data := setDataSimxLog(&input)
+
+	var tx *gorm.DB
+	if len(dbx) > 0 {
+		tx = dbx[0]
+	} else {
+		tx = dg.I
+	}
+
+	if err := tx.Create(&data).Error; err != nil {
+		return plh.HandleCreateError(input, event, err)
+	}
+
+	pl.SetLogInfo(event, nil, "complete")
+	return nil
+}

internal/use-case/simgos-sync-use-case/installation/middleware-runner.go

@@ -0,0 +1,103 @@
+package installation
+
+import (
+	e "simrs-vx/internal/domain/main-entities/installation"
+	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.Installation) 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.Installation) 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.Installation) 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.Installation) 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.Installation) 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/simgos-sync-use-case/installation/middleware.go

@@ -0,0 +1,9 @@
+package installation
+
+// 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/simgos-sync-use-case/installation/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 installation
+
+import (
+	"gorm.io/gorm"
+
+	e "simrs-vx/internal/domain/main-entities/installation"
+)
+
+type createMw struct {
+	Name string
+	Func func(input *e.CreateDto, data *e.Installation, tx *gorm.DB) error
+}
+
+type readListMw struct {
+	Name string
+	Func func(input *e.ReadListDto, data *e.Installation, tx *gorm.DB) error
+}
+
+type readDetailMw struct {
+	Name string
+	Func func(input *e.ReadDetailDto, data *e.Installation, 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