package main

import (
    "context"

    xLog "github.com/bamboo-services/bamboo-base-go/common/log"
    xMain "github.com/bamboo-services/bamboo-base-go/major/main"
    xOption "github.com/bamboo-services/bamboo-base-go/major/option"
    xOptCache "github.com/bamboo-services/bamboo-base-go/major/option/cache"
    xOptDatabase "github.com/bamboo-services/bamboo-base-go/major/option/database"
    xReg "github.com/bamboo-services/bamboo-base-go/major/register"

    // v1.2.0 起数据库驱动插件化：FromEnv 按 DATABASE_DRIVER=postgres 需空白导入对应插件
    _ "github.com/bamboo-services/bamboo-base-go/plugins/database/postgres"

    "your-project/internal/app/route"
    "your-project/internal/entity"
)

func main() {
    // v1.0.5 起：opts 直接传给 Register，声明式装配内置组件
    // DatabaseKey / CacheManagerKey / RedisClientKey / SnowflakeNodeKey
    // 由框架根据 opts 自动注册，业务侧不能在 nodeList 中重复注册
    reg := xReg.Register(context.Background(), nil,
        // 数据库：从环境变量装配（DATABASE_DRIVER=postgres，需导入 postgres 驱动插件）
        xOption.WithDatabase(
            xOptDatabase.FromEnv(),
            xOptDatabase.WithAutoMigrate(&entity.User{}),
        ),
        // 缓存：从环境变量装配（NOSQL_DRIVER=redis）
        xOption.WithCache(xOptCache.FromEnv()),
        // 路由
        xOption.WithRoute(route.NewRoute),
    )

    log := xLog.WithName(xLog.NamedMAIN)

    // Runner 启动 HTTP 服务并优雅关闭
    xMain.Runner(reg, log, nil)
}

grpcTask := xGrpcRunner.New(
    xGrpcRunner.WithLogger(xLog.WithName(xLog.NamedGRPC)),
    xGrpcRunner.WithRegisterService(func(ctx context.Context, server grpc.ServiceRegistrar) {
        // 注册你的 gRPC Service
    }),
    xGrpcRunner.WithUnaryInterceptors(
        xGrpcInterface.Recover(),
        xGrpcInterface.InitContext(reg.Init.Ctx),
        xGrpcInterface.ResponseBuilder(),
    ),
)

// opts 已通过 Register 装配（方式 A），Runner 传 nil 并附加 gRPC 任务
xMain.Runner(reg, log, nil, grpcTask)

package entity

import (
    xModels "github.com/bamboo-services/bamboo-base-go/major/models"
    xSnowflake "github.com/bamboo-services/bamboo-base-go/common/snowflake"
)

// User 用户实体
type User struct {
    xModels.BaseEntity                    // 继承基础实体（ID、CreatedAt、UpdatedAt）
    Username string `gorm:"type:varchar(64);uniqueIndex" json:"username"`
    Email    string `gorm:"type:varchar(128);uniqueIndex" json:"email"`
    Password string `gorm:"type:varchar(256)" json:"-"`
}

// GetGene 返回用户基因，用于雪花 ID 生成
func (u *User) GetGene() xSnowflake.Gene {
    return xSnowflake.GeneUser
}

package route
import (
    "context"

    "github.com/gin-gonic/gin"

    xMiddle "github.com/bamboo-services/bamboo-base-go/major/middleware"
    xRoute "github.com/bamboo-services/bamboo-base-go/major/route"
    "your-project/internal/handler"
)

func NewRoute(ctx context.Context, serve *gin.Engine) {
    // 全局异常处理
    serve.NoMethod(xRoute.NoMethod)
    serve.NoRoute(xRoute.NoRoute)

    // 全局中间件
    serve.Use(xMiddle.ResponseMiddleware)
    serve.Use(xMiddle.ReleaseAllCors)
    serve.Use(xMiddle.AllowOption)

    // API 路由组
    api := serve.Group("/api/v1")
    {
        userHandler := handler.NewUserHandler()

        // 用户路由
        user := api.Group("/user")
        user.POST("/register", userHandler.Register)
        user.POST("/login", userHandler.Login)
    }
}

package handler

import (
    xError "github.com/bamboo-services/bamboo-base-go/common/error"
    xLog "github.com/bamboo-services/bamboo-base-go/common/log"
    xResult "github.com/bamboo-services/bamboo-base-go/major/result"
    xUtil "github.com/bamboo-services/bamboo-base-go/common/utility"
    "github.com/gin-gonic/gin"
    apiUser "your-project/api/user"
    "your-project/internal/logic"
)

