vanilia
690 lines
16 KiB
Go
690 lines
16 KiB
Go
package encounter
|
|
|
|
import (
|
|
"errors"
|
|
authhelper "simrs-vx/internal/lib/auth"
|
|
"strconv"
|
|
"time"
|
|
|
|
dg "github.com/karincake/apem/db-gorm-pg"
|
|
d "github.com/karincake/dodol"
|
|
"gorm.io/gorm"
|
|
|
|
pl "simrs-vx/pkg/logger"
|
|
pu "simrs-vx/pkg/use-case-helper"
|
|
|
|
erc "simrs-vx/internal/domain/references/common"
|
|
ere "simrs-vx/internal/domain/references/encounter"
|
|
|
|
eaeh "simrs-vx/internal/domain/main-entities/adm-employee-hist"
|
|
ea "simrs-vx/internal/domain/main-entities/ambulatory"
|
|
ec "simrs-vx/internal/domain/main-entities/chemo"
|
|
edc "simrs-vx/internal/domain/main-entities/death-cause"
|
|
ed "simrs-vx/internal/domain/main-entities/doctor"
|
|
ee "simrs-vx/internal/domain/main-entities/emergency"
|
|
eem "simrs-vx/internal/domain/main-entities/employee"
|
|
e "simrs-vx/internal/domain/main-entities/encounter"
|
|
ei "simrs-vx/internal/domain/main-entities/inpatient"
|
|
erdh "simrs-vx/internal/domain/main-entities/responsible-doctor-hist"
|
|
es "simrs-vx/internal/domain/main-entities/soapi"
|
|
|
|
uaeh "simrs-vx/internal/use-case/main-use-case/adm-employee-hist"
|
|
ua "simrs-vx/internal/use-case/main-use-case/ambulatory"
|
|
uc "simrs-vx/internal/use-case/main-use-case/chemo"
|
|
udc "simrs-vx/internal/use-case/main-use-case/death-cause"
|
|
ud "simrs-vx/internal/use-case/main-use-case/doctor"
|
|
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"
|
|
urdh "simrs-vx/internal/use-case/main-use-case/responsible-doctor-hist"
|
|
us "simrs-vx/internal/use-case/main-use-case/soapi"
|
|
)
|
|
|
|
const source = "encounter"
|
|
|
|
var now = time.Now()
|
|
|
|
func Create(input e.CreateDto) (*d.Data, error) {
|
|
data := e.Encounter{}
|
|
|
|
event := pl.Event{
|
|
Feature: "Create",
|
|
Source: source,
|
|
}
|
|
|
|
// Start log
|
|
pl.SetLogInfo(&event, input, "started", "create")
|
|
|
|
// check if patient is new in the hospital
|
|
dataPatient, err := ReadList(e.ReadListDto{
|
|
FilterDto: e.FilterDto{Patient_Id: input.Patient_Id},
|
|
AuthInfo: authhelper.AuthInfo{User_Id: input.User_Id}})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if list, ok := dataPatient.Data.([]e.ResponseDto); ok {
|
|
if len(list) < 1 {
|
|
input.NewStatus = true
|
|
}
|
|
}
|
|
|
|
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 emp, err := uem.ReadDetailData(eem.ReadDetailDto{User_Id: &input.AuthInfo.User_Id}, &event, tx); err != nil {
|
|
return err
|
|
} else {
|
|
input.Adm_Employee_Id = &emp.Id
|
|
}
|
|
|
|
if resData, err := CreateData(input, &event, tx); err != nil {
|
|
return err
|
|
} else {
|
|
data = *resData
|
|
}
|
|
|
|
switch input.Class_Code {
|
|
case ere.ECAmbulatory:
|
|
subCode, err := ua.CheckClassCode(input.SubClass_Code)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
ambCreate := ea.CreateDto{
|
|
Encounter_Id: &data.Id,
|
|
Class_Code: subCode,
|
|
}
|
|
_, err = ua.CreateData(ambCreate, &event, tx)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if subCode == ere.ACCChemo {
|
|
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
|
|
}
|
|
emerCreate := ee.CreateDto{
|
|
Encounter_Id: &data.Id,
|
|
Class_Code: subCode,
|
|
}
|
|
_, 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,
|
|
Infra_Id: input.Infra_Id,
|
|
}
|
|
_, err = ui.CreateData(inpCreate, &event, tx)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
default:
|
|
return errors.New("invalid encounter class code")
|
|
}
|
|
|
|
// insert adm_employee_hist
|
|
if _, err := uaeh.Create(eaeh.CreateDto{
|
|
Encounter_Id: &data.Main.Id,
|
|
Employee_Id: data.Adm_Employee_Id,
|
|
StartedAt: &now,
|
|
}); err != nil {
|
|
return err
|
|
}
|
|
|
|
mwRunner.setMwType(pu.MWTPost)
|
|
// Run post-middleware
|
|
if err := mwRunner.RunCreateMiddleware(createPostMw, &input, &data); err != nil {
|
|
return err
|
|
}
|
|
|
|
pl.SetLogInfo(&event, nil, "complete")
|
|
|
|
return nil
|
|
})
|
|
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return &d.Data{
|
|
Meta: d.II{
|
|
"source": source,
|
|
"structure": "single-data",
|
|
"status": "created",
|
|
},
|
|
Data: data.ToResponse(),
|
|
}, nil
|
|
}
|
|
|
|
func ReadList(input e.ReadListDto) (*d.Data, error) {
|
|
var data *e.Encounter
|
|
var dataList []e.Encounter
|
|
var metaList *e.MetaDto
|
|
var err error
|
|
|
|
event := pl.Event{
|
|
Feature: "ReadList",
|
|
Source: source,
|
|
}
|
|
|
|
// Start log
|
|
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
|
|
})
|
|
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return &d.Data{
|
|
Meta: d.IS{
|
|
"source": source,
|
|
"structure": "list-data",
|
|
"status": "fetched",
|
|
"page_number": strconv.Itoa(metaList.PageNumber),
|
|
"page_size": strconv.Itoa(metaList.PageSize),
|
|
"record_totalCount": strconv.Itoa(metaList.Count),
|
|
"record_currentCount": strconv.Itoa(len(dataList)),
|
|
},
|
|
Data: e.ToResponseList(dataList),
|
|
}, nil
|
|
}
|
|
|
|
func ReadDetail(input e.ReadDetailDto) (*d.Data, error) {
|
|
var data *e.Encounter
|
|
var err error
|
|
|
|
event := pl.Event{
|
|
Feature: "ReadDetail",
|
|
Source: source,
|
|
}
|
|
|
|
// Start log
|
|
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
|
|
})
|
|
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return &d.Data{
|
|
Meta: d.IS{
|
|
"source": source,
|
|
"structure": "single-data",
|
|
"status": "fetched",
|
|
},
|
|
Data: data.ToResponse(),
|
|
}, nil
|
|
}
|
|
|
|
func Update(input e.UpdateDto) (*d.Data, error) {
|
|
rdDto := e.ReadDetailDto{Id: uint16(input.Id)}
|
|
var data *e.Encounter
|
|
var err error
|
|
|
|
event := pl.Event{
|
|
Feature: "Update",
|
|
Source: source,
|
|
}
|
|
|
|
// Start log
|
|
pl.SetLogInfo(&event, input, "started", "update")
|
|
|
|
err = dg.I.Transaction(func(tx *gorm.DB) error {
|
|
pl.SetLogInfo(&event, rdDto, "started", "DBReadDetail")
|
|
if data, err = ReadDetailData(rdDto, &event, tx); err != nil {
|
|
return err
|
|
}
|
|
|
|
if data.IsDone() {
|
|
event.Status = "failed"
|
|
event.ErrInfo = pl.ErrorInfo{
|
|
Code: "data-state-mismatch",
|
|
Detail: "encounter is done",
|
|
Raw: errors.New("encounter is done"),
|
|
}
|
|
return pl.SetLogError(&event, input)
|
|
}
|
|
|
|
mwRunner := newMiddlewareRunner(&event, tx)
|
|
mwRunner.setMwType(pu.MWTPre)
|
|
// Run pre-middleware
|
|
if err := mwRunner.RunUpdateMiddleware(readDetailPreMw, &rdDto, data); err != nil {
|
|
return err
|
|
}
|
|
|
|
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 {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
})
|
|
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return &d.Data{
|
|
Meta: d.IS{
|
|
"source": source,
|
|
"structure": "single-data",
|
|
"status": "updated",
|
|
},
|
|
Data: data.ToResponse(),
|
|
}, nil
|
|
|
|
}
|
|
|
|
func Delete(input e.DeleteDto) (*d.Data, error) {
|
|
rdDto := e.ReadDetailDto{Id: uint16(input.Id)}
|
|
var data *e.Encounter
|
|
var err error
|
|
|
|
event := pl.Event{
|
|
Feature: "Delete",
|
|
Source: source,
|
|
}
|
|
|
|
// Start log
|
|
pl.SetLogInfo(&event, input, "started", "delete")
|
|
|
|
err = dg.I.Transaction(func(tx *gorm.DB) error {
|
|
pl.SetLogInfo(&event, rdDto, "started", "DBReadDetail")
|
|
if data, err = ReadDetailData(rdDto, &event, tx); err != nil {
|
|
return err
|
|
}
|
|
|
|
mwRunner := newMiddlewareRunner(&event, tx)
|
|
mwRunner.setMwType(pu.MWTPre)
|
|
// Run pre-middleware
|
|
if err := mwRunner.RunDeleteMiddleware(readDetailPreMw, &rdDto, data); err != nil {
|
|
return err
|
|
}
|
|
|
|
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 {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
})
|
|
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return &d.Data{
|
|
Meta: d.IS{
|
|
"source": source,
|
|
"structure": "single-data",
|
|
"status": "deleted",
|
|
},
|
|
Data: data.ToResponse(),
|
|
}, nil
|
|
|
|
}
|
|
|
|
func CheckOut(input e.DischargeDto) (*d.Data, error) {
|
|
rdDto := e.ReadDetailDto{Id: uint16(input.Id)}
|
|
var data *e.Encounter
|
|
var err error
|
|
|
|
event := pl.Event{
|
|
Feature: "CheckOut",
|
|
Source: source,
|
|
}
|
|
|
|
// Start log
|
|
pl.SetLogInfo(&event, input, "started", "checkOut")
|
|
|
|
err = dg.I.Transaction(func(tx *gorm.DB) error {
|
|
pl.SetLogInfo(&event, rdDto, "started", "DBReadDetail")
|
|
if data, err = ReadDetailData(rdDto, &event, tx); err != nil {
|
|
return err
|
|
}
|
|
|
|
if data.IsDone() {
|
|
event.Status = "failed"
|
|
event.ErrInfo = pl.ErrorInfo{
|
|
Code: "data-state-mismatch",
|
|
Detail: "encounter is done",
|
|
Raw: errors.New("encounter is done"),
|
|
}
|
|
return pl.SetLogError(&event, input)
|
|
}
|
|
|
|
if err := checkSoapiByDocExists(data.Id, &event, tx); err != nil {
|
|
return err
|
|
}
|
|
|
|
if err := updateDischargeData(input, data, &event, tx); err != nil {
|
|
return err
|
|
}
|
|
|
|
if err := checkNewOrdersExist(data.Id, &event, tx); err != nil {
|
|
return err
|
|
}
|
|
|
|
if err := createMedication(data.Id, &event, tx); err != nil {
|
|
if !pu.IsDataNotFoundError(err) {
|
|
return err
|
|
}
|
|
}
|
|
|
|
// update finishedAt in latest responsible_doctor_hist
|
|
if err = updateLatestResponsibleDoctorHist(e.CheckinDto{Id: input.Id, StartedAt: &now}, &event, tx); err != nil {
|
|
return err
|
|
}
|
|
|
|
// update finishedAt in latest adm_employee_hist
|
|
if err = updateLatestAdmEmployeeHist(e.CheckinDto{Id: input.Id, StartedAt: &now}, &event, tx); err != nil {
|
|
return err
|
|
}
|
|
|
|
if *input.Discharge_Method_Code == ere.DMCDeath {
|
|
// insert data death-cause
|
|
if _, err = udc.CreateData(edc.CreateDto{Encounter_Id: &input.Id, Value: input.DeathCause}, &event, tx); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
//// bulk insert internal-references
|
|
//if err = createInternalReferences(input, &event, tx); err != nil {
|
|
// return err
|
|
//}
|
|
|
|
pl.SetLogInfo(&event, nil, "complete")
|
|
|
|
return nil
|
|
})
|
|
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return &d.Data{
|
|
Meta: d.IS{
|
|
"source": source,
|
|
"structure": "single-data",
|
|
"status": "checkOut",
|
|
},
|
|
Data: data.ToResponse(),
|
|
}, nil
|
|
}
|
|
|
|
func UpdateStatusCode(input e.UpdateStatusDto) (*d.Data, error) {
|
|
rdDto := e.ReadDetailDto{Id: input.Id}
|
|
var data *e.Encounter
|
|
var err error
|
|
|
|
event := pl.Event{
|
|
Feature: "Update Status Code",
|
|
Source: source,
|
|
}
|
|
|
|
// Start log
|
|
pl.SetLogInfo(&event, input, "started", "update")
|
|
|
|
err = dg.I.Transaction(func(tx *gorm.DB) error {
|
|
pl.SetLogInfo(&event, rdDto, "started", "DBReadDetail")
|
|
if data, err = ReadDetailData(rdDto, &event, tx); err != nil {
|
|
return err
|
|
}
|
|
|
|
if data.IsDone() {
|
|
event.Status = "failed"
|
|
event.ErrInfo = pl.ErrorInfo{
|
|
Code: "data-state-mismatch",
|
|
Detail: "encounter is done",
|
|
Raw: errors.New("encounter is done"),
|
|
}
|
|
return pl.SetLogError(&event, input)
|
|
}
|
|
|
|
mwRunner := newMiddlewareRunner(&event, tx)
|
|
mwRunner.setMwType(pu.MWTPre)
|
|
// Run pre-middleware
|
|
if err := mwRunner.RunUpdateMiddleware(readDetailPreMw, &rdDto, data); err != nil {
|
|
return err
|
|
}
|
|
|
|
if err := UpdateStatusData(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 {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
})
|
|
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return &d.Data{
|
|
Meta: d.IS{
|
|
"source": source,
|
|
"structure": "single-data",
|
|
"status": "updated",
|
|
},
|
|
Data: data.ToResponse(),
|
|
}, nil
|
|
|
|
}
|
|
|
|
func CheckIn(input e.CheckinDto) (*d.Data, error) {
|
|
rdDto := e.ReadDetailDto{Id: uint16(input.Id)}
|
|
var data *e.Encounter
|
|
var err error
|
|
|
|
event := pl.Event{
|
|
Feature: "CheckIn",
|
|
Source: source,
|
|
}
|
|
|
|
// Start log
|
|
pl.SetLogInfo(&event, input, "started", "checkIn")
|
|
|
|
// validate foreign key
|
|
if err := validateForeignKey(input); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// set startedAt
|
|
if input.StartedAt == nil {
|
|
input.StartedAt = &now
|
|
}
|
|
|
|
// validate if soapi exist
|
|
dataSoapi, err := us.ReadList(es.ReadListDto{FilterDto: es.FilterDto{Encounter_Id: &input.Id}})
|
|
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 {
|
|
return err
|
|
}
|
|
|
|
if data.IsDone() {
|
|
event.Status = "failed"
|
|
event.ErrInfo = pl.ErrorInfo{
|
|
Code: "data-state-mismatch",
|
|
Detail: "encounter is done",
|
|
Raw: errors.New("encounter is done"),
|
|
}
|
|
return pl.SetLogError(&event, input)
|
|
}
|
|
|
|
// Insert responsible_doctor_hist if responsible_doctor_id has changed && update latest history
|
|
if data.Responsible_Doctor_Id == nil || *input.Responsible_Doctor_Id != *data.Responsible_Doctor_Id {
|
|
// update finishedAt in latest responsible_doctor_hist
|
|
if err = updateLatestResponsibleDoctorHist(input, &event, tx); err != nil {
|
|
return err
|
|
}
|
|
|
|
//insert responsible_doctor_hist
|
|
if _, err = urdh.Create(erdh.CreateDto{
|
|
Encounter_Id: &input.Id,
|
|
Doctor_Id: input.Responsible_Doctor_Id,
|
|
StartedAt: input.StartedAt,
|
|
}); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
// Insert adm_employee_hist if adm_employee_id has changed && update latest history
|
|
if input.Adm_Employee_Id != nil && *input.Adm_Employee_Id != *data.Adm_Employee_Id {
|
|
// update finishedAt in latest adm_employee_hist
|
|
if err = updateLatestAdmEmployeeHist(input, &event, tx); err != nil {
|
|
return err
|
|
}
|
|
|
|
// insert responsible_doctor_hist
|
|
if _, err = uaeh.Create(eaeh.CreateDto{
|
|
Encounter_Id: &input.Id,
|
|
Employee_Id: input.Adm_Employee_Id,
|
|
StartedAt: input.StartedAt,
|
|
}); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
// update encounter data
|
|
if err := updateCheckInData(input, data, &event, tx); err != nil {
|
|
return err
|
|
}
|
|
|
|
pl.SetLogInfo(&event, nil, "complete")
|
|
|
|
return nil
|
|
})
|
|
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return &d.Data{
|
|
Meta: d.IS{
|
|
"source": source,
|
|
"structure": "single-data",
|
|
"status": "checkIn",
|
|
},
|
|
Data: data.ToResponse(),
|
|
}, nil
|
|
}
|
|
|
|
func validateForeignKey(input e.CheckinDto) error {
|
|
// validate employee_Id
|
|
if input.Adm_Employee_Id != nil {
|
|
if _, err := uem.ReadDetail(eem.ReadDetailDto{Id: uint16(*input.Adm_Employee_Id)}); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
// validate doctor_id
|
|
if input.Responsible_Doctor_Id != nil {
|
|
if _, err := ud.ReadDetail(ed.ReadDetailDto{Id: uint16(*input.Responsible_Doctor_Id)}); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|