first commit

internal/infrastructure/transport/http/handlers/satusehat/usecase/allergyintolerance_handler.go

@@ -0,0 +1,81 @@
+package usecase
+
+import (
+	"net/http"
+	"service/internal/satusehat/usecase/allergyintolerance"
+	"service/pkg/response"
+	"service/pkg/utils/validator"
+
+	"github.com/gin-gonic/gin"
+)
+
+type AllergyIntoleranceHandler struct{ service allergyintolerance.Service }
+
+func NewAllergyIntoleranceHandler(s allergyintolerance.Service) *AllergyIntoleranceHandler {
+	return &AllergyIntoleranceHandler{service: s}
+}
+
+func (h *AllergyIntoleranceHandler) RegisterRoutes(router *gin.RouterGroup) {
+	g := router.Group("/satusehat/allergyintolerance")
+	g.POST("", h.Create)
+	g.GET("", h.Search)
+	g.GET("/:id", h.GetByID)
+	g.PUT("/:id", h.Update)
+	g.PATCH("/:id", h.Patch)
+}
+
+func (h *AllergyIntoleranceHandler) Create(c *gin.Context) {
+	var req allergyintolerance.AllergyIntoleranceRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		response.ErrorWithLog(c, err, http.StatusBadRequest, "Invalid request", validator.TranslateError(err))
+		return
+	}
+	res, err := h.service.Create(c.Request.Context(), req)
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusCreated, "Success", res.FullResponse)
+}
+func (h *AllergyIntoleranceHandler) Update(c *gin.Context) {
+	var req allergyintolerance.AllergyIntoleranceRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		response.ErrorWithLog(c, err, http.StatusBadRequest, "Invalid request", validator.TranslateError(err))
+		return
+	}
+	res, err := h.service.Update(c.Request.Context(), c.Param("id"), req)
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusOK, "Success", res.FullResponse)
+}
+func (h *AllergyIntoleranceHandler) Patch(c *gin.Context) {
+	var req allergyintolerance.AllergyIntolerancePatchRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		response.ErrorWithLog(c, err, http.StatusBadRequest, "Invalid patch", validator.TranslateError(err))
+		return
+	}
+	res, err := h.service.Patch(c.Request.Context(), c.Param("id"), req)
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusOK, "Success", res.FullResponse)
+}
+func (h *AllergyIntoleranceHandler) GetByID(c *gin.Context) {
+	res, err := h.service.GetByID(c.Request.Context(), c.Param("id"))
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusOK, "Success", res.FullResponse)
+}
+func (h *AllergyIntoleranceHandler) Search(c *gin.Context) {
+	res, err := h.service.Search(c.Request.Context(), c.Request.URL.Query())
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusOK, "Success", res.FullResponse)
+}

internal/infrastructure/transport/http/handlers/satusehat/usecase/careplan_handler.go

@@ -0,0 +1,79 @@
+package usecase
+
+import (
+	"net/http"
+	"service/internal/satusehat/usecase/careplan"
+	"service/pkg/response"
+	"service/pkg/utils/validator"
+
+	"github.com/gin-gonic/gin"
+)
+
+type CarePlanHandler struct{ service careplan.Service }
+
+func NewCarePlanHandler(s careplan.Service) *CarePlanHandler { return &CarePlanHandler{service: s} }
+
+func (h *CarePlanHandler) RegisterRoutes(router *gin.RouterGroup) {
+	g := router.Group("/satusehat/careplan")
+	g.POST("", h.Create)
+	g.GET("", h.Search)
+	g.GET("/:id", h.GetByID)
+	g.PUT("/:id", h.Update)
+	g.PATCH("/:id", h.Patch)
+}
+
+func (h *CarePlanHandler) Create(c *gin.Context) {
+	var req careplan.CarePlanRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		response.ErrorWithLog(c, err, http.StatusBadRequest, "Invalid request", validator.TranslateError(err))
+		return
+	}
+	res, err := h.service.Create(c.Request.Context(), req)
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusCreated, "Success", res.FullResponse)
+}
+func (h *CarePlanHandler) Update(c *gin.Context) {
+	var req careplan.CarePlanRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		response.ErrorWithLog(c, err, http.StatusBadRequest, "Invalid request", validator.TranslateError(err))
+		return
+	}
+	res, err := h.service.Update(c.Request.Context(), c.Param("id"), req)
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusOK, "Success", res.FullResponse)
+}
+func (h *CarePlanHandler) Patch(c *gin.Context) {
+	var req careplan.CarePlanPatchRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		response.ErrorWithLog(c, err, http.StatusBadRequest, "Invalid patch", validator.TranslateError(err))
+		return
+	}
+	res, err := h.service.Patch(c.Request.Context(), c.Param("id"), req)
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusOK, "Success", res.FullResponse)
+}
+func (h *CarePlanHandler) GetByID(c *gin.Context) {
+	res, err := h.service.GetByID(c.Request.Context(), c.Param("id"))
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusOK, "Success", res.FullResponse)
+}
+func (h *CarePlanHandler) Search(c *gin.Context) {
+	res, err := h.service.Search(c.Request.Context(), c.Request.URL.Query())
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusOK, "Success", res.FullResponse)
+}

internal/infrastructure/transport/http/handlers/satusehat/usecase/clinicalImpression_handler.go

@@ -0,0 +1,81 @@
+package usecase
+
+import (
+	"net/http"
+	clinicalimpression "service/internal/satusehat/usecase/clinicalImpression"
+	"service/pkg/response"
+	"service/pkg/utils/validator"
+
+	"github.com/gin-gonic/gin"
+)
+
+type ClinicalImpressionHandler struct{ service clinicalimpression.Service }
+
+func NewClinicalImpressionHandler(s clinicalimpression.Service) *ClinicalImpressionHandler {
+	return &ClinicalImpressionHandler{service: s}
+}
+
+func (h *ClinicalImpressionHandler) RegisterRoutes(router *gin.RouterGroup) {
+	g := router.Group("/satusehat/clinicalimpression")
+	g.POST("", h.Create)
+	g.GET("", h.Search)
+	g.GET("/:id", h.GetByID)
+	g.PUT("/:id", h.Update)
+	g.PATCH("/:id", h.Patch)
+}
+
+func (h *ClinicalImpressionHandler) Create(c *gin.Context) {
+	var req clinicalimpression.ClinicalImpressionRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		response.ErrorWithLog(c, err, http.StatusBadRequest, "Invalid request", validator.TranslateError(err))
+		return
+	}
+	res, err := h.service.Create(c.Request.Context(), req)
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusCreated, "Success", res.FullResponse)
+}
+func (h *ClinicalImpressionHandler) Update(c *gin.Context) {
+	var req clinicalimpression.ClinicalImpressionRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		response.ErrorWithLog(c, err, http.StatusBadRequest, "Invalid request", validator.TranslateError(err))
+		return
+	}
+	res, err := h.service.Update(c.Request.Context(), c.Param("id"), req)
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusOK, "Success", res.FullResponse)
+}
+func (h *ClinicalImpressionHandler) Patch(c *gin.Context) {
+	var req clinicalimpression.ClinicalImpressionPatchRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		response.ErrorWithLog(c, err, http.StatusBadRequest, "Invalid patch", validator.TranslateError(err))
+		return
+	}
+	res, err := h.service.Patch(c.Request.Context(), c.Param("id"), req)
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusOK, "Success", res.FullResponse)
+}
+func (h *ClinicalImpressionHandler) GetByID(c *gin.Context) {
+	res, err := h.service.GetByID(c.Request.Context(), c.Param("id"))
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusOK, "Success", res.FullResponse)
+}
+func (h *ClinicalImpressionHandler) Search(c *gin.Context) {
+	res, err := h.service.Search(c.Request.Context(), c.Request.URL.Query())
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusOK, "Success", res.FullResponse)
+}

