rachmadiyanti.annisa.3004/be-service-qris
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

pembaruan generete tool

Browse Source
This commit is contained in:
Meninjar
2025-08-16 08:37:38 +07:00
parent ac15da3ed3
commit 229782dad8
4 changed files with 113 additions and 354 deletions
Download Patch File Download Diff File Expand all files Collapse all files

125
internal/handlers/employee/employee.go
View File

@@ -1,125 +0,0 @@
package handlers
import (
"net/http"
"api-service/internal/models"
"github.com/gin-gonic/gin"
"github.com/google/uuid"
)
// EmployeeHandler handles employee services
type EmployeeHandler struct{}
// NewEmployeeHandler creates a new EmployeeHandler
func NewEmployeeHandler() *EmployeeHandler {
// return &%!s(MISSING)Handler{}
return &EmployeeHandler{}
}
// GetEmployee godoc
// @Summary Get employee
// @Description Returns a list of employees
// @Tags employee
// @Accept json
// @Produce json
// @Success 200 {object} models.EmployeeGetResponse "Employee GET response"
// @Router /api/v1/employees [get]
func (h *EmployeeHandler) GetEmployee(c *gin.Context) {
response := models.EmployeeGetResponse{
Message: "List of employees",
Data: []string{"Employee 1", "Employee 2"},
}
c.JSON(http.StatusOK, response)
}
// GetEmployeeByID godoc
// @Summary Get employee by ID
// @Description Returns a single employee by ID
// @Tags employee
// @Accept json
// @Produce json
// @Param id path string true "Employee ID"
// @Success 200 {object} models.EmployeeGetByIDResponse "Employee GET by ID response"
// @Failure 404 {object} models.ErrorResponse "employee not found"
// @Router /api/v1/Employee/{id} [get]
func (h *EmployeeHandler) GetEmployeeByID(c *gin.Context) {
id := c.Param("id")
response := models.EmployeeGetByIDResponse{
ID: id,
Message: "employee details",
}
c.JSON(http.StatusOK, response)
}%!(EXTRA string=Employee)
// CreateEmployee godoc
// @Summary Create employee
// @Description Creates a new employee
// @Tags employee
// @Accept json
// @Produce json
// @Param request body models.EmployeeCreateRequest true "Employee creation request"
// @Success 201 {object} models.EmployeeCreateResponse "Employee created successfully"
// @Failure 400 {object} models.ErrorResponse "Bad request"
// @Router /api/v1/employees [post]
func (h *EmployeeHandler) CreateEmployee(c *gin.Context) {
var req models.EmployeeCreateRequest
if err := c.ShouldBindJSON(&req); err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
}
response := models.EmployeeCreateResponse{
ID: uuid.NewString(),
Message: "Employee created successfully",
Data: req,
}
c.JSON(http.StatusCreated, response)
}
// UpdateEmployee godoc
// @Summary Update employee
// @Description Updates an existing employee
// @Tags employee
// @Accept json
// @Produce json
// @Param id path string true "Employee ID"
// @Param request body models.employeeUpdateRequest true "Employee update request"
// @Success 200 {object} models.EmployeeUpdateResponse "Employee updated successfully"
// @Failure 400 {object} models.ErrorResponse "Bad request"
// @Failure 404 {object} models.ErrorResponse "employee not found"
// @Router /api/v1/Employee/{id} [put]
func (h *EmployeeHandler) UpdateEmployee(c *gin.Context) {
id := c.Param("id")
var req models.employeeUpdateRequest
if err := c.ShouldBindJSON(&req); err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
}
response := models.EmployeeUpdateResponse{
ID: id,
Message: "Employee updated successfully",
Data: req,
}
c.JSON(http.StatusOK, response)
}%!(EXTRA string=Employee, string=Employee)
// DeleteEmployee godoc
// @Summary Delete employee
// @Description Deletes a employee by ID
// @Tags employee
// @Accept json
// @Produce json
// @Param id path string true "Employee ID"
// @Success 200 {object} models.employeeDeleteResponse "Employee deleted successfully"
// @Failure 404 {object} models.ErrorResponse "Employee not found"
// @Router /api/v1/employee/{id} [delete]
func (h *EmployeeHandler) DeleteEmployee(c *gin.Context) {
id := c.Param("id")
response := models.EmployeeDeleteResponse{
ID: id,
Message: "Employee deleted successfully",
}
c.JSON(http.StatusOK, response)
}

