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

perbaikan

Browse Source
This commit is contained in:
Meninjar Mulyono
2025-09-04 18:52:50 +07:00
parent 8311311615
commit b438fd8dd4
7 changed files with 197 additions and 1054 deletions
Download Patch File Download Diff File Expand all files Collapse all files

276
internal/handlers/vclaim/peserta/peserta.go
View File

@@ -1,276 +0,0 @@
// Service: VClaim (vclaim)
// Description: BPJS VClaim service for eligibility and SEP management
package peserta
import (
"context"
"encoding/json"
"net/http"
"strings"
"time"
"api-service/internal/config"
"api-service/internal/models"
"api-service/internal/models/vclaim/peserta"
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 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/:nokartu/tglSEP/:tglsep [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,
"nokartu": c.Param("nokartu"),
"tglsep": c.Param("tglsep"),
})
// Extract path parameters
nokartu := c.Param("nokartu")
tglsep := c.Param("tglsep")
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/:nokartu/tglSEP/:tglsep"
endpoint = strings.Replace(endpoint, ":nokartu", nokartu, 1)
endpoint = strings.Replace(endpoint, ":tglsep", tglsep, 1)
resp, err := h.service.GetRawResponse(ctx, endpoint)
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
}
// Map the raw response
response.MetaData = resp.MetaData
if resp.Response != nil {
response.Data = &peserta.PesertaData{}
if respStr, ok := resp.Response.(string); ok {
// Decrypt the response string
consID, secretKey, _, tstamp, _ := h.config.SetHeader()
decryptedResp, err := services.ResponseVclaim(respStr, consID+secretKey+tstamp)
if err != nil {
h.logger.Error("Failed to decrypt response", map[string]interface{}{
"error": err.Error(),
"request_id": requestID,
})
} else {
json.Unmarshal([]byte(decryptedResp), response.Data)
}
} else if respMap, ok := resp.Response.(map[string]interface{}); ok {
// Response is already unmarshaled JSON
if pesertaMap, exists := respMap["peserta"]; exists {
pesertaBytes, _ := json.Marshal(pesertaMap)
json.Unmarshal(pesertaBytes, response.Data)
} else {
// Try to unmarshal the whole response
respBytes, _ := json.Marshal(resp.Response)
json.Unmarshal(respBytes, response.Data)
}
}
}
// 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/:nik/tglSEP/:tglsep [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/tglSEP/:tglsep",
"nik": c.Param("nik"),
})
// Extract path parameters
nik := c.Param("nik")
tglsep := c.Param("tglsep")
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
}
if tglsep == "" {
h.logger.Error("Missing required parameter Tanggal SEP", map[string]interface{}{
"request_id": requestID,
})
c.JSON(http.StatusBadRequest, models.ErrorResponseBpjs{
Status: "error",
Message: "Missing required parameter Tanggal SEP",
RequestID: requestID,
})
return
}
// Call service method
var response peserta.PesertaResponse
endpoint := "/Peserta/nik/:nik/tglSEP/:tglsep"
endpoint = strings.Replace(endpoint, ":nik", nik, 1)
endpoint = strings.Replace(endpoint, ":tglsep", tglsep, 1)
resp, err := h.service.GetRawResponse(ctx, endpoint)
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
}
// Map the raw response
response.MetaData = resp.MetaData
if resp.Response != nil {
response.Data = &peserta.PesertaData{}
if respStr, ok := resp.Response.(string); ok {
// Decrypt the response string
consID, secretKey, _, tstamp, _ := h.config.SetHeader()
decryptedResp, err := services.ResponseVclaim(respStr, consID+secretKey+tstamp)
if err != nil {
h.logger.Error("Failed to decrypt response", map[string]interface{}{
"error": err.Error(),
"request_id": requestID,
})
} else {
json.Unmarshal([]byte(decryptedResp), response.Data)
}
} else if respMap, ok := resp.Response.(map[string]interface{}); ok {
// Response is already unmarshaled JSON
if pesertaMap, exists := respMap["peserta"]; exists {
pesertaBytes, _ := json.Marshal(pesertaMap)
json.Unmarshal(pesertaBytes, response.Data)
} else {
// Try to unmarshal the whole response
respBytes, _ := json.Marshal(resp.Response)
json.Unmarshal(respBytes, response.Data)
}
}
}
// Ensure response has proper fields
response.Status = "success"
response.RequestID = requestID
c.JSON(http.StatusOK, response)
}