internal/infrastructure/transport/http/handlers/satusehat/usecase/composition_handler.go

@@ -0,0 +1,102 @@
+package usecase
+
+import (
+	"net/http"
+
+	"service/internal/satusehat/usecase/composition"
+	"service/pkg/response"
+	"service/pkg/utils/validator"
+
+	"github.com/gin-gonic/gin"
+)
+
+type CompositionHandler struct {
+	service composition.Service
+}
+
+func NewCompositionHandler(service composition.Service) *CompositionHandler {
+	return &CompositionHandler{
+		service: service,
+	}
+}
+
+func (h *CompositionHandler) RegisterRoutes(router *gin.RouterGroup) {
+	group := router.Group("/satusehat/composition")
+	{
+		group.POST("", h.Create)
+		group.GET("", h.Search)
+		group.GET("/:id", h.GetByID)
+		group.PUT("/:id", h.Update)
+		group.PATCH("/:id", h.Patch)
+	}
+}
+
+func (h *CompositionHandler) Create(c *gin.Context) {
+	var req composition.CompositionRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		customErr := validator.TranslateError(err)
+		response.ErrorWithLog(c, err, http.StatusBadRequest, "Format permintaan tidak valid", customErr)
+		return
+	}
+
+	result, err := h.service.Create(c.Request.Context(), req)
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusCreated, "Successfully created Composition", result.FullResponse)
+}
+
+func (h *CompositionHandler) Update(c *gin.Context) {
+	id := c.Param("id")
+	var req composition.CompositionRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		customErr := validator.TranslateError(err)
+		response.ErrorWithLog(c, err, http.StatusBadRequest, "Format permintaan tidak valid", customErr)
+		return
+	}
+
+	result, err := h.service.Update(c.Request.Context(), id, req)
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusOK, "Successfully updated Composition", result.FullResponse)
+}
+
+func (h *CompositionHandler) Patch(c *gin.Context) {
+	id := c.Param("id")
+	var req composition.CompositionPatchRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		customErr := validator.TranslateError(err)
+		response.ErrorWithLog(c, err, http.StatusBadRequest, "Format permintaan patch tidak valid", customErr)
+		return
+	}
+
+	result, err := h.service.Patch(c.Request.Context(), id, req)
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusOK, "Successfully patched Composition", result.FullResponse)
+}
+
+func (h *CompositionHandler) GetByID(c *gin.Context) {
+	id := c.Param("id")
+	result, err := h.service.GetByID(c.Request.Context(), id)
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusOK, "Successfully retrieved Composition", result.FullResponse)
+}
+
+func (h *CompositionHandler) Search(c *gin.Context) {
+	queryParams := c.Request.URL.Query()
+	result, err := h.service.Search(c.Request.Context(), queryParams)
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusOK, "Successfully retrieved Compositions", result.FullResponse)
+}

internal/infrastructure/transport/http/handlers/satusehat/usecase/condition_handler.go

@@ -0,0 +1,102 @@
+package usecase
+
+import (
+	"net/http"
+
+	"service/internal/satusehat/usecase/condition"
+	"service/pkg/response"
+	"service/pkg/utils/validator"
+
+	"github.com/gin-gonic/gin"
+)
+
+type ConditionHandler struct {
+	service condition.Service
+}
+
+func NewConditionHandler(service condition.Service) *ConditionHandler {
+	return &ConditionHandler{
+		service: service,
+	}
+}
+
+func (h *ConditionHandler) RegisterRoutes(router *gin.RouterGroup) {
+	group := router.Group("/satusehat/condition")
+	{
+		group.POST("", h.Create)
+		group.GET("", h.Search)
+		group.GET("/:id", h.GetByID)
+		group.PUT("/:id", h.Update)
+		group.PATCH("/:id", h.Patch)
+	}
+}
+
+func (h *ConditionHandler) Create(c *gin.Context) {
+	var req condition.ConditionRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		customErr := validator.TranslateError(err)
+		response.ErrorWithLog(c, err, http.StatusBadRequest, "Format permintaan tidak valid", customErr)
+		return
+	}
+
+	result, err := h.service.Create(c.Request.Context(), req)
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusCreated, "Successfully created Condition", result)
+}
+
+func (h *ConditionHandler) Update(c *gin.Context) {
+	id := c.Param("id")
+	var req condition.ConditionRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		customErr := validator.TranslateError(err)
+		response.ErrorWithLog(c, err, http.StatusBadRequest, "Format permintaan tidak valid", customErr)
+		return
+	}
+
+	result, err := h.service.Update(c.Request.Context(), id, req)
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusOK, "Successfully updated Condition", result)
+}
+
+func (h *ConditionHandler) Patch(c *gin.Context) {
+	id := c.Param("id")
+	var req condition.ConditionPatchRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		customErr := validator.TranslateError(err)
+		response.ErrorWithLog(c, err, http.StatusBadRequest, "Format permintaan patch tidak valid", customErr)
+		return
+	}
+
+	result, err := h.service.Patch(c.Request.Context(), id, req)
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusOK, "Successfully patched Condition", result)
+}
+
+func (h *ConditionHandler) GetByID(c *gin.Context) {
+	id := c.Param("id")
+	result, err := h.service.GetByID(c.Request.Context(), id)
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusOK, "Successfully retrieved Condition", result)
+}
+
+func (h *ConditionHandler) Search(c *gin.Context) {
+	queryParams := c.Request.URL.Query()
+	result, err := h.service.Search(c.Request.Context(), queryParams)
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusOK, "Successfully retrieved Conditions", result)
+}

internal/infrastructure/transport/http/handlers/satusehat/usecase/diagnosticreport_handler.go

