package cronjob

import (
	"gin/common/base"
	"gin/pkg/cli"
)

type DemoCommand struct {
	base.BaseCommand
}

func (m *DemoCommand) Name() string {
	return "demo-test"
}

func (m *DemoCommand) Description() string {
	return "command-desc"
}

func (m *DemoCommand) Help() []base.CommandOption {
	return []base.CommandOption{
		{
			base.Flag{
				Short: "a",
				Long:  "args",
			},
			"Example Argument, Example: arg1",
			true,
		},
	}
}

func (m *DemoCommand) Execute(values map[string]string) {
	// todo
}

func init() {
	cli.Register(&DemoCommand{})
}

//go:build cli

package main

import (
	"gin/app/facade"
	_ "gin/common/imports"
	"gin/pkg/cli"
)

func main() {
	_ = facade.Config()

	cli.Execute()
}

func (m *DemoCommand) Help() []base.CommandOption {
	return []base.CommandOption{
        {
            base.Flag{
                Short: "a",
                Long:  "args",
            },
            "Example Argument, Example: arg1",
            true,
        },
    }
}

ctx := facade.Grpc().WithToken(ctx, token)
userGrpc, err := facade.Grpc().Service(proto.NewUserServiceClient)
if err != nil {
    return err
}
resp, err := userGrpc.Detail(ctx, &proto.UserRequest{Id: 1})

// Code generated by gorm.io/gen. DO NOT EDIT.
// Code generated by gorm.io/gen. DO NOT EDIT.
// Code generated by gorm.io/gen. DO NOT EDIT.

package user

import "gin/app/model"

const TableNameUser = "user"

// User User-Table
type User struct {
	ID        int64            `gorm:"column:id;type:int(10) unsigned;primaryKey;autoIncrement:true;comment:ID" json:"id"`                       // ID
	Avatar    string           `gorm:"column:avatar;type:varchar(255);not null;comment:avatar" json:"avatar"`                                    // avatar
	Username  string           `gorm:"column:username;type:varchar(10);not null;comment:username" json:"username"`                               // username
	FullName  string           `gorm:"column:full_name;type:varchar(20);not null;comment:fullname" json:"fullName"`                              // fullName
	Email     string           `gorm:"column:email;type:varchar(50);not null;comment:email" json:"email"`                                        // email
	Password  string           `gorm:"column:password;type:varchar(255);not null;comment:password" json:"password"`                              // password
	Nickname  string           `gorm:"column:nickname;type:varchar(50);not null;comment:nickname" json:"nickname"`                               // nickname
	Gender    int64            `gorm:"column:gender;type:tinyint(1) unsigned;not null;comment:gender 1=male 2=female" json:"gender"`             // gender 1=male 2=female
	Age       int64            `gorm:"column:age;type:int(10) unsigned;not null;comment:age" json:"age"`                                         // age
	Status    int64            `gorm:"column:status;type:tinyint(3) unsigned;not null;default:1;comment:state 1=enable 2=disable" json:"status"` // state 1=enable 2=disable
	CreatedAt *model.DateTime  `gorm:"column:created_at;type:datetime;comment:Creation Time" json:"createdAt"`                                   // Creation Time
	UpdatedAt *model.DateTime  `gorm:"column:updated_at;type:datetime;comment:Update Time" json:"updatedAt"`                                     // Update Time
	DeletedAt *model.DeletedAt `gorm:"column:deleted_at;type:datetime;comment:Delete Time" json:"deletedAt" swaggerignore:"true"`                // Delete Time
}

// TableName User's table name
func (*User) TableName() string {
	return TableNameUser
}

// Connection Database connection name
func (*User) Connection() string {
	return "mysql"
}

package service

import (
	"context"
	"gin/app/model"
	"gin/app/request"
	"gin/common/base"
)

type UserService struct {
	base.BaseService
}

// List user-list
func (s *UserService) List(ctx context.Context, req request.User) (pageData request.PageData, err error) {
	var (
		m  []model.User
		db = s.DB(ctx, &model.User{})
	)

	// Search
	db = s.Search(db, req.Search)

	err = db.Count(&pageData.Total).Error
	if err != nil {
		return pageData, err
	}

	if req.NotPage {
		err = db.Preload("UserRoles").Order("id DESC").Find(&m).Error
		if err != nil {
			return pageData, err
		}
		pageData.List = m
	} else {
		pageData.Page = req.Page
		pageData.PageSize = req.PageSize
		offset, limit := request.Pagination(req.Page, req.PageSize)

		err = db.Offset(offset).Limit(limit).Order("id DESC").Find(&m).Error
		if err != nil {
			return pageData, err
		}
		pageData.List = m
	}

	return pageData, nil
}

package request

import (
	"gin/app/errcode"
	"gin/common/base"

	"github.com/gookit/validate"
)

// Roles role-request-validation
type Roles struct {
	base.BaseRequest
	ID     int64  `json:"id" form:"id" validate:"required|int|gt:0" label:"ID"`
	Name   string `json:"name" form:"name" validate:"required|max:255" label:"Role Name"`
	Desc   string `json:"desc" form:"desc" validate:"required|max:255" label:"Role Description"`
	Status int64  `json:"status" form:"status" validate:"required|int" label:"Status 1=Enable 2=Disable"`
	PageListValidate
}

func (s Roles) Validate(data Roles, scene string) error {
	v := validate.Struct(data, scene)
	if !v.Validate(scene) {
		return errcode.ArgsError().WithMsg(v.Errors.One())
	}
	return nil
}

// ConfigValidation Configuration-Validation
// - Define validation scenes
// - You can also add verification settings
func (s Roles) ConfigValidation(v *validate.Validation) {
	scenes := validate.SValues{
		"List":   []string{"PageListValidate.Page", "PageListValidate.PageSize"},
		"Create": []string{"Name", "Desc", "Status"},
		"Update": []string{"ID", "Name", "Desc", "Status"},
		"Detail": []string{"ID"},
		"Delete": []string{"ID"},
	}
	v.WithScenes(scenes)
}

// Messages messages
func (s Roles) Messages() map[string]string {
	return validate.MS{
		"required":    "Field {field} Required",
		"int":         "Field {field} Must be an integer",
		"Page.gt":     "Field {field} Must be greater than 0",
		"PageSize.gt": "Field {field} Must be greater than 0",
	}
}

