initiate repo

internal/domain/reference/kategori/handler.go

@@ -0,0 +1,24 @@
+package kategori
+
+import (
+	"net/http"
+
+	"github.com/gin-gonic/gin"
+)
+
+type KategoriHandler struct {
+	repo IKategoriRepository
+}
+
+func NewKategoriHandler(repo IKategoriRepository) KategoriHandler {
+	return KategoriHandler{repo}
+}
+
+func (h KategoriHandler) ListKategoriOperasi(c *gin.Context) {
+	list, err := h.repo.SearchableListKategori(c)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, err)
+	}
+
+	c.JSON(http.StatusOK, list)
+}

internal/domain/reference/kategori/model.go

@@ -0,0 +1,14 @@
+package kategori
+
+import (
+	"database/sql"
+	"time"
+)
+
+type KategoriOperasiModel struct {
+	ID          int          `json:"id" db:"id"`
+	Status      string       `json:"status" db:"status" validate:"oneof=draft published"`
+	Kategori    string       `json:"kategori" db:"kategori"`
+	DateCreated time.Time    `json:"date_created" db:"date_created"`
+	DateUpdated sql.NullTime `json:"date_updated" db:"date_updated"`
+}

internal/domain/reference/kategori/repository.go

@@ -0,0 +1,77 @@
+package kategori
+
+import (
+	"antrian-operasi/internal/database"
+	"log"
+
+	queryUtils "antrian-operasi/internal/utils/query"
+
+	"github.com/gin-gonic/gin"
+)
+
+const DB_NAME = "db_antrian"
+
+type IKategoriRepository interface {
+	SearchableListKategori(c *gin.Context) ([]KategoriOperasiModel, error)
+}
+
+type kategoriRepo struct {
+	queryBuilder *queryUtils.QueryBuilder
+	db           database.Service
+}
+
+func NewRepository(dbService database.Service) IKategoriRepository {
+	queryBuilder := queryUtils.NewQueryBuilder(queryUtils.DBTypePostgreSQL).
+		SetAllowedColumns([]string{
+			"id",
+			"status",
+			"date_created",
+			"date_updated",
+			"Kategori",
+		})
+	queryBuilder.SetSecurityOptions(false, 100)
+
+	return kategoriRepo{
+		queryBuilder: queryBuilder,
+		db:           dbService,
+	}
+}
+
+func (r kategoriRepo) SearchableListKategori(c *gin.Context) ([]KategoriOperasiModel, error) {
+	var result []KategoriOperasiModel
+	search := c.Query("search")
+
+	query := queryUtils.DynamicQuery{
+		From: "daftar_kategori_operasi",
+		Fields: []queryUtils.SelectField{
+			{Expression: "id"},
+			{Expression: "status"},
+			{Expression: "date_created"},
+			{Expression: "date_updated"},
+			{Expression: "Kategori", Alias: "kategori"},
+		},
+		Sort: []queryUtils.SortField{
+			{Column: "date_created", Order: "DESC"},
+		},
+	}
+
+	if search != "" {
+		searchFilters := []queryUtils.DynamicFilter{
+			{Column: "Kategori", 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)
+	}
+
+	err = r.queryBuilder.ExecuteQuery(
+		c, dbconn, query, &result)
+	if err != nil {
+		log.Fatalf("unable to execute query %s", err)
+	}
+
+	return result, nil
+}

internal/domain/reference/kategori/routes.go

@@ -0,0 +1,17 @@
+package kategori
+
+import (
+	"antrian-operasi/internal/database"
+
+	"github.com/gin-gonic/gin"
+)
+
+func RegisterRoutes(r *gin.RouterGroup, dbService database.Service) {
+	ketegoriRepo := NewRepository(dbService)
+	kategoriHandler := NewKategoriHandler(ketegoriRepo)
+
+	kategori := r.Group("/kategori")
+	{
+		kategori.GET("", kategoriHandler.ListKategoriOperasi)
+	}
+}

internal/domain/reference/spesialis/handler.go

@@ -0,0 +1,33 @@
+package spesialis
+
+import (
+	"net/http"
+
+	"github.com/gin-gonic/gin"
+)
+
+type SpesialisHandler struct {
+	repo ISpesialisRepository
+}
+
+func NewSpesialisHandler(repo ISpesialisRepository) SpesialisHandler {
+	return SpesialisHandler{repo}
+}
+
+func (h SpesialisHandler) ListSpesialis(c *gin.Context) {
+	list, err := h.repo.SearchableListSpesialis(c)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, err)
+	}
+
+	c.JSON(http.StatusOK, list)
+}
+
+func (h SpesialisHandler) ListSubSpesialis(c *gin.Context) {
+	list, err := h.repo.SearchableListSubSpesialis(c)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, err)
+	}
+
+	c.JSON(http.StatusOK, list)
+}

