941 lines
27 KiB
Go
941 lines
27 KiB
Go
package antrianoperasi
|
|
|
|
import (
|
|
"antrian-operasi/internal/database"
|
|
"antrian-operasi/internal/shared"
|
|
queryUtils "antrian-operasi/internal/utils/query"
|
|
"database/sql"
|
|
"log"
|
|
"time"
|
|
|
|
"context"
|
|
|
|
"github.com/google/uuid"
|
|
)
|
|
|
|
const DB_NAME = "db_antrian"
|
|
const TBL_NAME = "data_pasien_operasi"
|
|
const TBL_DIAGNOSA_OPERASI = "data_diagnosa_pasien_operasi"
|
|
const TBL_PASIEN_TELEPHONE = "data_telepon_pasien_operasi"
|
|
const TBL_TINDAKAN_OPERASI = "data_tindakan_pasien_operasi"
|
|
const TBL_DOKTER_OPERASI = "data_pasien_operasi_data_pegawai_2"
|
|
|
|
type IAntrianOperasiRepository interface {
|
|
CreateAntrianOperasi(c context.Context, req CreatePasienOperasiRequest) (CreatePasienOperasiRequest, error)
|
|
SearchableListAntrianOperasi(c context.Context, q AntrianQuery) (ListPasienOperasiPaginate, error)
|
|
GetAntrianOperasiById(c context.Context, id string) (DetailPasienOperasiResultQuery, error)
|
|
UpdateAntrianOperasi(c context.Context, id string, req CreatePasienOperasiRequest) (CreatePasienOperasiRequest, error)
|
|
UpdateStatusAntrianOperasi(c context.Context, id string, req StatusPasienRequest) (StatusPasienRequest, error)
|
|
DeleteStatusAntrianOperasi(c context.Context, id string) error
|
|
}
|
|
|
|
type antrianOperasiRepo struct {
|
|
queryBuilder *queryUtils.QueryBuilder
|
|
db database.Service
|
|
}
|
|
|
|
func NewRepository(dbService database.Service) IAntrianOperasiRepository {
|
|
queryBuilder := queryUtils.NewQueryBuilder(queryUtils.DBTypePostgreSQL).
|
|
SetAllowedColumns([]string{
|
|
"id", "status", "date_created", "date_updated", "\"No_rekam_medis\"", "\"No_KTP\"", "\"Nama_pasien\"",
|
|
"\"Jenis_kelamin\"", "\"Tanggal_lahir\"", "\"Umur\"", "\"Alamat\"", "\"Tanggal_daftar\"",
|
|
"\"Kategori_operasi\"", "\"Rencana_operasi\"", "\"Status_operasi\"", "\"Nomor\"",
|
|
"\"Spesialis\"", "\"Sub_spesialis\"", "\"Keterangan\"",
|
|
"\"Nomor_spesialis\"", "\"Nomor_sub_spesialis\"",
|
|
"\"Nomor_telepon\"", "\"Tanggal_selesai_operasi\"",
|
|
"\"FK_pasien_operasi_telepon_pasien_operasi_ID\"", "FK_pasien_operasi_telepon_pasien_operasi_ID",
|
|
"\"Kode_diagnosa\"", "\"Diagnosa\"", "\"Jenis_diagnosa\"", "\"FK_pasien_operasi_diagnosa_pasien_operasi_ID\"", "FK_pasien_operasi_diagnosa_pasien_operasi_ID",
|
|
"\"Kode_tindakan\"", "\"Tindakan\"", "\"Tindakan_tambahan\"", "\"FK_pasien_operasi_tindakan_pasien_operasi_ID\"", "FK_pasien_operasi_tindakan_pasien_operasi_ID",
|
|
"\"data_pasien_operasi_id\"", "\"data_pegawai_id\"", "data_pasien_operasi_id",
|
|
"no_urut_spesialis", "no_urut_sub_spesialis",
|
|
}).
|
|
SetAllowedTables([]string{TBL_NAME, TBL_DIAGNOSA_OPERASI})
|
|
queryBuilder.SetSecurityOptions(false, 100)
|
|
|
|
return antrianOperasiRepo{
|
|
queryBuilder: queryBuilder,
|
|
db: dbService,
|
|
}
|
|
}
|
|
|
|
func (r antrianOperasiRepo) insertAntrianChildTables(c context.Context, tx *sql.Tx, idAntrian string, req CreatePasienOperasiRequest) error {
|
|
returningCols := []string{
|
|
"id",
|
|
}
|
|
|
|
// INSERT data_telepon_pasien_operasi
|
|
if len(req.FormData.NoTelepon) != 0 {
|
|
var valuesInsertTelepon [][]interface{}
|
|
|
|
for _, telp := range req.FormData.NoTelepon {
|
|
idTelepon := uuid.New().String()
|
|
itemValues := []interface{}{idTelepon, telp, idAntrian}
|
|
valuesInsertTelepon = append(valuesInsertTelepon, itemValues)
|
|
}
|
|
|
|
insertTeleponQuery := queryUtils.InsertBulkData{
|
|
Columns: []string{
|
|
"id",
|
|
"\"Nomor_telepon\"",
|
|
"\"FK_pasien_operasi_telepon_pasien_operasi_ID\"",
|
|
},
|
|
Values: valuesInsertTelepon,
|
|
}
|
|
|
|
sql, args, err := r.queryBuilder.BuildBulkInsertQuery(TBL_PASIEN_TELEPHONE, insertTeleponQuery, returningCols...)
|
|
if err != nil {
|
|
log.Printf("error building query telepon %s", err)
|
|
|
|
return err
|
|
}
|
|
_, err = tx.ExecContext(c, sql, args...)
|
|
if err != nil {
|
|
log.Println(err)
|
|
return err
|
|
}
|
|
log.Printf("success insert telepon")
|
|
}
|
|
|
|
// INSERT data_diagnosa_pasien_operasi
|
|
var valuesDiagnosa [][]interface{}
|
|
|
|
for _, diagnosa := range req.DiagnosisItem {
|
|
idDiagnosa := uuid.New().String()
|
|
itemValues := []interface{}{
|
|
idDiagnosa,
|
|
diagnosa.KodeDiagnosa,
|
|
diagnosa.Diagnosa,
|
|
diagnosa.JenisDiagnosa,
|
|
idAntrian,
|
|
}
|
|
valuesDiagnosa = append(valuesDiagnosa, itemValues)
|
|
}
|
|
|
|
insertDiagnosaQuery := queryUtils.InsertBulkData{
|
|
Columns: []string{
|
|
"id",
|
|
"\"Kode_diagnosa\"",
|
|
"\"Diagnosa\"",
|
|
"\"Jenis_diagnosa\"",
|
|
"\"FK_pasien_operasi_diagnosa_pasien_operasi_ID\"",
|
|
},
|
|
Values: valuesDiagnosa,
|
|
}
|
|
|
|
sql, args, err := r.queryBuilder.BuildBulkInsertQuery(TBL_DIAGNOSA_OPERASI, insertDiagnosaQuery, returningCols...)
|
|
if err != nil {
|
|
log.Printf("error building query diagnosa %s", err)
|
|
return err
|
|
}
|
|
_, err = tx.ExecContext(c, sql, args...)
|
|
if err != nil {
|
|
log.Println(err)
|
|
return err
|
|
}
|
|
log.Printf("success insert diagnosa")
|
|
|
|
// INSERT data_tindakan_pasien_operasi
|
|
var valuesTindakan [][]interface{}
|
|
|
|
for _, tindakan := range req.TindakanItems {
|
|
idTindakan := uuid.New().String()
|
|
itemValues := []interface{}{
|
|
idTindakan,
|
|
tindakan.KodeTindakan,
|
|
tindakan.Tindakan,
|
|
tindakan.TindakanTambahan,
|
|
idAntrian,
|
|
}
|
|
valuesTindakan = append(valuesTindakan, itemValues)
|
|
}
|
|
|
|
insertTindakanQuery := queryUtils.InsertBulkData{
|
|
Columns: []string{
|
|
"id",
|
|
"\"Kode_tindakan\"",
|
|
"\"Tindakan\"",
|
|
"\"Tindakan_tambahan\"",
|
|
"\"FK_pasien_operasi_tindakan_pasien_operasi_ID\"",
|
|
},
|
|
Values: valuesTindakan,
|
|
}
|
|
|
|
sql, args, err = r.queryBuilder.BuildBulkInsertQuery(TBL_TINDAKAN_OPERASI, insertTindakanQuery, returningCols...)
|
|
if err != nil {
|
|
log.Printf("error building query tindakan %s", err)
|
|
return err
|
|
}
|
|
_, err = tx.ExecContext(c, sql, args...)
|
|
if err != nil {
|
|
log.Println(err)
|
|
return err
|
|
}
|
|
log.Printf("success insert tindakan")
|
|
|
|
// INSERT data_pasien_operasi_data_pegawai
|
|
if len(req.DokterPelaksanaItems) != 0 {
|
|
var valuesDokterPelaksana [][]interface{}
|
|
|
|
for _, dokter := range req.DokterPelaksanaItems {
|
|
itemValues := []interface{}{
|
|
idAntrian,
|
|
dokter.Id,
|
|
}
|
|
valuesDokterPelaksana = append(valuesDokterPelaksana, itemValues)
|
|
}
|
|
|
|
insertDokterPelaksanaQuery := queryUtils.InsertBulkData{
|
|
Columns: []string{
|
|
"\"data_pasien_operasi_id\"",
|
|
"\"data_pegawai_id\"",
|
|
},
|
|
Values: valuesDokterPelaksana,
|
|
}
|
|
|
|
sql, args, err = r.queryBuilder.BuildBulkInsertQuery(TBL_DOKTER_OPERASI, insertDokterPelaksanaQuery, returningCols...)
|
|
if err != nil {
|
|
log.Printf("error building query dokter pelaksana %s", err)
|
|
return err
|
|
}
|
|
_, err = tx.ExecContext(c, sql, args...)
|
|
if err != nil {
|
|
log.Println(err)
|
|
return err
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (r antrianOperasiRepo) deleteAntrianChildTables(c context.Context, tx *sql.Tx, idAntrian string) error {
|
|
// parsedId := uuid.MustParse(idAntrian)
|
|
// delete telephone
|
|
filters := []queryUtils.FilterGroup{
|
|
{
|
|
Filters: []queryUtils.DynamicFilter{
|
|
{Column: "FK_pasien_operasi_telepon_pasien_operasi_ID", Operator: queryUtils.OpEqual, Value: idAntrian},
|
|
},
|
|
},
|
|
}
|
|
sql, args, err := r.queryBuilder.BuildDeleteQuery(TBL_PASIEN_TELEPHONE, filters)
|
|
if err != nil {
|
|
log.Printf("Unable to create delete phone query : %v", err)
|
|
return err
|
|
}
|
|
_, err = tx.ExecContext(c, sql, args...)
|
|
if err != nil {
|
|
log.Printf("Unable to executing delete phone : %v", err)
|
|
return err
|
|
}
|
|
|
|
// delete diagnosa
|
|
filters = []queryUtils.FilterGroup{
|
|
{
|
|
Filters: []queryUtils.DynamicFilter{
|
|
{Column: "FK_pasien_operasi_diagnosa_pasien_operasi_ID", Operator: queryUtils.OpEqual, Value: idAntrian},
|
|
},
|
|
},
|
|
}
|
|
sql, args, err = r.queryBuilder.BuildDeleteQuery(TBL_DIAGNOSA_OPERASI, filters)
|
|
if err != nil {
|
|
log.Printf("Unable to create delete diagnosa query : %v", err)
|
|
return err
|
|
}
|
|
_, err = tx.ExecContext(c, sql, args...)
|
|
if err != nil {
|
|
log.Printf("Unable to executing delete diagnosa : %v", err)
|
|
return err
|
|
}
|
|
|
|
// delete tindakan
|
|
filters = []queryUtils.FilterGroup{
|
|
{
|
|
Filters: []queryUtils.DynamicFilter{
|
|
{Column: "FK_pasien_operasi_tindakan_pasien_operasi_ID", Operator: queryUtils.OpEqual, Value: idAntrian},
|
|
},
|
|
},
|
|
}
|
|
sql, args, err = r.queryBuilder.BuildDeleteQuery(TBL_TINDAKAN_OPERASI, filters)
|
|
if err != nil {
|
|
log.Printf("Unable to create delete tindakan query : %v", err)
|
|
return err
|
|
}
|
|
_, err = tx.ExecContext(c, sql, args...)
|
|
if err != nil {
|
|
log.Printf("Unable to executing delete tindakan : %v", err)
|
|
return err
|
|
}
|
|
|
|
// delete dokter
|
|
filters = []queryUtils.FilterGroup{
|
|
{
|
|
Filters: []queryUtils.DynamicFilter{
|
|
{Column: "data_pasien_operasi_id", Operator: queryUtils.OpEqual, Value: idAntrian},
|
|
},
|
|
},
|
|
}
|
|
sql, args, err = r.queryBuilder.BuildDeleteQuery(TBL_DOKTER_OPERASI, filters)
|
|
if err != nil {
|
|
log.Printf("Unable to create delete dokter operasi query : %v", err)
|
|
return err
|
|
}
|
|
_, err = tx.ExecContext(c, sql, args...)
|
|
if err != nil {
|
|
log.Printf("Unable to executing delete dokter operasi : %v", err)
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (r antrianOperasiRepo) CreateAntrianOperasi(c context.Context, req CreatePasienOperasiRequest) (CreatePasienOperasiRequest, error) {
|
|
db, err := r.db.GetSQLXDB(DB_NAME)
|
|
if err != nil {
|
|
return req, err
|
|
}
|
|
|
|
// START TRANSACTION
|
|
tx, err := db.BeginTx(c, nil)
|
|
if err != nil {
|
|
return req, err
|
|
}
|
|
|
|
// INSERTING
|
|
// INSERT MAIN TABLE : data_pasien_operasi
|
|
idAntrian := uuid.New().String()
|
|
insertMainQuery := queryUtils.InsertData{
|
|
Columns: []string{
|
|
"id", "status", "date_created", "\"No_rekam_medis\"", "\"No_KTP\"", "\"Nama_pasien\"",
|
|
"\"Jenis_kelamin\"", "\"Tanggal_lahir\"", "\"Umur\"", "\"Alamat\"", "\"Tanggal_daftar\"",
|
|
"\"Kategori_operasi\"", "\"Rencana_operasi\"", "\"Status_operasi\"", "\"Nomor\"",
|
|
"\"Spesialis\"", "\"Sub_spesialis\"", "\"Keterangan\"",
|
|
"\"Nomor_spesialis\"", "\"Nomor_sub_spesialis\"",
|
|
}, Values: []interface{}{
|
|
idAntrian,
|
|
"draft",
|
|
time.Now(),
|
|
req.FormData.NoRekamMedis,
|
|
req.FormData.NoKtp,
|
|
req.FormData.NamaPasien,
|
|
req.FormData.JenisKelamin,
|
|
req.FormData.TglLahir,
|
|
req.FormData.Umur,
|
|
req.FormData.Alamat,
|
|
req.RencanaOperasiData.TanggalDaftar,
|
|
req.RencanaOperasiData.KategoriOperasi,
|
|
req.RencanaOperasiData.RencanaOperasi,
|
|
"1",
|
|
1, // nomor
|
|
req.RencanaOperasiData.Spesialis,
|
|
req.RencanaOperasiData.SubSpesialis,
|
|
req.RencanaOperasiData.Keterangan,
|
|
req.RencanaOperasiData.Spesialis,
|
|
req.RencanaOperasiData.SubSpesialis,
|
|
},
|
|
}
|
|
returningCols := []string{
|
|
"id",
|
|
}
|
|
|
|
sql, args, err := r.queryBuilder.BuildInsertQuery("data_pasien_operasi", insertMainQuery, returningCols...)
|
|
_, err = tx.ExecContext(c, sql, args...)
|
|
if err != nil {
|
|
tx.Rollback()
|
|
log.Printf("error building query main %s", err)
|
|
return req, err
|
|
}
|
|
log.Printf("success insert main")
|
|
|
|
// INSERT CHILD TABLES
|
|
err = r.insertAntrianChildTables(c, tx, idAntrian, req)
|
|
if err != nil {
|
|
tx.Rollback()
|
|
return req, err
|
|
}
|
|
|
|
// COMMIT TRANSACTION
|
|
tx.Commit()
|
|
|
|
return req, nil
|
|
}
|
|
|
|
func (r antrianOperasiRepo) SearchableListAntrianOperasi(c context.Context, q AntrianQuery) (ListPasienOperasiPaginate, error) {
|
|
var result ListPasienOperasiPaginate
|
|
|
|
query := queryUtils.DynamicQuery{
|
|
From: TBL_NAME,
|
|
Aliases: "dpo",
|
|
Fields: []queryUtils.SelectField{
|
|
{Expression: "dpo.id"},
|
|
{Expression: "dpo.Tanggal_daftar", Alias: "tanggal_daftar"},
|
|
{Expression: "dpo.No_KTP", Alias: "no_ktp"},
|
|
{Expression: "dpo.No_rekam_medis", Alias: "no_rekam_medis"},
|
|
{Expression: "dpo.Nama_pasien", Alias: "nama_pasien"},
|
|
{Expression: "dpo.Status_operasi", Alias: "status_operasi"},
|
|
{Expression: "dpo.Jenis_kelamin", Alias: "jenis_kelamin"},
|
|
{Expression: "ds.Spesialis", Alias: "spesialis"},
|
|
{Expression: "dss.Subspesialis", Alias: "subspesialis"},
|
|
{Expression: "dko.Kategori", Alias: "kategori"},
|
|
},
|
|
Sort: []queryUtils.SortField{
|
|
{Column: "dpo.Tanggal_daftar", Order: "ASC"},
|
|
},
|
|
}
|
|
|
|
wfKategori := queryUtils.WindowFunction{
|
|
Function: "ROW_NUMBER",
|
|
Over: "\"dpo\".\"Kategori_operasi\"",
|
|
OrderBy: "\"dpo\".\"Tanggal_daftar\"",
|
|
Alias: "no_urut_kategori",
|
|
}
|
|
|
|
wfSpesialis := queryUtils.WindowFunction{
|
|
Function: "ROW_NUMBER",
|
|
Over: "\"dpo\".\"Spesialis\"",
|
|
OrderBy: "\"dpo\".\"Tanggal_daftar\", \"dpo\".\"date_created\", \"dpo\".\"date_updated\"",
|
|
Alias: "no_urut_spesialis",
|
|
}
|
|
wfSubSpesialis := queryUtils.WindowFunction{
|
|
Function: "ROW_NUMBER",
|
|
Over: "\"dpo\".\"Sub_spesialis\"",
|
|
OrderBy: "\"dpo\".\"Tanggal_daftar\", \"dpo\".\"date_created\", \"dpo\".\"date_updated\"",
|
|
Alias: "no_urut_sub_spesialis",
|
|
}
|
|
|
|
var selectFilter []queryUtils.DynamicFilter
|
|
typeIdColumn := ""
|
|
|
|
switch q.Type {
|
|
case "kategori":
|
|
typeIdColumn = "dko.id"
|
|
query.WindowFunctions = append(query.WindowFunctions, wfKategori, wfSpesialis, wfSubSpesialis)
|
|
query.Sort = append(query.Sort, queryUtils.SortField{Column: "no_urut_kategori", Order: "ASC"})
|
|
case "spesialis":
|
|
typeIdColumn = "ds.id"
|
|
query.WindowFunctions = append(query.WindowFunctions, wfSpesialis, wfSubSpesialis)
|
|
query.Sort = append(query.Sort, queryUtils.SortField{Column: "no_urut_spesialis", Order: "ASC"})
|
|
case "sub-spesialis":
|
|
typeIdColumn = "dss.id"
|
|
query.WindowFunctions = append(query.WindowFunctions, wfSubSpesialis)
|
|
query.Sort = append(query.Sort, queryUtils.SortField{Column: "no_urut_sub_spesialis", Order: "ASC"})
|
|
default:
|
|
query.WindowFunctions = append(query.WindowFunctions, wfKategori, wfSpesialis, wfSubSpesialis)
|
|
}
|
|
|
|
if q.TypeID != 0 && q.Type != "all" {
|
|
selectFilter = append(selectFilter, queryUtils.DynamicFilter{Column: typeIdColumn, Operator: queryUtils.OpEqual, Value: q.TypeID})
|
|
}
|
|
|
|
query.Joins = []queryUtils.Join{
|
|
{
|
|
Type: "LEFT",
|
|
Table: "daftar_spesialis",
|
|
Alias: "ds",
|
|
OnConditions: queryUtils.FilterGroup{
|
|
Filters: []queryUtils.DynamicFilter{
|
|
{
|
|
Column: "ds.id", Operator: queryUtils.OpEqual, Value: "dpo.Spesialis",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
Type: "LEFT",
|
|
Table: "daftar_subspesialis",
|
|
Alias: "dss",
|
|
OnConditions: queryUtils.FilterGroup{
|
|
Filters: []queryUtils.DynamicFilter{
|
|
{
|
|
Column: "dpo.Sub_spesialis", Operator: queryUtils.OpEqual, Value: "dss.id",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
Type: "LEFT",
|
|
Table: "daftar_kategori_operasi",
|
|
Alias: "dko",
|
|
OnConditions: queryUtils.FilterGroup{
|
|
Filters: []queryUtils.DynamicFilter{
|
|
{
|
|
Column: "dpo.Kategori_operasi", Operator: queryUtils.OpEqual, Value: "dko.id",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
// filtering search results
|
|
if q.Search != "" {
|
|
searchFilters := []queryUtils.DynamicFilter{
|
|
{Column: "dpo.No_KTP", Operator: queryUtils.OpILike, Value: "%" + q.Search + "%"},
|
|
{Column: "dpo.No_rekam_medis", Operator: queryUtils.OpILike, Value: "%" + q.Search + "%"},
|
|
{Column: "dpo.Nama_pasien", Operator: queryUtils.OpILike, Value: "%" + q.Search + "%"},
|
|
}
|
|
|
|
query.Filters = append(query.Filters, queryUtils.FilterGroup{Filters: searchFilters, LogicOp: "OR"})
|
|
}
|
|
|
|
if q.Status != "" {
|
|
selectFilter = append(selectFilter, queryUtils.DynamicFilter{Column: "dpo.Status_operasi", Operator: queryUtils.OpEqual, Value: q.Status})
|
|
}
|
|
|
|
// wiring all select filter
|
|
query.Filters = append(query.Filters, queryUtils.FilterGroup{Filters: selectFilter, LogicOp: "AND"})
|
|
|
|
dbconn, err := r.db.GetSQLXDB(DB_NAME)
|
|
if err != nil {
|
|
log.Printf("Unable to connect db : %s", err)
|
|
return result, err
|
|
}
|
|
|
|
// query count
|
|
countData, err := r.queryBuilder.ExecuteCount(c, dbconn, query)
|
|
if err != nil {
|
|
log.Printf("Unable to execute query count : %s ", err)
|
|
return result, err
|
|
}
|
|
result.Paging.Limit = q.Limit
|
|
result.Paging.Offset = q.Offset
|
|
result.Paging.Total = int(countData)
|
|
result.Paging.CalculatePagingInfo()
|
|
|
|
// query data
|
|
queryData := query
|
|
queryData.Limit = q.Limit
|
|
queryData.Offset = q.Offset
|
|
err = r.queryBuilder.ExecuteQuery(
|
|
c, dbconn, queryData, &result.Data)
|
|
if err != nil {
|
|
log.Printf("Unable to execute query data : %s", err)
|
|
return result, err
|
|
}
|
|
|
|
// filtering antrian ids
|
|
var antrianIds []string
|
|
for _, item := range result.Data {
|
|
antrianIds = append(antrianIds, item.ID)
|
|
}
|
|
|
|
// query additional data
|
|
queryDiagnosa := queryUtils.DynamicQuery{
|
|
From: TBL_DIAGNOSA_OPERASI,
|
|
Aliases: "ddpo",
|
|
Fields: []queryUtils.SelectField{
|
|
{Expression: "id", Alias: "id"},
|
|
{Expression: "Kode_diagnosa", Alias: "Kode_diagnosa"},
|
|
{Expression: "Diagnosa", Alias: "Diagnosa"},
|
|
{Expression: "Jenis_diagnosa", Alias: "Jenis_diagnosa"},
|
|
{Expression: "FK_pasien_operasi_diagnosa_pasien_operasi_ID", Alias: "antrian_id"},
|
|
},
|
|
Filters: []queryUtils.FilterGroup{
|
|
{
|
|
Filters: []queryUtils.DynamicFilter{
|
|
{Column: "FK_pasien_operasi_diagnosa_pasien_operasi_ID", Operator: queryUtils.OpIn, Value: antrianIds},
|
|
}, LogicOp: "AND",
|
|
},
|
|
},
|
|
}
|
|
|
|
var resultDiagnosa []DiagnosaOperasiModel
|
|
err = r.queryBuilder.ExecuteQuery(c, dbconn, queryDiagnosa, &resultDiagnosa)
|
|
if err != nil {
|
|
log.Printf("Unable to execute query diagnosa : %s", err)
|
|
return result, err
|
|
}
|
|
|
|
// attach support data to parent
|
|
shared.MapChildToParent(
|
|
result.Data, resultDiagnosa,
|
|
func(o *PasienOperasi) string { return o.ID },
|
|
func(d DiagnosaOperasiModel) string { return d.AntrianId },
|
|
func(o *PasienOperasi, d DiagnosaOperasiModel) {
|
|
o.Diagnosa = append(o.Diagnosa, d.Diagnosa.String)
|
|
},
|
|
)
|
|
|
|
return result, nil
|
|
}
|
|
|
|
func (r antrianOperasiRepo) GetAntrianOperasiById(c context.Context, id string) (DetailPasienOperasiResultQuery, error) {
|
|
var result DetailPasienOperasiResultQuery
|
|
|
|
// main query
|
|
query := queryUtils.DynamicQuery{
|
|
From: TBL_NAME,
|
|
Aliases: "dpo",
|
|
Fields: []queryUtils.SelectField{
|
|
{Expression: "dpo.id"},
|
|
{Expression: "dpo.Tanggal_daftar", Alias: "tanggal_daftar"},
|
|
{Expression: "dpo.Tanggal_selesai_operasi", Alias: "tanggal_selesai"},
|
|
{Expression: "dpo.Tanggal_lahir", Alias: "tanggal_lahir"},
|
|
{Expression: "dpo.Umur", Alias: "umur"},
|
|
{Expression: "dpo.Alamat", Alias: "alamat"},
|
|
{Expression: "dpo.No_KTP", Alias: "no_ktp"},
|
|
{Expression: "dpo.No_rekam_medis", Alias: "no_rekam_medis"},
|
|
{Expression: "dpo.Nama_pasien", Alias: "nama_pasien"},
|
|
{Expression: "dpo.Status_operasi", Alias: "status_operasi"},
|
|
{Expression: "dpo.Jenis_kelamin", Alias: "jenis_kelamin"},
|
|
{Expression: "dpo.Spesialis", Alias: "id_spesialis"},
|
|
{Expression: "dpo.Sub_spesialis", Alias: "id_sub_spesialis"},
|
|
{Expression: "dpo.Kategori_operasi", Alias: "id_kategori"},
|
|
{Expression: "dpo.Keterangan", Alias: "keterangan"},
|
|
{Expression: "ds.Spesialis", Alias: "spesialis"},
|
|
{Expression: "dss.Subspesialis", Alias: "subspesialis"},
|
|
{Expression: "dko.Kategori", Alias: "kategori"},
|
|
},
|
|
Filters: []queryUtils.FilterGroup{
|
|
{
|
|
Filters: []queryUtils.DynamicFilter{
|
|
{Column: "dpo.id", Operator: queryUtils.OpEqual, Value: id},
|
|
}, LogicOp: "AND",
|
|
},
|
|
},
|
|
Joins: []queryUtils.Join{
|
|
{
|
|
Type: "LEFT",
|
|
Table: "daftar_spesialis",
|
|
Alias: "ds",
|
|
OnConditions: queryUtils.FilterGroup{
|
|
Filters: []queryUtils.DynamicFilter{
|
|
{
|
|
Column: "ds.id", Operator: queryUtils.OpEqual, Value: "dpo.Spesialis",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
Type: "LEFT",
|
|
Table: "daftar_subspesialis",
|
|
Alias: "dss",
|
|
OnConditions: queryUtils.FilterGroup{
|
|
Filters: []queryUtils.DynamicFilter{
|
|
{
|
|
Column: "dpo.Sub_spesialis", Operator: queryUtils.OpEqual, Value: "dss.id",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
Type: "LEFT",
|
|
Table: "daftar_kategori_operasi",
|
|
Alias: "dko",
|
|
OnConditions: queryUtils.FilterGroup{
|
|
Filters: []queryUtils.DynamicFilter{
|
|
{
|
|
Column: "dpo.Kategori_operasi", Operator: queryUtils.OpEqual, Value: "dko.id",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
dbconn, err := r.db.GetSQLXDB(DB_NAME)
|
|
if err != nil {
|
|
log.Printf("Unable to connect db : %s", err)
|
|
return result, err
|
|
}
|
|
err = r.queryBuilder.ExecuteQueryRow(c, dbconn, query, &result.ResultMain)
|
|
if err != nil {
|
|
log.Printf("Unable to execute main query : %s", err)
|
|
return result, err
|
|
}
|
|
|
|
// query diagnosa
|
|
queryDiagnosa := queryUtils.DynamicQuery{
|
|
From: TBL_DIAGNOSA_OPERASI,
|
|
Fields: []queryUtils.SelectField{
|
|
{Expression: "id"},
|
|
{Expression: "Kode_diagnosa"},
|
|
{Expression: "Diagnosa"},
|
|
{Expression: "Jenis_diagnosa"},
|
|
},
|
|
Filters: []queryUtils.FilterGroup{
|
|
{
|
|
Filters: []queryUtils.DynamicFilter{
|
|
{Column: "FK_pasien_operasi_diagnosa_pasien_operasi_ID", Operator: queryUtils.OpEqual, Value: result.ResultMain.ID},
|
|
}, LogicOp: "AND",
|
|
},
|
|
},
|
|
}
|
|
|
|
err = r.queryBuilder.ExecuteQuery(c, dbconn, queryDiagnosa, &result.ResultDiagnosa)
|
|
if err != nil {
|
|
log.Printf("Unable to execute diagnosa query : %s", err)
|
|
return result, err
|
|
}
|
|
|
|
// query tindakan
|
|
queryTindakan := queryUtils.DynamicQuery{
|
|
From: TBL_TINDAKAN_OPERASI,
|
|
Fields: []queryUtils.SelectField{
|
|
{Expression: "id"},
|
|
{Expression: "Kode_tindakan"},
|
|
{Expression: "Tindakan"},
|
|
{Expression: "Tindakan_tambahan"},
|
|
},
|
|
Filters: []queryUtils.FilterGroup{
|
|
{
|
|
Filters: []queryUtils.DynamicFilter{
|
|
{Column: "FK_pasien_operasi_tindakan_pasien_operasi_ID", Operator: queryUtils.OpEqual, Value: result.ResultMain.ID},
|
|
}, LogicOp: "AND",
|
|
},
|
|
},
|
|
}
|
|
|
|
err = r.queryBuilder.ExecuteQuery(c, dbconn, queryTindakan, &result.ResultTindakan)
|
|
if err != nil {
|
|
log.Printf("Unable to execute tindakan query : %s", err)
|
|
return result, err
|
|
}
|
|
|
|
// query telepon
|
|
queryTelepon := queryUtils.DynamicQuery{
|
|
From: TBL_PASIEN_TELEPHONE,
|
|
Fields: []queryUtils.SelectField{
|
|
{Expression: "id"},
|
|
{Expression: "Nomor_telepon"},
|
|
},
|
|
Filters: []queryUtils.FilterGroup{
|
|
{
|
|
Filters: []queryUtils.DynamicFilter{
|
|
{Column: "FK_pasien_operasi_telepon_pasien_operasi_ID", Operator: queryUtils.OpEqual, Value: result.ResultMain.ID},
|
|
}, LogicOp: "AND",
|
|
},
|
|
},
|
|
}
|
|
|
|
err = r.queryBuilder.ExecuteQuery(c, dbconn, queryTelepon, &result.ResultTeleponOperasi)
|
|
if err != nil {
|
|
log.Printf("Unable to execute telepon query : %s", err)
|
|
return result, err
|
|
}
|
|
|
|
// query dokter
|
|
queryDokter := queryUtils.DynamicQuery{
|
|
From: TBL_DOKTER_OPERASI,
|
|
Aliases: "dpodp",
|
|
Fields: []queryUtils.SelectField{
|
|
{Expression: "dp.id"},
|
|
{Expression: "dp.NIP", Alias: "nip"},
|
|
{Expression: "dp.Nama_depan", Alias: "nama_depan"},
|
|
{Expression: "dp.Nama_belakang", Alias: "nama_belakang"},
|
|
{Expression: "dk.Nama_ksm", Alias: "satker"},
|
|
},
|
|
Filters: []queryUtils.FilterGroup{
|
|
{
|
|
Filters: []queryUtils.DynamicFilter{
|
|
{Column: "data_pasien_operasi_id", Operator: queryUtils.OpEqual, Value: result.ResultMain.ID},
|
|
}, LogicOp: "AND",
|
|
},
|
|
},
|
|
Joins: []queryUtils.Join{
|
|
{
|
|
Type: "LEFT",
|
|
Table: "data_pegawai",
|
|
Alias: "dp",
|
|
OnConditions: queryUtils.FilterGroup{
|
|
Filters: []queryUtils.DynamicFilter{
|
|
{
|
|
Column: "dpodp.data_pegawai_id", Operator: queryUtils.OpEqual, Value: "dp.id",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
Type: "LEFT",
|
|
Table: "daftar_ksm",
|
|
Alias: "dk",
|
|
OnConditions: queryUtils.FilterGroup{
|
|
Filters: []queryUtils.DynamicFilter{
|
|
{
|
|
Column: "dp.KSM", Operator: queryUtils.OpEqual, Value: "dk.id",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
err = r.queryBuilder.ExecuteQuery(c, dbconn, queryDokter, &result.ResultDokterOperasi)
|
|
if err != nil {
|
|
log.Printf("Unable to execute dokter query : %s", err)
|
|
return result, err
|
|
}
|
|
|
|
return result, nil
|
|
}
|
|
|
|
func (r antrianOperasiRepo) UpdateAntrianOperasi(c context.Context, id string, req CreatePasienOperasiRequest) (CreatePasienOperasiRequest, error) {
|
|
// Update main table
|
|
updateMainQuery := queryUtils.UpdateData{
|
|
Columns: []string{
|
|
"date_updated", "\"No_rekam_medis\"", "\"No_KTP\"", "\"Nama_pasien\"", "\"Jenis_kelamin\"",
|
|
"\"Tanggal_lahir\"", "\"Umur\"", "\"Alamat\"", "\"Kategori_operasi\"",
|
|
"\"Rencana_operasi\"", "\"Keterangan\"",
|
|
"\"Status_operasi\"", "\"Spesialis\"", "\"Sub_spesialis\"",
|
|
},
|
|
Values: []interface{}{
|
|
time.Now(), req.FormData.NoRekamMedis, req.FormData.NoKtp, req.FormData.NamaPasien, req.FormData.JenisKelamin,
|
|
req.FormData.TglLahir, req.FormData.Umur, req.FormData.Alamat, req.RencanaOperasiData.KategoriOperasi,
|
|
req.RencanaOperasiData.RencanaOperasi, req.RencanaOperasiData.Keterangan,
|
|
req.StatusPasienData.StatusOperasi, req.RencanaOperasiData.Spesialis, req.RencanaOperasiData.SubSpesialis,
|
|
},
|
|
}
|
|
|
|
filters := []queryUtils.FilterGroup{
|
|
{
|
|
Filters: []queryUtils.DynamicFilter{
|
|
{Column: "id", Operator: queryUtils.OpEqual, Value: id},
|
|
},
|
|
},
|
|
}
|
|
sqlUpdateMain, args, err := r.queryBuilder.BuildUpdateQuery(TBL_NAME, updateMainQuery, filters)
|
|
if err != nil {
|
|
log.Printf("Error build update query : %v", err)
|
|
return req, err
|
|
}
|
|
|
|
db, err := r.db.GetSQLXDB(DB_NAME)
|
|
if err != nil {
|
|
log.Printf("Erorr initiating db : %v", err)
|
|
return req, err
|
|
}
|
|
|
|
// START TRANSACTION
|
|
tx, err := db.BeginTx(c, nil)
|
|
if err != nil {
|
|
log.Printf("Error initiating update transaction : %v", err)
|
|
return req, err
|
|
}
|
|
|
|
_, err = tx.ExecContext(c, sqlUpdateMain, args...)
|
|
if err != nil {
|
|
log.Printf("Error executing main update query : %v", err)
|
|
tx.Rollback()
|
|
return req, err
|
|
}
|
|
|
|
// Delete all child tables
|
|
err = r.deleteAntrianChildTables(c, tx, id)
|
|
if err != nil {
|
|
log.Printf("Error deleting child tables, rollback.. : %v", err)
|
|
tx.Rollback()
|
|
return req, err
|
|
}
|
|
|
|
// Re-inserting updated child tables
|
|
err = r.insertAntrianChildTables(c, tx, id, req)
|
|
if err != nil {
|
|
log.Printf("Error re-inserting child tables, rollback.. : %v", err)
|
|
tx.Rollback()
|
|
return req, err
|
|
}
|
|
|
|
tx.Commit()
|
|
|
|
return req, nil
|
|
}
|
|
|
|
func (r antrianOperasiRepo) UpdateStatusAntrianOperasi(c context.Context, id string, req StatusPasienRequest) (StatusPasienRequest, error) {
|
|
// Update main table
|
|
updateMainQuery := queryUtils.UpdateData{
|
|
Columns: []string{
|
|
"date_updated", "\"Keterangan\"", "\"Status_operasi\"",
|
|
},
|
|
Values: []interface{}{
|
|
time.Now(), req.KeteranganStatus, req.StatusOperasi,
|
|
},
|
|
}
|
|
|
|
if req.StatusOperasi == "2" {
|
|
updateMainQuery.Columns = append(updateMainQuery.Columns, "\"Tanggal_selesai_operasi\"")
|
|
updateMainQuery.Values = append(updateMainQuery.Values, req.TglSelesai)
|
|
}
|
|
|
|
filters := []queryUtils.FilterGroup{
|
|
{
|
|
Filters: []queryUtils.DynamicFilter{
|
|
{Column: "id", Operator: queryUtils.OpEqual, Value: id},
|
|
},
|
|
},
|
|
}
|
|
|
|
sqlUpdateMain, args, err := r.queryBuilder.BuildUpdateQuery(TBL_NAME, updateMainQuery, filters)
|
|
if err != nil {
|
|
log.Printf("Unable to create query update : %s", err)
|
|
return req, err
|
|
}
|
|
|
|
db, err := r.db.GetSQLXDB(DB_NAME)
|
|
if err != nil {
|
|
log.Printf("Erorr initiating db : %v", err)
|
|
return req, err
|
|
}
|
|
|
|
_, err = db.ExecContext(c, sqlUpdateMain, args...)
|
|
if err != nil {
|
|
log.Printf("Error executing query : %v", err)
|
|
return req, err
|
|
}
|
|
|
|
return req, nil
|
|
}
|
|
|
|
func (r antrianOperasiRepo) DeleteStatusAntrianOperasi(c context.Context, id string) error {
|
|
db, err := r.db.GetSQLXDB(DB_NAME)
|
|
if err != nil {
|
|
log.Printf("Erorr initiating db : %v", err)
|
|
return err
|
|
}
|
|
|
|
// START TRANSACTION
|
|
tx, err := db.BeginTx(c, nil)
|
|
if err != nil {
|
|
log.Printf("Error initiating delete transaction : %v", err)
|
|
return err
|
|
}
|
|
|
|
// Delete all child tables
|
|
err = r.deleteAntrianChildTables(c, tx, id)
|
|
if err != nil {
|
|
log.Printf("Error deleting child tables, rollback.. : %v", err)
|
|
tx.Rollback()
|
|
return err
|
|
}
|
|
|
|
// delete main antrian table
|
|
filters := []queryUtils.FilterGroup{
|
|
{
|
|
Filters: []queryUtils.DynamicFilter{
|
|
{Column: "id", Operator: queryUtils.OpEqual, Value: id},
|
|
},
|
|
},
|
|
}
|
|
|
|
sql, args, err := r.queryBuilder.BuildDeleteQuery(TBL_NAME, filters)
|
|
if err != nil {
|
|
log.Printf("Unable to create delete main query : %v", err)
|
|
tx.Rollback()
|
|
return err
|
|
}
|
|
_, err = tx.ExecContext(c, sql, args...)
|
|
if err != nil {
|
|
log.Printf("Unable to executing delete antrian : %v", err)
|
|
tx.Rollback()
|
|
return err
|
|
}
|
|
|
|
_, err = tx.ExecContext(c, sql, args...)
|
|
if err != nil {
|
|
log.Printf("Error executing main delet query : %v", err)
|
|
tx.Rollback()
|
|
return err
|
|
}
|
|
|
|
tx.Commit()
|
|
|
|
return nil
|
|
}
|