// Translates translate
func (s Roles) Translates() map[string]string {
	return validate.MS{
		"ID":       "ID",
		"Name":     "Role Name",
		"Desc":     "Role Description",
		"Status":   "Status 1=Enable 2=Disable",
		"Page":     "Page",
		"PageSize": "Page Size",
	}
}

package request

// Roles role-request-validation
type Roles struct {
	base.BaseRequest
	ID     int64  `json:"id" form:"id" validate:"required|int|gt:0" label:"ID"`
	Name   string `json:"name" form:"name" validate:"required|maxLen:255" label:"Role Name"`
	Desc   string `json:"desc" form:"desc" validate:"required|maxLen:255" label:"Role Description"`
	Status int64  `json:"status" form:"status" validate:"required|int" label:"Status 1=Enable 2=Disable"`
	PageListValidate
}

package request

// ConfigValidation Configuration-Validation
// - Define validation scenes
// - You can also add verification settings
func (s Roles) ConfigValidation(v *validate.Validation) {
	scenes := validate.SValues{
		"List":   []string{"PageListValidate.Page", "PageListValidate.PageSize"},
		"Create": []string{"Name", "Desc", "Status"},
		"Update": []string{"ID", "Name", "Desc", "Status"},
		"Detail": []string{"ID"},
		"Delete": []string{"ID"},
	}
	v.WithScenes(scenes)
}

package request

// Messages Validator-Error-Message
func (s Roles) Messages() map[string]string {
	return validate.MS{
		"required":                     "Field {field} Required",
		"int":                          "Field {field} Must be an integer",
		"PageListValidate.Page.gt":     "Field {field} Must be greater than 0",
		"PageListValidate.PageSize.gt": "Field {field} Must be greater than 0",
	}
}

package request

// Translates Field-Translation
func (s Roles) Translates() map[string]string {
	return validate.MS{
		"ID":       "ID",
		"Name":     "Role Name",
		"Desc":     "Role Description",
		"Status":   "Status 1=Enable 2=Disable",
		"Page":     "Page",
		"PageSize": "Page Size",
	}
}

package request

import (
	"gin/app/errcode"
	"gin/pkg"

	"github.com/gookit/validate"
)

// UserImport User Import
type UserImport struct {
	Data []UserImportItem `json:"data" validate:"required|minLen:1" label:"Import Data"`
}

// UserImportItem User Import Item
type UserImportItem struct {
	Username string `json:"username" validate:"required|minLen:3|maxLen:20|regex:^[a-zA-Z0-9_]+$" label:"Username"`
	Password string `json:"password" validate:"required" label:"Password"`
	FullName string `json:"fullName" validate:"required" label:"FullName"`
	Nickname string `json:"nickname" validate:"required" label:"Nickname"`
	Email    string `json:"email" validate:"required|email" label:"Email"`
	Gender   int64  `json:"gender" validate:"required|int" label:"Gender"`
	Age      int64  `json:"age" validate:"int" label:"Age"`
	Status   int64  `json:"status" validate:"int" label:"Status"`
}

// Validate User Import Validate
func (s UserImport) Validate(data UserImport, scene string) error {
	v := validate.Struct(data, scene)
	if !v.Validate(scene) {
		return errcode.ArgsError().WithMsg(v.Errors.One())
	}
	return nil
}

// ConfigValidation Config Validation
func (s UserImport) ConfigValidation(v *validate.Validation) {
	scenes := validate.SValues{
		"Import": []string{"Data"},
	}
	v.WithScenes(scenes)
}

// Messages Validation Messages
func (s UserImport) Messages() map[string]string {
	return validate.MS{
		"required": "{field} Required",
		"minLen":   "{field} the length cannot be less than {min} characters",
		"maxLen":   "{field} the length cannot exceed {max} characters",
		"int":      "{field} Must be an integer",
		"regex":    "{field} format error",
		"email":    "{field} email format error",
	}
}

// Translates Translates
func (s UserImport) Translates() map[string]string {
	ms := validate.MS{
		"Data": "Import Data",
	}
	for i := range s.Data {
		prefix := pkg.Sprintf("Data.%d.", i)
		rowLabel := pkg.Sprintf("Line %d ", i+1)
		ms[prefix+"Username"] = rowLabel + "Username"
		ms[prefix+"Password"] = rowLabel + "Password"
		ms[prefix+"FullName"] = rowLabel + "FullName"
		ms[prefix+"Nickname"] = rowLabel + "Nickname"
		ms[prefix+"Email"] = rowLabel + "Email"
		ms[prefix+"Gender"] = rowLabel + "Gender"
		ms[prefix+"Age"] = rowLabel + "Age"
		ms[prefix+"Status"] = rowLabel + "Status"
	}
	return ms
}

package request

import (
	"fmt"
	"gin/app/errcode"

	"github.com/gookit/validate"
)

// SystemConfigValueUpdate Batch update of system configuration
type SystemConfigValueUpdate struct {
	ID           int64  `json:"id" validate:"required|int|gt:0"`
	Key          string `json:"key" validate:""`
	DefaultValue string `json:"defaultValue" validate:""`
}

// SystemConfigUpdates Batch update verification of system configuration
type SystemConfigUpdates struct {
	List []SystemConfigValueUpdate `json:"list" validate:"required" label:"Config List"`
}

// Validate System configuration batch update request verification
func (s SystemConfigUpdates) Validate() error {
	if len(s.List) == 0 {
		return errcode.ArgsError().WithMsg("The configuration list cannot be empty")
	}

	for i, item := range s.List {
		v := validate.Struct(item)
		if !v.Validate() {
			return errcode.ArgsError().WithMsg(fmt.Sprintf("list[%d]item %s", i, v.Errors.One()))
		}
	}

	return nil
}

// Translates Field translation
func (s SystemConfigValueUpdate) Translates() map[string]string {
	return validate.MS{
		"ID":               "ID",
		"Key":              "Identification",
		"Name":             "Name",
		"DefaultValue":     "DefaultValue",
		"OptionValue":      "OptionValue",
		"Type":             "Type 1=input 2=radio 3=checkbox 4=select 5=textarea 6=file",
		"ConfigCategoryId": "ConfigCategoryId",
	}
}

