rachmadiyanti.annisa.3004/antrean-anjungan
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

clear tool generete bpjs

Browse Source
This commit is contained in:
Meninjar Mulyono
2025-09-01 20:29:25 +07:00
parent 980f890a41
commit 2db9195c89
19 changed files with 2128 additions and 6690 deletions
Download Patch File Download Diff File Expand all files Collapse all files

510
internal/handlers/test.txt/sw
View File

@@ -1,510 +0,0 @@
// Code generated by generate-dynamic-handler.go DO NOT EDIT.
// Generated at 2025-09-01 13:38:57
// Service: VClaim (vclaim)
// Description: BPJS VClaim service for eligibility and SEP management
package handlers
import (
"context"
"net/http"
"strings"
"time"
"api-service/internal/config"
"api-service/internal/models"
"api-service/internal/models/vclaim/peserta"
"api-service/internal/models/vclaim/sep"
"api-service/internal/services"
"api-service/pkg/logger"
"github.com/gin-gonic/gin"
"github.com/go-playground/validator/v10"
"github.com/google/uuid"
)
// VClaimHandler handles VClaim BPJS services
type VClaimHandler struct {
service services.VClaimService
validator *validator.Validate
logger logger.Logger
config config.BpjsConfig
}
// VClaimHandlerConfig contains configuration for VClaimHandler
type VClaimHandlerConfig struct {
BpjsConfig config.BpjsConfig
Logger logger.Logger
Validator *validator.Validate
}
// NewVClaimHandler creates a new VClaimHandler
func NewVClaimHandler(cfg VClaimHandlerConfig) *VClaimHandler {
return &VClaimHandler{
service: services.NewService(cfg.BpjsConfig),
validator: cfg.Validator,
logger: cfg.Logger,
config: cfg.BpjsConfig,
}
}
// GetPesertaBynokartu godoc
// @Summary Get participant data by card number
// @Description Get participant eligibility information from BPJS by card number
// @Tags vclaim,peserta
// @Accept json
// @Produce json
// @Security ApiKeyAuth
// @Param X-Request-ID header string false "Request ID for tracking"
// @Param nokartu path string true "BPJS card number" example("0000054321654")
// @Success 200 {object} peserta.PesertaResponse "Successfully retrieved participant data"
// @Failure 400 {object} models.ErrorResponseBpjs "Bad request - invalid card number format"
// @Failure 401 {object} models.ErrorResponseBpjs "Unauthorized - invalid API credentials"
// @Failure 404 {object} models.ErrorResponseBpjs "Not found - participant not found"
// @Failure 500 {object} models.ErrorResponseBpjs "Internal server error"
// @Router /peserta/{nokartu} [get]
func (h *VClaimHandler) GetPesertaBynokartu(c *gin.Context) {
ctx, cancel := context.WithTimeout(c.Request.Context(), 30*time.Second)
defer cancel()
// Generate request ID if not present
requestID := c.GetHeader("X-Request-ID")
if requestID == "" {
requestID = uuid.New().String()
c.Header("X-Request-ID", requestID)
}
h.logger.Info("Processing GetPesertaBynokartu request", map[string]interface{}{
"request_id": requestID,
"endpoint": "peserta/{nokartu}",
"nokartu": c.Param("nokartu"),
})
// Extract path parameters
nokartu := c.Param("nokartu")
if nokartu == "" {
h.logger.Error("Missing required parameter: nokartu", map[string]interface{}{
"request_id": requestID,
})
c.JSON(http.StatusBadRequest, models.ErrorResponseBpjs{
Status: "error",
Message: "Missing required parameter: nokartu",
RequestID: requestID,
})
return
}
// Call service method
var response peserta.PesertaResponse
endpoint := "peserta/{nokartu}"
endpoint = strings.Replace(endpoint, "{nokartu}", nokartu, 1)
err := h.service.Get(ctx, endpoint, &response)
if err != nil {
h.logger.Error("Failed to get PesertaBynokartu", map[string]interface{}{
"error": err.Error(),
"request_id": requestID,
})
c.JSON(http.StatusInternalServerError, models.ErrorResponseBpjs{
Status: "error",
Message: "Internal server error",
RequestID: requestID,
})
return
}
// Ensure response has proper fields
response.Status = "success"
response.RequestID = requestID
c.JSON(http.StatusOK, response)
}
// GetPesertaBynik godoc
// @Summary Get participant data by NIK
// @Description Get participant eligibility information from BPJS by National ID Number (NIK)
// @Tags vclaim,peserta
// @Accept json
// @Produce json
// @Security ApiKeyAuth
// @Param X-Request-ID header string false "Request ID for tracking"
// @Param nik path string true "National ID Number (NIK)" example("3201234567890123")
// @Success 200 {object} peserta.PesertaResponse "Successfully retrieved participant data"
// @Failure 400 {object} models.ErrorResponseBpjs "Bad request - invalid NIK format"
// @Failure 401 {object} models.ErrorResponseBpjs "Unauthorized - invalid API credentials"
// @Failure 404 {object} models.ErrorResponseBpjs "Not found - participant not found"
// @Failure 500 {object} models.ErrorResponseBpjs "Internal server error"
// @Router /peserta/nik/{nik} [get]
func (h *VClaimHandler) GetPesertaBynik(c *gin.Context) {
ctx, cancel := context.WithTimeout(c.Request.Context(), 30*time.Second)
defer cancel()
// Generate request ID if not present
requestID := c.GetHeader("X-Request-ID")
if requestID == "" {
requestID = uuid.New().String()
c.Header("X-Request-ID", requestID)
}
h.logger.Info("Processing GetPesertaBynik request", map[string]interface{}{
"request_id": requestID,
"endpoint": "peserta/nik/{nik}",
"nik": c.Param("nik"),
})
// Extract path parameters
nik := c.Param("nik")
if nik == "" {
h.logger.Error("Missing required parameter: nik", map[string]interface{}{
"request_id": requestID,
})
c.JSON(http.StatusBadRequest, models.ErrorResponseBpjs{
Status: "error",
Message: "Missing required parameter: nik",
RequestID: requestID,
})
return
}
// Call service method
var response peserta.PesertaResponse
endpoint := "peserta/nik/{nik}"
endpoint = strings.Replace(endpoint, "{nik}", nik, 1)
err := h.service.Get(ctx, endpoint, &response)
if err != nil {
h.logger.Error("Failed to get PesertaBynik", map[string]interface{}{
"error": err.Error(),
"request_id": requestID,
})
c.JSON(http.StatusInternalServerError, models.ErrorResponseBpjs{
Status: "error",
Message: "Internal server error",
RequestID: requestID,
})
return
}
// Ensure response has proper fields
response.Status = "success"
response.RequestID = requestID
c.JSON(http.StatusOK, response)
}
// GetSepSep godoc
// @Summary Get SEP data by number
// @Description Get SEP (Surat Eligibilitas Peserta) information by SEP number
// @Tags vclaim,sep
// @Accept json
// @Produce json
// @Security ApiKeyAuth
// @Param X-Request-ID header string false "Request ID for tracking"
// @Param nosep path string true "SEP Number" example("0301R0010717V000001")
// @Success 200 {object} sep.SepResponse "Successfully retrieved SEP data"
// @Failure 400 {object} models.ErrorResponseBpjs "Bad request - invalid SEP number format"
// @Failure 401 {object} models.ErrorResponseBpjs "Unauthorized - invalid API credentials"
// @Failure 404 {object} models.ErrorResponseBpjs "Not found - SEP not found"
// @Failure 500 {object} models.ErrorResponseBpjs "Internal server error"
// @Router /sep/{nosep} [get]
func (h *VClaimHandler) GetSepSep(c *gin.Context) {
ctx, cancel := context.WithTimeout(c.Request.Context(), 30*time.Second)
defer cancel()
// Generate request ID if not present
requestID := c.GetHeader("X-Request-ID")
if requestID == "" {
requestID = uuid.New().String()
c.Header("X-Request-ID", requestID)
}
h.logger.Info("Processing GetSepSep request", map[string]interface{}{
"request_id": requestID,
"endpoint": "sep/{nosep}",
"nosep": c.Param("nosep"),
})
// Extract path parameters
nosep := c.Param("nosep")
if nosep == "" {
h.logger.Error("Missing required parameter: nosep", map[string]interface{}{
"request_id": requestID,
})
c.JSON(http.StatusBadRequest, models.ErrorResponseBpjs{
Status: "error",
Message: "Missing required parameter: nosep",
RequestID: requestID,
})
return
}
// Call service method
var response sep.SepResponse
endpoint := "sep/{nosep}"
endpoint = strings.Replace(endpoint, "{nosep}", nosep, 1)
err := h.service.Get(ctx, endpoint, &response)
if err != nil {
h.logger.Error("Failed to get SepSep", map[string]interface{}{
"error": err.Error(),
"request_id": requestID,
})
c.JSON(http.StatusInternalServerError, models.ErrorResponseBpjs{
Status: "error",
Message: "Internal server error",
RequestID: requestID,
})
return
}
// Ensure response has proper fields
response.Status = "success"
response.RequestID = requestID
c.JSON(http.StatusOK, response)
}
// CreateSepSep godoc
// @Summary Create new SEP
// @Description Create a new SEP (Surat Eligibilitas Peserta) for participant
// @Tags vclaim,sep
// @Accept json
// @Produce json
// @Security ApiKeyAuth
// @Param X-Request-ID header string false "Request ID for tracking"
// @Param request body sep.SepRequest true "SEP creation data"
// @Success 201 {object} sep.SepResponse "Successfully created SEP"
// @Failure 400 {object} models.ErrorResponseBpjs "Bad request - invalid request body or validation error"
// @Failure 401 {object} models.ErrorResponseBpjs "Unauthorized - invalid API credentials"
// @Failure 409 {object} models.ErrorResponseBpjs "Conflict - SEP already exists"
// @Failure 500 {object} models.ErrorResponseBpjs "Internal server error"
// @Router /sep [post]
func (h *VClaimHandler) CreateSepSep(c *gin.Context) {
ctx, cancel := context.WithTimeout(c.Request.Context(), 30*time.Second)
defer cancel()
requestID := c.GetHeader("X-Request-ID")
if requestID == "" {
requestID = uuid.New().String()
c.Header("X-Request-ID", requestID)
}
h.logger.Info("Processing CreateSepSep request", map[string]interface{}{
"request_id": requestID,
})
var req sep.SepRequest
if err := c.ShouldBindJSON(&req); err != nil {
h.logger.Error("Invalid request body", map[string]interface{}{
"error": err.Error(),
"request_id": requestID,
})
c.JSON(http.StatusBadRequest, models.ErrorResponseBpjs{
Status: "error",
Message: "Invalid request body: " + err.Error(),
RequestID: requestID,
})
return
}
// Validate request
if err := h.validator.Struct(&req); err != nil {
h.logger.Error("Validation failed", map[string]interface{}{
"error": err.Error(),
"request_id": requestID,
})
c.JSON(http.StatusBadRequest, models.ErrorResponseBpjs{
Status: "error",
Message: "Validation failed: " + err.Error(),
RequestID: requestID,
})
return
}
// Call service method
var response sep.SepResponse
err := h.service.Post(ctx, "sep", &req, &response)
if err != nil {
h.logger.Error("Failed to create SepSep", map[string]interface{}{
"error": err.Error(),
"request_id": requestID,
})
c.JSON(http.StatusInternalServerError, models.ErrorResponseBpjs{
Status: "error",
Message: "Internal server error",
RequestID: requestID,
})
return
}
// Ensure response has proper fields
response.Status = "success"
response.RequestID = requestID
c.JSON(http.StatusCreated, response)
}
// UpdateSepSep godoc
// @Summary Update existing SEP
// @Description Update an existing SEP (Surat Eligibilitas Peserta) by SEP number
// @Tags vclaim,sep
// @Accept json
// @Produce json
// @Security ApiKeyAuth
// @Param X-Request-ID header string false "Request ID for tracking"
// @Param nosep path string true "SEP Number to update" example("0301R0010717V000001")
// @Param request body sep.SepRequest true "SEP update data"
// @Success 200 {object} sep.SepResponse "Successfully updated SEP"
// @Failure 400 {object} models.ErrorResponseBpjs "Bad request - invalid request body or validation error"
// @Failure 401 {object} models.ErrorResponseBpjs "Unauthorized - invalid API credentials"
// @Failure 404 {object} models.ErrorResponseBpjs "Not found - SEP not found"
// @Failure 500 {object} models.ErrorResponseBpjs "Internal server error"
// @Router /sep/{nosep} [put]
func (h *VClaimHandler) UpdateSepSep(c *gin.Context) {
ctx, cancel := context.WithTimeout(c.Request.Context(), 30*time.Second)
defer cancel()
requestID := c.GetHeader("X-Request-ID")
if requestID == "" {
requestID = uuid.New().String()
c.Header("X-Request-ID", requestID)
}
h.logger.Info("Processing UpdateSepSep request", map[string]interface{}{
"request_id": requestID,
})
nosep := c.Param("nosep")
if nosep == "" {
h.logger.Error("Missing required parameter: nosep", map[string]interface{}{
"request_id": requestID,
})
c.JSON(http.StatusBadRequest, models.ErrorResponseBpjs{
Status: "error",
Message: "Missing required parameter: nosep",
RequestID: requestID,
})
return
}
var req sep.SepRequest
if err := c.ShouldBindJSON(&req); err != nil {
h.logger.Error("Invalid request body", map[string]interface{}{
"error": err.Error(),
"request_id": requestID,
})
c.JSON(http.StatusBadRequest, models.ErrorResponseBpjs{
Status: "error",
Message: "Invalid request body: " + err.Error(),
RequestID: requestID,
})
return
}
// Validate request
if err := h.validator.Struct(&req); err != nil {
h.logger.Error("Validation failed", map[string]interface{}{
"error": err.Error(),
"request_id": requestID,
})
c.JSON(http.StatusBadRequest, models.ErrorResponseBpjs{
Status: "error",
Message: "Validation failed: " + err.Error(),
RequestID: requestID,
})
return
}
// Call service method
var response sep.SepResponse
endpoint := "sep/{nosep}"
endpoint = strings.Replace(endpoint, "{nosep}", nosep, 1)
err := h.service.Put(ctx, endpoint, &req, &response)
if err != nil {
h.logger.Error("Failed to update SepSep", map[string]interface{}{
"error": err.Error(),
"request_id": requestID,
})
c.JSON(http.StatusInternalServerError, models.ErrorResponseBpjs{
Status: "error",
Message: "Internal server error",
RequestID: requestID,
})
return
}
// Ensure response has proper fields
response.Status = "success"
response.RequestID = requestID
c.JSON(http.StatusOK, response)
}
// DeleteSepSep godoc
// @Summary Delete SEP
// @Description Delete an existing SEP (Surat Eligibilitas Peserta) by SEP number
// @Tags vclaim,sep
// @Accept json
// @Produce json
// @Security ApiKeyAuth
// @Param X-Request-ID header string false "Request ID for tracking"
// @Param nosep path string true "SEP Number to delete" example("0301R0010717V000001")
// @Success 200 {object} sep.SepResponse "Successfully deleted SEP"
// @Failure 400 {object} models.ErrorResponseBpjs "Bad request - invalid SEP number format"
// @Failure 401 {object} models.ErrorResponseBpjs "Unauthorized - invalid API credentials"
// @Failure 404 {object} models.ErrorResponseBpjs "Not found - SEP not found"
// @Failure 500 {object} models.ErrorResponseBpjs "Internal server error"
// @Router /sep/{nosep} [delete]
func (h *VClaimHandler) DeleteSepSep(c *gin.Context) {
ctx, cancel := context.WithTimeout(c.Request.Context(), 30*time.Second)
defer cancel()
requestID := c.GetHeader("X-Request-ID")
if requestID == "" {
requestID = uuid.New().String()
c.Header("X-Request-ID", requestID)
}
h.logger.Info("Processing DeleteSepSep request", map[string]interface{}{
"request_id": requestID,
})
nosep := c.Param("nosep")
if nosep == "" {
h.logger.Error("Missing required parameter: nosep", map[string]interface{}{
"request_id": requestID,
})
c.JSON(http.StatusBadRequest, models.ErrorResponseBpjs{
Status: "error",
Message: "Missing required parameter: nosep",
RequestID: requestID,
})
return
}
// Call service method
var response sep.SepResponse
endpoint := "sep/{nosep}"
endpoint = strings.Replace(endpoint, "{nosep}", nosep, 1)
err := h.service.Delete(ctx, endpoint, &response)
if err != nil {
h.logger.Error("Failed to delete SepSep", map[string]interface{}{
"error": err.Error(),
"request_id": requestID,
})
c.JSON(http.StatusInternalServerError, models.ErrorResponseBpjs{
Status: "error",
Message: "Internal server error",
RequestID: requestID,
})
return
}
// Ensure response has proper fields
response.Status = "success"
response.RequestID = requestID
c.JSON(http.StatusOK, response)
}

