add seeder

internal/domain/simgos-entities/m-login/entity.go

@@ -0,0 +1,22 @@
+package m_login
+
+type MLogin struct {
+	NIP                    string  `gorm:"column:nip;primaryKey"`
+	Password               string  `gorm:"column:pwd"`
+	SesReg                 string  `gorm:"column:ses_reg"`
+	KdPerawat              uint    `gorm:"column:kdperawat"`
+	KdDokter               uint    `gorm:"column:kddokter"`
+	NamaPegawai            string  `gorm:"column:nama_pegawai"`
+	Roles                  int     `gorm:"column:roles"`
+	KdUnit                 uint    `gorm:"column:kdunit"`
+	Departemen             string  `gorm:"column:departemen"`
+	StDokterRajalEksekutif *uint16 `gorm:"column:st_dokter_rajal_eksekutif"`
+	StDokterRajalReguler   *uint16 `gorm:"column:st_dokter_rajal_reguler"`
+	StDokterRajalEmergency *uint16 `gorm:"column:st_dokter_rajal_emergency"`
+	NIPB                   *string `gorm:"column:nipb"`
+	Aktif                  uint16  `gorm:"column:aktif"`
+}
+
+func (MLogin) TableName() string {
+	return "m_login"
+}

internal/domain/simgos-entities/m-pegawai/entity.go

@@ -0,0 +1,38 @@
+package m_pegawai
+
+import "time"
+
+type MPegawai struct {
+	NoPeg          uint       `gorm:"column:no_peg;primaryKey"`
+	NamaPeg        string     `gorm:"column:nama_peg"`
+	NIPB           string     `gorm:"column:nipb"`
+	Gol            string     `gorm:"column:gol"`
+	SatuanKerja    string     `gorm:"column:satuan_kerja"`
+	Ruang          string     `gorm:"column:ruang"`
+	Pendidikan     string     `gorm:"column:pendidikan"`
+	Tenaga         string     `gorm:"column:tenaga"`
+	Tenaga1        string     `gorm:"column:tenaga1"`
+	Tenaga2        string     `gorm:"column:tenaga2"`
+	TMTMasuk       *time.Time `gorm:"column:tmt_masuk"`
+	TempatLahir    string     `gorm:"column:tmp_lahir"`
+	TanggalLahir   *time.Time `gorm:"column:tgl_lahir"`
+	Alamat         string     `gorm:"column:alamat"`
+	Telepon        string     `gorm:"column:telepon"`
+	HP             string     `gorm:"column:hp"`
+	Karpeg         string     `gorm:"column:karpeg"`
+	Kelamin        string     `gorm:"column:kelamin"`
+	Agama          string     `gorm:"column:agama"`
+	StatusTubel    uint16     `gorm:"column:status_tubel"` // smallint → bool
+	NIK            string     `gorm:"column:nik"`
+	Seksi          string     `gorm:"column:seksi"`
+	TMTAwalSIP     *time.Time `gorm:"column:tmt_awal_sip"`
+	TMTAkhirSIPStr *time.Time `gorm:"column:tmt_akhir_sip_str"`
+	NoSIP          string     `gorm:"column:no_sip"`
+	NoSTR          string     `gorm:"column:no_str"`
+	LoginID        string     `gorm:"column:login_id"`
+	CodeKasir      string     `gorm:"column:code_kasir"`
+}
+
+func (MPegawai) TableName() string {
+	return "m_pegawai"
+}

internal/interface/migration/migration.go

@@ -39,5 +39,4 @@ func getEntities(input string) []any {
 
 func Migrate(input string) {
 	loader(input)
-
 }

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

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

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

@@ -30,6 +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"
+
 	oldpatient "simrs-vx/internal/interface/simgos-sync-handler/old/patient"
 
 	oauth "simrs-vx/internal/interface/simgos-sync-handler/old/authentication" // just a reminder, an openauth
@@ -76,6 +78,12 @@ func SetRoutes() http.Handler {
 	})
 	hc.SyncCrud(r, prefixnew+"/v1/soapi", soapi.O)
 
+	/******************** SvcToNew ******************/
+	prefixseeder := "/new-seeder"
+	hk.GroupRoutes(prefixseeder+"/v1", r, hk.MapHandlerFunc{
+		"POST /doctor": ds.O.Seeder,
+	})
+
 	/******************** SvcToNew ******************/
 	prefixold := "/old-to-new"
 	hk.GroupRoutes(prefixold+"/v1/patient", r, oauth.OldGuardMW, hk.MapHandlerFunc{

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

@@ -0,0 +1,194 @@
+package doctor
+
+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 = "division"
+
+//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/doctor/helper.go

@@ -0,0 +1,54 @@
+/*
+DESCRIPTION:
+Any functions that are used internally by the use-case
+*/
+package doctor
+
+import (
+	"encoding/json"
+	erc "simrs-vx/internal/domain/references/common"
+	
+	esync "simrs-vx/internal/domain/sync-entities/doctor"
+	esyncLog "simrs-vx/internal/domain/sync-entities/log"
+)
+
+//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.DoctorSimxLog) {
+	// 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.DoctorLink) {
+	data.Simx_Id = simxId
+	data.Simgos_Id = simgosId
+	return
+}

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

@@ -0,0 +1,186 @@
+package doctor
+
+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"
+	
+	esync "simrs-vx/internal/domain/sync-entities/doctor"
+	esynclog "simrs-vx/internal/domain/sync-entities/log"
+)
+
+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.DoctorLink, 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.DoctorLink, error) {
+	pl.SetLogInfo(event, simxId, "started", "DBReadDetail")
+	data := esync.DoctorLink{}
+
+	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.DoctorLink, 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

@@ -0,0 +1,136 @@
+package doctor
+
+import (
+	"bytes"
+	"encoding/json"
+	"io"
+	"net/http"
+	cfg "simrs-vx/internal/infra/sync-cfg"
+	pl "simrs-vx/pkg/logger"
+	"strconv"
+
+	db "simrs-vx/pkg/dualtrx-helper"
+
+	erg "simrs-vx/internal/domain/references/organization"
+
+	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/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 {
+	tx := db.NewTx()
+	var users []User
+
+	err := tx.Simgos.Table("m_dokter").
+		Select(`
+			m_dokter.*,
+			l.*,
+			p.*
+		`).
+		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).
+		Order(`m_dokter.kddokter DESC`).
+		Limit(10).
+		Scan(&users).Error
+
+	if err != nil {
+		return err
+	}
+
+	// mapping
+	doctorsimx := []es.CreateDto{}
+	for i, d := range users {
+		kddokter := strconv.Itoa(int(d.Doctor.Kddokter))
+		doctorsimx = append(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,
+					BirthPlace: &d.Employee.TempatLahir,
+				},
+			},
+			Employee: &es.EmployeUpdateDto{
+				Position_Code: erg.EPCDoc,
+			},
+		})
+
+		// create request body
+		jsonUser, err := json.Marshal(doctorsimx[i])
+		if err != nil {
+			return err
+		}
+
+		reqBody := bytes.NewBuffer(jsonUser)
+		// send data to main-api
+		resp, err := send(http.MethodPost, path, reqBody, "von")
+		if err != nil {
+			return 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 err
+		}
+
+		if _, err := ud.CreateLinkData(data.Data.Id, d.Doctor.Kddokter, &pl.Event{}); err != nil {
+			return err
+		}
+	}
+
+	return nil
+
+}
+
+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()
+	respBody, _ := io.ReadAll(resp.Body)
+	return respBody, nil
+}