// Messages Validator error message
func (s SystemConfigValueUpdate) Messages() map[string]string {
	return validate.MS{
		"required": "Field {field} is required",
		"int":      "Field {field} must be an integer",
		"gt":       "Field {field} must be greater than 0",
	}
}

package main

import (
	"github.com/gookit/validate"
)

// Register during initialization
func init() {
	validate.AddValidator("is_even", func(val any, rule string) bool {
		num, ok := val.(int)
		if !ok {
			return false
		}
		return num%2 == 0
	})
}

package request

// ValidateIsEven Define local rule methods (naming convention: Validate<rule name>)
func (s User) ValidateIsEven(val any) bool {
	num := val.(int)
	return num%2 == 0
}

package request

import (
	"gin/app/errcode"
)

// Validate Request-Validation
func (s User) Validate(data User, scene string) error {
	v := validate.Struct(data, scene)
	v.AddValidator("is_even", func(val any, rule string) bool {
		num, ok := val.(int)
		if !ok {
			return false
		}
		return num%2 == 0
	})
	if !v.Validate(scene) {
		return errcode.ArgsError().WithMsg(v.Errors.One())
	}

	return nil
}

package request

type User struct {
	Age int `json:"gender" validate:"required|is_even" label:"age"`
}

package v1

import (
	"gin/app/errcode"
	"gin/app/facade"
	"gin/app/model"
	"gin/app/request"
	"gin/app/service"
	"gin/common/base"

	"github.com/gin-gonic/gin"
)

type UserController struct {
	base.BaseController
	service service.UserService
}

// List User-List
// @Tags User
// @Summary List
// @Description User-List
// @Param token header string true "Authentication Token"
// @Param page query string true "Page"
// @Param pageSize query string true "Page Size"
// @Success 200 {object} errcode.SuccessResponse{data=request.PageData{list=[]model.User}} "Login Successful"
// @Failure 400 {object} errcode.ArgsErrorResponse "Argument Error"
// @Failure 500 {object} errcode.SystemErrorResponse "System Error"
// @Router /api/v1/user [get]
func (s *UserController) List(c *gin.Context) {
	var (
		ctx = c.Request.Context()
		req request.User
	)

	// Method One
	/*err := c.ShouldBind(&req)
	  if err != nil {
	      s.Response.Error(c, err)
	      return
	  }

	  // Validator
	  err = facade.Request().Validate(c, &req, "List")
	  if err != nil {
	      s.Response.Error(c, err)
	      return
	  }*/
	// Method Two
	// Bind And Validate
	err := facade.Request().BindValidate(c, &req, "List")
	if err != nil {
		s.Response.Error(c, err)
		return
	}

	res, err := s.service.List(ctx, req)
	if err != nil {
		s.Response.Error(c, err)
		return
	}

	s.Response.Success(c, errcode.Success().WithData(res))
}

package v1

import (
	"gin/app/errcode"
	"gin/app/facade"
	"gin/app/request"
	"gin/app/service"
	"gin/common/base"
	"gin/pkg/serviceprovider/lang"

	"github.com/gin-gonic/gin"
	"github.com/gin-gonic/gin/binding"
	"github.com/go-viper/mapstructure/v2"
)

type UserController struct {
	base.BaseController
	service service.UserService
}

// List User List
// @Tags User
// @Summary List
// @Description User List
// @Param token header string true "Authentication Token"
// @Param page query string true "Page"
// @Param pageSize query string true "Page Size"
// @Success 200 {object} errcode.SuccessResponse{data=request.PageData{list=[]model.User}} "Success"
// @Failure 400 {object} errcode.ArgsErrorResponse "Arguments Error"
// @Failure 500 {object} errcode.SystemErrorResponse "System Error"
// @Router /api/v1/user [get]
func (s *UserController) List(c *gin.Context) {
	var (
		ctx = c.Request.Context()
		req request.User
	)

	// Bind parameters and validate
	err := facade.Request().BindValidate(c, &req, "List")
	if err != nil {
		s.Response.Error(c, err)
		return
	}

	res, err := s.service.List(ctx, req)
	if err != nil {
		s.Response.Error(c, err)
		return
	}

	s.Response.Success(c, errcode.Success().WithData(res))
}

// Create User Create
// @Tags User
// @Summary User
// @Description User Create
// @Param token header string true "Authentication Token"
// @Param data body request.UserCreate true "Create Params"
// @Success 200 {object} errcode.SuccessResponse{data=model.User} "Success"
// @Failure 400 {object} errcode.ArgsErrorResponse "Arguments Error"
// @Failure 500 {object} errcode.SystemErrorResponse "Syetem Error"
// @Router /api/v1/user [post]
func (s *UserController) Create(c *gin.Context) {
	var (
		ctx = c.Request.Context()
		req request.User
	)

	// Bind parameters and validate
	err := facade.Request().BindValidate(c, &req, "Create")
	if err != nil {
		s.Response.Error(c, err)
		return
	}

	user, err := s.service.Create(ctx, req)
	if err != nil {
		s.Response.Error(c, err)
		return
	}

	s.Response.Success(c, errcode.Success().WithData(user))
}

// Update User Update
// @Tags User
// @Summary Update
// @Description User Update
// @Param token header string true "Authentication Token"
// @Param id path int true "User ID"
// @Param data body request.UserUpdate true "Update Params"
// @Success 200 {object} errcode.SuccessResponse "Success"
// @Failure 400 {object} errcode.ArgsErrorResponse "Arguments Error"
// @Failure 500 {object} errcode.SystemErrorResponse "System Error"
// @Router /api/v1/user/{id} [put]
func (s *UserController) Update(c *gin.Context) {
	var (
		ctx  = c.Request.Context()
		data map[string]any
		req  request.User
	)

	err := c.ShouldBindBodyWith(&data, binding.JSON)
	if err != nil {
		s.Response.Error(c, err)
		return
	}

	err = mapstructure.Decode(data, &req)
	if err != nil {
		s.Response.Error(c, err)
		return
	}

	req.ID = facade.Request().Path[int64](c, "id", 0)
	err = facade.Request().Validate(c, &req, "Update")
	if err != nil {
		s.Response.Error(c, err)
		return
	}

	err = s.service.Update(ctx, req.ID, data)
	if err != nil {
		s.Response.Error(c, err)
		return
	}

	s.Response.Success(c, errcode.Success().WithData(data))
}