type UserHandler struct {
    log     *xLog.LogNamedLogger
}

func NewUserHandler() *UserHandler {
    return &UserHandler{
        log:     xLog.WithName(xLog.NamedCONT),
    }
}

// Register 用户注册
func (h *UserHandler) Register(c *gin.Context) {
    h.log.Info(c, "开始处理用户注册请求")

    // 1. 验证并绑定数据
    req := xUtil.Bind(c, &apiUser.RegisterRequest{}).Data()
    if req == nil {
        return
    }

    // 2. 调用业务逻辑（通过上下文获取资源）
    user, xErr := logic.NewUserLogic().CreateUser(c, req.Username, req.Email, req.Password)
    if xErr != nil {
        _ = c.Error(xErr)  // 传递给错误中间件处理
        return
    }

    // 3. 返回成功响应
    xResult.SuccessHasData(c, "注册成功", user)
}

// Login 用户登录
func (h *UserHandler) Login(c *gin.Context) {
    h.log.Info(c, "开始处理用户登录请求")

    req := xUtil.Bind(c, &apiUser.LoginRequest{}).Data()
    if req == nil {
        return
    }

    // 查找用户
    user, xErr := logic.NewUserLogic().GetUserByUsername(c, req.Username)
    if xErr != nil {
        _ = c.Error(xErr)
        return
    }

    // 验证密码
    if !logic.NewUserLogic().VerifyPassword(user.Password, req.Password) {
        // 创建错误并传递给中间件
        _ = c.Error(xError.NewError(c.Request.Context(), xError.Unauthorized, "用户名或密码错误", false))
        return
    }

    xResult.SuccessHasData(c, "登录成功", user)
}

package logic

import (
    xError "github.com/bamboo-services/bamboo-base-go/common/error"
    xLog "github.com/bamboo-services/bamboo-base-go/common/log"
    xUtil "github.com/bamboo-services/bamboo-base-go/common/utility"
    xCtxUtil "github.com/bamboo-services/bamboo-base-go/common/utility/context"
    "github.com/gin-gonic/gin"
    "gorm.io/gorm"
    "your-project/internal/entity"
)

type UserLogic struct {
    log *xLog.LogNamedLogger
}

func NewUserLogic() *UserLogic {
    return &UserLogic{
        log: xLog.WithName(xLog.NamedLOGC),
    }
}

// CreateUser 创建用户
func (l *UserLogic) CreateUser(c *gin.Context, username, email, password string) (*entity.User, *xError.Error) {
    l.log.Info(c, "开始创建用户")

    // 从上下文获取数据库连接
    ctx := c.Request.Context()
    db := xCtxUtil.MustGetDB(ctx)

    // 检查用户名是否存在
    var count int64
    db.Model(&entity.User{}).Where("username = ?", username).Count(&count)
    if count > 0 {
        return nil, xError.NewError(c.Request.Context(), xError.Existed, "用户名已存在", false)
    }

    // 加密密码
    hashedPassword, err := xUtil.Password().EncryptString(password)
    if err != nil {
        return nil, xError.NewInternalServerError(c.Request.Context(), "密码加密失败", err)
    }

    // 生成雪花 ID（从上下文获取节点）
    userID := xCtxUtil.MustGenerateGeneSnowflakeID(ctx, entity.User{}.GetGene())

    user := &entity.User{
        Username: username,
        Email:    email,
        Password: hashedPassword,
    }
    user.ID = userID

    if err := db.Create(user).Error; err != nil {
        return nil, xError.NewInternalServerError(c.Request.Context(), "创建用户失败", err)
    }

    return user, nil
}

// GetUserByUsername 根据用户名获取用户
func (l *UserLogic) GetUserByUsername(c *gin.Context, username string) (*entity.User, *xError.Error) {
    // 从上下文获取数据库连接
    db := xCtxUtil.MustGetDB(c.Request.Context())

    var user entity.User
    if err := db.Where("username = ?", username).First(&user).Error; err != nil {
        if err == gorm.ErrRecordNotFound {
            return nil, xError.NewError(c.Request.Context(), xError.UserNotFound, "用户不存在", false, err)
        }
        return nil, xError.NewInternalServerError(c.Request.Context(), "查询用户失败", err)
    }
    return &user, nil
}

// VerifyPassword 验证密码
func (l *UserLogic) VerifyPassword(hashedPassword, password string) bool {
    return xUtil.Password().IsValid(password, hashedPassword)
}