internal/domain/reference/spesialis/model.go

@@ -0,0 +1,16 @@
+package spesialis
+
+type SpesialisModel struct {
+	ID        int    `json:"id" db:"id"`
+	Kode      string `json:"kode" db:"Kode"`
+	Spesialis string `json:"spesialis" db:"Spesialis"`
+}
+
+type SubSpesialisModel struct {
+	ID               int    `json:"id" db:"id"`
+	KodeSpesialis    string `json:"kode_spesialis" db:"kode_spesialis"`
+	Spesialis        string `json:"spesialis" db:"spesialis"`
+	KodeSubSpesialis string `json:"kode" db:"Kode"`
+	SubSpesialis     string `json:"sub_spesialis" db:"Subspesialis"`
+	IDSpesialis      int    `json:"id_spesialis" db:"id_spesialis"`
+}

internal/domain/reference/spesialis/repository.go

@@ -0,0 +1,128 @@
+package spesialis
+
+import (
+	"antrian-operasi/internal/database"
+	"log"
+
+	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)
+}
+
+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 (r spesialisRepo) SearchableListSpesialis(c *gin.Context) ([]SpesialisModel, error) {
+	var result []SpesialisModel
+	search := c.Query("search")
+
+	query := queryUtils.DynamicQuery{
+		From: "daftar_spesialis",
+		Fields: []queryUtils.SelectField{
+			{Expression: "id"},
+			{Expression: "Kode"},
+			{Expression: "Spesialis"},
+		},
+	}
+
+	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)
+	}
+
+	err = r.queryBuilder.ExecuteQuery(
+		c, dbconn, query, &result)
+	if err != nil {
+		log.Fatalf("unable to execute query %s", err)
+	}
+
+	return result, nil
+}
+
+func (r spesialisRepo) SearchableListSubSpesialis(c *gin.Context) ([]SubSpesialisModel, error) {
+	var result []SubSpesialisModel
+	search := c.Query("search")
+
+	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",
+					},
+				},
+			},
+		},
+	}
+
+	if search != "" {
+		searchFilters := []queryUtils.DynamicFilter{
+			{Column: "dss.Kode", Operator: queryUtils.OpILike, Value: "%" + search + "%"},
+			{Column: "dss.Subspesialis", 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)
+	}
+
+	err = r.queryBuilder.ExecuteQuery(
+		c, dbconn, query, &result)
+	if err != nil {
+		log.Fatalf("unable to execute query %s", err)
+	}
+
+	return result, nil
+}

internal/domain/reference/spesialis/routes.go

@@ -0,0 +1,15 @@
+package spesialis
+
+import (
+	"antrian-operasi/internal/database"
+
+	"github.com/gin-gonic/gin"
+)
+
+func RegisterRoutes(r *gin.RouterGroup, dbService database.Service) {
+	spesialisRepo := NewRepository(dbService)
+	spesialisHandler := NewSpesialisHandler(spesialisRepo)
+
+	r.GET("/spesialis", spesialisHandler.ListSpesialis)
+	r.GET("/sub-spesialis", spesialisHandler.ListSubSpesialis)
+}