// Detail User Detail
// @Tags User
// @Summary Detail
// @Description User Detail
// @Param token header string true "Authentication Token"
// @Param id path int true "User ID"
// @Success 200 {object} errcode.SuccessResponse{data=model.User} "Success"
// @Failure 400 {object} errcode.ArgsErrorResponse "Arguments Error"
// @Failure 500 {object} errcode.SystemErrorResponse "System Error"
// @Router /api/v1/user/{id} [get]
func (s *UserController) Detail(c *gin.Context) {
	var (
		ctx = c.Request.Context()
		req request.User
	)

	req.ID = facade.Request().Path[int64](c, "id", 0)

	// Bind parameters and validate
	err := facade.Request().BindValidate(c, &req, "Detail")
	if err != nil {
		s.Response.Error(c, err)
		return
	}

	m, err := s.service.Detail(ctx, req.ID)
	if err != nil {
		s.Response.Error(c, err)
		return
	}

	s.Response.Success(c, errcode.Success().WithData(m))
}

// Delete User Delete
// @Tags User
// @Summary Delete
// @Description User Delete
// @Param token header string true "Authentication Token"
// @Param id path int true "User ID"
// @Success 200 {object} errcode.SuccessResponse "Success"
// @Failure 400 {object} errcode.ArgsErrorResponse "Arguments Error"
// @Failure 500 {object} errcode.SystemErrorResponse "System Error"
// @Router /api/v1/user/{id} [delete]
func (s *UserController) Delete(c *gin.Context) {
	var (
		ctx = c.Request.Context()
		req request.User
	)

	req.ID = facade.Request().Path[int64](c, "id", 0)

	// Bind parameters and validate
	err := facade.Request().BindValidate(c, &req, "Delete")
	if err != nil {
		s.Response.Error(c, err)
		return
	}

	err = s.service.Delete(ctx, req.ID)
	if err != nil {
		s.Response.Error(c, err)
		return
	}

	s.Response.Success(c, errcode.Success())
}

package router

import (
	"gin/app/controller/v1"

	"github.com/gin-gonic/gin"
)

// UserRouter User Router
type UserRouter struct{}

// Register Routes
func (r *UserRouter) Register(routerGroup *gin.RouterGroup) {
	var (
		user v1.UserController
	)

	router := routerGroup.Group("api/v1/user")
	{
		// List
		router.GET("", user.List)
		// Create
		router.POST("", user.Create)
		// Update
		router.PUT("/:id", user.Update)
		// Delete
		router.DELETE("/:id", user.Delete)
		// Detail
		router.GET("/:id", user.Detail)
	}
}

// IsAuth Is need auth
func (r *UserRouter) IsAuth() bool {
	return true
}

package router

import (
	"gin/app/facade"
	"gin/app/middleware"
	"gin/pkg/errcode"

	"github.com/gin-gonic/gin"
)

var rateLimitMiddleware middleware.RateLimit

// NewRouters Load Routers
func NewRouters(router *gin.Engine) {
	// Global Rate Limit
	group := router.Group("", rateLimitMiddleware.Handle())
	r := group.Group("")
	{
		r.GET("/global-test1", func(c *gin.Context) {
			facade.Response().Success(c, errcode.NewError(0, "global test1"))
		})

		r.GET("/global-test2", func(c *gin.Context) {
			facade.Response().Success(c, errcode.NewError(0, "global test2"))
		})
	}

	// Specify interface current limit
	// User Rate Limit
	// r How many tokens are generated per second
	// burst Bucket capacity
	userGroup := router.Group("", rateLimitMiddleware.UserRateLimit(1, 1))
	r1 := userGroup.Group("")
	{
		r1.GET("/test1", func(c *gin.Context) {
			facade.Response().Success(c, errcode.NewError(0, "user test1"))
		})

		r1.GET("/test2", func(c *gin.Context) {
			facade.Response().Success(c, errcode.NewError(0, "user test2"))
		})
	}

	// Specify interface current limit
	// Ip Rate Limit
	// r How many tokens are generated per second
	// burst Bucket capacity
	ipGroup := router.Group("", rateLimitMiddleware.IpRateLimit(1, 1))
	r2 := ipGroup.Group("")
	{
		r2.GET("/test1", func(c *gin.Context) {
			facade.Response().Success(c, errcode.NewError(0, "ip test1"))
		})

		r2.GET("/test2", func(c *gin.Context) {
			facade.Response().Success(c, errcode.NewError(0, "ip test2"))
		})
	}
}

package controller

import (
	"fmt"
	"gin/app/facade"
	"gin/common/base"
)

type TestController struct {
	base.BaseController
}

func (s *TestController) Test() {
	// Set Set-Cache	
	key := "test_key"
	value := "test_value"
	cache := facade.Cache()
	cache = facade.Cache("redis")
	err := cache.Set(key, value, time.Second*10)
	if err != nil {
		// Handle error	
	}

	// Get Get-Cache
	key = "test_key"
	value = "test_value"
	result, ok := cache.Get(key)
	if ok {
		println(result) // test_value	
	}

	// Delete Delete-Cache
	key = "test_key"
	err = cache.Delete(key)
	if err != nil {
		// Handle error	
	}

	// Expire Get-Cache-Expire
	key = "test_key"
	val, expireAt, ok, err := cache.Expire(key)
	if err != nil {
		// Handle error
	}
	if ok {
		fmt.Println(val)                       // test_value
		fmt.Printf("ExpireAt: %v\n", expireAt) // ExpireAt: 2025-10-28 11:23:38.7416956 +0800 CST
	}
}

package controller

import (
	"fmt"
	"gin/app/facade"
	"gin/common/base"
)

type TestController struct {
	base.BaseController
}