543
internal/handlers/test.txt/vclaim.backup
View File

@@ -1,543 +0,0 @@
// Code generated by generate-dynamic-handler.go; DO NOT EDIT.
// Generated at: 2025-09-01 13:38:57
// Service: VClaim (vclaim)
// Description: BPJS VClaim service for eligibility and SEP management
package handlers
import (
"context"
"net/http"
"strings"
"time"
"api-service/internal/config"
"api-service/internal/models"
"api-service/internal/models/vclaim/peserta"
"api-service/internal/models/vclaim/sep"
services "api-service/internal/services/bpjs"
"api-service/pkg/logger"
"github.com/gin-gonic/gin"
"github.com/go-playground/validator/v10"
"github.com/google/uuid"
)
// VClaimHandler handles VClaim BPJS services
type VClaimHandler struct {
service services.VClaimService
validator *validator.Validate
logger logger.Logger
config config.BpjsConfig
}
// VClaimHandlerConfig contains configuration for VClaimHandler
type VClaimHandlerConfig struct {
BpjsConfig config.BpjsConfig
Logger logger.Logger
Validator *validator.Validate
}
// NewVClaimHandler creates a new VClaimHandler
func NewVClaimHandler(cfg VClaimHandlerConfig) *VClaimHandler {
return &VClaimHandler{
service: services.NewService(cfg.BpjsConfig),
validator: cfg.Validator,
logger: cfg.Logger,
config: cfg.BpjsConfig,
}
}
/*
GetPesertaBynokartu godoc
@Summary Get PesertaBynokartu data
@Description Get participant eligibility information by card number
@Tags vclaim,peserta,nokartu
@Accept json
@Produce json
@Param nokartu path string true "nokartu"
@Success 200 {object} peserta.PesertaResponse
@Failure 400 {object} models.ErrorResponseBpjs
@Failure 500 {object} models.ErrorResponseBpjs
@Router /peserta/:nokartu [get]
*/
func (h *VClaimHandler) GetPesertaBynokartu(c *gin.Context) {
ctx, cancel := context.WithTimeout(c.Request.Context(), 30*time.Second)
defer cancel()
// Generate request ID if not present
requestID := c.GetHeader("X-Request-ID")
if requestID == "" {
requestID = uuid.New().String()
c.Header("X-Request-ID", requestID)
}
h.logger.Info("Processing GetPesertaBynokartu request", map[string]interface{}{
"request_id": requestID,
"endpoint": "/peserta/:nokartu",
"nokartu": c.Param("nokartu"),
})
// Extract path parameters
nokartu := c.Param("nokartu")
if nokartu == "" {
h.logger.Error("Missing required parameter nokartu", map[string]interface{}{
"request_id": requestID,
})
c.JSON(http.StatusBadRequest, models.ErrorResponseBpjs{
Status: "error",
Message: "Missing required parameter nokartu",
RequestID: requestID,
})
return
}
// Call service method
var response peserta.PesertaResponse
endpoint := "/peserta/:nokartu"
endpoint = strings.Replace(endpoint, ":nokartu", nokartu, 1)
err := h.service.Get(ctx, endpoint, &response)
if err != nil {
h.logger.Error("Failed to get PesertaBynokartu", map[string]interface{}{
"error": err.Error(),
"request_id": requestID,
})
c.JSON(http.StatusInternalServerError, models.ErrorResponseBpjs{
Status: "error",
Message: "Internal server error",
RequestID: requestID,
})
return
}
// Ensure response has proper fields
response.Status = "success"
response.RequestID = requestID
c.JSON(http.StatusOK, response)
}
/*
GetPesertaBynik godoc
@Summary Get PesertaBynik data
@Description Get participant eligibility information by NIK
@Tags vclaim,peserta,nik
@Accept json
@Produce json
@Param nik path string true "nik"
@Success 200 {object} peserta.PesertaResponse
@Failure 400 {object} models.ErrorResponseBpjs
@Failure 500 {object} models.ErrorResponseBpjs
@Router /peserta/nik/:nik [get]
*/
func (h *VClaimHandler) GetPesertaBynik(c *gin.Context) {
ctx, cancel := context.WithTimeout(c.Request.Context(), 30*time.Second)
defer cancel()
// Generate request ID if not present
requestID := c.GetHeader("X-Request-ID")
if requestID == "" {
requestID = uuid.New().String()
c.Header("X-Request-ID", requestID)
}
h.logger.Info("Processing GetPesertaBynik request", map[string]interface{}{
"request_id": requestID,
"endpoint": "/peserta/nik/:nik",
"nik": c.Param("nik"),
})
// Extract path parameters
nik := c.Param("nik")
if nik == "" {
h.logger.Error("Missing required parameter nik", map[string]interface{}{
"request_id": requestID,
})
c.JSON(http.StatusBadRequest, models.ErrorResponseBpjs{
Status: "error",
Message: "Missing required parameter nik",
RequestID: requestID,
})
return
}
// Call service method
var response peserta.PesertaResponse
endpoint := "/peserta/nik/:nik"
endpoint = strings.Replace(endpoint, ":nik", nik, 1)
err := h.service.Get(ctx, endpoint, &response)
if err != nil {
h.logger.Error("Failed to get PesertaBynik", map[string]interface{}{
"error": err.Error(),
"request_id": requestID,
})
c.JSON(http.StatusInternalServerError, models.ErrorResponseBpjs{
Status: "error",
Message: "Internal server error",
RequestID: requestID,
})
return
}
// Ensure response has proper fields
response.Status = "success"
response.RequestID = requestID
c.JSON(http.StatusOK, response)
}
/*
GetSepSep godoc
@Summary Get SepSep data
@Description Manage SEP (Surat Eligibilitas Peserta)
@Tags vclaim,sep
@Accept json
@Produce json
@Param nosep path string true "nosep"
@Success 200 {object} sep.SepResponse
@Failure 400 {object} models.ErrorResponseBpjs
@Failure 500 {object} models.ErrorResponseBpjs
@Router /sep/:nosep [get]
*/
func (h *VClaimHandler) GetSepSep(c *gin.Context) {
ctx, cancel := context.WithTimeout(c.Request.Context(), 30*time.Second)
defer cancel()
// Generate request ID if not present
requestID := c.GetHeader("X-Request-ID")
if requestID == "" {
requestID = uuid.New().String()
c.Header("X-Request-ID", requestID)
}
h.logger.Info("Processing GetSepSep request", map[string]interface{}{
"request_id": requestID,
"endpoint": "/sep/:nosep",
"nosep": c.Param("nosep"),
})
// Extract path parameters
nosep := c.Param("nosep")
if nosep == "" {
h.logger.Error("Missing required parameter nosep", map[string]interface{}{
"request_id": requestID,
})
c.JSON(http.StatusBadRequest, models.ErrorResponseBpjs{
Status: "error",
Message: "Missing required parameter nosep",
RequestID: requestID,
})
return
}
// Call service method
var response sep.SepResponse
endpoint := "/sep/:nosep"
endpoint = strings.Replace(endpoint, ":nosep", nosep, 1)
err := h.service.Get(ctx, endpoint, &response)
if err != nil {
h.logger.Error("Failed to get SepSep", map[string]interface{}{
"error": err.Error(),
"request_id": requestID,
})
c.JSON(http.StatusInternalServerError, models.ErrorResponseBpjs{
Status: "error",
Message: "Internal server error",
RequestID: requestID,
})
return
}
// Ensure response has proper fields
response.Status = "success"
response.RequestID = requestID
c.JSON(http.StatusOK, response)
}
/*
CreateSepSep godoc
@Summary Create SepSep
@Description Manage SEP (Surat Eligibilitas Peserta)
@Tags vclaim,sep
@Accept json
@Produce json
@Param request body sep.SepRequest true "SepSep data"
@Success 201 {object} sep.SepResponse
@Failure 400 {object} models.ErrorResponseBpjs
@Failure 500 {object} models.ErrorResponseBpjs
@Router /sep [post]
*/
func (h *VClaimHandler) CreateSepSep(c *gin.Context) {
ctx, cancel := context.WithTimeout(c.Request.Context(), 30*time.Second)
defer cancel()
requestID := c.GetHeader("X-Request-ID")
if requestID == "" {
requestID = uuid.New().String()
c.Header("X-Request-ID", requestID)
}
h.logger.Info("Processing CreateSepSep request", map[string]interface{}{
"request_id": requestID,
})
var req sep.SepRequest
if err := c.ShouldBindJSON(&req); err != nil {
h.logger.Error("Invalid request body", map[string]interface{}{
"error": err.Error(),
"request_id": requestID,
})
c.JSON(http.StatusBadRequest, models.ErrorResponseBpjs{
Status: "error",
Message: "Invalid request body: " + err.Error(),
RequestID: requestID,
})
return
}
// Validate request
if err := h.validator.Struct(&req); err != nil {
h.logger.Error("Validation failed", map[string]interface{}{
"error": err.Error(),
"request_id": requestID,
})
c.JSON(http.StatusBadRequest, models.ErrorResponseBpjs{
Status: "error",
Message: "Validation failed: " + err.Error(),
RequestID: requestID,
})
return
}
// Call service method
var response sep.SepResponse
err := h.service.Post(ctx, "/sep", &req, &response)
if err != nil {
h.logger.Error("Failed to create SepSep", map[string]interface{}{
"error": err.Error(),
"request_id": requestID,
})
c.JSON(http.StatusInternalServerError, models.ErrorResponseBpjs{
Status: "error",
Message: "Internal server error",
RequestID: requestID,
})
return
}
// Ensure response has proper fields
response.Status = "success"
response.RequestID = requestID
c.JSON(http.StatusCreated, response)
}
/*
UpdateSepSep godoc
@Summary Update SepSep
@Description Manage SEP (Surat Eligibilitas Peserta)
@Tags vclaim,sep
@Accept json
@Produce json
@Param nosep path string true "nosep"
@Param request body sep.SepRequest true "SepSep data"
@Success 200 {object} sep.SepResponse
@Failure 400 {object} models.ErrorResponseBpjs
@Failure 500 {object} models.ErrorResponseBpjs
@Router /sep/:nosep [put]
*/
func (h *VClaimHandler) UpdateSepSep(c *gin.Context) {
ctx, cancel := context.WithTimeout(c.Request.Context(), 30*time.Second)
defer cancel()
requestID := c.GetHeader("X-Request-ID")
if requestID == "" {
requestID = uuid.New().String()
c.Header("X-Request-ID", requestID)
}
h.logger.Info("Processing UpdateSepSep request", map[string]interface{}{
"request_id": requestID,
})
nosep := c.Param("nosep")
if nosep == "" {
h.logger.Error("Missing required parameter nosep", map[string]interface{}{
"request_id": requestID,
})
c.JSON(http.StatusBadRequest, models.ErrorResponseBpjs{
Status: "error",
Message: "Missing required parameter nosep",
RequestID: requestID,
})
return
}
var req sep.SepRequest
if err := c.ShouldBindJSON(&req); err != nil {
h.logger.Error("Invalid request body", map[string]interface{}{
"error": err.Error(),
"request_id": requestID,
})
c.JSON(http.StatusBadRequest, models.ErrorResponseBpjs{
Status: "error",
Message: "Invalid request body: " + err.Error(),
RequestID: requestID,
})
return
}
// Validate request
if err := h.validator.Struct(&req); err != nil {
h.logger.Error("Validation failed", map[string]interface{}{
"error": err.Error(),
"request_id": requestID,
})
c.JSON(http.StatusBadRequest, models.ErrorResponseBpjs{
Status: "error",
Message: "Validation failed: " + err.Error(),
RequestID: requestID,
})
return
}
// Call service method
var response sep.SepResponse
endpoint := "/sep/:nosep"
endpoint = strings.Replace(endpoint, ":nosep", nosep, 1)
err := h.service.Put(ctx, endpoint, &req, &response)
if err != nil {
h.logger.Error("Failed to update SepSep", map[string]interface{}{
"error": err.Error(),
"request_id": requestID,
})
c.JSON(http.StatusInternalServerError, models.ErrorResponseBpjs{
Status: "error",
Message: "Internal server error",
RequestID: requestID,
})
return
}
// Ensure response has proper fields
response.Status = "success"
response.RequestID = requestID
c.JSON(http.StatusOK, response)
}
/*
DeleteSepSep godoc
@Summary Delete SepSep
@Description Manage SEP (Surat Eligibilitas Peserta)
@Tags vclaim,sep
@Accept json
@Produce json
@Param nosep path string true "nosep"
@Success 200 {object} sep.SepResponse
@Failure 400 {object} models.ErrorResponseBpjs
@Failure 500 {object} models.ErrorResponseBpjs
@Router /sep/:nosep [delete]
*/
func (h *VClaimHandler) DeleteSepSep(c *gin.Context) {
ctx, cancel := context.WithTimeout(c.Request.Context(), 30*time.Second)
defer cancel()
requestID := c.GetHeader("X-Request-ID")
if requestID == "" {
requestID = uuid.New().String()
c.Header("X-Request-ID", requestID)
}
h.logger.Info("Processing DeleteSepSep request", map[string]interface{}{
"request_id": requestID,
})
nosep := c.Param("nosep")
if nosep == "" {
h.logger.Error("Missing required parameter nosep", map[string]interface{}{
"request_id": requestID,
})
c.JSON(http.StatusBadRequest, models.ErrorResponseBpjs{
Status: "error",
Message: "Missing required parameter nosep",
RequestID: requestID,
})
return
}
// Call service method
var response sep.SepResponse
endpoint := "/sep/:nosep"
endpoint = strings.Replace(endpoint, ":nosep", nosep, 1)
err := h.service.Delete(ctx, endpoint, &response)
if err != nil {
h.logger.Error("Failed to delete SepSep", map[string]interface{}{
"error": err.Error(),
"request_id": requestID,
})
c.JSON(http.StatusInternalServerError, models.ErrorResponseBpjs{
Status: "error",
Message: "Internal server error",
RequestID: requestID,
})
return
}
// Ensure response has proper fields
response.Status = "success"
response.RequestID = requestID
c.JSON(http.StatusOK, response)
}

