Merge pull request #182 from dikstub-rssa/feat/sync-from-simgos-161

merge old-to-new/patient
This commit is contained in:
vaniliacahya
2025-12-03 13:27:23 +07:00
committed by GitHub
7 changed files with 595 additions and 2 deletions
@@ -0,0 +1,165 @@
package patient
import (
"bytes"
"encoding/json"
"fmt"
"io"
"net/http"
cfg "simrs-vx/internal/infra/sync-cfg"
pl "simrs-vx/pkg/logger"
e "simrs-vx/internal/domain/main-entities/patient"
un "simrs-vx/internal/use-case/simgos-sync-use-case/new/patient"
d "github.com/karincake/dodol"
)
const source = "old-to-new-patient"
var path = "patient"
func Create(input e.Patient) (*d.Data, error) {
evt := pl.Event{
Feature: "Create",
Source: source,
}
pl.SetLogInfo(&evt, input, "started", "create")
// create request body
jsonPatient, err := json.Marshal(input)
if err != nil {
return nil, pl.SetLogError(&evt, input)
}
reqBody := bytes.NewBuffer(jsonPatient)
// send data to main-api
resp, err := send(http.MethodPost, path, reqBody, *input.RegisteredBy_User_Name)
if err != nil {
return nil, pl.SetLogError(&evt, input)
}
// getting response
var data MainApiResp
err = json.Unmarshal(resp, &data)
if err != nil {
return nil, pl.SetLogError(&evt, string(resp))
}
// create PatientLink
un.CreateLinkData(data.Data.Id, input.Id, &evt)
pl.SetLogInfo(&evt, nil, "complete")
return &d.Data{
Meta: d.II{
"source": source,
"structure": "single-data",
"status": "created",
},
Data: input.ToResponse(),
}, nil
}
func Update(input e.Patient) (*d.Data, error) {
evt := pl.Event{
Feature: "Update",
Source: source,
}
pl.SetLogInfo(&evt, input, "started", "update")
// get patient link from database
patientLink, err := ReadDetailLinkData(input.Id)
if err != nil {
return nil, pl.SetLogError(&evt, input)
}
// get data patient from main-api
resp, err := send(http.MethodGet, fmt.Sprintf("%s%v", "patient/", patientLink.Simx_Id), nil, *input.RegisteredBy_User_Name)
if err != nil {
return nil, pl.SetLogError(&evt, input)
}
// unpack data from resp
var respData MainApiResp
err = json.Unmarshal(resp, &respData)
if err != nil {
return nil, pl.SetLogError(&evt, input)
}
// copy data from simgos m_patient to simx Patient
preserve := map[string]bool{
"Main.Id": true,
"Person.Id": true,
}
simxPatient := respData.Data
SetPatient(&simxPatient, &input, preserve)
jsonPatient, err := json.Marshal(simxPatient)
if err != nil {
return nil, pl.SetLogError(&evt, input)
}
// send data to main api
url := fmt.Sprintf("%s%v", "patient/", simxPatient.Id)
reqBody := bytes.NewBuffer(jsonPatient)
_, err = send(http.MethodPatch, url, reqBody, *input.RegisteredBy_User_Name)
if err != nil {
return nil, pl.SetLogError(&evt, input)
}
pl.SetLogInfo(&evt, nil, "complete")
return &d.Data{
Meta: d.II{
"source": source,
"structure": "single-data",
"status": "updated",
},
Data: input.ToResponse(),
}, nil
}
func Delete(input e.Patient) (*d.Data, error) {
evt := pl.Event{
Feature: "Delete",
Source: source,
}
pl.SetLogInfo(&evt, input, "started", "delete")
// get patient link from database
patientLink, err := ReadDetailLinkData(input.Id)
if err != nil {
return nil, err
}
_, err = send(http.MethodDelete, fmt.Sprintf("%s%v", "patient/", patientLink.Simx_Id), nil, *input.RegisteredBy_User_Name)
if err != nil {
return nil, err
}
return &d.Data{
Meta: d.II{
"source": source,
"structure": "single-data",
"status": "deleted",
},
Data: input.ToResponse(),
}, nil
}
func send(method string, endpoint string, body *bytes.Buffer, username string) ([]byte, error) {
var url string = cfg.O.NewHost + 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
}
@@ -0,0 +1,69 @@
package patient
import (
"reflect"
"strings"
)
func SetPatient(dst, src interface{}, preserve map[string]bool) {
dv := reflect.ValueOf(dst).Elem()
sv := reflect.ValueOf(src).Elem()
for i := 0; i < dv.NumField(); i++ {
f := dv.Type().Field(i)
fieldName := f.Name
// skip preserved fields
if preserve[fieldName] {
continue
}
df := dv.Field(i)
sf := sv.Field(i)
if !df.CanSet() {
// skip unexported skip
continue
}
switch df.Kind() {
case reflect.Struct:
nestedPreserve := map[string]bool{}
for key := range preserve {
if strings.HasPrefix(key, fieldName+".") {
nestedPreserve[strings.TrimPrefix(key, fieldName+".")] = true
}
}
SetPatient(df.Addr().Interface(), sf.Addr().Interface(), nestedPreserve)
case reflect.Pointer:
// Check if pointer points to a struct
if df.Type().Elem().Kind() == reflect.Struct {
if sf.IsNil() {
break
}
// If dest pointer is nil, allocate it
if df.IsNil() {
df.Set(reflect.New(df.Type().Elem()))
}
// Recurse into struct via Elem()
nestedPreserve := map[string]bool{}
for key := range preserve {
if strings.HasPrefix(key, fieldName+".") {
nestedPreserve[strings.TrimPrefix(key, fieldName+".")] = true
}
}
SetPatient(df.Elem().Addr().Interface(), sf.Elem().Addr().Interface(), nestedPreserve)
}
default:
// Overwrite only when src has non-zero value
if !sf.IsZero() {
df.Set(sf)
}
}
}
}
@@ -0,0 +1,19 @@
package patient
import (
esync "simrs-vx/internal/domain/sync-entities/patient"
dg "github.com/karincake/apem/db-gorm-pg"
)
func ReadDetailLinkData(simgosId uint) (*esync.PatientLink, error) {
// log event
var data esync.PatientLink
var tx = dg.I
if err := tx.Where("\"Simgos_Id\" = ?", simgosId).First(&data).Error; err != nil {
return nil, err
}
// log end event
return &data, nil
}
@@ -0,0 +1,14 @@
package patient
import e "simrs-vx/internal/domain/main-entities/patient"
type MainApiResp struct {
Meta MetaData `json:"meta"`
Data e.Patient `json:"data"`
}
type MetaData struct {
Source string `json:"source"`
Status string `json:"status"`
Structure string `json:"structure"`
}