func (s *TestController) Test() {
	// Set Set-Cache	
	key := "test_key"
	value := "test_value"
	redisCache := facade.Redis()
	err := redisCache.Set(key, value, time.Second*10)
	if err != nil {
		// Handle error	
	}

	// Get Get-Cache
	key = "test_key"
	value = "test_value"
	result, ok := redisCache.Get(key)
	if ok {
		println(result) // test_value	
	}

	// Delete Delete-Cache
	key = "test_key"
	err = redisCache.Delete(key)
	if err != nil {
		// Handle error	
	}

	// Expire Get-Cache-Expire
	key = "test_key"
	val, expireAt, ok, err := redisCache.Expire(key)
	if err != nil {
		// Handle error
	}
	if ok {
		fmt.Println(val)                       // test_value
		fmt.Printf("ExpireAt: %v\n", expireAt) // ExpireAt: 2025-10-28 11:23:38.7416956 +0800 CST
	}

	// ... Other
}

package controller

import (
	"fmt"
	"gin/app/facade"
	"gin/common/base"
)

type TestController struct {
	base.BaseController
}

func (s *TestController) Test() {
	// Set Set-Cache	
	key := "test_key"
	value := "test_value"
	memoryCache := facade.Cache("memory")
	err := memoryCache.Set(key, value, time.Second*10)
	if err != nil {
		// Handle error	
	}

	// Get Get-Cache
	key = "test_key"
	value = "test_value"
	result, ok := memoryCache.Get(key)
	if ok {
		println(result) // test_value	
	}

	// Delete Delete-Cache
	key = "test_key"
	err = memoryCache.Delete(key)
	if err != nil {
		// Handle error	
	}

	// Expire Get-Cache-Expire
	key = "test_key"
	val, expireAt, ok, err := memoryCache.Expire(key)
	if err != nil {
		// Handle error
	}
	if ok {
		fmt.Println(val)                       // test_value
		fmt.Printf("ExpireAt: %v\n", expireAt) // ExpireAt: 2025-10-28 11:23:38.7416956 +0800 CST
	}

	// ... Other
}

package controller

import (
	"fmt"
	"gin/app/facade"
	"gin/common/base"
)

type TestController struct {
	base.BaseController
}

func (s *TestController) Test() {
	// Set Set-Cache	
	key := "test_key"
	value := "test_value"
	diskCache := facade.Cache("disk")
	err := diskCache.Set(key, value, time.Second*10)
	if err != nil {
		// Handle error	
	}

	// Get Get-Cache
	key = "test_key"
	value = "test_value"
	result, ok := diskCache.Get(key)
	if ok {
		println(result) // test_value	
	}

	// Delete Delete-Cache
	key = "test_key"
	err = diskCache.Delete(key)
	if err != nil {
		// Handle error	
	}

	// Expire Get-Cache-Expire
	key = "test_key"
	val, expireAt, ok, err := diskCache.Expire(key)
	if err != nil {
		// Handle error
	}
	if ok {
		fmt.Println(val)                       // test_value
		fmt.Printf("ExpireAt: %v\n", expireAt) // ExpireAt: 2025-10-28 11:23:38.7416956 +0800 CST
	}

	// ... Other
}    

package event

// UserLoginEvent event-data
type UserLoginEvent struct {
	UserId   int64
	Username string
}

// Name event-name
func (u UserLoginEvent) Name() string {
	return "user.login"
}

// Description event-description
func (u UserLoginEvent) Description() string {
	return "User Login Event"
}

package listener

import (
	"fmt"
	"gin/app/event"
	"time"
)

type UserLoginListener struct{}

func (l *UserLoginListener) Handle(e event.UserLoginEvent) {
	fmt.Printf(
		"Recieved Event: %s Event Description: %s Event Data: %T, Time: %s\n",
		e.Name(),
		e.Description(),
		e,
		time.Now().Format("2006-01-02 15:04:05"),
	)
}

listenerRegister(&UserLoginListener{}, event.UserLoginEvent{})

package consumer

import (
	"gin/app/facade"
	"gin/common/flag"
	"gin/config"
	"gin/pkg"
	"gin/pkg/serviceprovider/queue"
	"time"

	"github.com/segmentio/kafka-go"
)

// KafkaDemoConsumer Kafka consumer
type KafkaDemoConsumer struct {
	*queue.KafkaConsumer
}

// KafkaDemoPayload message payload
type KafkaDemoPayload struct {
	Name string `json:"name"`
}

func NewKafkaDemoConsumer() *KafkaDemoConsumer {
	cfg := facade.Config()
	kfk := queue.NewKafka(cfg, facade.Log(), facade.Event().Bus())
	kfk.Reader = kafka.NewReader(kafka.ReaderConfig{
		Brokers:        cfg.Queue.Kafka.Brokers,
		Topic:          "kafka_demo",
		GroupID:        "kafka_demo_group",
		MinBytes:       1,
		MaxBytes:       10e6,
		StartOffset:    kafka.LastOffset,
		CommitInterval: 0,
		MaxWait:        5 * time.Second,
	})
	return &KafkaDemoConsumer{
		KafkaConsumer: &queue.KafkaConsumer{
			Kafka: kfk,
			Topic: "kafka_demo",
			Group: "kafka_demo_group",
		},
	}
}

func (c *KafkaDemoConsumer) Name() string {
	return "kafka_demo"
}

func (c *KafkaDemoConsumer) Description() string {
	return "kafka demo"
}

func (c *KafkaDemoConsumer) Connection() string {
	return "kafka"
}

func (c *KafkaDemoConsumer) Retry() int {
	return 3
}

func (c *KafkaDemoConsumer) IsDelay() bool {
	return false
}

func (c *KafkaDemoConsumer) Start() error {
	c.KafkaConsumer.Start(c)
	flag.Infof("Kafka consumer started: %s", c.Name())
	return nil
}

func (c *KafkaDemoConsumer) Stop() error {
	return c.KafkaConsumer.Stop()
}

func (c *KafkaDemoConsumer) Enabled(cfg *config.Config) bool {
	return cfg.Queue.Kafka.Enabled
}

func (c *KafkaDemoConsumer) NewPayload() any {
	return &KafkaDemoPayload{}
}

func (c *KafkaDemoConsumer) Handle(payload any) error {
	data := payload.(*KafkaDemoPayload)
	facade.Log().Info(pkg.Sprintf("Kafka Received Msg: name=%s", data.Name))
	// todo business logic
	return nil
}

ConsumerFactory("kafka", appconsumer.NewKafkaDemoConsumer)

package producer

import (
	"context"
	"gin/app/facade"
	"gin/pkg/serviceprovider/queue"

	"github.com/segmentio/kafka-go"
)