261
internal/handlers/vclaim/rujukan/rujukan.go
View File

@@ -1,261 +0,0 @@
// Service: VClaim (vclaim)
// Description: BPJS VClaim service for eligibility and SEP management
package rujukan
import (
"context"
"encoding/json"
"net/http"
"strings"
"time"
"api-service/internal/config"
"api-service/internal/models"
"api-service/internal/models/vclaim/rujukan"
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,
}
}
// GetRujukanBynorujukan godoc
// @Summary Get RujukanBynorujukan data
// @Description Manage rujukan
// @Tags Rujukan
// @Accept json
// @Produce json
// @Security ApiKeyAuth
// @Param X-Request-ID header string false "Request ID for tracking"
// @Param norujukan path string true "norujukan" example("example_value")
// @Success 200 {object} rujukan.RujukanResponse "Successfully retrieved RujukanBynorujukan 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 - RujukanBynorujukan not found"
// @Failure 500 {object} models.ErrorResponseBpjs "Internal server error"
// @Router /Rujukan/:norujukan [get]
func (h *VClaimHandler) GetRujukanBynorujukan(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 GetRujukanBynorujukan request", map[string]interface{}{
"request_id": requestID,
"endpoint": "/Rujukan/:norujukan",
"norujukan": c.Param("norujukan"),
})
// Extract path parameters
norujukan := c.Param("norujukan")
if norujukan == "" {
h.logger.Error("Missing required parameter norujukan", map[string]interface{}{
"request_id": requestID,
})
c.JSON(http.StatusBadRequest, models.ErrorResponseBpjs{
Status: "error",
Message: "Missing required parameter norujukan",
RequestID: requestID,
})
return
}
// Call service method
var response rujukan.RujukanResponse
endpoint := "/Rujukan/RS/:norujukan"
endpoint = strings.Replace(endpoint, ":norujukan", norujukan, 1)
resp, err := h.service.GetRawResponse(ctx, endpoint)
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
}
// Map the raw response
response.MetaData = resp.MetaData
if resp.Response != nil {
response.Data = &rujukan.RujukanData{}
if respStr, ok := resp.Response.(string); ok {
// Decrypt the response string
consID, secretKey, _, tstamp, _ := h.config.SetHeader()
decryptedResp, err := services.ResponseVclaim(respStr, consID+secretKey+tstamp)
if err != nil {
h.logger.Error("Failed to decrypt response", map[string]interface{}{
"error": err.Error(),
"request_id": requestID,
})
} else {
json.Unmarshal([]byte(decryptedResp), response.Data)
}
} else if respMap, ok := resp.Response.(map[string]interface{}); ok {
// Response is already unmarshaled JSON
if pesertaMap, exists := respMap["rujukan"]; exists {
pesertaBytes, _ := json.Marshal(pesertaMap)
json.Unmarshal(pesertaBytes, response.Data)
} else {
// Try to unmarshal the whole response
respBytes, _ := json.Marshal(resp.Response)
json.Unmarshal(respBytes, response.Data)
}
}
}
// Ensure response has proper fields
response.Status = "success"
response.RequestID = requestID
c.JSON(http.StatusOK, response)
}
// GetRujukanBynokartu godoc
// @Summary Get RujukanBynokartu data
// @Description Manage rujukan
// @Tags Rujukan
// @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} rujukan.RujukanResponse "Successfully retrieved RujukanBynokartu 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 - RujukanBynokartu not found"
// @Failure 500 {object} models.ErrorResponseBpjs "Internal server error"
// @Router /Rujukan/Peserta/:nokartu [get]
func (h *VClaimHandler) GetRujukanBynokartu(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 GetRujukanBynokartu request", map[string]interface{}{
"request_id": requestID,
"endpoint": "/Rujukan/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 rujukan.RujukanResponse
endpoint := "/Rujukan/RS/Peserta/:nokartu"
endpoint = strings.Replace(endpoint, ":nokartu", nokartu, 1)
resp, err := h.service.GetRawResponse(ctx, endpoint)
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
}
// Map the raw response
response.MetaData = resp.MetaData
if resp.Response != nil {
response.Data = &rujukan.RujukanData{}
if respStr, ok := resp.Response.(string); ok {
// Decrypt the response string
consID, secretKey, _, tstamp, _ := h.config.SetHeader()
decryptedResp, err := services.ResponseVclaim(respStr, consID+secretKey+tstamp)
if err != nil {
h.logger.Error("Failed to decrypt response", map[string]interface{}{
"error": err.Error(),
"request_id": requestID,
})
} else {
json.Unmarshal([]byte(decryptedResp), response.Data)
}
} else if respMap, ok := resp.Response.(map[string]interface{}); ok {
// Response is already unmarshaled JSON
if pesertaMap, exists := respMap["rujukan"]; exists {
pesertaBytes, _ := json.Marshal(pesertaMap)
json.Unmarshal(pesertaBytes, response.Data)
} else {
// Try to unmarshal the whole response
respBytes, _ := json.Marshal(resp.Response)
json.Unmarshal(respBytes, response.Data)
}
}
}
// Ensure response has proper fields
response.Status = "success"
response.RequestID = requestID
c.JSON(http.StatusOK, response)
}

