rachmadiyanti.annisa.3004/antrean-anjungan
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
779bbc976cb04e605de73ced35fab719a9496458
antrean-anjungan/tools/bpjs/generete

2942 lines
97 KiB
Plaintext
Raw Blame History

package main
import (
"fmt"
"go/ast"
"go/parser"
"go/token"
"io/ioutil"
"os"
"path/filepath"
"regexp"
"strings"
"text/template"
"time"
"gopkg.in/yaml.v2"
)
// Enhanced structures untuk validasi
type HandlerValidation struct {
ExistingFunctions map[string]bool
NewFunctions []string
UpdatedFiles []string
CreatedFiles []string
}
type DirectoryInfo struct {
Path string
IsFile bool
Functions []FunctionInfo
Children map[string]*DirectoryInfo
}
type FunctionInfo struct {
Name string
Methods []string
Endpoint string
Config EndpointConfig
}
type EndpointConfig struct {
Methods []string `yaml:"methods"`
GetPath string `yaml:"get_path"`
PostPath string `yaml:"post_path"`
PutPath string `yaml:"put_path"`
DeletePath string `yaml:"delete_path"`
Model string `yaml:"model"`
ResponseModel string `yaml:"response_model"`
RequestModel string `yaml:"request_model"`
Description string `yaml:"description"`
Summary string `yaml:"summary"`
Tags []string `yaml:"tags"`
RequireAuth bool `yaml:"require_auth"`
CacheEnabled bool `yaml:"cache_enabled"`
CacheTTL int `yaml:"cache_ttl"`
}
type GlobalConfig struct {
ModuleName string `yaml:"module_name"`
OutputDir string `yaml:"output_dir"`
EnableSwagger bool `yaml:"enable_swagger"`
EnableLogging bool `yaml:"enable_logging"`
}
type ServiceConfig struct {
Global GlobalConfig `yaml:"global,omitempty"`
Services map[string]Service `yaml:"services"`
}
type Service struct {
Name string `yaml:"name"`
Category string `yaml:"category"`
Package string `yaml:"package"`
Description string `yaml:"description"`
BaseURL string `yaml:"base_url"`
Timeout int `yaml:"timeout"`
RetryCount int `yaml:"retry_count"`
Endpoints map[string]EndpointGroup `yaml:"endpoints"`
Dependencies string `yaml:"dependencies,omitempty"`
Middleware string `yaml:"middleware,omitempty"`
}
type EndpointGroup struct {
Description string `yaml:"description"`
HandlerFolder string `yaml:"handler_folder"`
HandlerFile string `yaml:"handler_file"`
Functions map[string]FunctionConfig `yaml:"functions"`
}
type FunctionConfig struct {
Methods []string `yaml:"methods"`
Path string `yaml:"path"`
Model string `yaml:"model"`
ResponseModel string `yaml:"response_model"`
RequestModel string `yaml:"request_model"`
Description string `yaml:"description"`
Summary string `yaml:"summary"`
Tags []string `yaml:"tags"`
RequireAuth bool `yaml:"require_auth"`
CacheEnabled bool `yaml:"cache_enabled"`
CacheTTL int `yaml:"cache_ttl"`
}
type TemplateData struct {
ServiceName string
ServiceLower string
ServiceUpper string
Category string
Package string
Description string
BaseURL string
Timeout int
RetryCount int
Endpoints []EndpointData
Timestamp string
ModuleName string
HasValidator bool
HasLogger bool
HasSwagger bool
GlobalConfig GlobalConfig
}
type EndpointData struct {
Name string
NameLower string
NameUpper string
NameCamel string
Methods []string
GetPath string
PostPath string
PutPath string
DeletePath string
Model string
ResponseModel string
RequestModel string
DataModel string
Description string
Summary string
Tags []string
HasGet bool
HasPost bool
HasPut bool
HasDelete bool
RequireAuth bool
CacheEnabled bool
CacheTTL int
PathParams []string
ModelPackage string
}
// Fungsi utama untuk generate handler dengan validasi
func generateHandlerWithValidation(serviceName string, svc Service, gc GlobalConfig) error {
baseDir := gc.OutputDir
for _, grp := range svc.Endpoints {
folder := filepath.Join(baseDir, grp.HandlerFolder)
if err := os.MkdirAll(folder, 0755); err != nil {
return fmt.Errorf("mkdir %s: %w", folder, err)
}
filePath := filepath.Join(folder, grp.HandlerFile)
// Check if file exists
fileExists := false
if _, err := os.Stat(filePath); err == nil {
fileExists = true
}
if !fileExists {
// Create new file with full template
err := createNewHandlerFileFromConfig(filePath, svc, grp, gc)
if err != nil {
return fmt.Errorf("create file %s: %w", filePath, err)
}
fmt.Printf("✅ Created new file: %s\n", filePath)
} else {
// Update existing file with functions only
err := updateExistingHandlerFile(filePath, svc, grp, gc)
if err != nil {
return fmt.Errorf("update file %s: %w", filePath, err)
}
fmt.Printf("✅ Updated existing file: %s\n", filePath)
}
}
return nil
}
// Create new handler file with full template
func createNewHandlerFileFromConfig(filePath string, svc Service, grp EndpointGroup, gc GlobalConfig) error {
// Collect all functions for this group
var allEndpoints []EndpointData
for fname, fcfg := range grp.Functions {
td := processFunctionData(svc, grp, fname, fcfg, gc)
allEndpoints = append(allEndpoints, td.Endpoints...)
}
templateData := TemplateData{
ServiceName: svc.Name,
ServiceLower: strings.ToLower(svc.Name),
ServiceUpper: strings.ToUpper(svc.Name),
Category: svc.Category,
Package: grp.HandlerFolder,
Description: svc.Description,
BaseURL: svc.BaseURL,
Timeout: svc.Timeout,
RetryCount: svc.RetryCount,
Endpoints: allEndpoints,
Timestamp: time.Now().Format("2006-01-02 15:04:05"),
ModuleName: gc.ModuleName,
HasValidator: true,
HasLogger: gc.EnableLogging,
HasSwagger: gc.EnableSwagger,
GlobalConfig: gc,
}
return createNewHandlerFile(filePath, templateData)
}
// Update existing handler file with functions only
func updateExistingHandlerFile(filePath string, svc Service, grp EndpointGroup, gc GlobalConfig) error {
// Read existing content
existingContent, err := ioutil.ReadFile(filePath)
if err != nil {
return err
}
content := string(existingContent)
// Check for existing functions and collect new ones
var newEndpoints []EndpointData
for fname, fcfg := range grp.Functions {
// Check for all possible function names that could be generated
functionExists := false
for _, method := range fcfg.Methods {
funcName := generateFunctionName(fname, method)
sig := fmt.Sprintf("func (h *%sHandler) %s", svc.Name, funcName)
if strings.Contains(content, sig) {
fmt.Printf("⚠️ Skip existing: %s (%s)\n", fname, funcName)
functionExists = true
break
}
}
if functionExists {
continue
}
// siapkan data
td := processFunctionData(svc, grp, fname, fcfg, gc)
newEndpoints = append(newEndpoints, td.Endpoints...)
fmt.Printf("✅ Will add: %s\n", fname)
}
if len(newEndpoints) == 0 {
fmt.Printf("⏭️ No new functions to add\n")
return nil
}
// Generate new functions using functions-only template
templateData := TemplateData{
ServiceName: svc.Name,
ServiceLower: strings.ToLower(svc.Name),
ServiceUpper: strings.ToUpper(svc.Name),
Category: svc.Category,
Package: grp.HandlerFolder,
Description: svc.Description,
BaseURL: svc.BaseURL,
Timeout: svc.Timeout,
RetryCount: svc.RetryCount,
Endpoints: newEndpoints,
Timestamp: time.Now().Format("2006-01-02 15:04:05"),
ModuleName: gc.ModuleName,
HasValidator: true,
HasLogger: gc.EnableLogging,
HasSwagger: gc.EnableSwagger,
GlobalConfig: gc,
}
newFunctions, err := generateNewFunctionsOnly(templateData)
if err != nil {
return err
}
// Merge content
mergedContent := mergeGoFileContent(content, newFunctions)
// Write back
return ioutil.WriteFile(filePath, []byte(mergedContent), 0644)
}
// Helper toCamelCase
func toCamelCase(s string) string {
parts := strings.FieldsFunc(s, func(r rune) bool {
return r == '_' || r == '-' || r == ' '
})
for i, p := range parts {
parts[i] = strings.Title(strings.ToLower(p))
}
return strings.Join(parts, "")
}
// Parse struktur direktori dari endpoints YAML
func parseDirectoryStructure(endpoints map[string]interface{}, serviceName string) *DirectoryInfo {
root := &DirectoryInfo{
Path: "",
Children: make(map[string]*DirectoryInfo),
}
for key, value := range endpoints {
parseNestedEndpoints(root, key, value)
}
return root
}
func parseNestedEndpoints(parent *DirectoryInfo, name string, value interface{}) {
switch v := value.(type) {
case map[string]interface{}:
// Check if this contains direct endpoint config
if isDirectEndpoint(v) {
// This is a direct endpoint - create as file
parent.Children[name] = &DirectoryInfo{
Path: name,
IsFile: true,
Functions: []FunctionInfo{parseEndpointToFunction(name, v)},
Children: make(map[string]*DirectoryInfo),
}
} else {
// This is nested structure - create as directory or file
child := &DirectoryInfo{
Path: name,
IsFile: false,
Functions: make([]FunctionInfo, 0),
Children: make(map[string]*DirectoryInfo),
}
// Check if any direct children are endpoints
hasDirectEndpoints := false
for childName, childValue := range v {
if childMap, ok := childValue.(map[string]interface{}); ok && isDirectEndpoint(childMap) {
hasDirectEndpoints = true
child.Functions = append(child.Functions, parseEndpointToFunction(childName, childMap))
}
}
if hasDirectEndpoints {
child.IsFile = true
}
parent.Children[name] = child
// Recursively parse nested children
for childName, childValue := range v {
if childMap, ok := childValue.(map[string]interface{}); ok && !isDirectEndpoint(childMap) {
parseNestedEndpoints(child, childName, childValue)
}
}
}
}
}
func isDirectEndpoint(m map[string]interface{}) bool {
_, hasMethods := m["methods"]
_, hasGetPath := m["get_path"]
_, hasPostPath := m["post_path"]
return hasMethods || hasGetPath || hasPostPath
}
func parseEndpointToFunction(name string, config map[string]interface{}) FunctionInfo {
function := FunctionInfo{
Name: name,
Endpoint: name,
Methods: make([]string, 0),
}
if methods, ok := config["methods"].([]interface{}); ok {
for _, method := range methods {
if methodStr, ok := method.(string); ok {
function.Methods = append(function.Methods, strings.ToUpper(strings.TrimSpace(methodStr)))
}
}
} else if methodStr, ok := config["methods"].(string); ok {
// Handle case where methods is a string like "GET,POST"
methods := strings.Split(methodStr, ",")
for _, method := range methods {
function.Methods = append(function.Methods, strings.ToUpper(strings.TrimSpace(method)))
}
}
return function
}
// Process directory structure dan generate files
func processDirectoryStructure(baseDir string, dirInfo *DirectoryInfo, service Service, globalConfig GlobalConfig, validation *HandlerValidation) error {
for name, child := range dirInfo.Children {
currentPath := filepath.Join(baseDir, child.Path)
if child.IsFile {
// Process as file
err := processHandlerFile(currentPath, name, child, service, globalConfig, validation)
if err != nil {
return fmt.Errorf("failed to process file %s: %w", name, err)
}
} else {
// Create directory dan process children
if err := os.MkdirAll(currentPath, 0755); err != nil {
return fmt.Errorf("failed to create directory %s: %w", currentPath, err)
}
err := processDirectoryStructure(currentPath, child, service, globalConfig, validation)
if err != nil {
return err
}
}
}
return nil
}
func processFunctionData(svc Service, grp EndpointGroup, fname string, fcfg FunctionConfig, gc GlobalConfig) TemplateData {
ed := EndpointData{
Name: toCamelCase(fname),
NameLower: strings.ToLower(fname),
NameUpper: strings.ToUpper(fname),
NameCamel: toCamelCase(fname),
Methods: fcfg.Methods,
GetPath: fcfg.Path,
PostPath: fcfg.Path,
PutPath: fcfg.Path,
DeletePath: fcfg.Path,
Model: fcfg.Model,
ResponseModel: fcfg.ResponseModel,
RequestModel: fcfg.RequestModel,
DataModel: strings.Replace(fcfg.ResponseModel, "Response", "Data", 1),
Description: fcfg.Description,
Summary: fcfg.Summary,
Tags: fcfg.Tags,
RequireAuth: fcfg.RequireAuth,
CacheEnabled: fcfg.CacheEnabled,
CacheTTL: fcfg.CacheTTL,
PathParams: extractPathParams(fcfg.Path),
ModelPackage: grp.HandlerFolder,
}
// set flags
for _, m := range fcfg.Methods {
switch strings.ToUpper(m) {
case "GET":
ed.HasGet = true
case "POST":
ed.HasPost = true
case "PUT":
ed.HasPut = true
case "DELETE":
ed.HasDelete = true
}
}
return TemplateData{
ServiceName: svc.Name,
ServiceLower: strings.ToLower(svc.Name),
ServiceUpper: strings.ToUpper(svc.Name),
Category: svc.Category,
Package: grp.HandlerFolder,
Description: svc.Description,
BaseURL: svc.BaseURL,
Timeout: svc.Timeout,
RetryCount: svc.RetryCount,
Endpoints: []EndpointData{ed},
Timestamp: time.Now().Format("2006-01-02 15:04:05"),
ModuleName: gc.ModuleName,
HasValidator: true,
HasLogger: gc.EnableLogging,
HasSwagger: gc.EnableSwagger,
GlobalConfig: gc,
}
}
// extractPathParams (jika belum ada)
func extractPathParams(path string) []string {
var ps []string
for _, part := range strings.Split(path, "/") {
if strings.HasPrefix(part, ":") {
ps = append(ps, strings.TrimPrefix(part, ":"))
}
}
return ps
}
// Process individual handler file
func processHandlerFile(basePath, fileName string, dirInfo *DirectoryInfo, service Service, globalConfig GlobalConfig, validation *HandlerValidation) error {
filePath := filepath.Join(filepath.Dir(basePath), fmt.Sprintf("%s.go", fileName))
fmt.Printf("📄 Processing file: %s\n", filePath)
// Check if file exists
fileExists := false
if _, err := os.Stat(filePath); err == nil {
fileExists = true
fmt.Printf(" 📋 File exists, checking functions...\n")
}
var existingFunctions map[string]bool
if fileExists {
// Parse existing functions
functions, err := extractExistingFunctions(filePath)
if err != nil {
fmt.Printf(" ⚠️ Warning: Could not parse existing file: %v\n", err)
existingFunctions = make(map[string]bool)
} else {
existingFunctions = functions
fmt.Printf(" ✓ Found %d existing functions\n", len(functions))
}
} else {
existingFunctions = make(map[string]bool)
}
// Determine which functions to generate
functionsToGenerate := make([]FunctionInfo, 0)
for _, fnInfo := range dirInfo.Functions {
for _, method := range fnInfo.Methods {
functionName := generateFunctionName(fnInfo.Name, method)
if !existingFunctions[functionName] {
functionsToGenerate = append(functionsToGenerate, FunctionInfo{
Name: fnInfo.Name,
Methods: []string{method},
Endpoint: fnInfo.Endpoint,
})
validation.NewFunctions = append(validation.NewFunctions, functionName)
fmt.Printf(" ✅ Will generate: %s\n", functionName)
} else {
fmt.Printf(" ⏭️ Already exists: %s\n", functionName)
}
}
}
// Generate file if needed
if len(functionsToGenerate) > 0 {
templateData := prepareTemplateData(fileName, service, globalConfig, functionsToGenerate)
if fileExists {
// Merge with existing file
err := mergeWithExistingFile(filePath, templateData)
if err != nil {
return fmt.Errorf("failed to merge file %s: %w", filePath, err)
}
validation.UpdatedFiles = append(validation.UpdatedFiles, filePath)
fmt.Printf(" 📝 Updated existing file\n")
} else {
// Create new file
err := createNewHandlerFile(filePath, templateData)
if err != nil {
return fmt.Errorf("failed to create file %s: %w", filePath, err)
}
validation.CreatedFiles = append(validation.CreatedFiles, filePath)
fmt.Printf(" 📁 Created new file\n")
}
} else if !fileExists {
fmt.Printf(" ⏭️ No functions to generate and file doesn't exist\n")
} else {
fmt.Printf(" ⏭️ All functions already exist\n")
}
return nil
}
// Extract existing functions from Go file
func extractExistingFunctions(filePath string) (map[string]bool, error) {
fileSet := token.NewFileSet()
node, err := parser.ParseFile(fileSet, filePath, nil, parser.ParseComments)
if err != nil {
return nil, err
}
functions := make(map[string]bool)
ast.Inspect(node, func(n ast.Node) bool {
if fn, ok := n.(*ast.FuncDecl); ok {
if fn.Name != nil {
functions[fn.Name.Name] = true
}
}
return true
})
return functions, nil
}
// Generate function name berdasarkan endpoint dan method
func generateFunctionName(endpointName, method string) string {
switch strings.ToUpper(method) {
case "GET":
return fmt.Sprintf("Get%s", strings.Title(endpointName))
case "POST":
return fmt.Sprintf("Create%s", strings.Title(endpointName))
case "PUT":
return fmt.Sprintf("Update%s", strings.Title(endpointName))
case "DELETE":
return fmt.Sprintf("Delete%s", strings.Title(endpointName))
case "PATCH":
return fmt.Sprintf("Patch%s", strings.Title(endpointName))
default:
return fmt.Sprintf("%s%s", strings.Title(method), strings.Title(endpointName))
}
}
// Prepare template data
func prepareTemplateData(packageName string, service Service, globalConfig GlobalConfig, functions []FunctionInfo) TemplateData {
endpoints := make([]EndpointData, 0)
for _, fnInfo := range functions {
endpoint := EndpointData{
Name: strings.Title(fnInfo.Name),
NameLower: strings.ToLower(fnInfo.Name),
NameUpper: strings.ToUpper(fnInfo.Name),
NameCamel: toCamelCase(fnInfo.Name),
ModelPackage: packageName,
Model: fmt.Sprintf("%sRequest", strings.Title(fnInfo.Name)),
ResponseModel: fmt.Sprintf("%sResponse", strings.Title(fnInfo.Name)),
RequestModel: fmt.Sprintf("%sRequest", strings.Title(fnInfo.Name)),
DataModel: fmt.Sprintf("%sData", strings.Title(fnInfo.Name)),
Description: fmt.Sprintf("Handle %s operations", fnInfo.Name),
Tags: []string{strings.Title(packageName)},
}
// Set paths dan methods
for _, method := range fnInfo.Methods {
switch strings.ToUpper(method) {
case "GET":
endpoint.HasGet = true
endpoint.GetPath = fmt.Sprintf("/%s/%s", packageName, fnInfo.Name)
case "POST":
endpoint.HasPost = true
endpoint.PostPath = fmt.Sprintf("/%s", packageName)
case "PUT":
endpoint.HasPut = true
endpoint.PutPath = fmt.Sprintf("/%s/%s", packageName, fnInfo.Name)
case "DELETE":
endpoint.HasDelete = true
endpoint.DeletePath = fmt.Sprintf("/%s/%s", packageName, fnInfo.Name)
}
}
endpoints = append(endpoints, endpoint)
}
return TemplateData{
ServiceName: service.Name,
ServiceLower: strings.ToLower(service.Name),
ServiceUpper: strings.ToUpper(service.Name),
Category: service.Category,
Package: packageName,
Description: service.Description,
BaseURL: service.BaseURL,
Timeout: getOrDefault(service.Timeout, 30),
RetryCount: getOrDefault(service.RetryCount, 3),
Endpoints: endpoints,
Timestamp: time.Now().Format("2006-01-02 15:04:05"),
ModuleName: globalConfig.ModuleName,
HasValidator: true,
HasLogger: globalConfig.EnableLogging,
HasSwagger: globalConfig.EnableSwagger,
GlobalConfig: globalConfig,
}
}
// Template untuk handler file lengkap (untuk file baru)
const handlerTemplate = `// Package {{.Package}} handles {{.ServiceName}} BPJS services
// Generated on: {{.Timestamp}}
package handlers
import (
"context"
"encoding/json"
"net/http"
"strings"
"time"
"{{.ModuleName}}/internal/config"
"{{.ModuleName}}/internal/models"
"{{.ModuleName}}/internal/models/vclaim/{{.Package}}"
"{{.ModuleName}}/internal/services/bpjs"
"{{.ModuleName}}/pkg/logger"
"github.com/gin-gonic/gin"
"github.com/go-playground/validator/v10"
"github.com/google/uuid"
)
// {{.ServiceName}}Handler handles {{.ServiceName}} BPJS services
type {{.ServiceName}}Handler struct {
service services.VClaimService
validator *validator.Validate
logger logger.Logger
config config.BpjsConfig
}
// {{.ServiceName}}HandlerConfig contains configuration for {{.ServiceName}}Handler
type {{.ServiceName}}HandlerConfig struct {
BpjsConfig config.BpjsConfig
Logger logger.Logger
Validator *validator.Validate
}
// New{{.ServiceName}}Handler creates a new {{.ServiceName}}Handler
func New{{.ServiceName}}Handler(cfg {{.ServiceName}}HandlerConfig) *{{.ServiceName}}Handler {
return &{{.ServiceName}}Handler{
service: services.NewService(cfg.BpjsConfig),
validator: cfg.Validator,
logger: cfg.Logger,
config: cfg.BpjsConfig,
}
}
{{range .Endpoints}}
{{if .HasGet}}
// Get{{.Name}} godoc
// @Summary Get {{.Name}} data
// @Description {{.Description}}
// @Tags {{index .Tags 0}}
// @Accept json
// @Produce json {{if .RequireAuth}}
// @Security ApiKeyAuth {{end}}
// @Param X-Request-ID header string false "Request ID for tracking" {{range .PathParams}}
// @Param {{.}} path string true "{{.}}" example("example_value") {{end}}
// @Success 200 {object} {{.ModelPackage}}.{{.ResponseModel}} "Successfully retrieved {{.Name}} 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 - {{.Name}} not found"
// @Failure 500 {object} models.ErrorResponseBpjs "Internal server error"
// @Router {{.GetPath}} [get]
func (h *{{$.ServiceName}}Handler) Get{{.Name}}(c *gin.Context) {
ctx, cancel := context.WithTimeout(c.Request.Context(), {{$.Timeout}}*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)
}
{{if $.HasLogger}}
h.logger.Info("Processing Get{{.Name}} request", map[string]interface{}{
"request_id": requestID,
"endpoint": "{{.GetPath}}",
{{range .PathParams}}
"{{.}}": c.Param("{{.}}"),
{{end}}
})
{{end}}
// Extract path parameters
{{range .PathParams}}
{{.}} := c.Param("{{.}}")
if {{.}} == "" {
{{if $.HasLogger}}
h.logger.Error("Missing required parameter {{.}}", map[string]interface{}{
"request_id": requestID,
})
{{end}}
c.JSON(http.StatusBadRequest, models.ErrorResponseBpjs{
Status: "error",
Message: "Missing required parameter {{.}}",
RequestID: requestID,
})
return
}
{{end}}
// Call service method
var response {{.ModelPackage}}.{{.ResponseModel}}
{{if .PathParams}}
endpoint := "{{.GetPath}}"
{{range .PathParams}}
endpoint = strings.Replace(endpoint, ":{{.}}", {{.}}, 1)
{{end}}
resp, err := h.service.GetRawResponse(ctx, endpoint)
{{else}}
resp, err := h.service.GetRawResponse(ctx, "{{.GetPath}}")
{{end}}
if err != nil {
{{if $.HasLogger}}
h.logger.Error("Failed to get {{.Name}}", map[string]interface{}{
"error": err.Error(),
"request_id": requestID,
})
{{end}}
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 = &{{.ModelPackage}}.{{.DataModel}}{}
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 {
{{if $.HasLogger}}
h.logger.Error("Failed to decrypt response", map[string]interface{}{
"error": err.Error(),
"request_id": requestID,
})
{{end}}
} else {
json.Unmarshal([]byte(decryptedResp), response.Data)
}
} else if respMap, ok := resp.Response.(map[string]interface{}); ok {
// Response is already unmarshaled JSON
if dataMap, exists := respMap["{{.ModelPackage}}"]; exists {
dataBytes, _ := json.Marshal(dataMap)
json.Unmarshal(dataBytes, 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)
}
{{end}}
{{if .HasPost}}
// Create{{.Name}} godoc
// @Summary Create new {{.Name}}
// @Description Create new {{.Name}} in BPJS system
// @Tags {{index .Tags 0}}
// @Accept json
// @Produce json {{if .RequireAuth}}
// @Security ApiKeyAuth {{end}}
// @Param X-Request-ID header string false "Request ID for tracking"
// @Param request body {{.ModelPackage}}.{{.RequestModel}} true "{{.Name}} data"
// @Success 201 {object} {{.ModelPackage}}.{{.ResponseModel}} "Successfully created {{.Name}}"
// @Failure 400 {object} models.ErrorResponseBpjs "Bad request"
// @Failure 401 {object} models.ErrorResponseBpjs "Unauthorized"
// @Failure 409 {object} models.ErrorResponseBpjs "Conflict"
// @Failure 500 {object} models.ErrorResponseBpjs "Internal server error"
// @Router {{.PostPath}} [post]
func (h *{{$.ServiceName}}Handler) Create{{.Name}}(c *gin.Context) {
ctx, cancel := context.WithTimeout(c.Request.Context(), {{$.Timeout}}*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)
}
{{if $.HasLogger}}
h.logger.Info("Processing Create{{.Name}} request", map[string]interface{}{
"request_id": requestID,
"endpoint": "{{.PostPath}}",
})
{{end}}
// Bind and validate request body
var req {{.ModelPackage}}.{{.RequestModel}}
if err := c.ShouldBindJSON(&req); err != nil {
{{if $.HasLogger}}
h.logger.Error("Failed to bind request body", map[string]interface{}{
"error": err.Error(),
"request_id": requestID,
})
{{end}}
c.JSON(http.StatusBadRequest, models.ErrorResponseBpjs{
Status: "error",
Message: "Invalid request body: " + err.Error(),
RequestID: requestID,
})
return
}
// Validate request structure
if err := h.validator.Struct(&req); err != nil {
{{if $.HasLogger}}
h.logger.Error("Request validation failed", map[string]interface{}{
"error": err.Error(),
"request_id": requestID,
})
{{end}}
c.JSON(http.StatusBadRequest, models.ErrorResponseBpjs{
Status: "error",
Message: "Validation failed: " + err.Error(),
RequestID: requestID,
})
return
}
{{if .PathParams}}
// Extract path parameters
{{range .PathParams}}
{{.}} := c.Param("{{.}}")
if {{.}} == "" {
{{if $.HasLogger}}
h.logger.Error("Missing required parameter {{.}}", map[string]interface{}{
"request_id": requestID,
})
{{end}}
c.JSON(http.StatusBadRequest, models.ErrorResponseBpjs{
Status: "error",
Message: "Missing required parameter {{.}}",
RequestID: requestID,
})
return
}
{{end}}
endpoint := "{{.PostPath}}"
{{range .PathParams}}
endpoint = strings.Replace(endpoint, ":{{.}}", {{.}}, 1)
{{end}}
{{end}}
// Call service method
var response {{.ModelPackage}}.{{.ResponseModel}}
{{if .PathParams}}
resp, err := h.service.PostRawResponse(ctx, endpoint, req)
{{else}}
resp, err := h.service.PostRawResponse(ctx, "{{.PostPath}}", req)
{{end}}
if err != nil {
{{if $.HasLogger}}
h.logger.Error("Failed to create {{.Name}}", map[string]interface{}{
"error": err.Error(),
"request_id": requestID,
})
{{end}}
// Handle specific BPJS errors
if strings.Contains(err.Error(), "409") || strings.Contains(err.Error(), "conflict") {
c.JSON(http.StatusConflict, models.ErrorResponseBpjs{
Status: "error",
Message: "{{.Name}} already exists or conflict occurred",
RequestID: requestID,
})
return
}
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 = &{{.ModelPackage}}.{{.DataModel}}{}
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 {
{{if $.HasLogger}}
h.logger.Error("Failed to decrypt response", map[string]interface{}{
"error": err.Error(),
"request_id": requestID,
})
{{end}}
} else {
json.Unmarshal([]byte(decryptedResp), response.Data)
}
} else if respMap, ok := resp.Response.(map[string]interface{}); ok {
// Response is already unmarshaled JSON
if dataMap, exists := respMap["{{.ModelPackage}}"]; exists {
dataBytes, _ := json.Marshal(dataMap)
json.Unmarshal(dataBytes, 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
{{if $.HasLogger}}
h.logger.Info("Successfully created {{.Name}}", map[string]interface{}{
"request_id": requestID,
})
{{end}}
c.JSON(http.StatusCreated, response)
}
{{end}}
{{if .HasPut}}
// Update{{.Name}} godoc
// @Summary Update existing {{.Name}}
// @Description Update existing {{.Name}} in BPJS system
// @Tags {{index .Tags 0}}
// @Accept json
// @Produce json {{if .RequireAuth}}
// @Security ApiKeyAuth {{end}}
// @Param X-Request-ID header string false "Request ID for tracking" {{range .PathParams}}
// @Param {{.}} path string true "{{.}}" example("example_value") {{end}}
// @Param request body {{.ModelPackage}}.{{.RequestModel}} true "{{.Name}} update data"
// @Success 200 {object} {{.ModelPackage}}.{{.ResponseModel}} "Successfully updated {{.Name}}"
// @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 - {{.Name}} not found"
// @Failure 409 {object} models.ErrorResponseBpjs "Conflict - update conflict occurred"
// @Failure 500 {object} models.ErrorResponseBpjs "Internal server error"
// @Router {{.PutPath}} [put]
func (h *{{$.ServiceName}}Handler) Update{{.Name}}(c *gin.Context) {
ctx, cancel := context.WithTimeout(c.Request.Context(), {{$.Timeout}}*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)
}
{{if $.HasLogger}}
h.logger.Info("Processing Update{{.Name}} request", map[string]interface{}{
"request_id": requestID,
"endpoint": "{{.PutPath}}",
{{range .PathParams}}
"{{.}}": c.Param("{{.}}"),
{{end}}
})
{{end}}
// Extract path parameters
{{range .PathParams}}
{{.}} := c.Param("{{.}}")
if {{.}} == "" {
{{if $.HasLogger}}
h.logger.Error("Missing required parameter {{.}}", map[string]interface{}{
"request_id": requestID,
})
{{end}}
c.JSON(http.StatusBadRequest, models.ErrorResponseBpjs{
Status: "error",
Message: "Missing required parameter {{.}}",
RequestID: requestID,
})
return
}
{{end}}
// Bind and validate request body
var req {{.ModelPackage}}.{{.RequestModel}}
if err := c.ShouldBindJSON(&req); err != nil {
{{if $.HasLogger}}
h.logger.Error("Failed to bind request body", map[string]interface{}{
"error": err.Error(),
"request_id": requestID,
})
{{end}}
c.JSON(http.StatusBadRequest, models.ErrorResponseBpjs{
Status: "error",
Message: "Invalid request body: " + err.Error(),
RequestID: requestID,
})
return
}
// Validate request structure
if err := h.validator.Struct(&req); err != nil {
{{if $.HasLogger}}
h.logger.Error("Request validation failed", map[string]interface{}{
"error": err.Error(),
"request_id": requestID,
})
{{end}}
c.JSON(http.StatusBadRequest, models.ErrorResponseBpjs{
Status: "error",
Message: "Validation failed: " + err.Error(),
RequestID: requestID,
})
return
}
// Call service method
var response {{.ModelPackage}}.{{.ResponseModel}}
{{if .PathParams}}
endpoint := "{{.PutPath}}"
{{range .PathParams}}
endpoint = strings.Replace(endpoint, ":{{.}}", {{.}}, 1)
{{end}}
resp, err := h.service.PutRawResponse(ctx, endpoint, req)
{{else}}
resp, err := h.service.PutRawResponse(ctx, "{{.PutPath}}", req)
{{end}}
if err != nil {
{{if $.HasLogger}}
h.logger.Error("Failed to update {{.Name}}", map[string]interface{}{
"error": err.Error(),
"request_id": requestID,
})
{{end}}
// Handle specific BPJS errors
if strings.Contains(err.Error(), "404") || strings.Contains(err.Error(), "not found") {
c.JSON(http.StatusNotFound, models.ErrorResponseBpjs{
Status: "error",
Message: "{{.Name}} not found",
RequestID: requestID,
})
return
}
if strings.Contains(err.Error(), "409") || strings.Contains(err.Error(), "conflict") {
c.JSON(http.StatusConflict, models.ErrorResponseBpjs{
Status: "error",
Message: "Update conflict occurred",
RequestID: requestID,
})
return
}
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 = &{{.ModelPackage}}.{{.DataModel}}{}
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 {
{{if $.HasLogger}}
h.logger.Error("Failed to decrypt response", map[string]interface{}{
"error": err.Error(),
"request_id": requestID,
})
{{end}}
} else {
json.Unmarshal([]byte(decryptedResp), response.Data)
}
} else if respMap, ok := resp.Response.(map[string]interface{}); ok {
// Response is already unmarshaled JSON
if dataMap, exists := respMap["{{.ModelPackage}}"]; exists {
dataBytes, _ := json.Marshal(dataMap)
json.Unmarshal(dataBytes, 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
{{if $.HasLogger}}
h.logger.Info("Successfully updated {{.Name}}", map[string]interface{}{
"request_id": requestID,
})
{{end}}
c.JSON(http.StatusOK, response)
}
{{end}}
{{if .HasDelete}}
// Delete{{.Name}} godoc
// @Summary Delete existing {{.Name}}
// @Description Delete existing {{.Name}} from BPJS system
// @Tags {{index .Tags 0}}
// @Accept json
// @Produce json {{if .RequireAuth}}
// @Security ApiKeyAuth {{end}}
// @Param X-Request-ID header string false "Request ID for tracking" {{range .PathParams}}
// @Param {{.}} path string true "{{.}}" example("example_value") {{end}}
// @Success 200 {object} {{.ModelPackage}}.{{.ResponseModel}} "Successfully deleted {{.Name}}"
// @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 - {{.Name}} not found"
// @Failure 500 {object} models.ErrorResponseBpjs "Internal server error"
// @Router {{.DeletePath}} [delete]
func (h *{{$.ServiceName}}Handler) Delete{{.Name}}(c *gin.Context) {
ctx, cancel := context.WithTimeout(c.Request.Context(), {{$.Timeout}}*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)
}
{{if $.HasLogger}}
h.logger.Info("Processing Delete{{.Name}} request", map[string]interface{}{
"request_id": requestID,
"endpoint": "{{.DeletePath}}",
{{range .PathParams}}
"{{.}}": c.Param("{{.}}"),
{{end}}
})
{{end}}
// Extract path parameters
{{range .PathParams}}
{{.}} := c.Param("{{.}}")
if {{.}} == "" {
{{if $.HasLogger}}
h.logger.Error("Missing required parameter {{.}}", map[string]interface{}{
"request_id": requestID,
})
{{end}}
c.JSON(http.StatusBadRequest, models.ErrorResponseBpjs{
Status: "error",
Message: "Missing required parameter {{.}}",
RequestID: requestID,
})
return
}
{{end}}
// Call service method
var response {{.ModelPackage}}.{{.ResponseModel}}
{{if .PathParams}}
endpoint := "{{.DeletePath}}"
{{range .PathParams}}
endpoint = strings.Replace(endpoint, ":{{.}}", {{.}}, 1)
{{end}}
resp, err := h.service.DeleteRawResponse(ctx, endpoint)
{{else}}
resp, err := h.service.DeleteRawResponse(ctx, "{{.DeletePath}}")
{{end}}
if err != nil {
{{if $.HasLogger}}
h.logger.Error("Failed to delete {{.Name}}", map[string]interface{}{
"error": err.Error(),
"request_id": requestID,
})
{{end}}
// Handle specific BPJS errors
if strings.Contains(err.Error(), "404") || strings.Contains(err.Error(), "not found") {
c.JSON(http.StatusNotFound, models.ErrorResponseBpjs{
Status: "error",
Message: "{{.Name}} not found",
RequestID: requestID,
})
return
}
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 = &{{.ModelPackage}}.{{.DataModel}}{}
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 {
{{if $.HasLogger}}
h.logger.Error("Failed to decrypt response", map[string]interface{}{
"error": err.Error(),
"request_id": requestID,
})
{{end}}
} else {
json.Unmarshal([]byte(decryptedResp), response.Data)
}
} else if respMap, ok := resp.Response.(map[string]interface{}); ok {
// Response is already unmarshaled JSON
if dataMap, exists := respMap["{{.ModelPackage}}"]; exists {
dataBytes, _ := json.Marshal(dataMap)
json.Unmarshal(dataBytes, response.Data)
} else {
// Try to unmarshal the whole response
respBytes, _ := json.Marshal(resp.Response)
json.Unmarshal(respBytes, response.Data)
}
}
} else {
// For delete operations, sometimes there's no data in response
response.Data = nil
}
// Ensure response has proper fields
response.Status = "success"
response.RequestID = requestID
{{if $.HasLogger}}
h.logger.Info("Successfully deleted {{.Name}}", map[string]interface{}{
"request_id": requestID,
})
{{end}}
c.JSON(http.StatusOK, response)
}
{{end}}
{{end}}`
// Template untuk menambah function saja (untuk file yang sudah ada)
const functionsOnlyTemplate = `{{range .Endpoints}}
{{if .HasGet}}
// Get{{.Name}} godoc
// @Summary Get {{.Name}} data
// @Description {{.Description}}
// @Tags {{index .Tags 0}}
// @Accept json
// @Produce json {{if .RequireAuth}}
// @Security ApiKeyAuth {{end}}
// @Param X-Request-ID header string false "Request ID for tracking" {{range .PathParams}}
// @Param {{.}} path string true "{{.}}" example("example_value") {{end}}
// @Success 200 {object} {{.ModelPackage}}.{{.ResponseModel}} "Successfully retrieved {{.Name}} 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 - {{.Name}} not found"
// @Failure 500 {object} models.ErrorResponseBpjs "Internal server error"
// @Router {{.GetPath}} [get]
func (h *{{$.ServiceName}}Handler) Get{{.Name}}(c *gin.Context) {
ctx, cancel := context.WithTimeout(c.Request.Context(), {{$.Timeout}}*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)
}
{{if $.HasLogger}}
h.logger.Info("Processing Get{{.Name}} request", map[string]interface{}{
"request_id": requestID,
"endpoint": "{{.GetPath}}",
{{range .PathParams}}
"{{.}}": c.Param("{{.}}"),
{{end}}
})
{{end}}
// Extract path parameters
{{range .PathParams}}
{{.}} := c.Param("{{.}}")
if {{.}} == "" {
{{if $.HasLogger}}
h.logger.Error("Missing required parameter {{.}}", map[string]interface{}{
"request_id": requestID,
})
{{end}}
c.JSON(http.StatusBadRequest, models.ErrorResponseBpjs{
Status: "error",
Message: "Missing required parameter {{.}}",
RequestID: requestID,
})
return
}
{{end}}
// Call service method
var response {{.ModelPackage}}.{{.ResponseModel}}
{{if .PathParams}}
endpoint := "{{.GetPath}}"
{{range .PathParams}}
endpoint = strings.Replace(endpoint, ":{{.}}", {{.}}, 1)
{{end}}
resp, err := h.service.GetRawResponse(ctx, endpoint)
{{else}}
resp, err := h.service.GetRawResponse(ctx, "{{.GetPath}}")
{{end}}
if err != nil {
{{if $.HasLogger}}
h.logger.Error("Failed to get {{.Name}}", map[string]interface{}{
"error": err.Error(),
"request_id": requestID,
})
{{end}}
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 = &{{.ModelPackage}}.{{.DataModel}}{}
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 {
{{if $.HasLogger}}
h.logger.Error("Failed to decrypt response", map[string]interface{}{
"error": err.Error(),
"request_id": requestID,
})
{{end}}
} else {
json.Unmarshal([]byte(decryptedResp), response.Data)
}
} else if respMap, ok := resp.Response.(map[string]interface{}); ok {
// Response is already unmarshaled JSON
if dataMap, exists := respMap["{{.ModelPackage}}"]; exists {
dataBytes, _ := json.Marshal(dataMap)
json.Unmarshal(dataBytes, 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)
}
{{end}}
{{if .HasPost}}
// Create{{.Name}} godoc
// @Summary Create new {{.Name}}
// @Description Create new {{.Name}} in BPJS system
// @Tags {{index .Tags 0}}
// @Accept json
// @Produce json {{if .RequireAuth}}
// @Security ApiKeyAuth {{end}}
// @Param X-Request-ID header string false "Request ID for tracking"
// @Param request body {{.ModelPackage}}.{{.RequestModel}} true "{{.Name}} data"
// @Success 201 {object} {{.ModelPackage}}.{{.ResponseModel}} "Successfully created {{.Name}}"
// @Failure 400 {object} models.ErrorResponseBpjs "Bad request"
// @Failure 401 {object} models.ErrorResponseBpjs "Unauthorized"
// @Failure 409 {object} models.ErrorResponseBpjs "Conflict"
// @Failure 500 {object} models.ErrorResponseBpjs "Internal server error"
// @Router {{.PostPath}} [post]
func (h *{{$.ServiceName}}Handler) Create{{.Name}}(c *gin.Context) {
ctx, cancel := context.WithTimeout(c.Request.Context(), {{$.Timeout}}*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)
}
{{if $.HasLogger}}
h.logger.Info("Processing Create{{.Name}} request", map[string]interface{}{
"request_id": requestID,
"endpoint": "{{.PostPath}}",
})
{{end}}
// Bind and validate request body
var req {{.ModelPackage}}.{{.RequestModel}}
if err := c.ShouldBindJSON(&req); err != nil {
{{if $.HasLogger}}
h.logger.Error("Failed to bind request body", map[string]interface{}{
"error": err.Error(),
"request_id": requestID,
})
{{end}}
c.JSON(http.StatusBadRequest, models.ErrorResponseBpjs{
Status: "error",
Message: "Invalid request body: " + err.Error(),
RequestID: requestID,
})
return
}
// Validate request structure
if err := h.validator.Struct(&req); err != nil {
{{if $.HasLogger}}
h.logger.Error("Request validation failed", map[string]interface{}{
"error": err.Error(),
"request_id": requestID,
})
{{end}}
c.JSON(http.StatusBadRequest, models.ErrorResponseBpjs{
Status: "error",
Message: "Validation failed: " + err.Error(),
RequestID: requestID,
})
return
}
{{if .PathParams}}
// Extract path parameters
{{range .PathParams}}
{{.}} := c.Param("{{.}}")
if {{.}} == "" {
{{if $.HasLogger}}
h.logger.Error("Missing required parameter {{.}}", map[string]interface{}{
"request_id": requestID,
})
{{end}}
c.JSON(http.StatusBadRequest, models.ErrorResponseBpjs{
Status: "error",
Message: "Missing required parameter {{.}}",
RequestID: requestID,
})
return
}
{{end}}
endpoint := "{{.PostPath}}"
{{range .PathParams}}
endpoint = strings.Replace(endpoint, ":{{.}}", {{.}}, 1)
{{end}}
{{end}}
// Call service method
var response {{.ModelPackage}}.{{.ResponseModel}}
{{if .PathParams}}
resp, err := h.service.PostRawResponse(ctx, endpoint, req)
{{else}}
resp, err := h.service.PostRawResponse(ctx, "{{.PostPath}}", req)
{{end}}
if err != nil {
{{if $.HasLogger}}
h.logger.Error("Failed to create {{.Name}}", map[string]interface{}{
"error": err.Error(),
"request_id": requestID,
})
{{end}}
// Handle specific BPJS errors
if strings.Contains(err.Error(), "409") || strings.Contains(err.Error(), "conflict") {
c.JSON(http.StatusConflict, models.ErrorResponseBpjs{
Status: "error",
Message: "{{.Name}} already exists or conflict occurred",
RequestID: requestID,
})
return
}
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 = &{{.ModelPackage}}.{{.DataModel}}{}
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 {
{{if $.HasLogger}}
h.logger.Error("Failed to decrypt response", map[string]interface{}{
"error": err.Error(),
"request_id": requestID,
})
{{end}}
} else {
json.Unmarshal([]byte(decryptedResp), response.Data)
}
} else if respMap, ok := resp.Response.(map[string]interface{}); ok {
// Response is already unmarshaled JSON
if dataMap, exists := respMap["{{.ModelPackage}}"]; exists {
dataBytes, _ := json.Marshal(dataMap)
json.Unmarshal(dataBytes, 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
{{if $.HasLogger}}
h.logger.Info("Successfully created {{.Name}}", map[string]interface{}{
"request_id": requestID,
})
{{end}}
c.JSON(http.StatusCreated, response)
}
{{end}}
{{if .HasPut}}
// Update{{.Name}} godoc
// @Summary Update existing {{.Name}}
// @Description Update existing {{.Name}} in BPJS system
// @Tags {{index .Tags 0}}
// @Accept json
// @Produce json {{if .RequireAuth}}
// @Security ApiKeyAuth {{end}}
// @Param X-Request-ID header string false "Request ID for tracking" {{range .PathParams}}
// @Param {{.}} path string true "{{.}}" example("example_value") {{end}}
// @Param request body {{.ModelPackage}}.{{.RequestModel}} true "{{.Name}} update data"
// @Success 200 {object} {{.ModelPackage}}.{{.ResponseModel}} "Successfully updated {{.Name}}"
// @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 - {{.Name}} not found"
// @Failure 409 {object} models.ErrorResponseBpjs "Conflict - update conflict occurred"
// @Failure 500 {object} models.ErrorResponseBpjs "Internal server error"
// @Router {{.PutPath}} [put]
func (h *{{$.ServiceName}}Handler) Update{{.Name}}(c *gin.Context) {
ctx, cancel := context.WithTimeout(c.Request.Context(), {{$.Timeout}}*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)
}
{{if $.HasLogger}}
h.logger.Info("Processing Update{{.Name}} request", map[string]interface{}{
"request_id": requestID,
"endpoint": "{{.PutPath}}",
{{range .PathParams}}
"{{.}}": c.Param("{{.}}"),
{{end}}
})
{{end}}
// Extract path parameters
{{range .PathParams}}
{{.}} := c.Param("{{.}}")
if {{.}} == "" {
{{if $.HasLogger}}
h.logger.Error("Missing required parameter {{.}}", map[string]interface{}{
"request_id": requestID,
})
{{end}}
c.JSON(http.StatusBadRequest, models.ErrorResponseBpjs{
Status: "error",
Message: "Missing required parameter {{.}}",
RequestID: requestID,
})
return
}
{{end}}
// Bind and validate request body
var req {{.ModelPackage}}.{{.RequestModel}}
if err := c.ShouldBindJSON(&req); err != nil {
{{if $.HasLogger}}
h.logger.Error("Failed to bind request body", map[string]interface{}{
"error": err.Error(),
"request_id": requestID,
})
{{end}}
c.JSON(http.StatusBadRequest, models.ErrorResponseBpjs{
Status: "error",
Message: "Invalid request body: " + err.Error(),
RequestID: requestID,
})
return
}
// Validate request structure
if err := h.validator.Struct(&req); err != nil {
{{if $.HasLogger}}
h.logger.Error("Request validation failed", map[string]interface{}{
"error": err.Error(),
"request_id": requestID,
})
{{end}}
c.JSON(http.StatusBadRequest, models.ErrorResponseBpjs{
Status: "error",
Message: "Validation failed: " + err.Error(),
RequestID: requestID,
})
return
}
// Call service method
var response {{.ModelPackage}}.{{.ResponseModel}}
{{if .PathParams}}
endpoint := "{{.PutPath}}"
{{range .PathParams}}
endpoint = strings.Replace(endpoint, ":{{.}}", {{.}}, 1)
{{end}}
resp, err := h.service.PutRawResponse(ctx, endpoint, req)
{{else}}
resp, err := h.service.PutRawResponse(ctx, "{{.PutPath}}", req)
{{end}}
if err != nil {
{{if $.HasLogger}}
h.logger.Error("Failed to update {{.Name}}", map[string]interface{}{
"error": err.Error(),
"request_id": requestID,
})
{{end}}
// Handle specific BPJS errors
if strings.Contains(err.Error(), "404") || strings.Contains(err.Error(), "not found") {
c.JSON(http.StatusNotFound, models.ErrorResponseBpjs{
Status: "error",
Message: "{{.Name}} not found",
RequestID: requestID,
})
return
}
if strings.Contains(err.Error(), "409") || strings.Contains(err.Error(), "conflict") {
c.JSON(http.StatusConflict, models.ErrorResponseBpjs{
Status: "error",
Message: "Update conflict occurred",
RequestID: requestID,
})
return
}
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 = &{{.ModelPackage}}.{{.DataModel}}{}
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 {
{{if $.HasLogger}}
h.logger.Error("Failed to decrypt response", map[string]interface{}{
"error": err.Error(),
"request_id": requestID,
})
{{end}}
} else {
json.Unmarshal([]byte(decryptedResp), response.Data)
}
} else if respMap, ok := resp.Response.(map[string]interface{}); ok {
// Response is already unmarshaled JSON
if dataMap, exists := respMap["{{.ModelPackage}}"]; exists {
dataBytes, _ := json.Marshal(dataMap)
json.Unmarshal(dataBytes, 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
{{if $.HasLogger}}
h.logger.Info("Successfully updated {{.Name}}", map[string]interface{}{
"request_id": requestID,
})
{{end}}
c.JSON(http.StatusOK, response)
}
{{end}}
{{if .HasDelete}}
// Delete{{.Name}} godoc
// @Summary Delete existing {{.Name}}
// @Description Delete existing {{.Name}} from BPJS system
// @Tags {{index .Tags 0}}
// @Accept json
// @Produce json {{if .RequireAuth}}
// @Security ApiKeyAuth {{end}}
// @Param X-Request-ID header string false "Request ID for tracking" {{range .PathParams}}
// @Param {{.}} path string true "{{.}}" example("example_value") {{end}}
// @Success 200 {object} {{.ModelPackage}}.{{.ResponseModel}} "Successfully deleted {{.Name}}"
// @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 - {{.Name}} not found"
// @Failure 500 {object} models.ErrorResponseBpjs "Internal server error"
// @Router {{.DeletePath}} [delete]
func (h *{{$.ServiceName}}Handler) Delete{{.Name}}(c *gin.Context) {
ctx, cancel := context.WithTimeout(c.Request.Context(), {{$.Timeout}}*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)
}
{{if $.HasLogger}}
h.logger.Info("Processing Delete{{.Name}} request", map[string]interface{}{
"request_id": requestID,
"endpoint": "{{.DeletePath}}",
{{range .PathParams}}
"{{.}}": c.Param("{{.}}"),
{{end}}
})
{{end}}
// Extract path parameters
{{range .PathParams}}
{{.}} := c.Param("{{.}}")
if {{.}} == "" {
{{if $.HasLogger}}
h.logger.Error("Missing required parameter {{.}}", map[string]interface{}{
"request_id": requestID,
})
{{end}}
c.JSON(http.StatusBadRequest, models.ErrorResponseBpjs{
Status: "error",
Message: "Missing required parameter {{.}}",
RequestID: requestID,
})
return
}
{{end}}
// Call service method
var response {{.ModelPackage}}.{{.ResponseModel}}
{{if .PathParams}}
endpoint := "{{.DeletePath}}"
{{range .PathParams}}
endpoint = strings.Replace(endpoint, ":{{.}}", {{.}}, 1)
{{end}}
resp, err := h.service.DeleteRawResponse(ctx, endpoint)
{{else}}
resp, err := h.service.DeleteRawResponse(ctx, "{{.DeletePath}}")
{{end}}
if err != nil {
{{if $.HasLogger}}
h.logger.Error("Failed to delete {{.Name}}", map[string]interface{}{
"error": err.Error(),
"request_id": requestID,
})
{{end}}
// Handle specific BPJS errors
if strings.Contains(err.Error(), "404") || strings.Contains(err.Error(), "not found") {
c.JSON(http.StatusNotFound, models.ErrorResponseBpjs{
Status: "error",
Message: "{{.Name}} not found",
RequestID: requestID,
})
return
}
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 = &{{.ModelPackage}}.{{.DataModel}}{}
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 {
{{if $.HasLogger}}
h.logger.Error("Failed to decrypt response", map[string]interface{}{
"error": err.Error(),
"request_id": requestID,
})
{{end}}
} else {
json.Unmarshal([]byte(decryptedResp), response.Data)
}
} else if respMap, ok := resp.Response.(map[string]interface{}); ok {
// Response is already unmarshaled JSON
if dataMap, exists := respMap["{{.ModelPackage}}"]; exists {
dataBytes, _ := json.Marshal(dataMap)
json.Unmarshal(dataBytes, response.Data)
} else {
// Try to unmarshal the whole response
respBytes, _ := json.Marshal(resp.Response)
json.Unmarshal(respBytes, response.Data)
}
}
} else {
// For delete operations, sometimes there's no data in response
response.Data = nil
}
// Ensure response has proper fields
response.Status = "success"
response.RequestID = requestID
{{if $.HasLogger}}
h.logger.Info("Successfully deleted {{.Name}}", map[string]interface{}{
"request_id": requestID,
})
{{end}}
c.JSON(http.StatusOK, response)
}
{{end}}
{{end}}`
// Create new handler file
func createNewHandlerFile(filePath string, templateData TemplateData) error {
// Create directory
if err := os.MkdirAll(filepath.Dir(filePath), 0755); err != nil {
return err
}
// Parse template
tmpl := template.New("handler").Funcs(template.FuncMap{
"title": strings.Title,
"index": func(slice []string, i int) string {
if i >= 0 && i < len(slice) {
return slice[i]
}
return ""
},
})
tmpl, err := tmpl.Parse(handlerTemplate)
if err != nil {
return err
}
// Create file
file, err := os.Create(filePath)
if err != nil {
return err
}
defer file.Close()
// Execute template
return tmpl.Execute(file, templateData)
}
// Merge dengan existing file
func mergeWithExistingFile(filePath string, templateData TemplateData) error {
// Read existing content
existingContent, err := ioutil.ReadFile(filePath)
if err != nil {
return err
}
// Generate new functions
newFunctions, err := generateNewFunctionsOnly(templateData)
if err != nil {
return err
}
// Merge content
mergedContent := mergeGoFileContent(string(existingContent), newFunctions)
// Write back
return ioutil.WriteFile(filePath, []byte(mergedContent), 0644)
}
func generateNewFunctionsOnly(templateData TemplateData) (string, error) {
funcTemplate := `
{{range .Endpoints}}
{{if .HasGet}}
// Get{{.Name}} godoc
// @Summary Get {{.Name}} data
// @Description {{.Description}}
// @Tags {{index .Tags 0}}
// @Accept json
// @Produce json {{if .RequireAuth}}
// @Security ApiKeyAuth {{end}}
// @Param X-Request-ID header string false "Request ID for tracking" {{range .PathParams}}
// @Param {{.}} path string true "{{.}}" example("example_value") {{end}}
// @Success 200 {object} {{.ModelPackage}}.{{.ResponseModel}} "Successfully retrieved {{.Name}} 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 - {{.Name}} not found"
// @Failure 500 {object} models.ErrorResponseBpjs "Internal server error"
// @Router {{.GetPath}} [get]
func (h *{{$.ServiceName}}Handler) Get{{.Name}}(c *gin.Context) {
ctx, cancel := context.WithTimeout(c.Request.Context(), {{$.Timeout}}*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)
}
{{if $.HasLogger}}
h.logger.Info("Processing Get{{.Name}} request", map[string]interface{}{
"request_id": requestID,
"endpoint": "{{.GetPath}}",
{{range .PathParams}}
"{{.}}": c.Param("{{.}}"),
{{end}}
})
{{end}}
// Extract path parameters
{{range .PathParams}}
{{.}} := c.Param("{{.}}")
if {{.}} == "" {
{{if $.HasLogger}}
h.logger.Error("Missing required parameter {{.}}", map[string]interface{}{
"request_id": requestID,
})
{{end}}
c.JSON(http.StatusBadRequest, models.ErrorResponseBpjs{
Status: "error",
Message: "Missing required parameter {{.}}",
RequestID: requestID,
})
return
}
{{end}}
// Call service method
var response {{.ModelPackage}}.{{.ResponseModel}}
{{if .PathParams}}
endpoint := "{{.GetPath}}"
{{range .PathParams}}
endpoint = strings.Replace(endpoint, ":{{.}}", {{.}}, 1)
{{end}}
resp, err := h.service.GetRawResponse(ctx, endpoint)
{{else}}
resp, err := h.service.GetRawResponse(ctx, "{{.GetPath}}")
{{end}}
if err != nil {
{{if $.HasLogger}}
h.logger.Error("Failed to get {{.Name}}", map[string]interface{}{
"error": err.Error(),
"request_id": requestID,
})
{{end}}
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 = &{{.ModelPackage}}.{{.DataModel}}{}
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 {
{{if $.HasLogger}}
h.logger.Error("Failed to decrypt response", map[string]interface{}{
"error": err.Error(),
"request_id": requestID,
})
{{end}}
} else {
json.Unmarshal([]byte(decryptedResp), response.Data)
}
} else if respMap, ok := resp.Response.(map[string]interface{}); ok {
// Response is already unmarshaled JSON
if dataMap, exists := respMap["{{.ModelPackage}}"]; exists {
dataBytes, _ := json.Marshal(dataMap)
json.Unmarshal(dataBytes, 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)
}
{{end}}
{{if .HasPost}}
// Create{{.Name}} godoc
// @Summary Create new {{.Name}}
// @Description Create new {{.Name}} in BPJS system
// @Tags {{index .Tags 0}}
// @Accept json
// @Produce json {{if .RequireAuth}}
// @Security ApiKeyAuth {{end}}
// @Param X-Request-ID header string false "Request ID for tracking"
// @Param request body {{.ModelPackage}}.{{.RequestModel}} true "{{.Name}} data"
// @Success 201 {object} {{.ModelPackage}}.{{.ResponseModel}} "Successfully created {{.Name}}"
// @Failure 400 {object} models.ErrorResponseBpjs "Bad request"
// @Failure 401 {object} models.ErrorResponseBpjs "Unauthorized"
// @Failure 409 {object} models.ErrorResponseBpjs "Conflict"
// @Failure 500 {object} models.ErrorResponseBpjs "Internal server error"
// @Router {{.PostPath}} [post]
func (h *{{$.ServiceName}}Handler) Create{{.Name}}(c *gin.Context) {
ctx, cancel := context.WithTimeout(c.Request.Context(), {{$.Timeout}}*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)
}
{{if $.HasLogger}}
h.logger.Info("Processing Create{{.Name}} request", map[string]interface{}{
"request_id": requestID,
"endpoint": "{{.PostPath}}",
})
{{end}}
// Bind and validate request body
var req {{.ModelPackage}}.{{.RequestModel}}
if err := c.ShouldBindJSON(&req); err != nil {
{{if $.HasLogger}}
h.logger.Error("Failed to bind request body", map[string]interface{}{
"error": err.Error(),
"request_id": requestID,
})
{{end}}
c.JSON(http.StatusBadRequest, models.ErrorResponseBpjs{
Status: "error",
Message: "Invalid request body: " + err.Error(),
RequestID: requestID,
})
return
}
// Validate request structure
if err := h.validator.Struct(&req); err != nil {
{{if $.HasLogger}}
h.logger.Error("Request validation failed", map[string]interface{}{
"error": err.Error(),
"request_id": requestID,
})
{{end}}
c.JSON(http.StatusBadRequest, models.ErrorResponseBpjs{
Status: "error",
Message: "Validation failed: " + err.Error(),
RequestID: requestID,
})
return
}
{{if .PathParams}}
// Extract path parameters
{{range .PathParams}}
{{.}} := c.Param("{{.}}")
if {{.}} == "" {
{{if $.HasLogger}}
h.logger.Error("Missing required parameter {{.}}", map[string]interface{}{
"request_id": requestID,
})
{{end}}
c.JSON(http.StatusBadRequest, models.ErrorResponseBpjs{
Status: "error",
Message: "Missing required parameter {{.}}",
RequestID: requestID,
})
return
}
{{end}}
endpoint := "{{.PostPath}}"
{{range .PathParams}}
endpoint = strings.Replace(endpoint, ":{{.}}", {{.}}, 1)
{{end}}
{{end}}
// Call service method
var response {{.ModelPackage}}.{{.ResponseModel}}
{{if .PathParams}}
resp, err := h.service.PostRawResponse(ctx, endpoint, req)
{{else}}
resp, err := h.service.PostRawResponse(ctx, "{{.PostPath}}", req)
{{end}}
if err != nil {
{{if $.HasLogger}}
h.logger.Error("Failed to create {{.Name}}", map[string]interface{}{
"error": err.Error(),
"request_id": requestID,
})
{{end}}
// Handle specific BPJS errors
if strings.Contains(err.Error(), "409") || strings.Contains(err.Error(), "conflict") {
c.JSON(http.StatusConflict, models.ErrorResponseBpjs{
Status: "error",
Message: "{{.Name}} already exists or conflict occurred",
RequestID: requestID,
})
return
}
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 = &{{.ModelPackage}}.{{.DataModel}}{}
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 {
{{if $.HasLogger}}
h.logger.Error("Failed to decrypt response", map[string]interface{}{
"error": err.Error(),
"request_id": requestID,
})
{{end}}
} else {
json.Unmarshal([]byte(decryptedResp), response.Data)
}
} else if respMap, ok := resp.Response.(map[string]interface{}); ok {
// Response is already unmarshaled JSON
if dataMap, exists := respMap["{{.ModelPackage}}"]; exists {
dataBytes, _ := json.Marshal(dataMap)
json.Unmarshal(dataBytes, 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
{{if $.HasLogger}}
h.logger.Info("Successfully created {{.Name}}", map[string]interface{}{
"request_id": requestID,
})
{{end}}
c.JSON(http.StatusCreated, response)
}
{{end}}
{{if .HasPut}}
// Update{{.Name}} godoc
// @Summary Update existing {{.Name}}
// @Description Update existing {{.Name}} in BPJS system
// @Tags {{index .Tags 0}}
// @Accept json
// @Produce json {{if .RequireAuth}}
// @Security ApiKeyAuth {{end}}
// @Param X-Request-ID header string false "Request ID for tracking" {{range .PathParams}}
// @Param {{.}} path string true "{{.}}" example("example_value") {{end}}
// @Param request body {{.ModelPackage}}.{{.RequestModel}} true "{{.Name}} update data"
// @Success 200 {object} {{.ModelPackage}}.{{.ResponseModel}} "Successfully updated {{.Name}}"
// @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 - {{.Name}} not found"
// @Failure 409 {object} models.ErrorResponseBpjs "Conflict - update conflict occurred"
// @Failure 500 {object} models.ErrorResponseBpjs "Internal server error"
// @Router {{.PutPath}} [put]
func (h *{{$.ServiceName}}Handler) Update{{.Name}}(c *gin.Context) {
ctx, cancel := context.WithTimeout(c.Request.Context(), {{$.Timeout}}*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)
}
{{if $.HasLogger}}
h.logger.Info("Processing Update{{.Name}} request", map[string]interface{}{
"request_id": requestID,
"endpoint": "{{.PutPath}}",
{{range .PathParams}}
"{{.}}": c.Param("{{.}}"),
{{end}}
})
{{end}}
// Extract path parameters
{{range .PathParams}}
{{.}} := c.Param("{{.}}")
if {{.}} == "" {
{{if $.HasLogger}}
h.logger.Error("Missing required parameter {{.}}", map[string]interface{}{
"request_id": requestID,
})
{{end}}
c.JSON(http.StatusBadRequest, models.ErrorResponseBpjs{
Status: "error",
Message: "Missing required parameter {{.}}",
RequestID: requestID,
})
return
}
{{end}}
// Bind and validate request body
var req {{.ModelPackage}}.{{.RequestModel}}
if err := c.ShouldBindJSON(&req); err != nil {
{{if $.HasLogger}}
h.logger.Error("Failed to bind request body", map[string]interface{}{
"error": err.Error(),
"request_id": requestID,
})
{{end}}
c.JSON(http.StatusBadRequest, models.ErrorResponseBpjs{
Status: "error",
Message: "Invalid request body: " + err.Error(),
RequestID: requestID,
})
return
}
// Validate request structure
if err := h.validator.Struct(&req); err != nil {
{{if $.HasLogger}}
h.logger.Error("Request validation failed", map[string]interface{}{
"error": err.Error(),
"request_id": requestID,
})
{{end}}
c.JSON(http.StatusBadRequest, models.ErrorResponseBpjs{
Status: "error",
Message: "Validation failed: " + err.Error(),
RequestID: requestID,
})
return
}
// Call service method
var response {{.ModelPackage}}.{{.ResponseModel}}
{{if .PathParams}}
endpoint := "{{.PutPath}}"
{{range .PathParams}}
endpoint = strings.Replace(endpoint, ":{{.}}", {{.}}, 1)
{{end}}
resp, err := h.service.PutRawResponse(ctx, endpoint, req)
{{else}}
resp, err := h.service.PutRawResponse(ctx, "{{.PutPath}}", req)
{{end}}
if err != nil {
{{if $.HasLogger}}
h.logger.Error("Failed to update {{.Name}}", map[string]interface{}{
"error": err.Error(),
"request_id": requestID,
})
{{end}}
// Handle specific BPJS errors
if strings.Contains(err.Error(), "404") || strings.Contains(err.Error(), "not found") {
c.JSON(http.StatusNotFound, models.ErrorResponseBpjs{
Status: "error",
Message: "{{.Name}} not found",
RequestID: requestID,
})
return
}
if strings.Contains(err.Error(), "409") || strings.Contains(err.Error(), "conflict") {
c.JSON(http.StatusConflict, models.ErrorResponseBpjs{
Status: "error",
Message: "Update conflict occurred",
RequestID: requestID,
})
return
}
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 = &{{.ModelPackage}}.{{.DataModel}}{}
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 {
{{if $.HasLogger}}
h.logger.Error("Failed to decrypt response", map[string]interface{}{
"error": err.Error(),
"request_id": requestID,
})
{{end}}
} else {
json.Unmarshal([]byte(decryptedResp), response.Data)
}
} else if respMap, ok := resp.Response.(map[string]interface{}); ok {
// Response is already unmarshaled JSON
if dataMap, exists := respMap["{{.ModelPackage}}"]; exists {
dataBytes, _ := json.Marshal(dataMap)
json.Unmarshal(dataBytes, 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
{{if $.HasLogger}}
h.logger.Info("Successfully updated {{.Name}}", map[string]interface{}{
"request_id": requestID,
})
{{end}}
c.JSON(http.StatusOK, response)
}
{{end}}
{{if .HasDelete}}
// Delete{{.Name}} godoc
// @Summary Delete existing {{.Name}}
// @Description Delete existing {{.Name}} from BPJS system
// @Tags {{index .Tags 0}}
// @Accept json
// @Produce json {{if .RequireAuth}}
// @Security ApiKeyAuth {{end}}
// @Param X-Request-ID header string false "Request ID for tracking" {{range .PathParams}}
// @Param {{.}} path string true "{{.}}" example("example_value") {{end}}
// @Success 200 {object} {{.ModelPackage}}.{{.ResponseModel}} "Successfully deleted {{.Name}}"
// @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 - {{.Name}} not found"
// @Failure 500 {object} models.ErrorResponseBpjs "Internal server error"
// @Router {{.DeletePath}} [delete]
func (h *{{$.ServiceName}}Handler) Delete{{.Name}}(c *gin.Context) {
ctx, cancel := context.WithTimeout(c.Request.Context(), {{$.Timeout}}*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)
}
{{if $.HasLogger}}
h.logger.Info("Processing Delete{{.Name}} request", map[string]interface{}{
"request_id": requestID,
"endpoint": "{{.DeletePath}}",
{{range .PathParams}}
"{{.}}": c.Param("{{.}}"),
{{end}}
})
{{end}}
// Extract path parameters
{{range .PathParams}}
{{.}} := c.Param("{{.}}")
if {{.}} == "" {
{{if $.HasLogger}}
h.logger.Error("Missing required parameter {{.}}", map[string]interface{}{
"request_id": requestID,
})
{{end}}
c.JSON(http.StatusBadRequest, models.ErrorResponseBpjs{
Status: "error",
Message: "Missing required parameter {{.}}",
RequestID: requestID,
})
return
}
{{end}}
// Call service method
var response {{.ModelPackage}}.{{.ResponseModel}}
{{if .PathParams}}
endpoint := "{{.DeletePath}}"
{{range .PathParams}}
endpoint = strings.Replace(endpoint, ":{{.}}", {{.}}, 1)
{{end}}
resp, err := h.service.DeleteRawResponse(ctx, endpoint)
{{else}}
resp, err := h.service.DeleteRawResponse(ctx, "{{.DeletePath}}")
{{end}}
if err != nil {
{{if $.HasLogger}}
h.logger.Error("Failed to delete {{.Name}}", map[string]interface{}{
"error": err.Error(),
"request_id": requestID,
})
{{end}}
// Handle specific BPJS errors
if strings.Contains(err.Error(), "404") || strings.Contains(err.Error(), "not found") {
c.JSON(http.StatusNotFound, models.ErrorResponseBpjs{
Status: "error",
Message: "{{.Name}} not found",
RequestID: requestID,
})
return
}
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 = &{{.ModelPackage}}.{{.DataModel}}{}
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 {
{{if $.HasLogger}}
h.logger.Error("Failed to decrypt response", map[string]interface{}{
"error": err.Error(),
"request_id": requestID,
})
{{end}}
} else {
json.Unmarshal([]byte(decryptedResp), response.Data)
}
} else if respMap, ok := resp.Response.(map[string]interface{}); ok {
// Response is already unmarshaled JSON
if dataMap, exists := respMap["{{.ModelPackage}}"]; exists {
dataBytes, _ := json.Marshal(dataMap)
json.Unmarshal(dataBytes, response.Data)
} else {
// Try to unmarshal the whole response
respBytes, _ := json.Marshal(resp.Response)
json.Unmarshal(respBytes, response.Data)
}
}
} else {
// For delete operations, sometimes there's no data in response
response.Data = nil
}
// Ensure response has proper fields
response.Status = "success"
response.RequestID = requestID
{{if $.HasLogger}}
h.logger.Info("Successfully deleted {{.Name}}", map[string]interface{}{
"request_id": requestID,
})
{{end}}
c.JSON(http.StatusOK, response)
}
{{end}}
{{end}}`
tmpl := template.New("functions")
tmpl, err := tmpl.Parse(funcTemplate)
if err != nil {
return "", err
}
var result strings.Builder
err = tmpl.Execute(&result, templateData)
if err != nil {
return "", err
}
// Remove duplicate function definitions by simple regex grouping
// This is a simple approach to avoid duplicate functions in merged content
funcRegex := regexp.MustCompile(`(?s)(func \(h \*\w+Handler\) Get\w+\(c \*gin.Context\) \{.*?\})`)
matches := funcRegex.FindAllString(result.String(), -1)
uniqueFuncs := make(map[string]bool)
var uniqueResult strings.Builder
for _, m := range matches {
if !uniqueFuncs[m] {
uniqueFuncs[m] = true
uniqueResult.WriteString(m)
uniqueResult.WriteString("\n\n")
}
}
// If no matches found, return original result
if uniqueResult.Len() == 0 {
return result.String(), nil
}
return uniqueResult.String(), nil
}
func mergeGoFileContent(existingContent, newFunctions string) string {
// Find last closing brace
re := regexp.MustCompile(`}\s*$`)
lastBraceIndex := re.FindStringIndex(existingContent)
if lastBraceIndex == nil {
return existingContent + "\n" + newFunctions
}
before := existingContent[:lastBraceIndex[0]]
after := existingContent[lastBraceIndex[0]:]
return before + "\n" + newFunctions + "\n" + after
}
// Main function
func main() {
if len(os.Args) < 2 {
printUsage()
os.Exit(1)
}
configFile := os.Args[1]
var targetService string
if len(os.Args) > 2 {
targetService = os.Args[2]
}
config, err := loadConfig(configFile)
if err != nil {
fmt.Printf("Error loading config: %v\n", err)
os.Exit(1)
}
fmt.Println("🚀 Starting BPJS Dynamic Handler Generation with Validation...")
fmt.Printf("📁 Config file: %s\n", configFile)
if targetService != "" {
fmt.Printf("🎯 Target service: %s\n", targetService)
}
generated := 0
errors := 0
for serviceName, service := range config.Services {
if targetService != "" && serviceName != targetService {
continue
}
err := generateHandlerWithValidation(serviceName, service, config.Global)
if err != nil {
fmt.Printf("❌ Error generating handler for %s: %v\n", serviceName, err)
errors++
continue
}
generated++
}
// Summary
fmt.Println("\n📊 Generation Summary:")
fmt.Printf("✅ Successfully processed: %d services\n", generated)
if errors > 0 {
fmt.Printf("❌ Failed: %d services\n", errors)
}
if generated > 0 {
fmt.Println("🎉 Generation completed successfully!")
}
}
// Helper functions
func loadConfig(filename string) (*ServiceConfig, error) {
data, err := ioutil.ReadFile(filename)
if err != nil {
return nil, err
}
var config ServiceConfig
err = yaml.Unmarshal(data, &config)
if err != nil {
return nil, err
}
// Set defaults
if config.Global.ModuleName == "" {
config.Global.ModuleName = "api-service"
}
if config.Global.OutputDir == "" {
config.Global.OutputDir = "internal/handlers"
}
return &config, nil
}
func getOrDefault(value, defaultValue int) int {
if value == 0 {
return defaultValue
}
return value
}
func printUsage() {
fmt.Println("BPJS Dynamic Handler Generator with Function Validation")
fmt.Println()
fmt.Println("Usage:")
fmt.Println(" go run generate-handler.go <config-file> [service-name]")
fmt.Println()
fmt.Println("Examples:")
fmt.Println(" go run generate-handler.go services-config-bpjs.yaml")
fmt.Println(" go run generate-handler.go services-config-bpjs.yaml vclaim")
}
func generateRoutes(serviceName string, service Service, globalConfig GlobalConfig) error {
// Read the main routes.go file
routesFilePath := "internal/routes/v1/routes.go"
routesContent, err := ioutil.ReadFile(routesFilePath)
if err != nil {
return fmt.Errorf("failed to read routes file: %w", err)
}
routesContentStr := string(routesContent)
// Check if routes are already registered
if strings.Contains(routesContentStr, fmt.Sprintf("Register%sRoutes", service.Name)) {
fmt.Printf("⚠️ Routes for %s already registered in main routes file\n", service.Name)
return nil
}
// Prepare template data for all groups
var allRoutes []string
// Loop over each module group in service.Endpoints
for groupName, subEndpoints := range service.Endpoints {
// Prepare template data for this group
templateData := TemplateData{
ServiceName: service.Name,
ServiceLower: strings.ToLower(service.Name),
ServiceUpper: strings.ToUpper(service.Name),
Category: service.Category,
Package: groupName, // package name is group name
Description: service.Description,
BaseURL: service.BaseURL,
Timeout: getOrDefault(service.Timeout, 30),
RetryCount: getOrDefault(service.RetryCount, 3),
Timestamp: time.Now().Format("2006-01-02 15:04:05"),
ModuleName: globalConfig.ModuleName,
HasValidator: true,
HasLogger: globalConfig.EnableLogging,
HasMetrics: globalConfig.EnableMetrics,
HasSwagger: globalConfig.EnableSwagger,
Dependencies: service.Dependencies,
Middleware: service.Middleware,
GlobalConfig: globalConfig,
}
// Process endpoints for this group
for subEndpointName, endpoint := range subEndpoints {
fullEndpointName := groupName
if subEndpointName != "" {
fullEndpointName = fullEndpointName + strings.Title(subEndpointName)
}
endpointData := processEndpoint(fullEndpointName, endpoint, groupName)
templateData.Endpoints = append(templateData.Endpoints, endpointData)
}
// Generate routes code for this group
var routesCode strings.Builder
routesCode.WriteString(fmt.Sprintf("\n\t// %s routes\n", strings.Title(groupName)))
routesCode.WriteString(fmt.Sprintf("\t%sHandler := %s.New%sHandler(%s.%sHandlerConfig{\n", groupName, groupName, service.Name, groupName, service.Name))
routesCode.WriteString("\t\tBpjsConfig: cfg.Bpjs,\n")
routesCode.WriteString("\t\tLogger: *logger.Default(),\n")
routesCode.WriteString("\t\tValidator: nil,\n")
routesCode.WriteString("\t})\n")
routesCode.WriteString(fmt.Sprintf("\t%sGroup := v1.Group(\"/%s\")\n", groupName, groupName))
for _, endpoint := range templateData.Endpoints {
if endpoint.HasGet {
routesCode.WriteString(fmt.Sprintf("\t%sGroup.GET(\"%s\", %sHandler.Get%s)\n", groupName, endpoint.GetPath, groupName, endpoint.Name))
}
if endpoint.HasPost {
routesCode.WriteString(fmt.Sprintf("\t%sGroup.POST(\"%s\", %sHandler.Create%s)\n", groupName, endpoint.PostPath, groupName, endpoint.Name))
}
if endpoint.HasPut {
routesCode.WriteString(fmt.Sprintf("\t%sGroup.PUT(\"%s\", %sHandler.Update%s)\n", groupName, endpoint.PutPath, groupName, endpoint.Name))
}
if endpoint.HasDelete {
routesCode.WriteString(fmt.Sprintf("\t%sGroup.DELETE(\"%s\", %sHandler.Delete%s)\n", groupName, endpoint.DeletePath, groupName, endpoint.Name))
}
if endpoint.HasPatch {
routesCode.WriteString(fmt.Sprintf("\t%sGroup.PATCH(\"%s\", %sHandler.Patch%s)\n", groupName, endpoint.PatchPath, groupName, endpoint.Name))
}
}
allRoutes = append(allRoutes, routesCode.String())
}
// Find the PUBLISHED ROUTES section and insert the routes
publishedRoutesMarker := "// ============= PUBLISHED ROUTES ==============================================="
if !strings.Contains(routesContentStr, publishedRoutesMarker) {
return fmt.Errorf("PUBLISHED ROUTES marker not found in routes.go")
}
// Insert the routes after the marker
insertionPoint := strings.Index(routesContentStr, publishedRoutesMarker) + len(publishedRoutesMarker)
newRoutesContent := routesContentStr[:insertionPoint] + "\n" + strings.Join(allRoutes, "\n") + "\n" + routesContentStr[insertionPoint:]
// Write back the modified routes file
err = ioutil.WriteFile(routesFilePath, []byte(newRoutesContent), 0644)
if err != nil {
return fmt.Errorf("failed to write updated routes file: %w", err)
}
fmt.Printf("✅ Updated main routes file with %s routes\n", service.Name)
return nil
}
func processEndpoint(name string, endpoint Endpoint, endpointGroup string) EndpointData {
data := EndpointData{
Name: strings.Title(name),
NameLower: strings.ToLower(name),
NameUpper: strings.ToUpper(name),
NameCamel: toCamelCase(name),
Methods: endpoint.Methods,
GetPath: endpoint.GetPath,
PostPath: endpoint.PostPath,
PutPath: endpoint.PutPath,
DeletePath: endpoint.DeletePath,
PatchPath: endpoint.PatchPath,
Model: endpoint.Model,
ResponseModel: endpoint.ResponseModel,
Description: endpoint.Description,
Summary: endpoint.Summary,
Tags: endpoint.Tags,
RequireAuth: endpoint.RequireAuth,
RateLimit: endpoint.RateLimit,
CacheEnabled: endpoint.CacheEnabled,
CacheTTL: getOrDefault(endpoint.CacheTTL, 300),
CustomHeaders: endpoint.CustomHeaders,
ModelPackage: endpointGroup, // Set the model package based on endpoint group
}
// Set method flags and extract path parameters
for _, method := range endpoint.Methods {
switch strings.ToUpper(method) {
case "GET":
data.HasGet = true
data.PathParams = extractPathParams(endpoint.GetPath)
case "POST":
data.HasPost = true
case "PUT":
data.HasPut = true
data.PathParams = extractPathParams(endpoint.PutPath)
case "DELETE":
data.HasDelete = true
data.PathParams = extractPathParams(endpoint.DeletePath)
case "PATCH":
data.HasPatch = true
data.PathParams = extractPathParams(endpoint.PatchPath)
}
}
return data
}
func extractPathParams(path string) []string {
if path == "" {
return nil
}
var params []string
parts := strings.Split(path, "/")
for _, part := range parts {
if strings.HasPrefix(part, ":") {
params = append(params, strings.TrimPrefix(part, ":"))
}
}
return params
}
func toCamelCase(str string) string {
words := strings.FieldsFunc(str, func(c rune) bool {
return c == '_' || c == '-' || c == ' '
})
if len(words) == 0 {
return str
}
result := strings.ToLower(words[0])
for _, word := range words[1:] {
result += strings.Title(strings.ToLower(word))
}
return result
}
func getOrDefault(value, defaultValue int) int {
if value == 0 {
return defaultValue
}
return value
}
Reference in New Issue View Git Blame Copy Permalink