@@ -0,0 +1,81 @@
+package usecase
+
+import (
+	"net/http"
+	"service/internal/satusehat/usecase/diagnosticreport"
+	"service/pkg/response"
+	"service/pkg/utils/validator"
+
+	"github.com/gin-gonic/gin"
+)
+
+type DiagnosticReportHandler struct{ service diagnosticreport.Service }
+
+func NewDiagnosticReportHandler(s diagnosticreport.Service) *DiagnosticReportHandler {
+	return &DiagnosticReportHandler{service: s}
+}
+
+func (h *DiagnosticReportHandler) RegisterRoutes(router *gin.RouterGroup) {
+	g := router.Group("/satusehat/diagnosticreport")
+	g.POST("", h.Create)
+	g.GET("", h.Search)
+	g.GET("/:id", h.GetByID)
+	g.PUT("/:id", h.Update)
+	g.PATCH("/:id", h.Patch)
+}
+
+func (h *DiagnosticReportHandler) Create(c *gin.Context) {
+	var req diagnosticreport.DiagnosticReportRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		response.ErrorWithLog(c, err, http.StatusBadRequest, "Invalid request", validator.TranslateError(err))
+		return
+	}
+	res, err := h.service.Create(c.Request.Context(), req)
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusCreated, "Success", res.FullResponse)
+}
+func (h *DiagnosticReportHandler) Update(c *gin.Context) {
+	var req diagnosticreport.DiagnosticReportRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		response.ErrorWithLog(c, err, http.StatusBadRequest, "Invalid request", validator.TranslateError(err))
+		return
+	}
+	res, err := h.service.Update(c.Request.Context(), c.Param("id"), req)
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusOK, "Success", res.FullResponse)
+}
+func (h *DiagnosticReportHandler) Patch(c *gin.Context) {
+	var req diagnosticreport.DiagnosticReportPatchRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		response.ErrorWithLog(c, err, http.StatusBadRequest, "Invalid patch", validator.TranslateError(err))
+		return
+	}
+	res, err := h.service.Patch(c.Request.Context(), c.Param("id"), req)
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusOK, "Success", res.FullResponse)
+}
+func (h *DiagnosticReportHandler) GetByID(c *gin.Context) {
+	res, err := h.service.GetByID(c.Request.Context(), c.Param("id"))
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusOK, "Success", res.FullResponse)
+}
+func (h *DiagnosticReportHandler) Search(c *gin.Context) {
+	res, err := h.service.Search(c.Request.Context(), c.Request.URL.Query())
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusOK, "Success", res.FullResponse)
+}

internal/infrastructure/transport/http/handlers/satusehat/usecase/encounter_handler.go

@@ -0,0 +1,149 @@
+package usecase
+
+import (
+	"errors"
+	"net/http"
+	"strconv"
+	"time"
+
+	"service/internal/interfaces/satusehat"
+	"service/internal/satusehat/usecase/encounter"
+	pkgErrors "service/pkg/errors"
+	"service/pkg/response"
+	"service/pkg/utils/validator"
+
+	"github.com/gin-gonic/gin"
+)
+
+type EncounterHandler struct {
+	service encounter.Service
+}
+
+func NewEncounterHandler(service encounter.Service) *EncounterHandler {
+	return &EncounterHandler{
+		service: service,
+	}
+}
+
+func (h *EncounterHandler) RegisterRoutes(router *gin.RouterGroup) {
+	group := router.Group("/satusehat/encounter")
+	{
+		group.POST("", h.Create)
+		group.POST("/sync/:idxdaftar", h.SyncFromSIMRS)
+		group.GET("", h.Search)
+		group.GET("/:id", h.GetByID)
+		group.PUT("/:id", h.Update)
+		group.PATCH("/:id", h.Patch)
+	}
+}
+
+// handleSatuSehatError mengekstrak OperationOutcome agar JSON bisa tampil terstruktur
+func handleSatuSehatError(c *gin.Context, err error) {
+	var ssErr *satusehat.ErrorOperationOutcome
+	if errors.As(err, &ssErr) {
+		c.Error(err) // Log error asli
+		c.JSON(ssErr.StatusCode, gin.H{
+			"status":  "error",
+			"message": ssErr.Outcome,
+			"error": gin.H{
+				"severity":  "error",
+				"timestamp": time.Now().UTC().Format(time.RFC3339),
+			},
+		})
+		return
+	}
+	appErr := pkgErrors.FromError(err)
+	response.ErrorWithLog(c, err, appErr.HTTPStatus(), appErr.Error(), appErr.Metadata())
+}
+
+func (h *EncounterHandler) Create(c *gin.Context) {
+	var req encounter.EncounterRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		customErr := validator.TranslateError(err)
+		response.ErrorWithLog(c, err, http.StatusBadRequest, "Format permintaan tidak valid", customErr)
+		return
+	}
+
+	result, err := h.service.Create(c.Request.Context(), req)
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+
+	// Di sini, Anda bisa menyimpan result.RawResponse atau result.ID ke database log jika diperlukan.
+	// Contoh:
+	// go logService.Create(c.Request.Context(), "encounter_create", req, result.RawResponse, http.StatusCreated)
+
+	response.Success(c, http.StatusCreated, "Successfully created Encounter", result.FullResponse)
+}
+
+func (h *EncounterHandler) Update(c *gin.Context) {
+	id := c.Param("id")
+	var req encounter.EncounterRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		customErr := validator.TranslateError(err)
+		response.ErrorWithLog(c, err, http.StatusBadRequest, "Format permintaan tidak valid", customErr)
+		return
+	}
+
+	result, err := h.service.Update(c.Request.Context(), id, req)
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusOK, "Successfully updated Encounter", result.FullResponse)
+}
+
+func (h *EncounterHandler) Patch(c *gin.Context) {
+	id := c.Param("id")
+	var req encounter.EncounterPatchRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		customErr := validator.TranslateError(err)
+		response.ErrorWithLog(c, err, http.StatusBadRequest, "Format permintaan patch tidak valid", customErr)
+		return
+	}
+
+	result, err := h.service.Patch(c.Request.Context(), id, req)
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusOK, "Successfully patched Encounter", result.FullResponse)
+}
+
+func (h *EncounterHandler) GetByID(c *gin.Context) {
+	id := c.Param("id")
+	result, err := h.service.GetByID(c.Request.Context(), id)
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusOK, "Successfully retrieved Encounter", result.FullResponse)
+}
+
+func (h *EncounterHandler) Search(c *gin.Context) {
+	// Get query parameters string natively and fetch it directly (like: ?patient=xxx&status=active)
+	queryParams := c.Request.URL.Query()
+	result, err := h.service.Search(c.Request.Context(), queryParams)
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusOK, "Successfully retrieved Encounters", result.FullResponse)
+}
+
+func (h *EncounterHandler) SyncFromSIMRS(c *gin.Context) {
+	idxdaftarStr := c.Param("idxdaftar")
+	idxdaftar, err := strconv.ParseInt(idxdaftarStr, 10, 64)
+	if err != nil {
+		response.ErrorWithLog(c, err, http.StatusBadRequest, "Format idxdaftar tidak valid", nil)
+		return
+	}
+
+	result, err := h.service.SyncFromSIMRS(c.Request.Context(), idxdaftar)
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusOK, "Successfully synced Encounter from SIMRS", result.FullResponse)
+}