46
internal/models/employee/employee.go
View File

@@ -1,46 +0,0 @@
package employee
// EmployeeGetResponse represents the response for GET employees
type EmployeeGetResponse struct {
Message string `json:"message"`
Data interface{} `json:"data"`
}
// EmployeeGetByIDResponse represents the response for GET employee by ID
type EmployeeGetByIDResponse struct {
ID string `json:"id"`
Message string `json:"message"`
}
// EmployeeCreateRequest represents the request for creating employee
type EmployeeCreateRequest struct {
Name string `json:"name" binding:"required"`
// Add more fields as needed
}
// EmployeeCreateResponse represents the response for creating employee
type EmployeeCreateResponse struct {
ID string `json:"id"`
Message string `json:"message"`
Data interface{} `json:"data"`
}
// EmployeeUpdateRequest represents the request for updating employee
type EmployeeUpdateRequest struct {
Name string `json:"name" binding:"required"`
// Add more fields as needed
}
// EmployeeUpdateResponse represents the response for updating employee
type EmployeeUpdateResponse struct {
ID string `json:"id"`
Message string `json:"message"`
Data interface{} `json:"data"`
}
// EmployeeDeleteResponse represents the response for deleting employee
type EmployeeDeleteResponse struct {
ID string `json:"id"`
Message string `json:"message"`
}
// ErrorResponse represents an error response
type ErrorResponse struct {
Error string `json:"error"`
}

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