232
internal/handlers/vclaim/peserta/peserta.go Normal file
View File

@@ -0,0 +1,232 @@
// Service: VClaim (vclaim)
// Description: BPJS VClaim service for eligibility and SEP management
package peserta
import (
"context"
"strings"
"net/http"
"time"
"api-service/internal/config"
"api-service/internal/models"
"api-service/internal/models/vclaim/peserta"
"api-service/internal/services/bpjs"
"api-service/pkg/logger"
"github.com/gin-gonic/gin"
"github.com/go-playground/validator/v10"
"github.com/google/uuid"
)
// VClaimHandler handles VClaim BPJS services
type VClaimHandler struct {
service services.VClaimService
validator *validator.Validate
logger logger.Logger
config config.BpjsConfig
}
// VClaimHandlerConfig contains configuration for VClaimHandler
type VClaimHandlerConfig struct {
BpjsConfig config.BpjsConfig
Logger logger.Logger
Validator *validator.Validate
}
// NewVClaimHandler creates a new VClaimHandler
func NewVClaimHandler(cfg VClaimHandlerConfig) *VClaimHandler {
return &VClaimHandler{
service: services.NewService(cfg.BpjsConfig),
validator: cfg.Validator,
logger: cfg.Logger,
config: cfg.BpjsConfig,
}
}
// GetPesertaBynokartu godoc
// @Summary Get PesertaBynokartu data
// @Description Get participant eligibility information by card number
// @Tags Peserta
// @Accept json
// @Produce json
// @Security ApiKeyAuth
// @Param X-Request-ID header string false "Request ID for tracking"
// @Param nokartu path string true "nokartu" example("example_value")
// @Success 200 {object} peserta.PesertaResponse "Successfully retrieved PesertaBynokartu data"
// @Failure 400 {object} models.ErrorResponseBpjs "Bad request - invalid parameters"
// @Failure 401 {object} models.ErrorResponseBpjs "Unauthorized - invalid API credentials"
// @Failure 404 {object} models.ErrorResponseBpjs "Not found - PesertaBynokartu not found"
// @Failure 500 {object} models.ErrorResponseBpjs "Internal server error"
// @Router /peserta/:nokartu [get]
func (h *VClaimHandler) GetPesertaBynokartu(c *gin.Context) {
ctx, cancel := context.WithTimeout(c.Request.Context(), 30*time.Second)
defer cancel()
// Generate request ID if not present
requestID := c.GetHeader("X-Request-ID")
if requestID == "" {
requestID = uuid.New().String()
c.Header("X-Request-ID", requestID)
}
h.logger.Info("Processing GetPesertaBynokartu request", map[string]interface{}{
"request_id": requestID,
"endpoint": "/peserta/:nokartu",
"nokartu": c.Param("nokartu"),
})
// Extract path parameters
nokartu := c.Param("nokartu")
if nokartu == "" {
h.logger.Error("Missing required parameter nokartu", map[string]interface{}{
"request_id": requestID,
})
c.JSON(http.StatusBadRequest, models.ErrorResponseBpjs{
Status: "error",
Message: "Missing required parameter nokartu",
RequestID: requestID,
})
return
}
// Call service method
var response peserta.PesertaResponse
endpoint := "/peserta/:nokartu"
endpoint = strings.Replace(endpoint, ":nokartu", nokartu, 1)
err := h.service.Get(ctx, endpoint, &response)
if err != nil {
h.logger.Error("Failed to get PesertaBynokartu", map[string]interface{}{
"error": err.Error(),
"request_id": requestID,
})
c.JSON(http.StatusInternalServerError, models.ErrorResponseBpjs{
Status: "error",
Message: "Internal server error",
RequestID: requestID,
})
return
}
// Ensure response has proper fields
response.Status = "success"
response.RequestID = requestID
c.JSON(http.StatusOK, response)
}
// GetPesertaBynik godoc
// @Summary Get PesertaBynik data
// @Description Get participant eligibility information by NIK
// @Tags Peserta
// @Accept json
// @Produce json
// @Security ApiKeyAuth
// @Param X-Request-ID header string false "Request ID for tracking"
// @Param nik path string true "nik" example("example_value")
// @Success 200 {object} peserta.PesertaResponse "Successfully retrieved PesertaBynik data"
// @Failure 400 {object} models.ErrorResponseBpjs "Bad request - invalid parameters"
// @Failure 401 {object} models.ErrorResponseBpjs "Unauthorized - invalid API credentials"
// @Failure 404 {object} models.ErrorResponseBpjs "Not found - PesertaBynik not found"
// @Failure 500 {object} models.ErrorResponseBpjs "Internal server error"
// @Router /peserta/nik/:nik [get]
func (h *VClaimHandler) GetPesertaBynik(c *gin.Context) {
ctx, cancel := context.WithTimeout(c.Request.Context(), 30*time.Second)
defer cancel()
// Generate request ID if not present
requestID := c.GetHeader("X-Request-ID")
if requestID == "" {
requestID = uuid.New().String()
c.Header("X-Request-ID", requestID)
}
h.logger.Info("Processing GetPesertaBynik request", map[string]interface{}{
"request_id": requestID,
"endpoint": "/peserta/nik/:nik",
"nik": c.Param("nik"),
})
// Extract path parameters
nik := c.Param("nik")
if nik == "" {
h.logger.Error("Missing required parameter nik", map[string]interface{}{
"request_id": requestID,
})
c.JSON(http.StatusBadRequest, models.ErrorResponseBpjs{
Status: "error",
Message: "Missing required parameter nik",
RequestID: requestID,
})
return
}
// Call service method
var response peserta.PesertaResponse
endpoint := "/peserta/nik/:nik"
endpoint = strings.Replace(endpoint, ":nik", nik, 1)
err := h.service.Get(ctx, endpoint, &response)
if err != nil {
h.logger.Error("Failed to get PesertaBynik", map[string]interface{}{
"error": err.Error(),
"request_id": requestID,
})
c.JSON(http.StatusInternalServerError, models.ErrorResponseBpjs{
Status: "error",
Message: "Internal server error",
RequestID: requestID,
})
return
}
// Ensure response has proper fields
response.Status = "success"
response.RequestID = requestID
c.JSON(http.StatusOK, response)
}