type KafkaDemoProducer struct {
	*queue.KafkaProducer
}

func NewKafkaDemoProducer() *KafkaDemoProducer {
	cfg := facade.Config()
	kfk := queue.NewKafka(cfg, facade.Log(), facade.Event().Bus())
	kfk.Writer = &kafka.Writer{
		Addr:         kafka.TCP(cfg.Queue.Kafka.Brokers...),
		Topic:        "kafka_demo",
		Balancer:     &kafka.LeastBytes{},
		RequiredAcks: kafka.RequireAll,
	}
	p := &KafkaDemoProducer{
		KafkaProducer: &queue.KafkaProducer{
			Kafka: kfk,
			Topic: "kafka_demo",
			Key:   "kafka_demo_key",
		},
	}
	p.KafkaProducer.Owner = p
	return p
}

func (p *KafkaDemoProducer) Name() string {
	return "kafka_demo"
}

func (p *KafkaDemoProducer) Description() string {
	return "kafka demo"
}

func (p *KafkaDemoProducer) Connection() string {
	return "kafka"
}

func (p *KafkaDemoProducer) IsDelay() bool {
	return false
}

func (p *KafkaDemoProducer) DelayMs() int64 {
	return 0
}

func (p *KafkaDemoProducer) Publish(ctx context.Context, msg any) error {
	return p.KafkaProducer.Publish(ctx, msg)
}

func (p *KafkaDemoProducer) Close() error {
	return p.KafkaProducer.Close()
}

ProducerFactory("kafka", appproducer.NewKafkaDemoProducer)

package controller

import (
	"gin/app/facade"
	"gin/app/queue/consumer"
	"gin/common/base"
)

type TestController struct {
	base.BaseController
}

func (s *TestController) Test(ctx context.Context) {
	// Kafka
	_ = facade.Queue().Producer("kafka_demo").Publish(ctx, consumer.KafkaDemoPayload{Name: "kafka_test111"})
	_ = facade.Queue().Producer("kafka_delay_demo").Publish(ctx, consumer.KafkaDelayDemoPayload{Name: "kafka_test222"})

	// RabbitMQ
	_ = facade.Queue().Producer("rabbitmq_demo").Publish(ctx, consumer.RabbitmqDemoPayload{Name: "test111"})
	_ = facade.Queue().Producer("rabbitmq_delay_demo").Publish(ctx, consumer.RabbitmqDelayDemoPayload{Name: "test222"})

	// Redis
	_ = facade.Queue().Producer("redis_demo").Publish(ctx, consumer.RedisDemoPayload{Name: "redis_test111"})
	_ = facade.Queue().Producer("redis_delay_demo").Publish(ctx, consumer.RedisDelayDemoPayload{Name: "redis_test222"})
}

consumers := facade.Queue().Consumers()
producers := facade.Queue().Producers()
consumerNames := facade.Queue().ConsumerNames()
runningConsumers := facade.Queue().RunningConsumers()
stoppedConsumers := facade.Queue().StoppedConsumers()
consumerStatuses := facade.Queue().ConsumerStatus()
producerStatuses := facade.Queue().ProducerStatus()

consumer := facade.Queue().Consumer("kafka_demo")
producer := facade.Queue().Producer("kafka_demo")

package job

import (
	"gin/app/facade"
	"gin/pkg"
)

type SendEmailJob struct{}

type SendEmail struct {
	To      string `json:"to"`
	Subject string `json:"subject"`
	Content string `json:"content"`
}

func (j *SendEmailJob) Name() string        { return "send_email" }
func (j *SendEmailJob) Description() string { return "Send email task" }
func (j *SendEmailJob) Connection() string  { return "redis" }
func (j *SendEmailJob) Retry() int          { return 3 }
func (j *SendEmailJob) Delay() int64        { return 3000 }
func (j *SendEmailJob) NewPayload() any     { return &SendEmail{} }

func (j *SendEmailJob) Handle(payload any) error {
	data := payload.(*SendEmail)
	// todo: implement business logic
	facade.Log().Info(pkg.Sprintf("Sending email to: %s, subject: %s", data.To, data.Subject))
	return nil
}

return []servicejob.Job{
	&SendEmailJob{},
}

package v1

import (
	"gin/app/facade"
	"gin/app/job"
	"github.com/gin-gonic/gin"
)

func (s *TestController) Test(c *gin.Context) {
	ctx := c.Request.Context()

	// Async dispatch (redis/kafka/rabbitmq)
	_ = facade.Job().Dispatch(ctx, "send_email", job.SendEmail{
		To:      "user@example.com",
		Subject: "Hello",
		Content: "Test email content",
	})

	// Sync dispatch (sync driver)
	_ = facade.Job().Dispatch(ctx, "sync_user", job.SyncUser{
		UserID: 1,
		Action: "update",
	})
}

jobs := facade.Job().Jobs()
stats := facade.Job().GetAllJobs()
count, err := facade.Job().Count(ctx)

package v1

import (
	"gin/app/errcode"
	"gin/app/facade"
	"gin/app/model"
	"gin/app/request"
	"gin/app/service"
	"gin/common/base"

	"github.com/gin-gonic/gin"
)

type LoginController struct {
	base.BaseController
	service service.LoginService
}

// Token token-info
type Token struct {
	AccessToken        string `json:"accessToken"`
	RefreshToken       string `json:"refreshToken"`
	TokenExpire        int64  `json:"tokenExpire" example:"7200"`
	RefreshTokenExpire int64  `json:"refreshTokenExpire" example:"172800"`
}

type LoginResponse struct {
	Token Token `json:"token"`
	User  model.User
}

