on going

cmd/main-migration/migrations/atlas.sum

@@ -1,4 +1,4 @@
-h1:B/ZKq0d90aqLf0EvQfND4cd8ZRHcmxfzKF2N1lpSeIs=
+h1:EHAhH6MGySJoRcgSvt6ywIwf2q43rG18Z8fwEpuukdM=
 20250904105930.sql h1:MEM6blCgke9DzWQSTnLzasbPIrcHssNNrJqZpSkEo6k=
 20250904141448.sql h1:J8cmYNk4ZrG9fhfbi2Z1IWz7YkfvhFqTzrLFo58BPY0=
 20250908062237.sql h1:Pu23yEW/aKkwozHoOuROvHS/GK4ngARJGdO7FB7HZuI=
@@ -156,6 +156,7 @@ h1:B/ZKq0d90aqLf0EvQfND4cd8ZRHcmxfzKF2N1lpSeIs=
 20251209022744.sql h1:y5/PAiZH/fYCpDJpkQdNRJwWICHH2iNIwM1V+S1P6KA=
 20251209025908.sql h1:p3kZA8kyEj+mQZSrdY3k2K1NojQzFJh/MlZJ0Oy6t/k=
 20251209030538.sql h1:zltV6/Fu2zJW0/lVBl7MdnWuJcqNTUIRcqYYZ8Fi1wo=
-20251209064304.sql h1:Mj6Zh+2b/4AkM1HjnJGjAs788kVN0UaL34jeaKQIjT0=
+20251209051742.sql h1:BBNSmWfkamWrcKdxWjPiBS9yJ8yyQQUQIj3kip53nuE=
-20251209070128.sql h1:ip4wNCIF/UFQlNo6KpFG87/XA08aG3/Rf5zpxz3xioY=
+20251209064304.sql h1:Xs73yQbuJvuQ0OnW1FAZpeytmUl/bGTlJFrwGOsTF4w=
-20251209084929.sql h1:Z5higP1Ecq5UPWhrWZ5UCrxddMNqiJi8PbCNvGBE48A=
+20251209070128.sql h1:fPGE6xOV6uCiVOqnvwn2L/GsBbgp2wxgmZOhF3bSGGM=
+20251209084929.sql h1:u4LPMvkGAH4RfGC2IlBTIm7T7paMHoBSvTQ0w5Br7d0=

cmd/simgos-sync-api/main.go

