vanilia
751 lines
18 KiB
Go
751 lines
18 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"
|
|
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"
|
|
|
|
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"
|
|
ur "simrs-vx/internal/use-case/main-use-case/rehab"
|
|
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{}
|
|
createSoapi := []es.CreateDto{}
|
|
|
|
event := pl.Event{
|
|
Feature: "Create",
|
|
Source: source,
|
|
}
|
|
|
|
// 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.ACCRehab &&
|
|
*input.VisitMode_Code == ere.VMCSeries {
|
|
|
|
dataEncounter, valid, err := verifyAllocatedVisitCount(input, &event)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if !valid {
|
|
event.Status = "failed"
|
|
event.ErrInfo = pl.ErrorInfo{
|
|
Code: "visit-limit-exceeded",
|
|
Detail: "Encounter has exceeded the allowed number of visits",
|
|
Raw: errors.New("visit count exceeds allowed limit"),
|
|
}
|
|
return nil, pl.SetLogError(&event, input)
|
|
}
|
|
|
|
// 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},
|
|
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
|
|
}
|
|
|
|
// create encounter
|
|
if resData, err := CreateData(input, &event, tx); err != nil {
|
|
return err
|
|
} else {
|
|
data = *resData
|
|
}
|
|
|
|
switch input.Class_Code {
|
|
case ere.ECAmbulatory:
|
|
subCodeAmbulatory := subCode.(ere.AmbulatoryClassCode)
|
|
ambCreate := ea.CreateDto{
|
|
Encounter_Id: &data.Id,
|
|
Class_Code: subCodeAmbulatory,
|
|
VisitMode_Code: *input.VisitMode_Code,
|
|
}
|
|
_, err = ua.CreateData(ambCreate, &event, tx)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if subCodeAmbulatory == 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
|
|
}
|
|
}
|
|
|
|
if subCodeAmbulatory == ere.ACCRehab && *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.ACCRehab && *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.(ere.EmergencyClassCode),
|
|
}
|
|
_, err = ue.CreateData(emerCreate, &event, tx)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
case ere.ECInpatient:
|
|
inpCreate := ei.CreateDto{
|
|
Encounter_Id: &data.Id,
|
|
Class_Code: subCode.(ere.InpatientClassCode),
|
|
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.CreateData(eaeh.CreateDto{
|
|
Encounter_Id: &data.Main.Id,
|
|
Employee_Id: data.Adm_Employee_Id,
|
|
StartedAt: &now}, &event, tx); 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), Includes: "Ambulatory"}
|
|
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 data.Ambulatory != nil && (data.Ambulatory.Class_Code == ere.ACCReg || data.Ambulatory.Class_Code == ere.ACCRehab) {
|
|
// validate if soapi exist
|
|
err = getSoapiByTypeCode(input.Id, *data.Ambulatory, &event, "check-out")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
} else {
|
|
// chemo TBC
|
|
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
|
|
}
|
|
|
|
switch *input.Discharge_Method_Code {
|
|
case 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
|
|
}
|
|
case ere.DMCConsulPoly, ere.DMCConsulExecutive:
|
|
// 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), Includes: "Rehab,Ambulatory"}
|
|
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
|
|
}
|
|
|
|
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)
|
|
}
|
|
|
|
// validate if soapi exist
|
|
if data.Ambulatory != nil && (data.Ambulatory.Class_Code == ere.ACCReg || data.Ambulatory.Class_Code == ere.ACCRehab) {
|
|
err = getSoapiByTypeCode(input.Id, *data.Ambulatory, &event, "check-in")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
// 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 {
|
|
// upsert responsibleDoctorHist
|
|
if err = upsertResponsibleDoctorHist(erdh.CreateDto{
|
|
Encounter_Id: &data.Id,
|
|
Doctor_Id: input.Responsible_Doctor_Id,
|
|
StartedAt: input.StartedAt,
|
|
}, &event, tx); 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 {
|
|
// upsert admEmployeeHist
|
|
if err = upsertAdmEmployeeHist(eaeh.CreateDto{
|
|
Encounter_Id: &data.Id,
|
|
Employee_Id: input.Adm_Employee_Id,
|
|
StartedAt: input.StartedAt,
|
|
}, &event, tx); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
// update encounter data
|
|
if err := updateCheckInData(input, data, &event, tx); err != nil {
|
|
return err
|
|
}
|
|
|
|
if data.Ambulatory.Class_Code == ere.ACCRehab {
|
|
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
|
|
})
|
|
|
|
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
|
|
}
|
|
|
|
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
|
|
}
|