// Login login
// @Tags login
// @Summary login
// @Description User login
// @Accept json
// @Produce json
// @Param data body request.UserLogin true "Login Argument"
// @Success 200 {object} errcode.SuccessResponse{data=LoginResponse} "Success"
// @Failure 400 {object} errcode.ArgsErrorResponse "Argument Error"
// @Failure 500 {object} errcode.SystemErrorResponse "System Error"
// @Router /api/v1/login [post]
func (s *LoginController) Login(c *gin.Context) {
	var (
		ctx = c.Request.Context()
		req request.Login
	)

	// Bind And Validate
	err := facade.Request().BindValidate(c, &req, "Login")
	if err != nil {
		s.Response.Error(c, err)
		return
	}

	err, userModel, accessToken, refreshToken, tokenExpire, refreshTokenExpire := s.service.Login(ctx, req.Username, req.Password)
	if err != nil {
		s.Response.Error(c, err)
		return
	}

	// Publish Event
	facade.Event().Publish[event.UserLoginEvent](ctx, event.UserLoginEvent{
		UserId:   userModel.ID,
		Username: userModel.Username,
	})

	s.Response.Success(
		c, errcode.Success().WithMsg(
			facade.Lang().Trans(ctx, "login.success", map[string]any{
				"name": userModel.Username,
			}),
		).WithData(LoginResponse{
			Token{
				AccessToken:        accessToken,
				RefreshToken:       refreshToken,
				TokenExpire:        tokenExpire,
				RefreshTokenExpire: refreshTokenExpire,
			},
			userModel,
		}),
	)
}

package v1

import (
	"gin/app/errcode"
	"gin/app/facade"
	"gin/common/base"

	"github.com/gin-gonic/gin"
)

type TestController struct {
	base.BaseController
}

func (s *TestController) Test(c *gin.Context) {
	return s.Response.Success(c, errcode.Success())
}

func (s *TestController) Test1(c *gin.Context) {
	return facade.Response().Success(c, errcode.Success())
}

package v1

import (
	"gin/app/errcode"
	"gin/app/facade"
	"gin/common/base"

	"github.com/gin-gonic/gin"
)

type TestController struct {
	base.BaseController
}

func (s *TestController) Test(c *gin.Context) {
	return s.Response.Success(c, errcode.Success().WithMsg("Success"))
}

func (s *TestController) Test1(c *gin.Context) {
	return facade.Response().Success(c, errcode.Success().WithMsg("Success"))
}

package v1

import (
	"gin/app/errcode"
	"gin/app/facade"
	"gin/common/base"

	"github.com/gin-gonic/gin"
)

type TestController struct {
	base.BaseController
}

func (s *TestController) Test(c *gin.Context) {
	return s.Response.Success(c, errcode.Success().WithData([]string{"test data"}))
}

func (s *TestController) Test1(c *gin.Context) {
	return facade.Response().Success(c, errcode.Success().WithData([]string{"test data"}))
}

package v1

import (
	"gin/app/errcode"
	"gin/app/facade"
	"gin/common/base"

	"github.com/gin-gonic/gin"
)

type TestController struct {
	base.BaseController
}

func (s *TestController) Test(c *gin.Context) {
	return s.Response.Error(c, errcode.SystemError())
}

func (s *TestController) Test1(c *gin.Context) {
	return facade.Response().Error(c, errcode.SystemError())
}

package v1

import (
	"gin/app/errcode"
	"gin/app/facade"
	"gin/common/base"

	"github.com/gin-gonic/gin"
)

type TestController struct {
	base.BaseController
}

func (s *TestController) Test(c *gin.Context) {
	return s.Response.Error(c, errcode.SystemError().WithCode(500))
}

func (s *TestController) Test1(c *gin.Context) {
	return facade.Response().Error(c, errcode.SystemError().WithCode(500))
}

package v1

import (
	"gin/app/errcode"
	"gin/app/facade"
	"gin/common/base"

	"github.com/gin-gonic/gin"
)

type TestController struct {
	base.BaseController
}

func (s *TestController) Test(c *gin.Context) {
	return s.Response.Error(c, errcode.SystemError().WithMsg("System Error"))
}

func (s *TestController) Test1(c *gin.Context) {
	return facade.Response().Error(c, errcode.SystemError().WithMsg("System Error"))
}

package v1

import (
	"gin/app/errcode"
	"gin/app/facade"
	"gin/common/base"

	"github.com/gin-gonic/gin"
)

type TestController struct {
	base.BaseController
}

func (s *TestController) Test(c *gin.Context) {
	return s.Response.Error(c, errcode.SystemError().WithData([]string{"test data"}))
}

func (s *TestController) Test1(c *gin.Context) {
	return facade.Response().Error(c, errcode.SystemError().WithData([]string{"test data"}))
}

package v1

import (
	"gin/app/errcode"
	"gin/common/base"
	"net/http"

	"github.com/gin-gonic/gin"
)

type TestController struct {
	base.BaseController
}

func (s *TestController) Test(c *gin.Context) {
	return s.Response.Error(c, errcode.ArgsError().WithHttpCode(http.StatusBadRequest).WithData([]string{"test data"}))
}

package v1

import (
	"gin/app/errcode"
    "gin/app/facade"
    "gin/common/base"
	"net/http"
    
    "github.com/gin-gonic/gin"
)

type TestController struct {
    base.BaseController
}

func (s *TestController) Test(c *gin.Context) {
    return s.Response.WithHeader("X-ID", "XXX").Error(c, errcode.ArgsError())
}

func (s *TestController) Test(c *gin.Context) {
	return facade.Response().WithHeader("X-ID", "XXX").Error(c, errcode.ArgsError())
}

package v1

import (
	"gin/app/facade"
	"github.com/gin-gonic/gin"
)

type TestController struct {
	base.BaseController
}

func (s *TestController) Test(c *gin.Context) {
	facade.Log().Error("System Error")
}

package v1

import (
	"gin/app/facade"
	"gin/common/base"
	"github.com/gin-gonic/gin"
)

type TestController struct {
	base.BaseController
}

func (s *TestController) Test(c *gin.Context) {
	ctx := c.Request.Context()
	facade.Log().WithDebugger(ctx).Error("System Error")
}

package controller

import (
	"fmt"
	"gin/app/facade"
	"gin/common/base"
	"github.com/gin-gonic/gin"
)

type TestController struct {
	base.BaseController
}

func (s *TestController) Test(c *gin.Context) {
	ctx := c.Request.Context()
	trans := facade.Lang().Trans(ctx, "login.username", nil)
	fmt.Println(trans) // Output: 用户名, English Output: Username
}

package controller

import (
	"fmt"
	"gin/app/facade"
	"gin/common/base"
	"github.com/gin-gonic/gin"
)

type TestController struct {
	base.BaseController
}