internal/infrastructure/transport/http/handlers/satusehat/usecase/episodeofcare_handler.go

@@ -0,0 +1,102 @@
+package usecase
+
+import (
+	"net/http"
+
+	"service/internal/satusehat/usecase/episodeofcare"
+	"service/pkg/response"
+	"service/pkg/utils/validator"
+
+	"github.com/gin-gonic/gin"
+)
+
+type EpisodeOfCareHandler struct {
+	service episodeofcare.Service
+}
+
+func NewEpisodeOfCareHandler(service episodeofcare.Service) *EpisodeOfCareHandler {
+	return &EpisodeOfCareHandler{
+		service: service,
+	}
+}
+
+func (h *EpisodeOfCareHandler) RegisterRoutes(router *gin.RouterGroup) {
+	group := router.Group("/satusehat/episodeofcare")
+	{
+		group.POST("", h.Create)
+		group.GET("", h.Search)
+		group.GET("/:id", h.GetByID)
+		group.PUT("/:id", h.Update)
+		group.PATCH("/:id", h.Patch)
+	}
+}
+
+func (h *EpisodeOfCareHandler) Create(c *gin.Context) {
+	var req episodeofcare.EpisodeOfCareRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		customErr := validator.TranslateError(err)
+		response.ErrorWithLog(c, err, http.StatusBadRequest, "Format permintaan tidak valid", customErr)
+		return
+	}
+
+	result, err := h.service.Create(c.Request.Context(), req)
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusCreated, "Successfully created EpisodeOfCare", result)
+}
+
+func (h *EpisodeOfCareHandler) Update(c *gin.Context) {
+	id := c.Param("id")
+	var req episodeofcare.EpisodeOfCareRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		customErr := validator.TranslateError(err)
+		response.ErrorWithLog(c, err, http.StatusBadRequest, "Format permintaan tidak valid", customErr)
+		return
+	}
+
+	result, err := h.service.Update(c.Request.Context(), id, req)
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusOK, "Successfully updated EpisodeOfCare", result)
+}
+
+func (h *EpisodeOfCareHandler) Patch(c *gin.Context) {
+	id := c.Param("id")
+	var req episodeofcare.EpisodeOfCarePatchRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		customErr := validator.TranslateError(err)
+		response.ErrorWithLog(c, err, http.StatusBadRequest, "Format permintaan patch tidak valid", customErr)
+		return
+	}
+
+	result, err := h.service.Patch(c.Request.Context(), id, req)
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusOK, "Successfully patched EpisodeOfCare", result)
+}
+
+func (h *EpisodeOfCareHandler) GetByID(c *gin.Context) {
+	id := c.Param("id")
+	result, err := h.service.GetByID(c.Request.Context(), id)
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusOK, "Successfully retrieved EpisodeOfCare", result)
+}
+
+func (h *EpisodeOfCareHandler) Search(c *gin.Context) {
+	queryParams := c.Request.URL.Query()
+	result, err := h.service.Search(c.Request.Context(), queryParams)
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusOK, "Successfully retrieved EpisodeOfCare records", result)
+}

internal/infrastructure/transport/http/handlers/satusehat/usecase/imagingstudy_handler.go

@@ -0,0 +1,102 @@
+package usecase
+
+import (
+	"net/http"
+
+	"service/internal/satusehat/usecase/imagingstudy"
+	"service/pkg/response"
+	"service/pkg/utils/validator"
+
+	"github.com/gin-gonic/gin"
+)
+
+type ImagingStudyHandler struct {
+	service imagingstudy.Service
+}
+
+func NewImagingStudyHandler(service imagingstudy.Service) *ImagingStudyHandler {
+	return &ImagingStudyHandler{
+		service: service,
+	}
+}
+
+func (h *ImagingStudyHandler) RegisterRoutes(router *gin.RouterGroup) {
+	group := router.Group("/satusehat/imagingstudy")
+	{
+		group.POST("", h.Create)
+		group.GET("", h.Search)
+		group.GET("/:id", h.GetByID)
+		group.PUT("/:id", h.Update)
+		group.PATCH("/:id", h.Patch)
+	}
+}
+
+func (h *ImagingStudyHandler) Create(c *gin.Context) {
+	var req imagingstudy.ImagingStudyRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		customErr := validator.TranslateError(err)
+		response.ErrorWithLog(c, err, http.StatusBadRequest, "Format permintaan tidak valid", customErr)
+		return
+	}
+
+	result, err := h.service.Create(c.Request.Context(), req)
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusCreated, "Successfully created ImagingStudy", result)
+}
+
+func (h *ImagingStudyHandler) Update(c *gin.Context) {
+	id := c.Param("id")
+	var req imagingstudy.ImagingStudyRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		customErr := validator.TranslateError(err)
+		response.ErrorWithLog(c, err, http.StatusBadRequest, "Format permintaan tidak valid", customErr)
+		return
+	}
+
+	result, err := h.service.Update(c.Request.Context(), id, req)
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusOK, "Successfully updated ImagingStudy", result)
+}
+
+func (h *ImagingStudyHandler) Patch(c *gin.Context) {
+	id := c.Param("id")
+	var req imagingstudy.ImagingStudyPatchRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		customErr := validator.TranslateError(err)
+		response.ErrorWithLog(c, err, http.StatusBadRequest, "Format permintaan patch tidak valid", customErr)
+		return
+	}
+
+	result, err := h.service.Patch(c.Request.Context(), id, req)
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusOK, "Successfully patched ImagingStudy", result)
+}
+
+func (h *ImagingStudyHandler) GetByID(c *gin.Context) {
+	id := c.Param("id")
+	result, err := h.service.GetByID(c.Request.Context(), id)
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusOK, "Successfully retrieved ImagingStudy", result)
+}
+
+func (h *ImagingStudyHandler) Search(c *gin.Context) {
+	queryParams := c.Request.URL.Query()
+	result, err := h.service.Search(c.Request.Context(), queryParams)
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusOK, "Successfully retrieved ImagingStudies", result)
+}

internal/infrastructure/transport/http/handlers/satusehat/usecase/immunization_handler.go

