api-antrian-operasi/internal/domain/antrian_operasi/repository.go

package antrianoperasi

import (
	"antrian-operasi/internal/database"
	queryUtils "antrian-operasi/internal/utils/query"
	"log"
	"time"

	"github.com/gin-gonic/gin"
	"github.com/google/uuid"
)

const DB_NAME = "db_antrian"
const TBL_NAME = "data_pasien_operasi"

type IAntrianOperasiRepository interface {
	CreateAntrianOperasi(c *gin.Context, req CreatePasienOperasiRequest) (CreatePasienOperasiRequest, error)
	SearchableListAntrianOperasi(c *gin.Context) ([]PasienOperasi, 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\"",
			"\"Kode_diagnosa\"", "\"Diagnosa\"", "\"Jenis_diagnosa\"", "\"FK_pasien_operasi_diagnosa_pasien_operasi_ID\"",
			"\"Kode_tindakan\"", "\"Tindakan\"", "\"Tindakan_tambahan\"", "\"FK_pasien_operasi_tindakan_pasien_operasi_ID\"",
			"\"data_pasien_operasi_id\"", "\"data_pegawai_id\"",
		})
	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) ([]PasienOperasi, error) {
	var result []PasienOperasi
	search := c.Query("search")

	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: "ds.Spesialis", Alias: "spesialis"},
			{Expression: "dss.Subspesialis", Alias: "subspesialis"},
			{Expression: "ddpo.Kode_diagnosa", Alias: "kode_diagnosa"},
			{Expression: "ddpo.Diagnosa", Alias: "diagnosa"},
			{Expression: "dko.Kategori", Alias: "kategori"},
		},
		Limit: 10,
		Sort: []queryUtils.SortField{
			{Column: "created_at", Order: "DESC"}},
	}

	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",
					},
				},
			},
		},
		{
			Type:  "LEFT",
			Table: "data_diagnosa_pasien_operasi",
			Alias: "ddpo",
			OnConditions: queryUtils.FilterGroup{
				Filters: []queryUtils.DynamicFilter{
					{
						Column: "dpo.id", Operator: queryUtils.OpEqual, Value: "ddpo.FK_pasien_operasi_diagnosa_pasien_operasi_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"})
	}

	dbconn, err := r.db.GetSQLXDB(DB_NAME)
	if err != nil {
		log.Printf("Unable to connect db : %s", err)
		return result, err
	}

	err = r.queryBuilder.ExecuteQuery(
		c, dbconn, query, &result)
	if err != nil {
		log.Printf("Unable to execute query : %s", err)
		return result, err
	}

	return result, nil
}