api-antrian-operasi/internal/domain/reference/spesialis/repository.go

package spesialis

import (
	"antrian-operasi/internal/database"
	"errors"

	queryUtils "antrian-operasi/internal/utils/query"

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

const DB_NAME = "db_antrian"

type ISpesialisRepository interface {
	SearchableListSpesialis(c *gin.Context) ([]SpesialisModel, error)
	SearchableListSubSpesialis(c *gin.Context) ([]SubSpesialisModel, error)
	GetSpesialisById(c *gin.Context, id int) (SpesialisModel, error)
	GetSubSpesialisById(c *gin.Context, id int) (SubSpesialisModel, error)
}

type spesialisRepo struct {
	queryBuilder *queryUtils.QueryBuilder
	db           database.Service
}

func NewRepository(dbService database.Service) ISpesialisRepository {
	queryBuilder := queryUtils.NewQueryBuilder(queryUtils.DBTypePostgreSQL).
		SetAllowedColumns([]string{
			"id",
			"Kode",
			"Spesialis",
			"Subspesialis",
			"FK_daftar_spesialis_ID",
		})
	queryBuilder.SetSecurityOptions(false, 100)

	return spesialisRepo{
		queryBuilder: queryBuilder,
		db:           dbService,
	}
}

func baseQueryListSpesialis() queryUtils.DynamicQuery {
	return queryUtils.DynamicQuery{
		From: "daftar_spesialis",
		Fields: []queryUtils.SelectField{
			{Expression: "id"},
			{Expression: "Kode"},
			{Expression: "Spesialis"},
		},
	}
}

func baseQueryListSubSpesialis() queryUtils.DynamicQuery {
	query := queryUtils.DynamicQuery{
		From:    "daftar_subspesialis",
		Aliases: "dss",
		Fields: []queryUtils.SelectField{
			{Expression: "dss.id", Alias: "id"},
			{Expression: "dss.Kode", Alias: "Kode"},
			{Expression: "Subspesialis", Alias: "Subspesialis"},
			{Expression: "ds.Kode", Alias: "kode_spesialis"},
			{Expression: "ds.Spesialis", Alias: "spesialis"},
			{Expression: "ds.id", Alias: "id_spesialis"},
		},
	}

	query.Joins = []queryUtils.Join{
		{
			Type:  "LEFT",
			Table: "daftar_spesialis",
			Alias: "ds",
			OnConditions: queryUtils.FilterGroup{
				Filters: []queryUtils.DynamicFilter{
					{
						Column: "FK_daftar_spesialis_ID", Operator: queryUtils.OpEqual, Value: "ds.id",
					},
				},
			},
		},
	}

	return query
}

func (r spesialisRepo) SearchableListSpesialis(c *gin.Context) ([]SpesialisModel, error) {
	var result []SpesialisModel
	search := c.Query("search")

	query := baseQueryListSpesialis()

	if search != "" {
		searchFilters := []queryUtils.DynamicFilter{
			{Column: "Kode", Operator: queryUtils.OpILike, Value: "%" + search + "%"},
			{Column: "Spesialis", 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.Fatalf("unable to connect db %s", err)
		return result, err
	}

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

	return result, nil
}

func (r spesialisRepo) SearchableListSubSpesialis(c *gin.Context) ([]SubSpesialisModel, error) {
	var result []SubSpesialisModel
	search := c.Query("search")
	idSpesialis := c.Query("id_spesialis")

	query := baseQueryListSubSpesialis()

	if search != "" {
		searchFilters := []queryUtils.DynamicFilter{
			{Column: "dss.Kode", Operator: queryUtils.OpILike, Value: "%" + search + "%"},
			{Column: "dss.Subspesialis", Operator: queryUtils.OpILike, Value: "%" + search + "%"},
			{Column: "ds.Kode", Operator: queryUtils.OpILike, Value: "%" + search + "%"},
			{Column: "ds.Spesialis", Operator: queryUtils.OpILike, Value: "%" + search + "%"},
		}
		query.Filters = append(query.Filters, queryUtils.FilterGroup{Filters: searchFilters, LogicOp: "OR"})
	}

	if idSpesialis != "" {
		spesialisFilter := []queryUtils.DynamicFilter{
			{Column: "ds.id", Operator: queryUtils.OpEqual, Value: idSpesialis},
		}
		query.Filters = append(query.Filters, queryUtils.FilterGroup{Filters: spesialisFilter})
	}

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

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

	return result, nil
}

func (r spesialisRepo) GetSpesialisById(c *gin.Context, id int) (SpesialisModel, error) {
	var resultQuery []SpesialisModel
	var result SpesialisModel

	query := baseQueryListSpesialis()

	query.Filters = append(query.Filters, queryUtils.FilterGroup{Filters: []queryUtils.DynamicFilter{
		{Column: "id", Operator: queryUtils.OpEqual, Value: id},
	}})

	dbconn, err := r.db.GetSQLXDB(DB_NAME)
	if err != nil {
		return result, err
	}

	err = r.queryBuilder.ExecuteQuery(
		c, dbconn, query, &resultQuery)
	if err != nil {
		return result, err
	}

	if len(resultQuery) == 0 {
		notFoundError := errors.New("spesialis not found")
		return result, notFoundError
	}

	return resultQuery[0], nil
}

func (r spesialisRepo) GetSubSpesialisById(c *gin.Context, id int) (SubSpesialisModel, error) {
	var resultQuery []SubSpesialisModel
	var result SubSpesialisModel

	query := baseQueryListSubSpesialis()

	query.Filters = append(query.Filters, queryUtils.FilterGroup{Filters: []queryUtils.DynamicFilter{
		{Column: "dss.id", Operator: queryUtils.OpEqual, Value: id},
	}})

	dbconn, err := r.db.GetSQLXDB(DB_NAME)
	if err != nil {
		return result, err
	}

	err = r.queryBuilder.ExecuteQuery(
		c, dbconn, query, &resultQuery)
	if err != nil {
		return result, err
	}

	if len(resultQuery) == 0 {
		notFoundError := errors.New("sub spesialisasi not found")
		return result, notFoundError
	}

	return resultQuery[0], nil
}