@@ -0,0 +1,81 @@
+package usecase
+
+import (
+	"net/http"
+	"service/internal/satusehat/usecase/immunization"
+	"service/pkg/response"
+	"service/pkg/utils/validator"
+
+	"github.com/gin-gonic/gin"
+)
+
+type ImmunizationHandler struct{ service immunization.Service }
+
+func NewImmunizationHandler(s immunization.Service) *ImmunizationHandler {
+	return &ImmunizationHandler{service: s}
+}
+
+func (h *ImmunizationHandler) RegisterRoutes(router *gin.RouterGroup) {
+	g := router.Group("/satusehat/immunization")
+	g.POST("", h.Create)
+	g.GET("", h.Search)
+	g.GET("/:id", h.GetByID)
+	g.PUT("/:id", h.Update)
+	g.PATCH("/:id", h.Patch)
+}
+
+func (h *ImmunizationHandler) Create(c *gin.Context) {
+	var req immunization.ImmunizationRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		response.ErrorWithLog(c, err, http.StatusBadRequest, "Invalid request", validator.TranslateError(err))
+		return
+	}
+	res, err := h.service.Create(c.Request.Context(), req)
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusCreated, "Success", res.FullResponse)
+}
+func (h *ImmunizationHandler) Update(c *gin.Context) {
+	var req immunization.ImmunizationRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		response.ErrorWithLog(c, err, http.StatusBadRequest, "Invalid request", validator.TranslateError(err))
+		return
+	}
+	res, err := h.service.Update(c.Request.Context(), c.Param("id"), req)
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusOK, "Success", res.FullResponse)
+}
+func (h *ImmunizationHandler) Patch(c *gin.Context) {
+	var req immunization.ImmunizationPatchRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		response.ErrorWithLog(c, err, http.StatusBadRequest, "Invalid patch", validator.TranslateError(err))
+		return
+	}
+	res, err := h.service.Patch(c.Request.Context(), c.Param("id"), req)
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusOK, "Success", res.FullResponse)
+}
+func (h *ImmunizationHandler) GetByID(c *gin.Context) {
+	res, err := h.service.GetByID(c.Request.Context(), c.Param("id"))
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusOK, "Success", res.FullResponse)
+}
+func (h *ImmunizationHandler) Search(c *gin.Context) {
+	res, err := h.service.Search(c.Request.Context(), c.Request.URL.Query())
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusOK, "Success", res.FullResponse)
+}

internal/infrastructure/transport/http/handlers/satusehat/usecase/medication_handler.go

@@ -0,0 +1,102 @@
+package usecase
+
+import (
+	"net/http"
+
+	"service/internal/satusehat/usecase/medication"
+	"service/pkg/response"
+	"service/pkg/utils/validator"
+
+	"github.com/gin-gonic/gin"
+)
+
+type MedicationHandler struct {
+	service medication.Service
+}
+
+func NewMedicationHandler(service medication.Service) *MedicationHandler {
+	return &MedicationHandler{
+		service: service,
+	}
+}
+
+func (h *MedicationHandler) RegisterRoutes(router *gin.RouterGroup) {
+	group := router.Group("/satusehat/medication")
+	{
+		group.POST("", h.Create)
+		group.GET("", h.Search)
+		group.GET("/:id", h.GetByID)
+		group.PUT("/:id", h.Update)
+		group.PATCH("/:id", h.Patch)
+	}
+}
+
+func (h *MedicationHandler) Create(c *gin.Context) {
+	var req medication.MedicationRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		customErr := validator.TranslateError(err)
+		response.ErrorWithLog(c, err, http.StatusBadRequest, "Format permintaan tidak valid", customErr)
+		return
+	}
+
+	result, err := h.service.Create(c.Request.Context(), req)
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusCreated, "Successfully created Medication", result.FullResponse)
+}
+
+func (h *MedicationHandler) Update(c *gin.Context) {
+	id := c.Param("id")
+	var req medication.MedicationRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		customErr := validator.TranslateError(err)
+		response.ErrorWithLog(c, err, http.StatusBadRequest, "Format permintaan tidak valid", customErr)
+		return
+	}
+
+	result, err := h.service.Update(c.Request.Context(), id, req)
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusOK, "Successfully updated Medication", result.FullResponse)
+}
+
+func (h *MedicationHandler) Patch(c *gin.Context) {
+	id := c.Param("id")
+	var req medication.MedicationPatchRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		customErr := validator.TranslateError(err)
+		response.ErrorWithLog(c, err, http.StatusBadRequest, "Format permintaan patch tidak valid", customErr)
+		return
+	}
+
+	result, err := h.service.Patch(c.Request.Context(), id, req)
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusOK, "Successfully patched Medication", result.FullResponse)
+}
+
+func (h *MedicationHandler) GetByID(c *gin.Context) {
+	id := c.Param("id")
+	result, err := h.service.GetByID(c.Request.Context(), id)
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusOK, "Successfully retrieved Medication", result.FullResponse)
+}
+
+func (h *MedicationHandler) Search(c *gin.Context) {
+	queryParams := c.Request.URL.Query()
+	result, err := h.service.Search(c.Request.Context(), queryParams)
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusOK, "Successfully retrieved Medications", result.FullResponse)
+}

internal/infrastructure/transport/http/handlers/satusehat/usecase/medicationdispense_handler.go

@@ -0,0 +1,91 @@
+package usecase
+
+import (
+	"net/http"
+
+	"service/internal/satusehat/usecase/medicationdispense"
+	"service/pkg/response"
+	"service/pkg/utils/validator"
+
+	"github.com/gin-gonic/gin"
+)
+
+type MedicationDispenseHandler struct {
+	service medicationdispense.Service
+}
+
+func NewMedicationDispenseHandler(service medicationdispense.Service) *MedicationDispenseHandler {
+	return &MedicationDispenseHandler{service: service}
+}
+
+func (h *MedicationDispenseHandler) RegisterRoutes(router *gin.RouterGroup) {
+	group := router.Group("/satusehat/medicationdispense")
+	{
+		group.POST("", h.Create)
+		group.GET("", h.Search)
+		group.GET("/:id", h.GetByID)
+		group.PUT("/:id", h.Update)
+		group.PATCH("/:id", h.Patch)
+	}
+}
+
+func (h *MedicationDispenseHandler) Create(c *gin.Context) {
+	var req medicationdispense.MedicationDispenseRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		response.ErrorWithLog(c, err, http.StatusBadRequest, "Format permintaan tidak valid", validator.TranslateError(err))
+		return
+	}
+	result, err := h.service.Create(c.Request.Context(), req)
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusCreated, "Successfully created MedicationDispense", result.FullResponse)
+}
+
+func (h *MedicationDispenseHandler) Update(c *gin.Context) {
+	id := c.Param("id")
+	var req medicationdispense.MedicationDispenseRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		response.ErrorWithLog(c, err, http.StatusBadRequest, "Format permintaan tidak valid", validator.TranslateError(err))
+		return
+	}
+	result, err := h.service.Update(c.Request.Context(), id, req)
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusOK, "Successfully updated MedicationDispense", result.FullResponse)
+}
+
+func (h *MedicationDispenseHandler) Patch(c *gin.Context) {
+	id := c.Param("id")
+	var req medicationdispense.MedicationDispensePatchRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		response.ErrorWithLog(c, err, http.StatusBadRequest, "Format permintaan patch tidak valid", validator.TranslateError(err))
+		return
+	}
+	result, err := h.service.Patch(c.Request.Context(), id, req)
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusOK, "Successfully patched MedicationDispense", result.FullResponse)
+}
+
+func (h *MedicationDispenseHandler) GetByID(c *gin.Context) {
+	result, err := h.service.GetByID(c.Request.Context(), c.Param("id"))
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusOK, "Successfully retrieved", result.FullResponse)
+}
+func (h *MedicationDispenseHandler) Search(c *gin.Context) {
+	result, err := h.service.Search(c.Request.Context(), c.Request.URL.Query())
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusOK, "Successfully retrieved", result.FullResponse)
+}

