renaldybrada
690 lines
20 KiB
Go
690 lines
20 KiB
Go
package antrianoperasi
|
|
|
|
import (
|
|
"antrian-operasi/internal/database"
|
|
"antrian-operasi/internal/shared"
|
|
queryUtils "antrian-operasi/internal/utils/query"
|
|
"log"
|
|
"slices"
|
|
"strconv"
|
|
"time"
|
|
|
|
"github.com/gin-gonic/gin"
|
|
"github.com/google/uuid"
|
|
)
|
|
|
|
const DB_NAME = "db_antrian"
|
|
const TBL_NAME = "data_pasien_operasi"
|
|
const TBL_DIAGNOSA_OPERASI = "data_diagnosa_pasien_operasi"
|
|
|
|
type IAntrianOperasiRepository interface {
|
|
CreateAntrianOperasi(c *gin.Context, req CreatePasienOperasiRequest) (CreatePasienOperasiRequest, error)
|
|
SearchableListAntrianOperasi(c *gin.Context) (ListPasienOperasiPaginate, error)
|
|
GetAntrianOperasiById(c *gin.Context, id string) (DetailPasienOperasiResultQuery, 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", "\"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_status_pasien\"",
|
|
"\"Nomor_spesialis\"", "\"Nomor_sub_spesialis\"",
|
|
"\"Nomor_telepon\"",
|
|
"\"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",
|
|
}).
|
|
SetAllowedTables([]string{TBL_NAME, TBL_DIAGNOSA_OPERASI})
|
|
queryBuilder.SetSecurityOptions(false, 100)
|
|
|
|
return antrianOperasiRepo{
|
|
queryBuilder: queryBuilder,
|
|
db: dbService,
|
|
}
|
|
}
|
|
|
|
func (r antrianOperasiRepo) CreateAntrianOperasi(c *gin.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_status_pasien\"",
|
|
"\"Nomor_spesialis\"", "\"Nomor_sub_spesialis\"",
|
|
}, Values: []interface{}{
|
|
idAntrian,
|
|
req.StatusPasienData.StatusOperasi,
|
|
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,
|
|
req.StatusPasienData.StatusOperasi,
|
|
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 data_telepon_pasien_operasi
|
|
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("data_telepon_pasien_operasi", insertTeleponQuery, returningCols...)
|
|
if err != nil {
|
|
log.Printf("error building query telepon %s", err)
|
|
tx.Rollback()
|
|
|
|
return req, err
|
|
}
|
|
_, err = tx.ExecContext(c, sql, args...)
|
|
if err != nil {
|
|
tx.Rollback()
|
|
|
|
log.Println(err)
|
|
|
|
return req, 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("data_diagnosa_pasien_operasi", insertDiagnosaQuery, returningCols...)
|
|
if err != nil {
|
|
log.Printf("error building query diagnosa %s", err)
|
|
tx.Rollback()
|
|
|
|
return req, err
|
|
}
|
|
_, err = tx.ExecContext(c, sql, args...)
|
|
if err != nil {
|
|
tx.Rollback()
|
|
|
|
log.Println(err)
|
|
|
|
return req, 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("data_tindakan_pasien_operasi", insertTindakanQuery, returningCols...)
|
|
if err != nil {
|
|
log.Printf("error building query tindakan %s", err)
|
|
tx.Rollback()
|
|
|
|
return req, err
|
|
}
|
|
_, err = tx.ExecContext(c, sql, args...)
|
|
if err != nil {
|
|
tx.Rollback()
|
|
|
|
log.Println(err)
|
|
|
|
return req, err
|
|
}
|
|
log.Printf("success insert tindakan")
|
|
|
|
// INSERT data_pasien_operasi_data_pegawai
|
|
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("data_pasien_operasi_data_pegawai", insertDokterPelaksanaQuery, returningCols...)
|
|
if err != nil {
|
|
log.Printf("error building query dokter pelaksana %s", err)
|
|
tx.Rollback()
|
|
|
|
return req, err
|
|
}
|
|
_, err = tx.ExecContext(c, sql, args...)
|
|
if err != nil {
|
|
tx.Rollback()
|
|
|
|
log.Println(err)
|
|
|
|
return req, err
|
|
}
|
|
log.Printf("success insert dokter pelaksana")
|
|
|
|
// COMMIT TRANSACTION
|
|
tx.Commit()
|
|
|
|
return req, nil
|
|
}
|
|
|
|
func (r antrianOperasiRepo) SearchableListAntrianOperasi(c *gin.Context) (ListPasienOperasiPaginate, error) {
|
|
var result ListPasienOperasiPaginate
|
|
search := c.Query("search")
|
|
availableType := []string{"all", "kategori", "spesialis", "sub-spesialis"}
|
|
antrianType := c.Query("type")
|
|
antrianTypeId, err := strconv.Atoi(c.Query("type_id"))
|
|
if err != nil {
|
|
antrianTypeId = 0
|
|
}
|
|
if !slices.Contains(availableType, antrianType) {
|
|
antrianType = "all"
|
|
}
|
|
limit := shared.ParseQueryLimit(c)
|
|
offset := shared.ParseQueryOffset(c)
|
|
statusOp := c.Query("status")
|
|
|
|
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\".\"Kategori_operasi\", \"dpo\".\"Spesialis\"",
|
|
OrderBy: "\"dpo\".\"Tanggal_daftar\"",
|
|
Alias: "no_urut_spesialis",
|
|
}
|
|
wfSubSpesialis := queryUtils.WindowFunction{
|
|
Function: "ROW_NUMBER",
|
|
Over: "\"dpo\".\"Kategori_operasi\", \"dpo\".\"Spesialis\", \"dpo\".\"Sub_spesialis\"",
|
|
OrderBy: "\"dpo\".\"Tanggal_daftar\"",
|
|
Alias: "no_urut_sub_spesialis",
|
|
}
|
|
|
|
var selectFilter []queryUtils.DynamicFilter
|
|
typeIdColumn := ""
|
|
|
|
switch antrianType {
|
|
case "kategori":
|
|
typeIdColumn = "dko.id"
|
|
query.WindowFunctions = append(query.WindowFunctions, wfKategori, wfSpesialis, wfSubSpesialis)
|
|
case "spesialis":
|
|
typeIdColumn = "ds.id"
|
|
query.WindowFunctions = append(query.WindowFunctions, wfSpesialis, wfSubSpesialis)
|
|
case "sub-spesialis":
|
|
typeIdColumn = "dss.id"
|
|
query.WindowFunctions = append(query.WindowFunctions, wfSubSpesialis)
|
|
default:
|
|
query.WindowFunctions = append(query.WindowFunctions, wfKategori, wfSpesialis, wfSubSpesialis)
|
|
}
|
|
|
|
if antrianTypeId != 0 && antrianType != "all" {
|
|
selectFilter = append(selectFilter, queryUtils.DynamicFilter{Column: typeIdColumn, Operator: queryUtils.OpEqual, Value: antrianTypeId})
|
|
}
|
|
|
|
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 search != "" {
|
|
searchFilters := []queryUtils.DynamicFilter{
|
|
{Column: "dpo.No_KTP", Operator: queryUtils.OpILike, Value: "%" + search + "%"},
|
|
{Column: "dpo.No_rekam_medis", Operator: queryUtils.OpILike, Value: "%" + search + "%"},
|
|
{Column: "dpo.Nama_pasien", Operator: queryUtils.OpILike, Value: "%" + search + "%"},
|
|
}
|
|
|
|
query.Filters = append(query.Filters, queryUtils.FilterGroup{Filters: searchFilters, LogicOp: "OR"})
|
|
}
|
|
|
|
if statusOp != "" {
|
|
selectFilter = append(selectFilter, queryUtils.DynamicFilter{Column: "dpo.Status_operasi", Operator: queryUtils.OpEqual, Value: statusOp})
|
|
}
|
|
|
|
// 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 = limit
|
|
result.Paging.Offset = offset
|
|
result.Paging.Total = int(countData)
|
|
result.Paging.CalculatePagingInfo()
|
|
|
|
// query data
|
|
queryData := query
|
|
queryData.Limit = limit
|
|
queryData.Offset = 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 *gin.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: "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: "data_diagnosa_pasien_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: "data_tindakan_pasien_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: "data_telepon_pasien_operasi",
|
|
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: "data_pasien_operasi_data_pegawai_2",
|
|
Aliases: "dpodp",
|
|
Fields: []queryUtils.SelectField{
|
|
{Expression: "dpodp.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
|
|
}
|