func (s *TestController) Test(c *gin.Context) {
	ctx := c.Request.Context()
	trans := facade.Lang().Trans(ctx, "login.success", map[string]any{
		"name": "admin",
	}),
		fmt.Println(trans) // Output: admin,登录成功 English Output: admin,Login Success
}

package controller

import (
	"gin/app/facade"
	"gin/common/base"
	"github.com/gin-gonic/gin"
)

type TestController struct {
	base.BaseController
}

func (s *TestController) Test(c *gin.Context) {
	ctx := c.Request.Context()
	cache := facade.Cache()
	redisCache := facade.Cache("redis")
	// Bind context to cache
	redisCache = redisCache.WithContext(ctx)
	memoryCache := facade.Cache("memory")
	diskCache := facade.Cache("disk")
	// Other facade usage ...
}

package enum

import (
	"gin/common/base"
)

const (
	UserGenderSecret = 0 // secrecy
	UserGenderMale   = 1 // male
	UserGenderFemale = 2 // female
)

const (
	UserStatusEnabled  = "enable"  // enable
	UserStatusDisabled = "disable" // disable
)

// UserEnum user-enum
type UserEnum struct{}

// Gender gender
func (s *UserEnum) Gender() *base.Enum[int] {
	return base.NewEnum(
		base.Item[int]{Value: UserGenderSecret, Desc: "secrecy"},
		base.Item[int]{Value: UserGenderMale, Desc: "male"},
		base.Item[int]{Value: UserGenderFemale, Desc: "female"},
	)
}

// Status status
func (s *UserEnum) Status() *base.Enum[string] {
	return base.NewEnum(
		base.Item[string]{Value: UserStatusEnabled, Desc: "enable"},
		base.Item[string]{Value: UserStatusDisabled, Desc: "disable"},
	)
}

package v1

import (
	"gin/app/enum"
	"gin/app/errcode"
	"gin/common/base"

	"github.com/gin-gonic/gin"
)

type LoginController struct {
	base.BaseController
	service service.LoginService
}

// Test 
// @Tags Login
// @Summary test
// @Description test
// @Accept json
// @Produce json
// @Success 200 {object} errcode.SuccessResponse{data=map[string]any{}} "success"
// @Router /api/v1/test [post]
func (s *LoginController) Test(c *gin.Context) {
	var (
		userEnum enum.UserEnum
	)

	status := userEnum.Status().Get()
	desc1 := userEnum.Status().Desc(enum.UserStatusEnabled)
	value1 := userEnum.Status().Value("enable")
	_map := userEnum.Status().Map()
	containsValue := userEnum.Status().ContainsValue(enum.UserStatusEnabled)
	containsDesc := userEnum.Status().ContainsDesc("disable")
	length := userEnum.Status().Len()

	gender := userEnum.Gender().Get()
	desc2 := userEnum.Gender().Desc(enum.UserGenderMale)
	value2 := userEnum.Gender().Value("male")
	_map2 := userEnum.Gender().Map()
	containsValue2 := userEnum.Gender().ContainsValue(enum.UserGenderMale)
	containsDesc2 := userEnum.Gender().ContainsDesc("male")
	length2 := userEnum.Gender().Len()

	s.Response.Success(c, errcode.Success().WithData(map[string]any{
		"status":         status,
		"desc1":          desc1,
		"value1":         value1,
		"map":            _map,
		"containsValue":  containsValue,
		"containsDesc":   containsDesc,
		"length":         length,
		"gender":         gender,
		"desc2":          desc2,
		"value2":         value2,
		"map2":           _map2,
		"containsValue2": containsValue2,
		"containsDesc2":  containsDesc2,
		"length2":        length2,
	}))
}

package service

import (
	"context"
	"gin/app/errcode"
)

type UserService struct{}

func (s *UserService) Detail(ctx context.Context, id int64) error {
	var (
		userErr errcode.UserErrCode
	)
	// todo query user
	return userErr.ExampleError()
}

package controller

import (
	"gin/app/facade"
	"gin/common/base"
	
	"github.com/gin-gonic/gin"
)

type TestController struct {
	base.BaseController
}

func (s *TestController) Test(c *gin.Context) {
	ctx := c.Request.Context()
	// Default Connection
	db := facade.DB()
	// Using context
	db1 := facade.DB().WithContext(ctx)
	// Connection pgsql
	db2 := facade.DB("pgsql").WithContext(ctx)
	// Connection sqlsrv
	db3 := facade.DB("sqlsrv").WithContext(ctx)
	// todo ...
}

package controller

import (
	"gin/app/errcode"
	"gin/app/facade"
	"gin/app/model"
	"gin/app/request"
	"gin/app/service"
	
	"github.com/gin-gonic/gin"
)

type UserController struct {
	base.BaseController
	service service.UserService
}

func (s *UserController) Test(c *gin.Context) {
	var (
		ctx = c.Request.Context()
		req request.User
	)

	// Bind and validate parameters
	err := facade.Request().BindValidate(c, &req, "List")
	if err != nil {
		s.Response.Error(c, err)
		return
	}

	res, err := s.service.List(ctx, req)
	if err != nil {
		s.Response.Error(c, err)
		return
	}

	s.Response.Success(c, errcode.Success().WithData(res))
}

package service

import (
	"context"
	"gin/app/model"
	"gin/app/request"
	"gin/common/base"
)

type UserService struct {
	base.BaseService
}

// List
func (s *UserService) List(ctx context.Context, req request.User) (pageData request.PageData, err error) {
	var (
		m  []model.User
		db = s.DB(ctx, &model.User{})
	)

	// Search 
	db = (s.Search(db, m, req.Search)).
		Model(&m).
		Preload("UserRoles")

	err = db.Count(&pageData.Total).Error
	if err != nil {
		return pageData, err
	}

	if req.NotPage {
		err = db.Order("id DESC").Find(&m).Error
		if err != nil {
			return pageData, err
		}
		pageData.List = m
	} else {
		pageData.Page = req.Page
		pageData.PageSize = req.PageSize
		offset, limit := request.Pagination(req.Page, req.PageSize)

		err = db.Offset(offset).Limit(limit).Order("id DESC").Find(&m).Error
		if err != nil {
			return pageData, err
		}
		pageData.List = m
	}

	return pageData, nil
}