internal/infrastructure/transport/http/handlers/satusehat/usecase/medicationrequest_handler.go

@@ -0,0 +1,91 @@
+package usecase
+
+import (
+	"net/http"
+
+	"service/internal/satusehat/usecase/medicationrequest"
+	"service/pkg/response"
+	"service/pkg/utils/validator"
+
+	"github.com/gin-gonic/gin"
+)
+
+type MedicationRequestHandler struct {
+	service medicationrequest.Service
+}
+
+func NewMedicationRequestHandler(service medicationrequest.Service) *MedicationRequestHandler {
+	return &MedicationRequestHandler{service: service}
+}
+
+func (h *MedicationRequestHandler) RegisterRoutes(router *gin.RouterGroup) {
+	group := router.Group("/satusehat/medicationrequest")
+	{
+		group.POST("", h.Create)
+		group.GET("", h.Search)
+		group.GET("/:id", h.GetByID)
+		group.PUT("/:id", h.Update)
+		group.PATCH("/:id", h.Patch)
+	}
+}
+
+func (h *MedicationRequestHandler) Create(c *gin.Context) {
+	var req medicationrequest.MedicationRequestRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		response.ErrorWithLog(c, err, http.StatusBadRequest, "Format permintaan tidak valid", validator.TranslateError(err))
+		return
+	}
+	result, err := h.service.Create(c.Request.Context(), req)
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusCreated, "Successfully created MedicationRequest", result.FullResponse)
+}
+
+func (h *MedicationRequestHandler) Update(c *gin.Context) {
+	id := c.Param("id")
+	var req medicationrequest.MedicationRequestRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		response.ErrorWithLog(c, err, http.StatusBadRequest, "Format permintaan tidak valid", validator.TranslateError(err))
+		return
+	}
+	result, err := h.service.Update(c.Request.Context(), id, req)
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusOK, "Successfully updated MedicationRequest", result.FullResponse)
+}
+
+func (h *MedicationRequestHandler) Patch(c *gin.Context) {
+	id := c.Param("id")
+	var req medicationrequest.MedicationRequestPatchRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		response.ErrorWithLog(c, err, http.StatusBadRequest, "Format permintaan patch tidak valid", validator.TranslateError(err))
+		return
+	}
+	result, err := h.service.Patch(c.Request.Context(), id, req)
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusOK, "Successfully patched MedicationRequest", result.FullResponse)
+}
+
+func (h *MedicationRequestHandler) GetByID(c *gin.Context) {
+	result, err := h.service.GetByID(c.Request.Context(), c.Param("id"))
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusOK, "Successfully retrieved", result.FullResponse)
+}
+func (h *MedicationRequestHandler) Search(c *gin.Context) {
+	result, err := h.service.Search(c.Request.Context(), c.Request.URL.Query())
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusOK, "Successfully retrieved", result.FullResponse)
+}

internal/infrastructure/transport/http/handlers/satusehat/usecase/medicationstatement_handler.go

@@ -0,0 +1,91 @@
+package usecase
+
+import (
+	"net/http"
+
+	"service/internal/satusehat/usecase/medicationstatement"
+	"service/pkg/response"
+	"service/pkg/utils/validator"
+
+	"github.com/gin-gonic/gin"
+)
+
+type MedicationStatementHandler struct {
+	service medicationstatement.Service
+}
+
+func NewMedicationStatementHandler(service medicationstatement.Service) *MedicationStatementHandler {
+	return &MedicationStatementHandler{service: service}
+}
+
+func (h *MedicationStatementHandler) RegisterRoutes(router *gin.RouterGroup) {
+	group := router.Group("/satusehat/medicationstatement")
+	{
+		group.POST("", h.Create)
+		group.GET("", h.Search)
+		group.GET("/:id", h.GetByID)
+		group.PUT("/:id", h.Update)
+		group.PATCH("/:id", h.Patch)
+	}
+}
+
+func (h *MedicationStatementHandler) Create(c *gin.Context) {
+	var req medicationstatement.MedicationStatementRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		response.ErrorWithLog(c, err, http.StatusBadRequest, "Format permintaan tidak valid", validator.TranslateError(err))
+		return
+	}
+	result, err := h.service.Create(c.Request.Context(), req)
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusCreated, "Successfully created MedicationStatement", result.FullResponse)
+}
+
+func (h *MedicationStatementHandler) Update(c *gin.Context) {
+	id := c.Param("id")
+	var req medicationstatement.MedicationStatementRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		response.ErrorWithLog(c, err, http.StatusBadRequest, "Format permintaan tidak valid", validator.TranslateError(err))
+		return
+	}
+	result, err := h.service.Update(c.Request.Context(), id, req)
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusOK, "Successfully updated MedicationStatement", result.FullResponse)
+}
+
+func (h *MedicationStatementHandler) Patch(c *gin.Context) {
+	id := c.Param("id")
+	var req medicationstatement.MedicationStatementPatchRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		response.ErrorWithLog(c, err, http.StatusBadRequest, "Format permintaan patch tidak valid", validator.TranslateError(err))
+		return
+	}
+	result, err := h.service.Patch(c.Request.Context(), id, req)
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusOK, "Successfully patched MedicationStatement", result.FullResponse)
+}
+
+func (h *MedicationStatementHandler) GetByID(c *gin.Context) {
+	result, err := h.service.GetByID(c.Request.Context(), c.Param("id"))
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusOK, "Successfully retrieved", result.FullResponse)
+}
+func (h *MedicationStatementHandler) Search(c *gin.Context) {
+	result, err := h.service.Search(c.Request.Context(), c.Request.URL.Query())
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusOK, "Successfully retrieved", result.FullResponse)
+}

internal/infrastructure/transport/http/handlers/satusehat/usecase/observation_handler.go

