munawwirul_jamal/simrsx-be
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

adjustment encounter

Browse Source
This commit is contained in:
vanilia
2025-11-04 10:26:11 +07:00
parent e88f891d03
commit 8a3a140cde
8 changed files with 403 additions and 67 deletions
Download Patch File Download Diff File Expand all files Collapse all files
internal/domain/main-entities/encounter/dto.go
+2 -8
View File
@@ -16,15 +16,11 @@ import (
// internal - domain - main-entities
evs "simrs-vx/internal/domain/bpjs-entities/vclaim-sep"
eam "simrs-vx/internal/domain/main-entities/ambulatory"
ea "simrs-vx/internal/domain/main-entities/appointment"
ed "simrs-vx/internal/domain/main-entities/doctor"
eem "simrs-vx/internal/domain/main-entities/emergency"
ee "simrs-vx/internal/domain/main-entities/employee"
ei "simrs-vx/internal/domain/main-entities/inpatient"
eir "simrs-vx/internal/domain/main-entities/internal-reference"
ep "simrs-vx/internal/domain/main-entities/patient"
er "simrs-vx/internal/domain/main-entities/rehab/base"
es "simrs-vx/internal/domain/main-entities/specialist"
ess "simrs-vx/internal/domain/main-entities/subspecialist"
eu "simrs-vx/internal/domain/main-entities/unit"
@@ -52,10 +48,8 @@ type CreateDto struct {
Appointment_Id *uint `json:"appointment_id"`
RefTypeCode ere.RefTypeCode `json:"refTypeCode"`
NewStatus bool `json:"newStatus"`
Ambulatory *eam.CreateDto `json:"ambulatory"`
Emergency *eem.CreateDto `json:"emergency"`
Inpatient *ei.Inpatient `json:"inpatient"`
Rehab *er.Basic `json:"rehab"`
VisitMode_Code *ere.VisitModeCode `json:"visitMode_code"` // if subClass_Code is rehab
AllocatedVisitCount *int `json:"allocatedVisitCount"`
pa.AuthInfo
}
internal/interface/main-handler/encounter/handler.go
+5
View File
@@ -26,10 +26,15 @@ func (obj myBase) Create(w http.ResponseWriter, r *http.Request) {
if err != nil {
rw.WriteJSON(w, http.StatusUnauthorized, d.IS{"message": err.Error()}, nil)
}
dto := e.CreateDto{}
if res := rw.ValidateStructByIOR(w, r.Body, &dto); !res {
return
}
if valid := validateRequestCreate(w, dto); !valid {
return
}
dto.AuthInfo = *authInfo
res, err := u.Create(dto)
rw.DataResponse(w, res, err)
internal/interface/main-handler/encounter/request-validation.go
+10 -15
View File
@@ -67,22 +67,17 @@ func validateRequestCheckIn(w http.ResponseWriter, i e.CheckinDto) (valid bool)
func validateRequestCreate(w http.ResponseWriter, i e.CreateDto) (valid bool) {
switch {
case i.Class_Code == ere.ECAmbulatory:
if i.Ambulatory == nil {
rw.DataResponse(w, nil, d.FieldError{
Code: dataValidationFail,
Message: "ambulatory required",
})
// field allocatedVisitCount required if ambulatory visitMode_Code is adm
if ere.AmbulatoryClassCode(*i.SubClass_Code) == ere.ACCRme && *i.VisitMode_Code == ere.VMCAdm {
if *i.AllocatedVisitCount == 0 {
rw.DataResponse(w, nil, d.FieldError{
Code: dataValidationFail,
Message: "allocatedVisitCount required",
})
return
}
}
}
if i.Class_Code == ere.ECAmbulatory && i.Ambulatory.Class_Code == ere.ACCRme && i.Ambulatory.VisitMode_Code == ere.VMCAdm {
if *i.Rehab.AllocatedVisitCount == 0 {
rw.DataResponse(w, nil, d.FieldError{
Code: dataValidationFail,
Message: "rehab.AllocatedVisitCode required",
})
return
}
}
return
return true
}
internal/use-case/main-use-case/ambulatory/helper.go
+1
View File
@@ -22,6 +22,7 @@ func setData[T *e.CreateDto | *e.UpdateDto](input T, data *e.Ambulatory) {
data.Encounter_Id = inputSrc.Encounter_Id
data.Class_Code = inputSrc.Class_Code
data.VisitMode_Code = inputSrc.VisitMode_Code
}
func CheckClassCode(input *string) (ere.AmbulatoryClassCode, error) {
internal/use-case/main-use-case/encounter/case.go
+104 -44
View File
@@ -25,6 +25,7 @@ import (
eem "simrs-vx/internal/domain/main-entities/employee"
e "simrs-vx/internal/domain/main-entities/encounter"
ei "simrs-vx/internal/domain/main-entities/inpatient"
er "simrs-vx/internal/domain/main-entities/rehab"
erdh "simrs-vx/internal/domain/main-entities/responsible-doctor-hist"
es "simrs-vx/internal/domain/main-entities/soapi"
@@ -36,6 +37,7 @@ import (
ue "simrs-vx/internal/use-case/main-use-case/emergency"
uem "simrs-vx/internal/use-case/main-use-case/employee"
ui "simrs-vx/internal/use-case/main-use-case/inpatient"
ur "simrs-vx/internal/use-case/main-use-case/rehab"
urdh "simrs-vx/internal/use-case/main-use-case/responsible-doctor-hist"
us "simrs-vx/internal/use-case/main-use-case/soapi"
)
@@ -46,6 +48,7 @@ var now = time.Now()
func Create(input e.CreateDto) (*d.Data, error) {
data := e.Encounter{}
createSoapi := []es.CreateDto{}
event := pl.Event{
Feature: "Create",
@@ -55,6 +58,33 @@ func Create(input e.CreateDto) (*d.Data, error) {
// Start log
pl.SetLogInfo(&event, input, "started", "create")
// validate SubClass
var subCode interface{}
subCode, err := verifyClassCode(input)
if err != nil {
return nil, err
}
// verify whether the allocated visit count has not exceeded the limit
if input.Class_Code == ere.ECAmbulatory && subCode.(ere.AmbulatoryClassCode) == ere.ACCRme &&
*input.VisitMode_Code == ere.VMCSeries {
dataEncounter, valid, err := verifyAllocatedVisitCount(input, &event)
if err != nil {
return nil, err
}
if !valid {
return nil, err
}
// get data soapi
createSoapi, err = getSoapiEncounterAdm(dataEncounter, &event)
if err != nil {
return nil, err
}
}
// check if patient is new in the hospital
dataPatient, err := ReadList(e.ReadListDto{
FilterDto: e.FilterDto{Patient_Id: input.Patient_Id},
@@ -62,7 +92,6 @@ func Create(input e.CreateDto) (*d.Data, error) {
if err != nil {
return nil, err
}
if list, ok := dataPatient.Data.([]e.ResponseDto); ok {
if len(list) < 1 {
input.NewStatus = true
@@ -83,6 +112,7 @@ func Create(input e.CreateDto) (*d.Data, error) {
input.Adm_Employee_Id = &emp.Id
}
// create encounter
if resData, err := CreateData(input, &event, tx); err != nil {
return err
} else {
@@ -91,52 +121,57 @@ func Create(input e.CreateDto) (*d.Data, error) {
switch input.Class_Code {
case ere.ECAmbulatory:
subCode, err := ua.CheckClassCode(input.SubClass_Code)
if err != nil {
return err
}
subCodeAmbulatory := subCode.(ere.AmbulatoryClassCode)
ambCreate := ea.CreateDto{
Encounter_Id: &data.Id,
Class_Code: subCode,
Encounter_Id: &data.Id,
Class_Code: subCodeAmbulatory,
VisitMode_Code: *input.VisitMode_Code,
}
_, err = ua.CreateData(ambCreate, &event, tx)
if err != nil {
return err
}
if subCode == ere.ACCCac || subCode == ere.ACCCad {
if subCodeAmbulatory == ere.ACCCac || subCodeAmbulatory == ere.ACCCad {
chemoCreate := ec.CreateDto{
Encounter_Id: &data.Id,
Status_Code: erc.DVCNew,
SrcUnit_Id: input.Unit_Id,
}
_, err = uc.CreateData(chemoCreate, &event, tx)
if err != nil {
return err
}
}
case ere.ECEmergency:
subCode, err := ue.CheckClassCode(input.SubClass_Code)
if err != nil {
return err
if subCodeAmbulatory == ere.ACCRme && *input.VisitMode_Code == ere.VMCAdm {
// create data rehab
if _, err = ur.CreateData(er.CreateDto{
Encounter_Id: &data.Id,
Doctor_Id: input.Appointment_Doctor_Id,
AllocatedVisitCount: input.AllocatedVisitCount}, &event, tx); err != nil {
return err
}
} else if subCodeAmbulatory == ere.ACCRme && *input.VisitMode_Code == ere.VMCSeries {
// Insert Soapi
if err = us.CreateBulkData(createSoapi, data.Id, &event, tx); err != nil {
return err
}
}
case ere.ECEmergency:
emerCreate := ee.CreateDto{
Encounter_Id: &data.Id,
Class_Code: subCode,
Class_Code: subCode.(ere.EmergencyClassCode),
}
_, err = ue.CreateData(emerCreate, &event, tx)
if err != nil {
return err
}
case ere.ECInpatient:
subCode, err := ui.CheckClassCode(input.SubClass_Code)
if err != nil {
return err
}
inpCreate := ei.CreateDto{
Encounter_Id: &data.Id,
Class_Code: subCode,
Class_Code: subCode.(ere.InpatientClassCode),
Infra_Id: input.Infra_Id,
}
_, err = ui.CreateData(inpCreate, &event, tx)
@@ -148,11 +183,10 @@ func Create(input e.CreateDto) (*d.Data, error) {
}
// insert adm_employee_hist
if _, err := uaeh.Create(eaeh.CreateDto{
if _, err := uaeh.CreateData(eaeh.CreateDto{
Encounter_Id: &data.Main.Id,
Employee_Id: data.Adm_Employee_Id,
StartedAt: &now,
}); err != nil {
StartedAt: &now}, &event, tx); err != nil {
return err
}
@@ -430,8 +464,16 @@ func CheckOut(input e.DischargeDto) (*d.Data, error) {
return pl.SetLogError(&event, input)
}
if err := checkSoapiByDocExists(data.Id, &event, tx); err != nil {
return err
if data.Class_Code == ere.ECAmbulatory {
// validate if soapi exist
err = getSoapiByTypeCode(input.Id, &event, "check-out")
if err != nil {
return err
}
} else {
if err := checkSoapiByDocExists(data.Id, &event, tx); err != nil {
return err
}
}
if err := updateDischargeData(input, data, &event, tx); err != nil {
@@ -557,7 +599,7 @@ func UpdateStatusCode(input e.UpdateStatusDto) (*d.Data, error) {
}
func CheckIn(input e.CheckinDto) (*d.Data, error) {
rdDto := e.ReadDetailDto{Id: uint16(input.Id)}
rdDto := e.ReadDetailDto{Id: uint16(input.Id), Includes: "Rehab"}
var data *e.Encounter
var err error
@@ -580,23 +622,11 @@ func CheckIn(input e.CheckinDto) (*d.Data, error) {
}
// validate if soapi exist
dataSoapi, err := us.ReadList(es.ReadListDto{FilterDto: es.FilterDto{Encounter_Id: &input.Id}})
err = getSoapiByTypeCode(input.Id, &event, "check-in")
if err != nil {
return nil, err
}
if list, ok := dataSoapi.Data.([]es.ResponseDto); ok {
if len(list) > 0 {
event.Status = "failed"
event.ErrInfo = pl.ErrorInfo{
Code: "data-state-mismatch",
Detail: "soapi already exist",
Raw: errors.New("soapi already exist"),
}
return nil, pl.SetLogError(&event, input)
}
}
err = dg.I.Transaction(func(tx *gorm.DB) error {
pl.SetLogInfo(&event, rdDto, "started", "DBReadDetail")
if data, err = ReadDetailData(rdDto, &event, tx); err != nil {
@@ -621,11 +651,10 @@ func CheckIn(input e.CheckinDto) (*d.Data, error) {
}
//insert responsible_doctor_hist
if _, err = urdh.Create(erdh.CreateDto{
if _, err = urdh.CreateData(erdh.CreateDto{
Encounter_Id: &input.Id,
Doctor_Id: input.Responsible_Doctor_Id,
StartedAt: input.StartedAt,
}); err != nil {
StartedAt: input.StartedAt}, &event, tx); err != nil {
return err
}
}
@@ -638,11 +667,10 @@ func CheckIn(input e.CheckinDto) (*d.Data, error) {
}
// insert responsible_doctor_hist
if _, err = uaeh.Create(eaeh.CreateDto{
if _, err = uaeh.CreateData(eaeh.CreateDto{
Encounter_Id: &input.Id,
Employee_Id: input.Adm_Employee_Id,
StartedAt: input.StartedAt,
}); err != nil {
StartedAt: input.StartedAt}, &event, tx); err != nil {
return err
}
}
@@ -652,6 +680,15 @@ func CheckIn(input e.CheckinDto) (*d.Data, error) {
return err
}
if err := updateRehabDoctor(er.UpdateDto{
CreateDto: er.CreateDto{
Encounter_Id: &data.Id,
Doctor_Id: input.Responsible_Doctor_Id,
},
}, &event, tx); err != nil {
return err
}
pl.SetLogInfo(&event, nil, "complete")
return nil
@@ -688,3 +725,26 @@ func validateForeignKey(input e.CheckinDto) error {
return nil
}
func verifyClassCode(input e.CreateDto) (subCode interface{}, err error) {
switch input.Class_Code {
case ere.ECAmbulatory:
subCode, err = ua.CheckClassCode(input.SubClass_Code)
if err != nil {
return nil, err
}
case ere.ECEmergency:
subCode, err = ue.CheckClassCode(input.SubClass_Code)
if err != nil {
return nil, err
}
case ere.ECInpatient:
subCode, err = ui.CheckClassCode(input.SubClass_Code)
if err != nil {
return nil, err
}
default:
return nil, errors.New("invalid encounter class code")
}
return
}
internal/use-case/main-use-case/encounter/lib.go
+245
View File
@@ -3,6 +3,12 @@ package encounter
import (
// std
"errors"
"fmt"
erc "simrs-vx/internal/domain/references/clinical"
ere "simrs-vx/internal/domain/references/encounter"
ero "simrs-vx/internal/domain/references/organization"
"strings"
// external
dg "github.com/karincake/apem/db-gorm-pg"
gh "github.com/karincake/getuk"
@@ -15,8 +21,11 @@ import (
// internal
eaeh "simrs-vx/internal/domain/main-entities/adm-employee-hist"
ea "simrs-vx/internal/domain/main-entities/ambulatory"
e "simrs-vx/internal/domain/main-entities/encounter"
er "simrs-vx/internal/domain/main-entities/rehab"
erdh "simrs-vx/internal/domain/main-entities/responsible-doctor-hist"
es "simrs-vx/internal/domain/main-entities/soapi"
)
func CreateData(input e.CreateDto, event *pl.Event, dbx ...*gorm.DB) (*e.Encounter, error) {
@@ -333,3 +342,239 @@ func updateLatestAdmEmployeeHist(input e.CheckinDto, event *pl.Event, dbx ...*go
pl.SetLogInfo(event, nil, "complete")
return nil
}
func verifyAllocatedVisitCount(i e.CreateDto, event *pl.Event) (e.Encounter, bool, error) {
pl.SetLogInfo(event, nil, "started", "DBGetRecentEncounterAdm")
var (
tx = dg.I
recentEncounterAdm e.Encounter
countEncounterSeries int64
)
err := tx.
Scopes(gh.Preload("Rehab,Responsible_Doctor")).
Joins("JOIN \"Ambulatory\" ON \"Ambulatory\".\"Encounter_Id\" = \"Encounter\".\"Id\"").
Where("\"Patient_Id\" = ?", i.Patient_Id).
Where("\"Ambulatory\".\"Class_Code\" = ? AND \"Ambulatory\".\"VisitMode_Code\" = ?", ere.ACCRme, ere.VMCAdm).
Order("\"CreatedAt\" DESC").
First(&recentEncounterAdm).Error
if err != nil {
event.Status = "failed"
event.ErrInfo = pl.ErrorInfo{
Code: "read-recentEncounter-fail",
Detail: "Database read failed",
Raw: err,
}
return e.Encounter{}, false, pl.SetLogError(event, i)
}
err = tx.
Model(&e.Encounter{}).
Joins("JOIN \"Ambulatory\" ON \"Ambulatory\".\"Encounter_Id\" = \"Encounter\".\"Id\"").
Where("\"Patient_Id\" = ?", i.Patient_Id).
Where("\"Ambulatory\".\"Class_Code\" = ? AND \"Ambulatory\".\"VisitMode_Code\" = ?", ere.ECAmbulatory, ere.VMCSeries).
Where("\"CreatedAt\" > ?", recentEncounterAdm.CreatedAt).
Count(&countEncounterSeries).Error
if err != nil {
event.Status = "failed"
event.ErrInfo = pl.ErrorInfo{
Code: "read-countEncounter-fail",
Detail: "Database read failed",
Raw: err,
}
return e.Encounter{}, false, pl.SetLogError(event, i)
}
return recentEncounterAdm, countEncounterSeries < int64(*recentEncounterAdm.Rehab.AllocatedVisitCount), nil
}
func getSoapiEncounterAdm(enc e.Encounter, event *pl.Event) (dataSoapi []es.CreateDto, err error) {
var data []es.Soapi
pl.SetLogInfo(event, enc, "started", "DBReadList")
if enc.Responsible_Doctor == nil {
event.Status = "failed"
event.ErrInfo = pl.ErrorInfo{
Code: "no responsible-doctor found",
Detail: "Encounter does not have responsible-doctor",
}
}
err = dg.I.
Model(&es.Soapi{}).
Joins("JOIN \"Employee\" ON \"Employee\".\"Id\" = \"Soapi\".\"Employee_Id\"").
Where("\"Encounter_Id\" = ?", enc.Id).
Where("\"Employee\".\"Position_Code\" = ?", ero.EPCDoc).
Where("\"Soapi\".\"TypeCode\" IN ?", []erc.SoapiTypeCode{erc.STCEEarlyMedic, erc.STCFunc}).
Where("\"Soapi\".\"Employee_Id\" = ?", *enc.Responsible_Doctor.Employee_Id).
Find(&data).Error
if err != nil {
event.Status = "failed"
event.ErrInfo = pl.ErrorInfo{
Raw: err,
}
if errors.Is(err, gorm.ErrRecordNotFound) {
event.ErrInfo.Code = "data-not-found"
event.ErrInfo.Detail = "Data not found"
return nil, pl.SetLogError(event, enc)
}
event.ErrInfo.Code = "read-fail"
event.ErrInfo.Detail = "Database read failed"
return nil, pl.SetLogError(event, enc)
}
pl.SetLogInfo(event, nil, "complete")
for _, s := range data {
// set data soapi for copy
dataSoapi = append(dataSoapi, es.CreateDto{
Employee_Id: s.Employee_Id,
Time: s.Time,
TypeCode: s.TypeCode,
Value: s.Value,
})
}
if len(dataSoapi) < 2 {
event.Status = "failed"
event.ErrInfo = pl.ErrorInfo{
Code: "missing-soapi",
Detail: fmt.Sprintf("Missing required Soapi types"),
}
return nil, pl.SetLogError(event, enc)
}
return
}
func getSoapiByTypeCode(encounterId uint, event *pl.Event, mode string) (err error) {
pl.SetLogInfo(event, encounterId, "started", "DBReadList")
var (
dataAmbulatory ea.Ambulatory
dataSoapi []es.Soapi
)
// Get Data Ambulatory
if err = dg.I.
Where("\"Encounter_Id\" = ?", encounterId).
First(&dataAmbulatory).Error; err != nil {
return setDBError(event, err, encounterId)
}
// Set Query for get data Soapi
tx := dg.I.
Model(&es.Soapi{}).
Joins("JOIN \"Employee\" ON \"Employee\".\"Id\" = \"Soapi\".\"Employee_Id\"").
Where("\"Encounter_Id\" = ?", encounterId).
Where("\"Employee\".\"Position_Code\" = ?", ero.EPCDoc)
// Set Case
switch {
case dataAmbulatory.Class_Code == ere.ACCReg:
tx = tx.Where("\"Soapi\".\"TypeCode\" = ?", erc.STCEEarlyMedic)
case dataAmbulatory.Class_Code == ere.ACCRme && dataAmbulatory.VisitMode_Code == ere.VMCAdm:
tx = tx.Where("\"Soapi\".\"TypeCode\" IN ?", []erc.SoapiTypeCode{erc.STCEEarlyMedic, erc.STCFunc})
case dataAmbulatory.Class_Code == ere.ACCRme && dataAmbulatory.VisitMode_Code == ere.VMCSeries:
tx = tx.Where("\"Soapi\".\"TypeCode\" = ?", erc.STCEarlyRehab)
}
if err = tx.Find(&dataSoapi).Error; err != nil {
return setDBError(event, err, encounterId)
}
pl.SetLogInfo(event, nil, "complete")
return validateExistedSoapi(dataSoapi, &dataAmbulatory, event, mode)
}
func validateExistedSoapi(dataSoapi []es.Soapi, dataAmbulatory *ea.Ambulatory, event *pl.Event, mode string) error {
typeExist := make(map[erc.SoapiTypeCode]bool)
for _, s := range dataSoapi {
typeExist[s.TypeCode] = true
}
required := []erc.SoapiTypeCode{}
switch {
case dataAmbulatory.Class_Code == ere.ACCReg:
required = []erc.SoapiTypeCode{erc.STCEEarlyMedic}
case dataAmbulatory.Class_Code == ere.ACCRme && dataAmbulatory.VisitMode_Code == ere.VMCAdm:
required = []erc.SoapiTypeCode{erc.STCEEarlyMedic, erc.STCEarlyRehab, erc.STCFunc}
case dataAmbulatory.Class_Code == ere.ACCRme && dataAmbulatory.VisitMode_Code == ere.VMCSeries:
required = []erc.SoapiTypeCode{erc.STCEarlyRehab}
}
var missing, existing []string
for _, code := range required {
if typeExist[code] {
existing = append(existing, string(code))
} else {
missing = append(missing, string(code))
}
}
switch mode {
case "check-in":
if len(existing) > 0 {
return setSoapiError(event, fmt.Sprintf("Soapi type(s) %s exist, can't check-in", strings.Join(existing, ", ")))
}
case "check-out":
if len(missing) > 0 {
return setSoapiError(event, fmt.Sprintf("Soapi type(s) %s not found, can't check-out", strings.Join(missing, ", ")))
}
}
return nil
}
func setSoapiError(event *pl.Event, detail string) error {
event.Status = "failed"
event.ErrInfo = pl.ErrorInfo{
Code: "invalid-soapi-state",
Detail: detail,
}
return pl.SetLogError(event, detail)
}
func setDBError(event *pl.Event, err error, ctx any) error {
event.Status = "failed"
event.ErrInfo = pl.ErrorInfo{
Raw: err,
Code: "read-fail",
Detail: "Database read failed",
}
return pl.SetLogError(event, ctx)
}
func updateRehabDoctor(input er.UpdateDto, event *pl.Event, dbx ...*gorm.DB) error {
pl.SetLogInfo(event, "started", "DBUpdate")
var tx *gorm.DB
if len(dbx) > 0 {
tx = dbx[0]
} else {
tx = dg.I
}
result := tx.
Model(&er.Rehab{}).
Where("\"Encounter_Id\" = (?)", input.Encounter_Id).
Update("\"Doctor_Id\"", input.Doctor_Id)
if result.Error != nil {
event.Status = "failed"
event.ErrInfo = pl.ErrorInfo{
Code: "data-update-fail",
Detail: "Database update failed",
Raw: result.Error,
}
return pl.SetLogError(event, input)
}
pl.SetLogInfo(event, nil, "complete")
return nil
}
internal/use-case/main-use-case/soapi/helper.go
+16
View File
@@ -23,3 +23,19 @@ func setData[T *e.CreateDto | *e.UpdateDto](input T, data *e.Soapi) {
data.TypeCode = inputSrc.TypeCode
data.Value = inputSrc.Value
}
func setBulkData(input []e.CreateDto, encounterId uint) []e.Soapi {
var data []e.Soapi
for _, v := range input {
data = append(data, e.Soapi{
Encounter_Id: &encounterId,
Employee_Id: v.Employee_Id,
Time: v.Time,
TypeCode: v.TypeCode,
Value: v.Value,
})
}
return data
}
internal/use-case/main-use-case/soapi/lib.go
+20
View File
@@ -138,3 +138,23 @@ func DeleteData(data *e.Soapi, event *pl.Event, dbx ...*gorm.DB) error {
pl.SetLogInfo(event, nil, "complete")
return nil
}
func CreateBulkData(input []e.CreateDto, encounterId uint, event *pl.Event, dbx ...*gorm.DB) error {
pl.SetLogInfo(event, nil, "started", "DBCreate")
data := setBulkData(input, encounterId)
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
}