416
internal/handlers/vclaim/sep/sep.go
View File

@@ -1,416 +0,0 @@
// Service: VClaim (vclaim)
// Description: BPJS VClaim service for eligibility and SEP management
package sep
import (
"context"
"strings"
"net/http"
"time"
"api-service/internal/config"
"api-service/internal/models"
"api-service/internal/models/vclaim/sep"
"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,
}
}
// GetSepSep godoc
// @Summary Get SepSep data
// @Description Manage SEP (Surat Eligibilitas Peserta)
// @Tags Sep
// @Accept json
// @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"
// @Failure 404 {object} models.ErrorResponseBpjs "Not found - SepSep 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 SepSep
// @Description Manage SEP (Surat Eligibilitas Peserta)
// @Tags Sep
// @Accept 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"
// @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 - SepSep 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 SepSep
// @Description Manage SEP (Surat Eligibilitas Peserta)
// @Tags Sep
// @Accept json
// @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"
// @Failure 401 {object} models.ErrorResponseBpjs "Unauthorized - invalid API credentials"
// @Failure 404 {object} models.ErrorResponseBpjs "Not found - SepSep 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 existing SepSep
// @Description Manage SEP (Surat Eligibilitas Peserta)
// @Tags Sep
// @Accept json
// @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"
// @Failure 404 {object} models.ErrorResponseBpjs "Not found - SepSep 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)
}

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