@@ -0,0 +1,102 @@
+package usecase
+
+import (
+	"net/http"
+
+	"service/internal/satusehat/usecase/observation"
+	"service/pkg/response"
+	"service/pkg/utils/validator"
+
+	"github.com/gin-gonic/gin"
+)
+
+type ObservationHandler struct {
+	service observation.Service
+}
+
+func NewObservationHandler(service observation.Service) *ObservationHandler {
+	return &ObservationHandler{
+		service: service,
+	}
+}
+
+func (h *ObservationHandler) RegisterRoutes(router *gin.RouterGroup) {
+	group := router.Group("/satusehat/observation")
+	{
+		group.POST("", h.Create)
+		group.GET("", h.Search)
+		group.GET("/:id", h.GetByID)
+		group.PUT("/:id", h.Update)
+		group.PATCH("/:id", h.Patch)
+	}
+}
+
+func (h *ObservationHandler) Create(c *gin.Context) {
+	var req observation.ObservationRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		customErr := validator.TranslateError(err)
+		response.ErrorWithLog(c, err, http.StatusBadRequest, "Format permintaan tidak valid", customErr)
+		return
+	}
+
+	result, err := h.service.Create(c.Request.Context(), req)
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusCreated, "Successfully created Observation", result.FullResponse)
+}
+
+func (h *ObservationHandler) Update(c *gin.Context) {
+	id := c.Param("id")
+	var req observation.ObservationRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		customErr := validator.TranslateError(err)
+		response.ErrorWithLog(c, err, http.StatusBadRequest, "Format permintaan tidak valid", customErr)
+		return
+	}
+
+	result, err := h.service.Update(c.Request.Context(), id, req)
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusOK, "Successfully updated Observation", result.FullResponse)
+}
+
+func (h *ObservationHandler) Patch(c *gin.Context) {
+	id := c.Param("id")
+	var req observation.ObservationPatchRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		customErr := validator.TranslateError(err)
+		response.ErrorWithLog(c, err, http.StatusBadRequest, "Format permintaan patch tidak valid", customErr)
+		return
+	}
+
+	result, err := h.service.Patch(c.Request.Context(), id, req)
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusOK, "Successfully patched Observation", result.FullResponse)
+}
+
+func (h *ObservationHandler) GetByID(c *gin.Context) {
+	id := c.Param("id")
+	result, err := h.service.GetByID(c.Request.Context(), id)
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusOK, "Successfully retrieved Observation", result.FullResponse)
+}
+
+func (h *ObservationHandler) Search(c *gin.Context) {
+	queryParams := c.Request.URL.Query()
+	result, err := h.service.Search(c.Request.Context(), queryParams)
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusOK, "Successfully retrieved Observations", result.FullResponse)
+}

internal/infrastructure/transport/http/handlers/satusehat/usecase/procedure_handler.go

@@ -0,0 +1,102 @@
+package usecase
+
+import (
+	"net/http"
+
+	"service/internal/satusehat/usecase/procedure"
+	"service/pkg/response"
+	"service/pkg/utils/validator"
+
+	"github.com/gin-gonic/gin"
+)
+
+type ProcedureHandler struct {
+	service procedure.Service
+}
+
+func NewProcedureHandler(service procedure.Service) *ProcedureHandler {
+	return &ProcedureHandler{
+		service: service,
+	}
+}
+
+func (h *ProcedureHandler) RegisterRoutes(router *gin.RouterGroup) {
+	group := router.Group("/satusehat/procedure")
+	{
+		group.POST("", h.Create)
+		group.GET("", h.Search)
+		group.GET("/:id", h.GetByID)
+		group.PUT("/:id", h.Update)
+		group.PATCH("/:id", h.Patch)
+	}
+}
+
+func (h *ProcedureHandler) Create(c *gin.Context) {
+	var req procedure.ProcedureRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		customErr := validator.TranslateError(err)
+		response.ErrorWithLog(c, err, http.StatusBadRequest, "Format permintaan tidak valid", customErr)
+		return
+	}
+
+	result, err := h.service.Create(c.Request.Context(), req)
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusCreated, "Successfully created Procedure", result.FullResponse)
+}
+
+func (h *ProcedureHandler) Update(c *gin.Context) {
+	id := c.Param("id")
+	var req procedure.ProcedureRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		customErr := validator.TranslateError(err)
+		response.ErrorWithLog(c, err, http.StatusBadRequest, "Format permintaan tidak valid", customErr)
+		return
+	}
+
+	result, err := h.service.Update(c.Request.Context(), id, req)
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusOK, "Successfully updated Procedure", result.FullResponse)
+}
+
+func (h *ProcedureHandler) Patch(c *gin.Context) {
+	id := c.Param("id")
+	var req procedure.ProcedurePatchRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		customErr := validator.TranslateError(err)
+		response.ErrorWithLog(c, err, http.StatusBadRequest, "Format permintaan patch tidak valid", customErr)
+		return
+	}
+
+	result, err := h.service.Patch(c.Request.Context(), id, req)
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusOK, "Successfully patched Procedure", result.FullResponse)
+}
+
+func (h *ProcedureHandler) GetByID(c *gin.Context) {
+	id := c.Param("id")
+	result, err := h.service.GetByID(c.Request.Context(), id)
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusOK, "Successfully retrieved Procedure", result.FullResponse)
+}
+
+func (h *ProcedureHandler) Search(c *gin.Context) {
+	queryParams := c.Request.URL.Query()
+	result, err := h.service.Search(c.Request.Context(), queryParams)
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusOK, "Successfully retrieved Procedures", result.FullResponse)
+}

internal/infrastructure/transport/http/handlers/satusehat/usecase/questionnaireresponse_handler.go

@@ -0,0 +1,91 @@
+package usecase
+
+import (
+	"net/http"
+
+	"service/internal/satusehat/usecase/questionnaireresponse"
+	"service/pkg/response"
+	"service/pkg/utils/validator"
+
+	"github.com/gin-gonic/gin"
+)
+
+type QuestionnaireResponseHandler struct {
+	service questionnaireresponse.Service
+}
+
+func NewQuestionnaireResponseHandler(service questionnaireresponse.Service) *QuestionnaireResponseHandler {
+	return &QuestionnaireResponseHandler{service: service}
+}
+
+func (h *QuestionnaireResponseHandler) RegisterRoutes(router *gin.RouterGroup) {
+	group := router.Group("/satusehat/questionnaireresponse")
+	{
+		group.POST("", h.Create)
+		group.GET("", h.Search)
+		group.GET("/:id", h.GetByID)
+		group.PUT("/:id", h.Update)
+		group.PATCH("/:id", h.Patch)
+	}
+}
+
+func (h *QuestionnaireResponseHandler) Create(c *gin.Context) {
+	var req questionnaireresponse.QuestionnaireResponseRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		response.ErrorWithLog(c, err, http.StatusBadRequest, "Format permintaan tidak valid", validator.TranslateError(err))
+		return
+	}
+	result, err := h.service.Create(c.Request.Context(), req)
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusCreated, "Successfully created QuestionnaireResponse", result.FullResponse)
+}
+
+func (h *QuestionnaireResponseHandler) Update(c *gin.Context) {
+	id := c.Param("id")
+	var req questionnaireresponse.QuestionnaireResponseRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		response.ErrorWithLog(c, err, http.StatusBadRequest, "Format permintaan tidak valid", validator.TranslateError(err))
+		return
+	}
+	result, err := h.service.Update(c.Request.Context(), id, req)
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusOK, "Successfully updated QuestionnaireResponse", result.FullResponse)
+}
+
+func (h *QuestionnaireResponseHandler) Patch(c *gin.Context) {
+	id := c.Param("id")
+	var req questionnaireresponse.QuestionnaireResponsePatchRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		response.ErrorWithLog(c, err, http.StatusBadRequest, "Format permintaan patch tidak valid", validator.TranslateError(err))
+		return
+	}
+	result, err := h.service.Patch(c.Request.Context(), id, req)
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusOK, "Successfully patched QuestionnaireResponse", result.FullResponse)
+}
+
+func (h *QuestionnaireResponseHandler) GetByID(c *gin.Context) {
+	result, err := h.service.GetByID(c.Request.Context(), c.Param("id"))
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusOK, "Successfully retrieved", result.FullResponse)
+}
+func (h *QuestionnaireResponseHandler) Search(c *gin.Context) {
+	result, err := h.service.Search(c.Request.Context(), c.Request.URL.Query())
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusOK, "Successfully retrieved", result.FullResponse)
+}