@@ -1,10 +1,10 @@
 package main
 
 import (
-	a "github.com/karincake/apem"
-
 	h "simrs-vx/internal/interface/simgos-sync-handler"
 
+	a "github.com/karincake/apem"
+
 	d "github.com/karincake/apem/db-gorm-pg"
 
 	l "github.com/karincake/apem/logger-zerolog"

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

@@ -0,0 +1,18 @@
+package nurse
+
+import (
+	"net/http"
+	"simrs-vx/internal/use-case/simgos-sync-use-case/seeder/nurse"
+
+	rw "github.com/karincake/risoles"
+)
+
+type myBase struct{}
+
+var O myBase
+
+func (obj myBase) Seeder(w http.ResponseWriter, r *http.Request) {
+
+	err := nurse.SeedNurse()
+	rw.DataResponse(w, nil, err)
+}

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

@@ -30,7 +30,8 @@ import (
 	"simrs-vx/internal/interface/simgos-sync-handler/new/subspecialist"
 	"simrs-vx/internal/interface/simgos-sync-handler/new/unit"
 
-	ds "simrs-vx/internal/interface/simgos-sync-handler/seeder/doctor"
+	sd "simrs-vx/internal/interface/simgos-sync-handler/seeder/doctor"
+	sn "simrs-vx/internal/interface/simgos-sync-handler/seeder/nurse"
 
 	oldpatient "simrs-vx/internal/interface/simgos-sync-handler/old/patient"
 
@@ -81,7 +82,8 @@ func SetRoutes() http.Handler {
 	/******************** SvcToNew ******************/
 	prefixseeder := "/new-seeder"
 	hk.GroupRoutes(prefixseeder+"/v1", r, hk.MapHandlerFunc{
-		"POST /doctor": ds.O.Seeder,
+		"POST /doctor": sd.O.Seeder,
+		"POST /nurse":  sn.O.Seeder,
 	})
 
 	/******************** SvcToNew ******************/

internal/use-case/simgos-sync-use-case/new/nurse/case.go

@@ -0,0 +1,194 @@
+package nurse
+
+import (
+	pl "simrs-vx/pkg/logger"
+
+	d "github.com/karincake/dodol"
+	"gorm.io/gorm"
+
+	db "simrs-vx/pkg/dualtrx-helper"
+
+	elog "simrs-vx/internal/domain/sync-entities/log"
+)
+
+const source = "patient"
+
+//func Create(input e.CreateDto) (*d.Data, error) {
+//	var (
+//		sgData   *esimgos.MUnit
+//		syncLink *esync.DivisionLink
+//		err      error
+//	)
+//
+//	event := pl.Event{
+//		Feature: "Create",
+//		Source:  source,
+//	}
+//
+//	// Start log
+//	pl.SetLogInfo(&event, input, "started", "create")
+//
+//	err = db.WithDualTx(func(tx *db.Dualtx) error {
+//		// STEP 1: Insert to simgos
+//		sgData, err = CreateSimgosData(input, &event, tx.Simgos)
+//		if err != nil {
+//			return err
+//		}
+//
+//		// STEP 2: Insert to Link
+//		syncLink, err = CreateLinkData(*input.Id, sgData.KodeUnit, &event, tx.Sync)
+//		if err != nil {
+//			return err
+//		}
+//
+//		return nil
+//	})
+//
+//	if err != nil {
+//		if syncLink != nil {
+//			go func() { _ = DeleteLinkData(syncLink, &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 elog.SimxLogDto) (*d.Data, error) {
+	event := pl.Event{
+		Feature: "Create",
+		Source:  source,
+	}
+
+	// Start log
+	pl.SetLogInfo(&event, input, "started", "create")
+
+	tx := db.NewTx()
+	err := tx.Sync.Transaction(func(tx *gorm.DB) error {
+		// Insert to Log
+		if err := CreateLogData(input, &event, tx); err != nil {
+			return err
+		}
+
+		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) {
+//	event := pl.Event{
+//		Feature: "Update",
+//		Source:  source,
+//	}
+//
+//	// Start log
+//	pl.SetLogInfo(&event, input, "started", "update")
+//
+//	// STEP 1: Get Link
+//	syncLink, err := ReadDetailLinkData(*input.Id, &event)
+//	if err != nil {
+//		return nil, err
+//	}
+//
+//	tx := db.NewTx()
+//	err = tx.Simgos.Transaction(func(tx *gorm.DB) error {
+//		// Step 2: Update Simgos
+//		if err = UpdateSimgosData(input, syncLink, &event, tx); err != nil {
+//			return err
+//		}
+//
+//		return nil
+//	})
+//
+//	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 isLinkDeleted bool
+//
+//	event := pl.Event{
+//		Feature: "Delete",
+//		Source:  source,
+//	}
+//
+//	// Start log
+//	pl.SetLogInfo(&event, input, "started", "delete")
+//
+//	// STEP 1: Get Link
+//	syncLink, err := ReadDetailLinkData(*input.Id, &event)
+//	if err != nil {
+//		return nil, err
+//	}
+//
+//	// STEP 2: Get Simgos
+//	sgData, err := ReadDetailSimgosData(uint16(syncLink.Simgos_Id), &event)
+//	if err != nil {
+//		return nil, err
+//	}
+//
+//	err = db.WithDualTx(func(tx *db.Dualtx) error {
+//		// STEP 3: Delete Simgos
+//		err = HardDeleteSimgosData(sgData, &event, tx.Simgos)
+//		if err != nil {
+//			return err
+//		}
+//
+//		// STEP 4: Delete Link
+//		err = DeleteLinkData(syncLink, &event, tx.Sync)
+//		if err != nil {
+//			return err
+//		}
+//
+//		isLinkDeleted = true
+//		return nil
+//	})
+//
+//	if err != nil {
+//		if isLinkDeleted {
+//			go func() {
+//				_, _ = CreateLinkData(uint(*input.Id), sgData.KodeUnit, &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/new/nurse/helper.go

@@ -0,0 +1,54 @@
+/*
+DESCRIPTION:
+Any functions that are used internally by the use-case
+*/
+package nurse
+
+import (
+	"encoding/json"
+	erc "simrs-vx/internal/domain/references/common"
+
+	esyncLog "simrs-vx/internal/domain/sync-entities/log"
+	esync "simrs-vx/internal/domain/sync-entities/nurse"
+)
+
+//func setDataSimgos[T *e.CreateDto | *e.UpdateDto](input T) (data esimgos.MDokter) {
+//	var inputSrc *e.CreateDto
+//	if inputT, ok := any(input).(*e.CreateDto); ok {
+//		inputSrc = inputT
+//	} else {
+//		inputTemp := any(input).(*e.UpdateDto)
+//		inputSrc = &inputTemp.CreateDto
+//	}
+//
+//	data.NamaUnit = inputSrc.Name
+//	return
+//}
+
+func setDataSimxLog(input *esyncLog.SimxLogDto) (data esync.NurseSimxLog) {
+	// 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.NurseLink) {
+	data.Simx_Id = simxId
+	data.Simgos_Id = simgosId
+	return
+}

internal/use-case/simgos-sync-use-case/new/nurse/lib.go

@@ -0,0 +1,186 @@
+package nurse
+
+import (
+	plh "simrs-vx/pkg/lib-helper"
+	pl "simrs-vx/pkg/logger"
+	pu "simrs-vx/pkg/use-case-helper"
+	"time"
+
+	dg "github.com/karincake/apem/db-gorm-pg"
+	"gorm.io/gorm"
+
+	esynclog "simrs-vx/internal/domain/sync-entities/log"
+	esync "simrs-vx/internal/domain/sync-entities/nurse"
+)
+
+var now = time.Now()
+
+//func CreateSimgosData(input e.CreateDto, event *pl.Event, dbx ...*gorm.DB) (*esimgos.MDokter, 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.MUnit, error) {
+//	pl.SetLogInfo(event, simgosId, "started", "DBReadDetail")
+//	data := esimgos.MUnit{}
+//
+//	var tx = dg.IS["simrs"]
+//
+//	if err := tx.
+//		Where("\"kode_unit\" = ?", simgosId).
+//		First(&data).Error; err != nil {
+//		if processedErr := pu.HandleReadError(err, event, source, simgosId, data); processedErr != nil {
+//			return nil, processedErr
+//		}
+//	}
+//
+//	pl.SetLogInfo(event, nil, "complete")
+//	return &data, nil
+//}
+
+//func UpdateSimgosData(input e.UpdateDto, dataSimgos *esync.DivisionLink, event *pl.Event, dbx ...*gorm.DB) error {
+//	pl.SetLogInfo(event, input, "started", "DBUpdate")
+//
+//	data := setDataSimgos(&input)
+//	data.KodeUnit = 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 HardDeleteSimgosData(data *esimgos.MUnit, 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"]
+//	}
+//
+//	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 CreateLinkData(simxId, simgosId uint, event *pl.Event, dbx ...*gorm.DB) (*esync.NurseLink, 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 nil, plh.HandleCreateError(data, event, err)
+	}
+
+	pl.SetLogInfo(event, nil, "complete")
+	return &data, nil
+}
+
+func ReadDetailLinkData(simxId uint16, event *pl.Event) (*esync.NurseLink, error) {
+	pl.SetLogInfo(event, simxId, "started", "DBReadDetail")
+	data := esync.NurseLink{}
+
+	var tx = dg.I
+
+	if err := tx.
+		Where("\"Simx_Id\" = ?", simxId).
+		First(&data).Error; err != nil {
+		if processedErr := pu.HandleReadError(err, event, source, simxId, data); processedErr != nil {
+			return nil, processedErr
+		}
+	}
+
+	pl.SetLogInfo(event, nil, "complete")
+	return &data, nil
+}
+
+func DeleteLinkData(data *esync.NurseLink, 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/seeder/doctor/seeder.go

@@ -1,11 +1,13 @@
 package doctor
 
 import (
-	"bytes"
 	"encoding/json"
-	"io"
+	"fmt"
+
+	"log"
 	"net/http"
-	cfg "simrs-vx/internal/infra/sync-cfg"
+
+	"simrs-vx/internal/use-case/simgos-sync-use-case/seeder"
 	pl "simrs-vx/pkg/logger"
 	"strconv"
 
@@ -13,27 +15,22 @@ import (
 
 	erg "simrs-vx/internal/domain/references/organization"
 
-	ed "simrs-vx/internal/domain/simgos-entities/m-dokter"
+	eed "simrs-vx/internal/domain/main-entities/doctor"
-	el "simrs-vx/internal/domain/simgos-entities/m-login"
-	ep "simrs-vx/internal/domain/simgos-entities/m-pegawai"
-
 	epr "simrs-vx/internal/domain/main-entities/person"
 	es "simrs-vx/internal/domain/main-entities/user"
 
 	ud "simrs-vx/internal/use-case/simgos-sync-use-case/new/doctor"
 )
 
-type User struct {
-	Doctor   ed.MDokter  `gorm:"embedded"`
-	Employee ep.MPegawai `gorm:"embedded"`
-	Login    el.MLogin   `gorm:"embedded"`
-}
-
-var path = "user"
-
 func SeedDoctor() error {
+
+	log.Println("=== START SeedDoctor ===")
+
 	tx := db.NewTx()
-	var users []User
+
+	var users []seeder.User
+
+	log.Println("Querying SIMRS doctors...")
 
 	err := tx.Simgos.Table("m_dokter").
 		Select(`
@@ -43,94 +40,101 @@ func SeedDoctor() error {
 		`).
 		Joins(`LEFT JOIN m_login   l ON l.kddokter = m_dokter.kddokter`).
 		Joins(`LEFT JOIN m_pegawai p ON p.no_peg = m_dokter.kddokter`).
-		Where(`m_dokter.aktif = ?`, 1).
+		Where(`p.nik != '' AND p.nik != '0' AND l.nip != ''`).
 		Order(`m_dokter.kddokter DESC`).
 		Limit(10).
 		Scan(&users).Error
 
 	if err != nil {
+		log.Println("Error Querying SIMRS:", err)
 		return err
 	}
 
+	log.Printf("Found %d doctors to seed\n", len(users))
+
 	// mapping
-	doctorsimx := []es.CreateDto{}
 	for i, d := range users {
+		log.Printf("[%d/%d] Processing doctor KdDokter=%d ...", i+1, len(users), d.Doctor.Kddokter)
+
 		kddokter := strconv.Itoa(int(d.Doctor.Kddokter))
-		doctorsimx = append(doctorsimx, es.CreateDto{
+		doctorsimx := es.CreateDto{
 			Name:                  d.Login.NIP,
 			Password:              "1234",
 			ContractPosition_Code: erg.CSCEmp,
 			Code:                  &kddokter,
 			Person: &epr.UpdateDto{
 				CreateDto: epr.CreateDto{
-					Name:       d.Employee.NamaPeg,
+					Name:                   d.Employee.NamaPeg,
-					BirthPlace: &d.Employee.TempatLahir,
+					BirthPlace:             &d.Employee.TempatLahir,
+					ResidentIdentityNumber: &d.Employee.NIK,
 				},
 			},
 			Employee: &es.EmployeUpdateDto{
 				Position_Code: erg.EPCDoc,
 			},
-		})
+		}
 
-		// create request body
+		log.Printf("[%d] Creating User for NIP=%s ...", i+1, d.Login.NIP)
-		jsonUser, err := json.Marshal(doctorsimx[i])
+
+		// create user
+		user, err := seeder.CreateUser(doctorsimx)
 		if err != nil {
+			log.Println("Error createUser:", err)
 			return err
 		}
 
-		reqBody := bytes.NewBuffer(jsonUser)
+		log.Printf("[%d] User created: ID=%d", i+1, user.Id)
-		// send data to main-api
+
-		resp, err := send(http.MethodPost, path, reqBody, "von")
+		log.Printf("[%d] Fetching doctor with code=%s ...", i+1, kddokter)
+		// get doctor
+		dataDoctor, err := getDoctors(kddokter)
 		if err != nil {
+			log.Println("Error getDoctors:", err)
 			return err
 		}
 
-		type MetaData struct {
+		doc := *dataDoctor
-			Source    string `json:"source"`
+		ddoc := doc[0]
-			Status    string `json:"status"`
-			Structure string `json:"structure"`
-		}
 
-		type MainApiResp struct {
+		log.Printf("[%d] Linking doctor %d to %d ...", i+1, ddoc.Id, d.Doctor.Kddokter)
-			Meta MetaData `json:"meta"`
+		if _, err := ud.CreateLinkData(ddoc.Id, d.Doctor.Kddokter, &pl.Event{}); err != nil {
-			Data es.User  `json:"data"`
-		}
-
-		// getting response
-		var data MainApiResp
-		err = json.Unmarshal(resp, &data)
-		if err != nil {
 			return err
 		}
 
-		if _, err := ud.CreateLinkData(data.Data.Id, d.Doctor.Kddokter, &pl.Event{}); err != nil {
+		log.Printf("[%d] Link created successfully.", i+1)
-			return err
-		}
 	}
 
+	log.Println("=== FINISH SeedDoctor ===")
+
 	return nil
 
 }
 
-func send(method string, endpoint string, body *bytes.Buffer, username string) ([]byte, error) {
+func getDoctors(code string) (*[]eed.Doctor, error) {
-	var url string = cfg.O.NewHost + "/v1" + endpoint
+	path := fmt.Sprintf("doctor?code=%s", code)
-	var reader io.Reader = nil
+
-	if body != nil {
+	resp, err := seeder.Send(http.MethodGet, path, nil, "von")
-		reader = body
-	}
-	req, err := http.NewRequest(method, url, reader)
 	if err != nil {
 		return nil, err
 	}
-	req.Header.Set("Content-Type", "application/json")
+
-	req.Header.Set("X-Sync-Source", cfg.O.OldSource)
+	type MetaData struct {
-	req.Header.Set("X-Sync-SecretKey", cfg.O.NewSecretKey)
+		Source    string `json:"source"`
-	req.Header.Set("X-Sync-UserName", username)
+		Status    string `json:"status"`
-	resp, err := http.DefaultClient.Do(req)
+		Structure string `json:"structure"`
+	}
+
+	type MainApiResp struct {
+		Meta MetaData     `json:"meta"`
+		Data []eed.Doctor `json:"data"`
+	}
+
+	// getting response
+	var data MainApiResp
+	err = json.Unmarshal(resp, &data)
 	if err != nil {
 		return nil, err
 	}
-	defer resp.Body.Close()
+
-	respBody, _ := io.ReadAll(resp.Body)
+	return &data.Data, nil
-	return respBody, nil
 }

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

@@ -0,0 +1,86 @@
+package seeder
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	es "simrs-vx/internal/domain/main-entities/user"
+	ed "simrs-vx/internal/domain/simgos-entities/m-dokter"
+	el "simrs-vx/internal/domain/simgos-entities/m-login"
+	ep "simrs-vx/internal/domain/simgos-entities/m-pegawai"
+	epr "simrs-vx/internal/domain/simgos-entities/m-perawat"
+	cfg "simrs-vx/internal/infra/sync-cfg"
+)
+
+type User struct {
+	Login    el.MLogin    `gorm:"embedded"`
+	Nurse    epr.MPerawat `gorm:"embedded"`
+	Doctor   ed.MDokter   `gorm:"embedded"`
+	Employee ep.MPegawai  `gorm:"embedded"`
+}
+
+func Send(method string, endpoint string, body *bytes.Buffer, username string) ([]byte, error) {
+	var url string = cfg.O.NewHost + "v1/" + endpoint
+	var reader io.Reader = nil
+	if body != nil {
+		reader = body
+	}
+	req, err := http.NewRequest(method, url, reader)
+	if err != nil {
+		return nil, err
+	}
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("X-Sync-Source", cfg.O.OldSource)
+	req.Header.Set("X-Sync-SecretKey", cfg.O.NewSecretKey)
+	req.Header.Set("X-Sync-UserName", username)
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("http status code %d", resp.StatusCode)
+	}
+	respBody, _ := io.ReadAll(resp.Body)
+	return respBody, nil
+}
+
+func CreateUser(user es.CreateDto) (*es.User, error) {
+	var path = "user"
+
+	// create request body
+	jsonUser, err := json.Marshal(user)
+	if err != nil {
+		return nil, err
+	}
+
+	reqBody := bytes.NewBuffer(jsonUser)
+	// send data to main-api
+	resp, err := Send(http.MethodPost, path, reqBody, "von")
+	if err != nil {
+		return nil, err
+	}
+
+	type MetaData struct {
+		Source    string `json:"source"`
+		Status    string `json:"status"`
+		Structure string `json:"structure"`
+	}
+
+	type MainApiResp struct {
+		Meta MetaData `json:"meta"`
+		Data es.User  `json:"data"`
+	}
+
+	// getting response
+	var data MainApiResp
+	err = json.Unmarshal(resp, &data)
+	if err != nil {
+		return nil, err
+	}
+
+	return &data.Data, nil
+}

internal/use-case/simgos-sync-use-case/seeder/nurse/seeder.go

@@ -0,0 +1,164 @@
+package nurse
+
+import (
+	"encoding/json"
+	"fmt"
+	"log"
+	"math/rand"
+	"net/http"
+	"simrs-vx/internal/use-case/simgos-sync-use-case/seeder"
+	pl "simrs-vx/pkg/logger"
+	"strconv"
+	"time"
+
+	db "simrs-vx/pkg/dualtrx-helper"
+
+	erg "simrs-vx/internal/domain/references/organization"
+
+	en "simrs-vx/internal/domain/main-entities/nurse"
+	epr "simrs-vx/internal/domain/main-entities/person"
+	es "simrs-vx/internal/domain/main-entities/user"
+
+	un "simrs-vx/internal/use-case/simgos-sync-use-case/new/nurse"
+)
+
+func SeedNurse() error {
+
+	log.Println("=== START SeedNurse ===")
+
+	tx := db.NewTx()
+
+	var users []seeder.User
+
+	log.Println("Querying SIMRS nurses...")
+
+	err := tx.Simgos.Table("m_perawat").
+		Select("m_perawat.*, l.*").
+		Joins("LEFT JOIN m_login l ON l.kdperawat = m_perawat.idperawat").
+		Where("l.roles = ?", 4).
+		Order("m_perawat.idperawat DESC").
+		Limit(10).
+		Scan(&users).Error
+
+	if err != nil {
+		log.Println("Error Querying SIMRS:", err)
+		return err
+	}
+
+	log.Printf("Found %d nurses to seed\n", len(users))
+
+	// mapping
+	for i, d := range users {
+		log.Printf("[%d/%d] Processing nurse KdPerawat=%d ...", i+1, len(users), d.Nurse.NIP)
+
+		kdprawat := strconv.Itoa(int(*d.Nurse.Idperawat))
+		nik := GenerateDummyNIK("F")
+		nursesimx := es.CreateDto{
+			Name:                  d.Login.NIP,
+			Password:              "1234",
+			ContractPosition_Code: erg.CSCEmp,
+			Code:                  &kdprawat,
+			Person: &epr.UpdateDto{
+				CreateDto: epr.CreateDto{
+					Name:                   d.Employee.NamaPeg,
+					BirthPlace:             &d.Employee.TempatLahir,
+					ResidentIdentityNumber: &nik,
+				},
+			},
+			Employee: &es.EmployeUpdateDto{
+				Position_Code: erg.EPCNur,
+			},
+		}
+
+		log.Printf("[%d] Creating User for NIP=%s ...", i+1, d.Login.NIP)
+
+		// create user
+		user, err := seeder.CreateUser(nursesimx)
+		if err != nil {
+			log.Println("Error createUser:", err)
+			return err
+		}
+
+		log.Printf("[%d] User created: ID=%d", i+1, user.Id)
+
+		log.Printf("[%d] Fetching nurse with code=%s ...", i+1, kdprawat)
+		// get nurse
+		dataNurse, err := getNurse(kdprawat)
+		if err != nil {
+			log.Println("Error getnurses:", err)
+			return err
+		}
+
+		data := *dataNurse
+		ddata := data[0]
+
+		log.Printf("[%d] Linking nurse %d to %d ...", i+1, ddata.Id, d.Nurse.Idperawat)
+		if _, err := un.CreateLinkData(ddata.Id, *d.Nurse.Idperawat, &pl.Event{}); err != nil {
+			return err
+		}
+
+		log.Printf("[%d] Link created successfully.", i+1)
+	}
+
+	log.Println("=== FINISH Seednurse ===")
+
+	return nil
+
+}
+
+func getNurse(code string) (*[]en.Nurse, error) {
+	path := fmt.Sprintf("nurse?code=%s", code)
+
+	resp, err := seeder.Send(http.MethodGet, path, nil, "von")
+	if err != nil {
+		return nil, err
+	}
+
+	type MetaData struct {
+		Source    string `json:"source"`
+		Status    string `json:"status"`
+		Structure string `json:"structure"`
+	}
+
+	type MainApiResp struct {
+		Meta MetaData   `json:"meta"`
+		Data []en.Nurse `json:"data"`
+	}
+
+	// getting response
+	var data MainApiResp
+	err = json.Unmarshal(resp, &data)
+	if err != nil {
+		return nil, err
+	}
+
+	return &data.Data, nil
+}
+
+func GenerateDummyNIK(gender string) string {
+	rand.Seed(time.Now().UnixNano())
+
+	// 1️⃣ Kode wilayah (6 digit)
+	// Bisa di-random, atau gunakan kode tetap seperti Jakarta: 317301
+	region := rand.Intn(999999) // 000000 - 999999
+	regionCode := fmt.Sprintf("%06d", region)
+
+	// 2️⃣ Tanggal lahir (DDMMYY)
+	year := rand.Intn(30) + 70 // antara tahun 1970-1999 (bisa diganti range lain)
+	month := rand.Intn(12) + 1
+	day := rand.Intn(28) + 1 // selalu valid
+
+	if gender == "F" {
+		day += 40 // aturan NIK perempuan: tanggal lahir + 40
+	}
+
+	birth := fmt.Sprintf("%02d%02d%02d", day, month, year)
+
+	// 3️⃣ Nomor urut (4 digit)
+	sequence := fmt.Sprintf("%04d", rand.Intn(9999))
+
+	// 4️⃣ Susun NIK akhir
+	nik := regionCode + birth + sequence
+
+	return nik
+}