@@ -13,7 +13,6 @@ import (
authHandlers "api-service/internal/handlers/auth"
componentHandlers "api-service/internal/handlers/component"
employeeHandlers "api-service/internal/handlers/employee"
)
// RegisterRoutes registers all API routes for version 1
@@ -57,15 +56,6 @@ func RegisterRoutes(cfg *config.Config) *gin.Engine {
// Protected routes (require authentication)
// Employee endpoints
employeeHandler := employeeHandlers.NewEmployeeHandler()
v1.GET("/employees", employeeHandler.GetEmployee)
v1.GET("/employees/:id", employeeHandler.GetEmployeeByID)
v1.POST("/employees", employeeHandler.CreateEmployee)
v1.PUT("/employees/:id", employeeHandler.UpdateEmployee)
v1.DELETE("/employees/:id", employeeHandler.DeleteEmployee)
protected := v1.Group("/")
protected.Use(middleware.JWTAuthMiddleware(authService))
{

286
tools/generate-handler.go
View File

@@ -26,33 +26,30 @@ type HandlerData struct {
func main() {
if len(os.Args) < 2 {
fmt.Println("Usage: go run generate-handler.go <nama-handler> [methods]")
fmt.Println("Example: go run generate-handler.go user get post put delete")
fmt.Println("Example: go run generate-handler.go product get post")
fmt.Println("Usage: go run generate-handler.go entity [methods]")
os.Exit(1)
}
handlerName := strings.Title(os.Args[1])
methods := []string{"get", "post"}
handlerName := strings.Title(os.Args[1]) // PascalCase entity name
methods := []string{}
if len(os.Args) > 2 {
methods = os.Args[2:]
}
// Convert to lowercase for file names
handlerLower := strings.ToLower(handlerName)
handlerPlural := handlerLower + "s"
data := HandlerData{
Name: handlerName,
NameLower: handlerLower,
NamePlural: handlerPlural,
ModuleName: "api-service",
Timestamp: time.Now().Format("2006-01-02 15:04:05"),
Name: handlerName,
NameLower: handlerLower,
NamePlural: handlerPlural,
ModuleName: "api-service",
Timestamp: time.Now().Format("2006-01-02 15:04:05"),
HasResponse: true,
}
// Check which methods are requested
for _, method := range methods {
switch strings.ToLower(method) {
for _, m := range methods {
switch strings.ToLower(m) {
case "get":
data.HasGet = true
case "post":
@@ -63,51 +60,31 @@ func main() {
data.HasDelete = true
}
}
// Check if we need request/response models
data.HasRequest = data.HasPost || data.HasPut
data.HasResponse = true
data.HasParam = data.HasGet || data.HasPut || data.HasDelete
fmt.Printf("Generating handler: %s with methods: %v\n", handlerName, methods)
// Create directories with proper structure
handlerDir := filepath.Join("internal", "handlers", handlerLower)
modelDir := filepath.Join("internal", "models", handlerLower)
// Create directories if they don't exist
dirs := []string{
handlerDir,
modelDir,
}
for _, dir := range dirs {
if err := os.MkdirAll(dir, 0755); err != nil {
fmt.Printf("Error creating directory %s: %v\n", dir, err)
os.Exit(1)
for _, d := range []string{handlerDir, modelDir} {
if err := os.MkdirAll(d, 0755); err != nil {
panic(err)
}
fmt.Printf("Created directory: %s\n", dir)
}
// Generate files
generateHandlerFile(data, handlerDir)
generateModelFile(data, modelDir)
updateRoutesFile(data)
fmt.Printf("Successfully generated handler: %s\n", handlerName)
fmt.Println("Don't forget to:")
fmt.Println("1. Run: swag init -g cmd/api/main.go")
fmt.Println("2. Update your service layer if needed")
fmt.Println("3. Add repository layer if required")
fmt.Printf("✅ Successfully generated handler: %s\n", handlerName)
}
// ================= HANDLER =====================
func generateHandlerFile(data HandlerData, handlerDir string) {
handlerContent := fmt.Sprintf(`package handlers
import (
models "%s/internal/models/%s"
"net/http"
"api-service/internal/models"
"github.com/gin-gonic/gin"
"github.com/google/uuid"
)
@@ -118,14 +95,18 @@ type %sHandler struct{}
// New%sHandler creates a new %sHandler
func New%sHandler() *%sHandler {
return &%sHandler{}
}`, data.Name, data.NameLower, data.Name, data.Name, data.Name, data.Name, data.Name)
}
`, data.ModuleName, data.NameLower,
data.Name, data.NameLower,
data.Name,
data.Name, data.Name,
data.Name, data.Name, data.Name)
// Add methods based on requested operations
var methodsContent string
// GET
if data.HasGet {
methodsContent += fmt.Sprintf(`
// Get%s godoc
// @Summary Get %s
// @Description Returns a list of %s
@@ -137,7 +118,7 @@ func New%sHandler() *%sHandler {
func (h *%sHandler) Get%s(c *gin.Context) {
response := models.%sGetResponse{
Message: "List of %s",
Data: []string{"%s 1", "%s 2"},
Data: []string{"%s 1", "%s 2"},
}
c.JSON(http.StatusOK, response)
}
@@ -155,22 +136,24 @@ func (h *%sHandler) Get%s(c *gin.Context) {
func (h *%sHandler) Get%sByID(c *gin.Context) {
id := c.Param("id")
response := models.%sGetByIDResponse{
ID: id,
ID: id,
Message: "%s details",
}
c.JSON(http.StatusOK, response)
}`,
data.Name, data.NameLower, data.NamePlural, data.NameLower,
}
`, data.Name, data.NameLower, data.NamePlural, data.NameLower,
data.Name, data.Name, data.NamePlural,
data.Name, data.Name, data.Name, data.NamePlural, data.Name, data.Name,
data.Name, data.Name,
data.Name, data.NamePlural, data.Name, data.Name,
data.Name,
data.Name, data.NameLower, data.NameLower, data.NameLower,
data.Name, data.Name, data.Name, data.NameLower, data.Name,
data.Name, data.Name, data.Name, data.NameLower, data.Name)
data.Name, data.Name, data.Name, data.NameLower,
data.Name, data.Name, data.Name)
}
// POST
if data.HasPost {
methodsContent += fmt.Sprintf(`
// Create%s godoc
// @Summary Create %s
// @Description Creates a new %s
@@ -187,22 +170,22 @@ func (h *%sHandler) Create%s(c *gin.Context) {
c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
}
response := models.%sCreateResponse{
ID: uuid.NewString(),
ID: uuid.NewString(),
Message: "%s created successfully",
Data: req,
Data: req,
}
c.JSON(http.StatusCreated, response)
}`,
data.Name, data.NameLower, data.NameLower, data.NameLower,
}
`, data.Name, data.NameLower, data.NameLower, data.NameLower,
data.Name, data.Name, data.Name, data.Name, data.NamePlural,
data.Name, data.Name, data.Name, data.Name, data.Name)
data.Name, data.Name, data.Name,
data.Name, data.Name)
}
// PUT
if data.HasPut {
methodsContent += fmt.Sprintf(`
// Update%s godoc
// @Summary Update %s
// @Description Updates an existing %s
@@ -222,23 +205,23 @@ func (h *%sHandler) Update%s(c *gin.Context) {
c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
}
response := models.%sUpdateResponse{
ID: id,
ID: id,
Message: "%s updated successfully",
Data: req,
Data: req,
}
c.JSON(http.StatusOK, response)
}`,
data.Name, data.NameLower, data.NameLower, data.NameLower,
data.Name, data.NameLower, data.Name, data.Name, data.Name,
data.NameLower, data.Name, data.Name, data.Name, data.NameLower,
data.Name, data.Name, data.Name, data.Name)
}
`, data.Name, data.NameLower, data.NameLower, data.NameLower,
data.Name, data.Name, data.Name, data.Name, data.Name,
data.Name, data.Name, data.NameLower,
data.Name, data.Name, data.Name,
data.Name)
}
// DELETE
if data.HasDelete {
methodsContent += fmt.Sprintf(`
// Delete%s godoc
// @Summary Delete %s
// @Description Deletes a %s by ID
@@ -252,73 +235,73 @@ func (h *%sHandler) Update%s(c *gin.Context) {
func (h *%sHandler) Delete%s(c *gin.Context) {
id := c.Param("id")
response := models.%sDeleteResponse{
ID: id,
ID: id,
Message: "%s deleted successfully",
}
c.JSON(http.StatusOK, response)
}`,
data.Name, data.NameLower, data.NameLower, data.NameLower,
data.Name, data.NameLower, data.Name, data.Name, data.NameLower,
data.Name, data.Name, data.Name, data.Name)
}
`, data.Name, data.NameLower, data.NameLower, data.NameLower,
data.Name, data.Name, data.Name, data.Name, data.NameLower,
data.Name, data.Name, data.Name)
}
fullContent := handlerContent + methodsContent
handlerFile := filepath.Join(handlerDir, data.NameLower+".go")
writeFile(handlerFile, fullContent)
writeFile(filepath.Join(handlerDir, data.NameLower+".go"), handlerContent+methodsContent)
}
// ================= MODELS =====================
func generateModelFile(data HandlerData, modelDir string) {
modelContent := fmt.Sprintf("package %s\n\n", data.NameLower)
modelContent := "package models\n\n"
if data.HasGet {
modelContent += fmt.Sprintf(`// %sGetResponse represents the response for GET %s
modelContent += fmt.Sprintf(`// %sGetResponse response for GET %s
type %sGetResponse struct {
Message string `+"`json:\"message\"`"+`
Message string `+"`json:\"message\"`"+`
Data interface{} `+"`json:\"data\"`"+`
}
// %sGetByIDResponse represents the response for GET %s by ID
// %sGetByIDResponse response for GET %s by ID
type %sGetByIDResponse struct {
ID string `+"`json:\"id\"`"+`
Message string `+"`json:\"message\"`"+`
}
`, data.Name, data.NamePlural, data.Name, data.Name, data.NameLower, data.Name)
`, data.Name, data.NamePlural, data.Name,
data.Name, data.NameLower, data.Name)
}
if data.HasPost {
modelContent += fmt.Sprintf(`// %sCreateRequest represents the request for creating %s
modelContent += fmt.Sprintf(`// %sCreateRequest request for creating %s
type %sCreateRequest struct {
Name string `+"`json:\"name\" binding:\"required\"`"+`
// Add more fields as needed
}
// %sCreateResponse represents the response for creating %s
// %sCreateResponse response for creating %s
type %sCreateResponse struct {
ID string `+"`json:\"id\"`"+`
Message string `+"`json:\"message\"`"+`
ID string `+"`json:\"id\"`"+`
Message string `+"`json:\"message\"`"+`
Data interface{} `+"`json:\"data\"`"+`
}
`, data.Name, data.NameLower, data.Name, data.Name, data.NameLower, data.Name)
`, data.Name, data.NameLower, data.Name,
data.Name, data.NameLower, data.Name)
}
if data.HasPut {
modelContent += fmt.Sprintf(`// %sUpdateRequest represents the request for updating %s
modelContent += fmt.Sprintf(`// %sUpdateRequest request for updating %s
type %sUpdateRequest struct {
Name string `+"`json:\"name\" binding:\"required\"`"+`
// Add more fields as needed
}
// %sUpdateResponse represents the response for updating %s
// %sUpdateResponse response for updating %s
type %sUpdateResponse struct {
ID string `+"`json:\"id\"`"+`
Message string `+"`json:\"message\"`"+`
ID string `+"`json:\"id\"`"+`
Message string `+"`json:\"message\"`"+`
Data interface{} `+"`json:\"data\"`"+`
}
`, data.Name, data.NameLower, data.Name, data.Name, data.NameLower, data.Name)
`, data.Name, data.NameLower, data.Name,
data.Name, data.NameLower, data.Name)
}
if data.HasDelete {
modelContent += fmt.Sprintf(`// %sDeleteResponse represents the response for deleting %s
modelContent += fmt.Sprintf(`// %sDeleteResponse response for deleting %s
type %sDeleteResponse struct {
ID string `+"`json:\"id\"`"+`
Message string `+"`json:\"message\"`"+`
@@ -326,124 +309,81 @@ type %sDeleteResponse struct {
`, data.Name, data.NameLower, data.Name)
}
modelContent += `// ErrorResponse represents an error response
modelContent += `// ErrorResponse common error response
type ErrorResponse struct {
Error string ` + "`json:\"error\"`" + `
}
`
modelFile := filepath.Join(modelDir, data.NameLower+".go")
writeFile(modelFile, modelContent)
writeFile(filepath.Join(modelDir, data.NameLower+".go"), modelContent)
}
// ================= ROUTES =====================
func updateRoutesFile(data HandlerData) {
fmt.Println("Updating routes file...") // Debug statement
routesFile := "internal/routes/v1/routes.go"
// Read existing routes file
content, err := os.ReadFile(routesFile)
if err != nil {
fmt.Printf("Error reading routes file: %v\n", err)
fmt.Printf("Error reading routes.go: %v\n", err)
return
}
routesContent := string(content)
// Check if import already exists
importPattern := fmt.Sprintf(`%sHandlers "api-service/internal/handlers/%s"`, data.NameLower, data.NameLower)
// import
importPattern := fmt.Sprintf("%sHandlers \"%s/internal/handlers/%s\"",
data.NameLower, data.ModuleName, data.NameLower)
if !strings.Contains(routesContent, importPattern) {
// Find the import block and insert the new import
importToAdd := fmt.Sprintf("\t%sHandlers \"api-service/internal/handlers/%s\"", data.NameLower, data.NameLower)
// Find the import block end
importEndMarker := "\n)\n\n// RegisterRoutes"
if !strings.Contains(routesContent, importEndMarker) {
importEndMarker = "\n)\n\nfunc RegisterRoutes"
}
// Find the line before the closing parenthesis
lines := strings.Split(routesContent, "\n")
var newLines []string
importBlockFound := false
importAdded := false
for _, line := range lines {
newLines = append(newLines, line)
// Check if we're in the import block
if strings.Contains(line, "import (") {
importBlockFound = true
continue
}
// Check if we're at the end of import block
if importBlockFound && strings.TrimSpace(line) == ")" && !importAdded {
// Insert the new import before the closing parenthesis
newLines = newLines[:len(newLines)-1] // Remove the last line (closing parenthesis)
newLines = append(newLines, importToAdd)
newLines = append(newLines, line) // Add back the closing parenthesis
importAdded = true
}
}
if importAdded {
routesContent = strings.Join(newLines, "\n")
} else {
// Fallback to simple string replacement
if strings.Contains(routesContent, importEndMarker) {
routesContent = strings.Replace(routesContent, importEndMarker, "\n"+importToAdd+importEndMarker, 1)
}
importToAdd := fmt.Sprintf("\t%sHandlers \"%s/internal/handlers/%s\"",
data.NameLower, data.ModuleName, data.NameLower)
if strings.Contains(routesContent, "import (") {
routesContent = strings.Replace(routesContent, "import (",
"import (\n"+importToAdd, 1)
}
}
// Generate new routes
// routes
newRoutes := fmt.Sprintf("\t\t// %s endpoints\n", data.Name)
newRoutes += fmt.Sprintf("\t\t%sHandler := %sHandlers.New%sHandler()\n", data.NameLower, data.NameLower, data.Name)
newRoutes += fmt.Sprintf("\t\t%sHandler := %sHandlers.New%sHandler()\n",
data.NameLower, data.NameLower, data.Name)
if data.HasGet {
newRoutes += fmt.Sprintf("\t\tv1.GET(\"/%s\", %sHandler.Get%s)\n", data.NamePlural, data.NameLower, data.Name)
newRoutes += fmt.Sprintf("\t\tv1.GET(\"/%s/:id\", %sHandler.Get%sByID)\n", data.NamePlural, data.NameLower, data.Name)
newRoutes += fmt.Sprintf("\t\tv1.GET(\"/%s\", %sHandler.Get%s)\n",
data.NamePlural, data.NameLower, data.Name)
newRoutes += fmt.Sprintf("\t\tv1.GET(\"/%s/:id\", %sHandler.Get%sByID)\n",
data.NameLower, data.NameLower, data.Name)
}
if data.HasPost {
newRoutes += fmt.Sprintf("\t\tv1.POST(\"/%s\", %sHandler.Create%s)\n", data.NamePlural, data.NameLower, data.Name)
newRoutes += fmt.Sprintf("\t\tv1.POST(\"/%s\", %sHandler.Create%s)\n",
data.NamePlural, data.NameLower, data.Name)
}
if data.HasPut {
newRoutes += fmt.Sprintf("\t\tv1.PUT(\"/%s/:id\", %sHandler.Update%s)\n", data.NamePlural, data.NameLower, data.Name)
newRoutes += fmt.Sprintf("\t\tv1.PUT(\"/%s/:id\", %sHandler.Update%s)\n",
data.NameLower, data.NameLower, data.Name)
}
if data.HasDelete {
newRoutes += fmt.Sprintf("\t\tv1.DELETE(\"/%s/:id\", %sHandler.Delete%s)\n", data.NamePlural, data.NameLower, data.Name)
newRoutes += fmt.Sprintf("\t\tv1.DELETE(\"/%s/:id\", %sHandler.Delete%s)\n",
data.NameLower, data.NameLower, data.Name)
}
newRoutes += "\n"
// Find the place to insert new routes (after the protected group)
insertMarker := "\t\tprotected := v1.Group(\"/\")"
// Check if routes already exist
if strings.Contains(routesContent, fmt.Sprintf("New%sHandler", data.Name)) {
fmt.Printf("Routes for %s already exist, skipping...\n", data.Name)
return
if strings.Contains(routesContent, insertMarker) {
if !strings.Contains(routesContent, fmt.Sprintf("New%sHandler", data.Name)) {
routesContent = strings.Replace(routesContent, insertMarker,
newRoutes+insertMarker, 1)
} else {
fmt.Printf("⚠️ Routes for %s already exist, skipping...\n", data.Name)
}
}
// Insert new routes before the protected group
newContent := strings.Replace(routesContent, insertMarker, newRoutes+insertMarker, 1)
// Write back to file
err = os.WriteFile(routesFile, []byte(newContent), 0644)
if err != nil {
fmt.Printf("Error writing routes file: %v\n", err)
if err := os.WriteFile(routesFile, []byte(routesContent), 0644); err != nil {
fmt.Printf("Error writing routes.go: %v\n", err)
return
}
fmt.Printf("Updated routes file with %s endpoints\n", data.Name)
fmt.Printf("✅ Updated routes.go with %s endpoints\n", data.Name)
}
// ================= UTIL =====================
func writeFile(filename, content string) {
err := os.WriteFile(filename, []byte(content), 0644)
if err != nil {
if err := os.WriteFile(filename, []byte(content), 0644); err != nil {
fmt.Printf("Error creating file %s: %v\n", filename, err)
return
}