internal/infrastructure/transport/http/handlers/satusehat/usecase/servicerequest_handler.go

@@ -0,0 +1,102 @@
+package usecase
+
+import (
+	"net/http"
+
+	"service/internal/satusehat/usecase/servicerequest"
+	"service/pkg/response"
+	"service/pkg/utils/validator"
+
+	"github.com/gin-gonic/gin"
+)
+
+type ServiceRequestHandler struct {
+	service servicerequest.Service
+}
+
+func NewServiceRequestHandler(service servicerequest.Service) *ServiceRequestHandler {
+	return &ServiceRequestHandler{
+		service: service,
+	}
+}
+
+func (h *ServiceRequestHandler) RegisterRoutes(router *gin.RouterGroup) {
+	group := router.Group("/satusehat/servicerequest")
+	{
+		group.POST("", h.Create)
+		group.GET("", h.Search)
+		group.GET("/:id", h.GetByID)
+		group.PUT("/:id", h.Update)
+		group.PATCH("/:id", h.Patch)
+	}
+}
+
+func (h *ServiceRequestHandler) Create(c *gin.Context) {
+	var req servicerequest.ServiceRequestRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		customErr := validator.TranslateError(err)
+		response.ErrorWithLog(c, err, http.StatusBadRequest, "Format permintaan tidak valid", customErr)
+		return
+	}
+
+	result, err := h.service.Create(c.Request.Context(), req)
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusCreated, "Successfully created ServiceRequest", result.FullResponse)
+}
+
+func (h *ServiceRequestHandler) Update(c *gin.Context) {
+	id := c.Param("id")
+	var req servicerequest.ServiceRequestRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		customErr := validator.TranslateError(err)
+		response.ErrorWithLog(c, err, http.StatusBadRequest, "Format permintaan tidak valid", customErr)
+		return
+	}
+
+	result, err := h.service.Update(c.Request.Context(), id, req)
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusOK, "Successfully updated ServiceRequest", result.FullResponse)
+}
+
+func (h *ServiceRequestHandler) Patch(c *gin.Context) {
+	id := c.Param("id")
+	var req servicerequest.ServiceRequestPatchRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		customErr := validator.TranslateError(err)
+		response.ErrorWithLog(c, err, http.StatusBadRequest, "Format permintaan patch tidak valid", customErr)
+		return
+	}
+
+	result, err := h.service.Patch(c.Request.Context(), id, req)
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusOK, "Successfully patched ServiceRequest", result.FullResponse)
+}
+
+func (h *ServiceRequestHandler) GetByID(c *gin.Context) {
+	id := c.Param("id")
+	result, err := h.service.GetByID(c.Request.Context(), id)
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusOK, "Successfully retrieved ServiceRequest", result.FullResponse)
+}
+
+func (h *ServiceRequestHandler) Search(c *gin.Context) {
+	queryParams := c.Request.URL.Query()
+	result, err := h.service.Search(c.Request.Context(), queryParams)
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusOK, "Successfully retrieved ServiceRequests", result.FullResponse)
+}

internal/infrastructure/transport/http/handlers/satusehat/usecase/specimen_handler.go

@@ -0,0 +1,79 @@
+package usecase
+
+import (
+	"net/http"
+	"service/internal/satusehat/usecase/specimen"
+	"service/pkg/response"
+	"service/pkg/utils/validator"
+
+	"github.com/gin-gonic/gin"
+)
+
+type SpecimenHandler struct{ service specimen.Service }
+
+func NewSpecimenHandler(s specimen.Service) *SpecimenHandler { return &SpecimenHandler{service: s} }
+
+func (h *SpecimenHandler) RegisterRoutes(router *gin.RouterGroup) {
+	g := router.Group("/satusehat/specimen")
+	g.POST("", h.Create)
+	g.GET("", h.Search)
+	g.GET("/:id", h.GetByID)
+	g.PUT("/:id", h.Update)
+	g.PATCH("/:id", h.Patch)
+}
+
+func (h *SpecimenHandler) Create(c *gin.Context) {
+	var req specimen.SpecimenRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		response.ErrorWithLog(c, err, http.StatusBadRequest, "Invalid request", validator.TranslateError(err))
+		return
+	}
+	res, err := h.service.Create(c.Request.Context(), req)
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusCreated, "Success", res.FullResponse)
+}
+func (h *SpecimenHandler) Update(c *gin.Context) {
+	var req specimen.SpecimenRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		response.ErrorWithLog(c, err, http.StatusBadRequest, "Invalid request", validator.TranslateError(err))
+		return
+	}
+	res, err := h.service.Update(c.Request.Context(), c.Param("id"), req)
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusOK, "Success", res.FullResponse)
+}
+func (h *SpecimenHandler) Patch(c *gin.Context) {
+	var req specimen.SpecimenPatchRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		response.ErrorWithLog(c, err, http.StatusBadRequest, "Invalid patch", validator.TranslateError(err))
+		return
+	}
+	res, err := h.service.Patch(c.Request.Context(), c.Param("id"), req)
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusOK, "Success", res.FullResponse)
+}
+func (h *SpecimenHandler) GetByID(c *gin.Context) {
+	res, err := h.service.GetByID(c.Request.Context(), c.Param("id"))
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusOK, "Success", res.FullResponse)
+}
+func (h *SpecimenHandler) Search(c *gin.Context) {
+	res, err := h.service.Search(c.Request.Context(), c.Request.URL.Query())
+	if err != nil {
+		handleSatuSehatError(c, err)
+		return
+	}
+	response.Success(c, http.StatusOK, "Success", res.FullResponse)
+}