241
internal/handlers/vclaim_handler.go → internal/handlers/vclaim/sep/sep.go
View File

@@ -2,7 +2,7 @@
// Service: VClaim (vclaim)
// Description: BPJS VClaim service for eligibility and SEP management
package handlers
package sep
import (
"context"
@@ -12,7 +12,6 @@ import (
"api-service/internal/config"
"api-service/internal/models"
"api-service/internal/models/vclaim/peserta"
"api-service/internal/models/vclaim/sep"
"api-service/internal/services/bpjs"
"api-service/pkg/logger"
@@ -48,205 +47,15 @@ func NewVClaimHandler(cfg VClaimHandlerConfig) *VClaimHandler {
}
// GetPESERTABYNIK godoc
// @Summary Get PesertaBynik data
// @Description Get participant eligibility information by NIK
// @Tags vclaim,peserta,nik
// @Accept json
// @Produce json
// @Param X-Request-ID header string false "Request ID for tracking"
// @Param nik path string true "nik" example("example_value")
// @Success 200 {object} peserta.PesertaResponse "Successfully retrieved PesertaBynik data"
// @Failure 400 {object} models.ErrorResponseBpjs "Bad request - invalid parameters"
// @Failure 401 {object} models.ErrorResponseBpjs "Unauthorized - invalid API credentials"
// @Failure 404 {object} models.ErrorResponseBpjs "Not found - PesertaBynik not found"
// @Failure 500 {object} models.ErrorResponseBpjs "Internal server error"
// @Router /peserta/nik/:nik [get]
func (h *VClaimHandler) GetPesertaBynik(c *gin.Context) {
ctx, cancel := context.WithTimeout(c.Request.Context(), 30*time.Second)
defer cancel()
// Generate request ID if not present
requestID := c.GetHeader("X-Request-ID")
if requestID == "" {
requestID = uuid.New().String()
c.Header("X-Request-ID", requestID)
}
h.logger.Info("Processing GetPesertaBynik request", map[string]interface{}{
"request_id": requestID,
"endpoint": "/peserta/nik/:nik",
"nik": c.Param("nik"),
})
// Extract path parameters
nik := c.Param("nik")
if nik == "" {
h.logger.Error("Missing required parameter nik", map[string]interface{}{
"request_id": requestID,
})
c.JSON(http.StatusBadRequest, models.ErrorResponseBpjs{
Status: "error",
Message: "Missing required parameter nik",
RequestID: requestID,
})
return
}
// Call service method
var response peserta.PesertaResponse
endpoint := "/peserta/nik/:nik"
endpoint = strings.Replace(endpoint, ":nik", nik, 1)
err := h.service.Get(ctx, endpoint, &response)
if err != nil {
h.logger.Error("Failed to get PesertaBynik", map[string]interface{}{
"error": err.Error(),
"request_id": requestID,
})
c.JSON(http.StatusInternalServerError, models.ErrorResponseBpjs{
Status: "error",
Message: "Internal server error",
RequestID: requestID,
})
return
}
// Ensure response has proper fields
response.Status = "success"
response.RequestID = requestID
c.JSON(http.StatusOK, response)
}
// GetPESERTABYNOKARTU godoc
// @Summary Get PesertaBynokartu data
// @Description Get participant eligibility information by card number
// @Tags vclaim,peserta,nokartu
// @Accept json
// @Produce json
// @Param X-Request-ID header string false "Request ID for tracking"
// @Param nokartu path string true "nokartu" example("example_value")
// @Success 200 {object} peserta.PesertaResponse "Successfully retrieved PesertaBynokartu data"
// @Failure 400 {object} models.ErrorResponseBpjs "Bad request - invalid parameters"
// @Failure 401 {object} models.ErrorResponseBpjs "Unauthorized - invalid API credentials"
// @Failure 404 {object} models.ErrorResponseBpjs "Not found - PesertaBynokartu not found"
// @Failure 500 {object} models.ErrorResponseBpjs "Internal server error"
// @Router /peserta/:nokartu [get]
func (h *VClaimHandler) GetPesertaBynokartu(c *gin.Context) {
ctx, cancel := context.WithTimeout(c.Request.Context(), 30*time.Second)
defer cancel()
// Generate request ID if not present
requestID := c.GetHeader("X-Request-ID")
if requestID == "" {
requestID = uuid.New().String()
c.Header("X-Request-ID", requestID)
}
h.logger.Info("Processing GetPesertaBynokartu request", map[string]interface{}{
"request_id": requestID,
"endpoint": "/peserta/:nokartu",
"nokartu": c.Param("nokartu"),
})
// Extract path parameters
nokartu := c.Param("nokartu")
if nokartu == "" {
h.logger.Error("Missing required parameter nokartu", map[string]interface{}{
"request_id": requestID,
})
c.JSON(http.StatusBadRequest, models.ErrorResponseBpjs{
Status: "error",
Message: "Missing required parameter nokartu",
RequestID: requestID,
})
return
}
// Call service method
var response peserta.PesertaResponse
endpoint := "/peserta/:nokartu"
endpoint = strings.Replace(endpoint, ":nokartu", nokartu, 1)
err := h.service.Get(ctx, endpoint, &response)
if err != nil {
h.logger.Error("Failed to get PesertaBynokartu", map[string]interface{}{
"error": err.Error(),
"request_id": requestID,
})
c.JSON(http.StatusInternalServerError, models.ErrorResponseBpjs{
Status: "error",
Message: "Internal server error",
RequestID: requestID,
})
return
}
// Ensure response has proper fields
response.Status = "success"
response.RequestID = requestID
c.JSON(http.StatusOK, response)
}
// GetSEPSEP godoc
// GetSepSep godoc
// @Summary Get SepSep data
// @Description Manage SEP (Surat Eligibilitas Peserta)
// @Tags vclaim,sep
// @Tags Sep
// @Accept json
// @Produce json
// @Param X-Request-ID header string false "Request ID for tracking"
// @Param nosep path string true "nosep" example("example_value")
// @Produce json
// @Security ApiKeyAuth
// @Param X-Request-ID header string false "Request ID for tracking"
// @Param nosep path string true "nosep" example("example_value")
// @Success 200 {object} sep.SepResponse "Successfully retrieved SepSep data"
// @Failure 400 {object} models.ErrorResponseBpjs "Bad request - invalid parameters"
// @Failure 401 {object} models.ErrorResponseBpjs "Unauthorized - invalid API credentials"
@@ -324,13 +133,13 @@ func (h *VClaimHandler) GetSepSep(c *gin.Context) {
// CreateSEPSEP godoc
// CreateSepSep godoc
// @Summary Create new SepSep
// @Description Manage SEP (Surat Eligibilitas Peserta)
// @Tags vclaim,sep
// @Tags Sep
// @Accept json
// @Produce json
// @Produce json
// @Security ApiKeyAuth
// @Param X-Request-ID header string false "Request ID for tracking"
// @Param request body sep.SepRequest true "SepSep data"
// @Success 201 {object} sep.SepResponse "Successfully created SepSep"
@@ -413,17 +222,15 @@ func (h *VClaimHandler) CreateSepSep(c *gin.Context) {
// UpdateSEPSEP godoc
// UpdateSepSep godoc
// @Summary Update existing SepSep
// @Description Manage SEP (Surat Eligibilitas Peserta)
// @Tags vclaim,sep
// @Tags Sep
// @Accept json
// @Produce json
// @Param X-Request-ID header string false "Request ID for tracking"
// @Param nosep path string true "nosep" example("example_value")
// @Produce json
// @Security ApiKeyAuth
// @Param X-Request-ID header string false "Request ID for tracking"
// @Param nosep path string true "nosep" example("example_value")
// @Param request body sep.SepRequest true "SepSep data"
// @Success 200 {object} sep.SepResponse "Successfully updated SepSep"
// @Failure 400 {object} models.ErrorResponseBpjs "Bad request - invalid parameters or request body"
@@ -528,17 +335,15 @@ func (h *VClaimHandler) UpdateSepSep(c *gin.Context) {
// DeleteSEPSEP godoc
// DeleteSepSep godoc
// @Summary Delete existing SepSep
// @Description Manage SEP (Surat Eligibilitas Peserta)
// @Tags vclaim,sep
// @Tags Sep
// @Accept json
// @Produce json
// @Param X-Request-ID header string false "Request ID for tracking"
// @Param nosep path string true "nosep" example("example_value")
// @Produce json
// @Security ApiKeyAuth
// @Param X-Request-ID header string false "Request ID for tracking"
// @Param nosep path string true "nosep" example("example_value")
// @Success 200 {object} sep.SepResponse "Successfully deleted SepSep"
// @Failure 400 {object} models.ErrorResponseBpjs "Bad request - invalid parameters"
// @Failure 401 {object} models.ErrorResponseBpjs "Unauthorized - invalid API credentials"

47
internal/routes/v1/routes.go
View File

@@ -6,6 +6,8 @@ import (
authHandlers "api-service/internal/handlers/auth"
healthcheckHandlers "api-service/internal/handlers/healthcheck"
retribusiHandlers "api-service/internal/handlers/retribusi"
"api-service/internal/handlers/vclaim/peserta"
"api-service/internal/handlers/vclaim/sep"
"api-service/internal/middleware"
services "api-service/internal/services/auth"
"api-service/pkg/logger"
@@ -66,6 +68,28 @@ func RegisterRoutes(cfg *config.Config) *gin.Engine {
// ============= PUBLISHED ROUTES ===============================================
// Peserta routes
pesertaHandler := peserta.NewVClaimHandler(peserta.VClaimHandlerConfig{
BpjsConfig: cfg.Bpjs,
Logger: *logger.Default(),
Validator: nil,
})
pesertaGroup := v1.Group("/peserta")
pesertaGroup.GET("/peserta/:nokartu", pesertaHandler.GetPesertaBynokartu)
pesertaGroup.GET("/peserta/nik/:nik", pesertaHandler.GetPesertaBynik)
// Sep routes
sepHandler := sep.NewVClaimHandler(sep.VClaimHandlerConfig{
BpjsConfig: cfg.Bpjs,
Logger: *logger.Default(),
Validator: nil,
})
sepGroup := v1.Group("/sep")
sepGroup.GET("/sep/:nosep", sepHandler.GetSepSep)
sepGroup.POST("/sep", sepHandler.CreateSepSep)
sepGroup.PUT("/sep/:nosep", sepHandler.UpdateSepSep)
sepGroup.DELETE("/sep/:nosep", sepHandler.DeleteSepSep)
// // Retribusi endpoints
// retribusiHandler := retribusiHandlers.NewRetribusiHandler()
// retribusiGroup := v1.Group("/retribusi")
@@ -100,5 +124,28 @@ func RegisterRoutes(cfg *config.Config) *gin.Engine {
protectedRetribusi.DELETE("/:id", retribusiHandler.DeleteRetribusi) // DELETE /api/v1/retribusi/:id
}
// // BPJS VClaim endpoints (require authentication)
// // Peserta routes
// pesertaHandler := peserta.NewVClaimHandler(peserta.VClaimHandlerConfig{
// BpjsConfig: cfg.Bpjs,
// Logger: *logger.Default(),
// Validator: nil,
// })
// protectedPeserta := protected.Group("/peserta")
// protectedPeserta.GET("/peserta/:nokartu", pesertaHandler.GetPesertaBynokartu)
// protectedPeserta.GET("/peserta/nik/:nik", pesertaHandler.GetPesertaBynik)
// // Sep routes
// sepHandler := sep.NewVClaimHandler(sep.VClaimHandlerConfig{
// BpjsConfig: cfg.Bpjs,
// Logger: *logger.Default(),
// Validator: nil,
// })
// protectedSep := protected.Group("/sep")
// protectedSep.GET("/sep/:nosep", sepHandler.GetSepSep)
// protectedSep.POST("/sep", sepHandler.CreateSepSep)
// protectedSep.PUT("/sep/:nosep", sepHandler.UpdateSepSep)
// protectedSep.DELETE("/sep/:nosep", sepHandler.DeleteSepSep)
return router
}