@@ -6,9 +6,6 @@ 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/rujukan"
"api-service/internal/handlers/vclaim/sep"
"api-service/internal/middleware"
services "api-service/internal/services/auth"
"api-service/pkg/logger"
@@ -69,37 +66,37 @@ func RegisterRoutes(cfg *config.Config) *gin.Engine {
// ============= PUBLISHED ROUTES ===============================================
// Rujukan routes
rujukanHandler := rujukan.NewVClaimHandler(rujukan.VClaimHandlerConfig{
BpjsConfig: cfg.Bpjs,
Logger: *logger.Default(),
Validator: nil,
})
rujukanGroup := v1.Group("/rujukan")
rujukanGroup.GET("/nokartu/:nokartu", rujukanHandler.GetRujukanBynokartu)
rujukanGroup.GET("/norujukan/:norujukan", rujukanHandler.GetRujukanBynorujukan)
// // Rujukan routes
// rujukanHandler := rujukan.NewVClaimHandler(rujukan.VClaimHandlerConfig{
// BpjsConfig: cfg.Bpjs,
// Logger: *logger.Default(),
// Validator: nil,
// })
// rujukanGroup := v1.Group("/rujukan")
// rujukanGroup.GET("/nokartu/:nokartu", rujukanHandler.GetRujukanBynokartu)
// rujukanGroup.GET("/norujukan/:norujukan", rujukanHandler.GetRujukanBynorujukan)
// Peserta routes
pesertaHandler := peserta.NewVClaimHandler(peserta.VClaimHandlerConfig{
BpjsConfig: cfg.Bpjs,
Logger: *logger.Default(),
Validator: nil,
})
pesertaGroup := v1.Group("/peserta")
pesertaGroup.GET("/nokartu/:nokartu/tglSEP/:tglsep", pesertaHandler.GetPesertaBynokartu)
pesertaGroup.GET("/nik/:nik/tglSEP/:tglsep", pesertaHandler.GetPesertaBynik)
// // Peserta routes
// pesertaHandler := peserta.NewVClaimHandler(peserta.VClaimHandlerConfig{
// BpjsConfig: cfg.Bpjs,
// Logger: *logger.Default(),
// Validator: nil,
// })
// pesertaGroup := v1.Group("/peserta")
// pesertaGroup.GET("/nokartu/:nokartu/tglSEP/:tglsep", pesertaHandler.GetPesertaBynokartu)
// pesertaGroup.GET("/nik/:nik/tglSEP/:tglsep", 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)
// // 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()

145
services-config-bpjs.yaml
View File

@@ -1,4 +1,3 @@
# BPJS Services Configuration
global:
module_name: "api-service"
output_dir: "internal/handlers"
@@ -14,66 +13,90 @@ services:
base_url: "https://apijkn.bpjs-kesehatan.go.id/vclaim-rest"
timeout: 30
retry_count: 3
endpoints:
peserta:
bynokartu:
methods: ["GET"]
get_path: "/peserta/:nokartu"
model: "PesertaRequest"
response_model: "PesertaResponse"
description: "Get participant eligibility information by card number"
summary: "Get Participant Info by No Kartu"
tags: ["Peserta"]
require_auth: true
cache_enabled: true
cache_ttl: 300
bynik:
methods: ["GET"]
get_path: "/peserta/nik/:nik"
model: "PesertaRequest"
response_model: "PesertaResponse"
description: "Get participant eligibility information by NIK"
summary: "Get Participant Info by NIK"
tags: ["Peserta"]
require_auth: true
cache_enabled: true
cache_ttl: 300
sep:
sep:
methods: ["GET", "POST", "PUT", "DELETE"]
get_path: "/sep/:nosep"
post_path: "/sep"
put_path: "/sep/:nosep"
delete_path: "/sep/:nosep"
model: "SepRequest"
response_model: "SepResponse"
description: "Manage SEP (Surat Eligibilitas Peserta)"
summary: "SEP Management"
tags: ["Sep"]
require_auth: true
cache_enabled: true
cache_ttl: 180
description: "Participant eligibility information"
handler_folder: "peserta"
handler_file: "peserta.go"
functions:
bynokartu:
methods: ["GET"]
path: "/peserta/:nokartu"
model: "PesertaRequest"
response_model: "PesertaResponse"
description: "Get participant eligibility information by card number"
summary: "Get Participant Info by No Kartu"
tags: ["Peserta"]
require_auth: true
cache_enabled: true
cache_ttl: 300
bynik:
methods: ["GET"]
path: "/peserta/nik/:nik"
model: "PesertaRequest"
response_model: "PesertaResponse"
description: "Get participant eligibility information by NIK"
summary: "Get Participant Info by NIK"
tags: ["Peserta"]
require_auth: true
cache_enabled: true
cache_ttl: 300
rujukan:
bynorujukan:
methods: ["GET"]
get_path: "/Rujukan/:norujukan"
model: "RujukanRequest"
response_model: "RujukanResponse"
description: "Manage rujukan"
summary: "Rujukan Management"
tags: ["Rujukan"]
require_auth: true
cache_enabled: true
cache_ttl: 300
bynokartu:
methods: ["GET"]
get_path: "/Rujukan/:nokartu"
model: "RujukanRequest"
response_model: "RujukanResponse"
description: "Manage rujukan"
summary: "Rujukan Management"
tags: ["Rujukan"]
require_auth: true
cache_enabled: true
cache_ttl: 300
description: "Rujukan management endpoints"
handler_folder: "rujukan"
handler_file: "rujukan.go"
functions:
rujukan:
methods: ["POST", "PUT", "DELETE"]
path: "/Rujukan"
model: "RujukanRequest"
response_model: "RujukanResponse"
description: "Manage rujukan"
summary: "Rujukan Management"
tags: ["Rujukan"]
require_auth: true
cache_enabled: true
cache_ttl: 180
rujukan:
methods: ["GET"]
path: "/Rujukan"
model: "RujukanRequest"
response_model: "RujukanResponse"
description: "Manage rujukan"
summary: "Rujukan Management"
tags: ["Rujukan"]
require_auth: true
cache_enabled: true
cache_ttl: 180
search:
description: "Search for rujukan endpoints"
handler_folder: "rujukan"
handler_file: "search.go"
functions:
bynorujukan:
methods: ["GET"]
path: "/Rujukan/:norujukan"
model: "RujukanRequest"
response_model: "RujukanResponse"
description: "Get rujukan by nomor rujukan"
summary: "Rujukan Management"
tags: ["Rujukan"]
require_auth: true
cache_enabled: true
cache_ttl: 300
bynokartu:
methods: ["GET"]
path: "/Rujukan/:nokartu"
model: "RujukanRequest"
response_model: "RujukanResponse"
description: "Get rujukan by card number"
summary: "Rujukan Management"
tags: ["Rujukan"]
require_auth: true
cache_enabled: true
cache_ttl: 300

76
services-config-old.yaml Normal file
View File

@@ -0,0 +1,76 @@
# BPJS Services Configuration
global:
module_name: "api-service"
output_dir: "internal/handlers"
enable_swagger: true
enable_logging: true
services:
vclaim:
name: "VClaim"
category: "vclaim"
package: "vclaim"
description: "BPJS VClaim service for eligibility and SEP management"
base_url: "https://apijkn.bpjs-kesehatan.go.id/vclaim-rest"
timeout: 30
retry_count: 3
endpoints:
peserta: # file .go handler file dan directori folder name
bynokartu: #fuction
methods: ["GET"]
get_path: "/peserta/:nokartu"
model: "PesertaRequest"
response_model: "PesertaResponse"
description: "Get participant eligibility information by card number"
summary: "Get Participant Info by No Kartu"
tags: ["Peserta"]
require_auth: true
cache_enabled: true
cache_ttl: 300
bynik: #fuction
methods: ["GET"]
get_path: "/peserta/nik/:nik"
model: "PesertaRequest"
response_model: "PesertaResponse"
description: "Get participant eligibility information by NIK"
summary: "Get Participant Info by NIK"
tags: ["Peserta"]
require_auth: true
cache_enabled: true
cache_ttl: 300
rujukan: # directori folder name
rujukan: # file .go handler file
methods: ["POST,PUT, DELETE"]
post_path: "/Rujukan"
model: "RujukanRequest"
response_model: "RujukanResponse"
description: "Manage rujukan"
summary: "Rujukan Management"
tags: ["Rujukan"]
require_auth: true
cache_enabled: true
cache_ttl: 180
search: # file .go handler file
bynorujukan: #fuction
methods: ["GET"]
get_path: "/Rujukan/:norujukan"
model: "RujukanRequest"
response_model: "RujukanResponse"
description: "Manage rujukan"
summary: "Rujukan Management"
tags: ["Rujukan"]
require_auth: true
cache_enabled: true
cache_ttl: 300
bynokartu: #fuction
methods: ["GET"]
get_path: "/Rujukan/:nokartu"
model: "RujukanRequest"
response_model: "RujukanResponse"
description: "Manage rujukan"
summary: "Rujukan Management"
tags: ["Rujukan"]
require_auth: true
cache_enabled: true
cache_ttl: 300

16
tools/bpjs/generate-handler.go
View File

@@ -717,14 +717,14 @@ func main() {
fmt.Printf("✅ Generated handler: %s.go\n", strings.ToLower(serviceName))
// Generate routes for this service
err = generateRoutes(serviceName, service, config.Global)
if err != nil {
fmt.Printf("❌ Error generating routes for %s: %v\n", serviceName, err)
errors++
continue
}
fmt.Printf("✅ Generated routes: %s_routes.go\n", strings.ToLower(serviceName))
generated++
// err = generateRoutes(serviceName, service, config.Global)
// if err != nil {
// fmt.Printf("❌ Error generating routes for %s: %v\n", serviceName, err)
// errors++
// continue
// }
// fmt.Printf("✅ Generated routes: %s_routes.go\n", strings.ToLower(serviceName))
// generated++
}
// Summary