### Install GoAdmin CLI

Source: https://github.com/goadmingroup/go-admin/blob/main/README.md

Installs the GoAdmin command-line interface tool. Ensure you have Go installed and configured.

```shell
go install github.com/GoAdminGroup/adm@latest
```

--------------------------------

### Create New Project Directory

Source: https://github.com/goadmingroup/go-admin/blob/main/README.md

Creates a new directory for your project and navigates into it. This is the first step before installing GoAdmin.

```shell
mkdir new_project && cd new_project
```

--------------------------------

### Install GoAdmin with Go Modules

Source: https://github.com/goadmingroup/go-admin/wiki/使用GoAdmin可视化工具搭建golang应用管理平台

Use this command to get the latest version of GoAdmin. Ensure GO111MODULE is set to 'on'.

```bash
go get github.com/chenhg5/go-admin@latest
```

--------------------------------

### Install Admin CLI Tool

Source: https://github.com/goadmingroup/go-admin/wiki/使用GoAdmin可视化工具搭建golang应用管理平台

This command installs the 'admincli' command-line tool, which is used to generate data model files.

```bash
go install github.com/chenhg5/go-admin/admincli
```

--------------------------------

### Add Third-Party Plugins

Source: https://context7.com/goadmingroup/go-admin/llms.txt

Extend GoAdmin's functionality by adding custom plugins that implement the `plugins.Plugin` interface. The `example` plugin is shown here.

```go
import "github.com/GoAdminGroup/go-admin/plugins/example"

examplePlugin := example.NewExample()

eng.AddConfig(&cfg).
    AddGenerators(myGenerators).
    AddPlugins(examplePlugin).
    Use(r)
```

--------------------------------

### Generate Data Model Files

Source: https://github.com/goadmingroup/go-admin/wiki/使用GoAdmin可视化工具搭建golang应用管理平台

Execute this command in your project directory after installing the admincli tool to generate data table model files.

```bash
admincli generate
```

--------------------------------

### Add New Dependency

Source: https://github.com/goadmingroup/go-admin/blob/main/CONTRIBUTING.md

Use the 'go get' command to add or update external package dependencies. This command supports fetching the latest tagged release or a specific version.

```bash
# Pick the latest tagged release.
go get example.com/some/module/pkg

# Pick a specific version.
go get example.com/some/module/pkg@vX.Y.Z
```

--------------------------------

### Retrieve Authenticated User in GoAdmin Handler

Source: https://context7.com/goadmingroup/go-admin/llms.txt

Use `auth.Auth(ctx)` within a GoAdmin handler to get the authenticated `UserModel`. This allows access to user details like name and roles, and enables permission checks.

```go
// Inside a GoAdmin handler
func myHandler(ctx *context.Context) {
    user := auth.Auth(ctx)                  // models.UserModel
    fmt.Println(user.Name, user.Roles)

    // Check permission
    if !user.CheckPermissionByURLMethod(ctx.Path(), ctx.Method(), ctx.PostForm()) {
        ctx.JSON(http.StatusForbidden, map[string]interface{}{"error": "forbidden"})
        return
    }
}
```

--------------------------------

### Initialize GoAdmin Engine with Gin Framework

Source: https://context7.com/goadmingroup/go-admin/llms.txt

This snippet shows how to initialize the GoAdmin engine and integrate it with the Gin web framework. It includes setting up database connections, generators, and configuration.

```go
package main

import (
    "time"

    _ "github.com/GoAdminGroup/go-admin/adapter/gin"
    _ "github.com/GoAdminGroup/go-admin/modules/db/drivers/mysql"
    _ "github.com/GoAdminGroup/themes/adminlte"

    "github.com/GoAdminGroup/go-admin/engine"
    "github.com/GoAdminGroup/go-admin/modules/config"
    "github.com/GoAdminGroup/go-admin/modules/language"
    "github.com/gin-gonic/gin"
)

func main() {
    r := gin.Default()
    eng := engine.Default()

    cfg := config.Config{
        Env: config.EnvLocal,
        Databases: config.DatabaseList{
            "default": {
                Host:            "127.0.0.1",
                Port:            "3306",
                User:            "root",
                Pwd:             "secret",
                Name:            "myapp",
                MaxIdleConns:    50,
                MaxOpenConns:    150,
                ConnMaxLifetime: time.Hour,
                Driver:          config.DriverMysql,
            },
        },
        UrlPrefix: "admin",
        Language:  language.EN,
        Debug:     true,
        Store: config.Store{
            Path:   "./uploads",
            Prefix: "uploads",
        },
    }

    if err := eng.AddConfig(&cfg).
        AddGenerators(myGenerators).   // map[string]table.Generator
        AddGenerator("user", GetUserTable).
        Use(r); err != nil {
        panic(err)
    }

    r.Static("/uploads", "./uploads")
    _ = r.Run(":9033")
}
// Expected: GoAdmin admin panel served at http://localhost:9033/admin
```

--------------------------------

### Framework Adapters for Web Frameworks

Source: https://context7.com/goadmingroup/go-admin/llms.txt

Switch the underlying web framework by importing the corresponding adapter. The adapter registers itself automatically. For `net/http`, use the `goadminhttp.Content` helper to wrap handlers.

```go
// Gin
import _ "github.com/GoAdminGroup/go-admin/adapter/gin"

// Echo
import _ "github.com/GoAdminGroup/go-admin/adapter/echo"

// Beego
import _ "github.com/GoAdminGroup/go-admin/adapter/beego"

// Chi
import _ "github.com/GoAdminGroup/go-admin/adapter/chi"

// net/http
import _ "github.com/GoAdminGroup/go-admin/adapter/nethttp"

// GoFiber
import _ "github.com/GoAdminGroup/go-admin/adapter/gofiber"

// For net/http, wrap handlers using the framework-specific helper:
import goadminhttp "github.com/GoAdminGroup/go-admin/adapter/nethttp"

http.HandleFunc("/admin/dashboard", goadminhttp.Content(func(w http.ResponseWriter, r *http.Request) (types.Panel, error) {
    return GetDashboardContent(r.Context())
}))
```

--------------------------------

### Initialize New GoAdmin Project

Source: https://github.com/goadmingroup/go-admin/blob/main/README.md

Initializes a new web project using the GoAdmin CLI. This command sets up the basic project structure.

```shell
adm init web
```

--------------------------------

### Configure Multiple Database Connections

Source: https://context7.com/goadmingroup/go-admin/llms.txt

Define database configurations in `DatabaseList` and access them by driver name using the engine. This allows for managing different database types and credentials.

```go
cfg := config.Config{
    Databases: config.DatabaseList{
        "default": {Driver: config.DriverMysql,  Host: "mysql-host",  Port: "3306", ...},
        "pg":      {Driver: config.DriverPostgresql, Dsn: "host=pg-host port=5432 ..."},
        "cache":   {Driver: config.DriverSqlite,  File: "./cache.db"},
    },
}

// After eng.AddConfig(&cfg):
mysqlConn    := eng.MysqlConnection()
pgConn       := eng.PostgresqlConnection()
sqliteConn   := eng.SqliteConnection()

// Or resolve via callback
eng.ResolveMysqlConnection(func(conn db.Connection) {
    myRepository.SetConn(conn)
})
```

--------------------------------

### Configure and Run GoAdmin with Gin

Source: https://github.com/goadmingroup/go-admin/wiki/使用GoAdmin可视化工具搭建golang应用管理平台

This Go code demonstrates how to integrate GoAdmin with a Gin web application. It includes global configuration for the database, domain, and logging, and adds an admin plugin with a user generator.

```go
package main

import (
	"github.com/gin-gonic/gin"
	_ "github.com/chenhg5/go-admin/adapter/gin"
	"github.com/chenhg5/go-admin/engine"
	"github.com/chenhg5/go-admin/plugins/admin"
	"github.com/chenhg5/go-admin/modules/config"
	"github.com/chenhg5/go-admin/examples/datamodel"
	"github.com/chenhg5/go-admin/modules/language"
)

func main() {
	r := gin.Default()

	eng := engine.Default()

	// global config
	cfg := config.Config{
	    DATABASE: config.DatabaseList{
	        "default": {
		    HOST:         "127.0.0.1",
		    PORT:         "3306",
		    USER:         "root",
		    PWD:          "root",
		    NAME:         "godmin",
		    MAX_IDLE_CON: 50,
		    MAX_OPEN_CON: 150,
		    DRIVER:       "mysql",
	        },
        	},
		DOMAIN: "localhost", // 是cookie相关的，访问网站的域名
		PREFIX: "admin",
		// STORE 必须设置且保证有写权限，否则增加不了新的管理员用户
		STORE: config.Store{
		    PATH:   "./uploads",
		    PREFIX: "uploads",
		},
		LANGUAGE: language.CN, 
		// 开发模式
                DEBUG: true,
                // 日志文件位置，需为绝对路径
                INFOLOG: "/var/logs/info.log",
                ACCESSLOG: "/var/logs/access.log",
                ERRORLOG: "/var/logs/error.log",
	}

    	// Generators： 详见 https://github.com/chenhg5/go-admin/blob/master/examples/datamodel/tables.go
	adminPlugin := admin.NewAdmin(datamodel.Generators)
	
	// 增加 generator, 第一个参数是对应的访问路由前缀
	// 例子:
	//
	// "user" => http://localhost:9033/admin/info/user
	//
	adminPlugin.AddGenerator("user", datamodel.GetUserTable)

	_ = eng.AddConfig(cfg).AddPlugins(adminPlugin).Use(r)

	_ = r.Run(":9033")
}
```

--------------------------------

### Run Tests

Source: https://github.com/goadmingroup/go-admin/blob/main/CONTRIBUTING.md

Execute the test suite before committing your changes. This ensures that your contributions do not break existing functionality.

```bash
make test
```

--------------------------------

### Serve Static HTML Files within Admin Layout using GoAdmin

Source: https://context7.com/goadmingroup/go-admin/llms.txt

Use `eng.HTMLFile` for a single file or `eng.HTMLFiles` for multiple template files. These methods wrap the provided templates within the admin layout, preserving the sidebar and navbar. `eng.HTMLFilesNoAuth` can be used to serve public pages.

```go
// Single file
eng.HTMLFile("GET", "/admin/report", "./templates/report.html", map[string]interface{}{
    "title": "Monthly Report",
    "data":  reportData,
})

// Multiple template files (parsed together)
eng.HTMLFiles("GET", "/admin/docs", map[string]interface{}{"version": "v1.0"},
    "./templates/base.html", "./templates/docs.html")

// Without auth check
eng.HTMLFilesNoAuth("GET", "/admin/public-page", nil, "./templates/public.html")
```

--------------------------------

### Database Query Builder Operations

Source: https://context7.com/goadmingroup/go-admin/llms.txt

Use the `db` package for fluent, dialect-aware database queries. Supports SELECT, FIND, COUNT, INSERT, UPDATE, DELETE, aggregate functions, and transactions. Ensure a database connection is established before use.

```go
import "github.com/GoAdminGroup/go-admin/modules/db"

conn := eng.DefaultConnection()

// SELECT with WHERE, ORDER, LIMIT
rows, err := db.WithDriver(conn).
    Table("posts").
    Select("id", "title", "created_at").
    Where("status", "=", "published").
    OrderBy("created_at", "desc").
    Take(10).
    Skip(0).
    All()
// rows: []map[string]interface{}

// Find by primary key
row, err := db.WithDriver(conn).Table("users").Find(42)
// row: map[string]interface{}{"id": 42, "name": "Alice", ...}

// Count
total, err := db.WithDriver(conn).Table("posts").
    Where("author_id", "=", 5).
    Count()

// Insert
id, err := db.WithDriver(conn).Table("posts").Insert(db.H{
    "title":   "Hello GoAdmin",
    "content": "...",
    "date":    "2024-01-15",
})

// Update
_, err = db.WithDriver(conn).Table("posts").
    Where("id", "=", id).
    Update(db.H{"title": "Updated Title"})

// Delete
err = db.WithDriver(conn).Table("posts").
    Where("id", "=", id).
    Delete()

// Aggregate
total_revenue, err := db.WithDriver(conn).Table("orders").Sum("amount")
max_price, err     := db.WithDriver(conn).Table("products").Max("price")

// Transaction
_, err = db.WithDriver(conn).Table("accounts").
    WithTransaction(func(tx *sql.Tx) (error, map[string]interface{}) {
        _, err := db.WithDriver(conn).Table("accounts").
            WithTx(tx).Where("id", "=", 1).Update(db.H{"balance": 900})
        if err != nil { return err, nil }
        _, err  = db.WithDriver(conn).Table("accounts").
            WithTx(tx).Where("id", "=", 2).Update(db.H{"balance": 1100})
        return err, nil
    })
```

--------------------------------

### Load GoAdmin Configuration from YAML File

Source: https://context7.com/goadmingroup/go-admin/llms.txt

Load GoAdmin configuration from a YAML file using `AddConfigFromYAML`. This is an alternative to using JSON or Go structs for configuration.

```go
// YAML equivalent
// eng.AddConfigFromYAML("./config.yaml")
```

--------------------------------

### Define Table Model with InfoPanel and FormPanel

Source: https://context7.com/goadmingroup/go-admin/llms.txt

Creates a table model with CRUD capabilities. Configure the list/filter view using GetInfo() and the create/edit form using GetForm().

```go
package datamodel

import (
    "github.com/GoAdminGroup/go-admin/context"
    "github.com/GoAdminGroup/go-admin/modules/db"
    "github.com/GoAdminGroup/go-admin/plugins/admin/modules/table"
    "github.com/GoAdminGroup/go-admin/template/types"
    "github.com/GoAdminGroup/go-admin/template/types/form"
)

func GetPostsTable(ctx *context.Context) table.Table {
    postsTable := table.NewDefaultTable(ctx, table.DefaultConfig().SetExportable(true))

    // ---- Info (list) panel ----
    info := postsTable.GetInfo()
    info.AddField("ID",    "id",    db.Int).FieldSortable()
    info.AddField("Title", "title", db.Varchar)
    info.AddField("Date",  "date",  db.Varchar).FieldFilterable()
    info.SetTable("posts").SetTitle("Posts").SetDescription("Blog posts")

    // ---- Form (create/edit) panel ----
    formList := postsTable.GetForm()
    formList.AddField("ID",      "id",      db.Int,     form.Default).
        FieldDisplayButCanNotEditWhenUpdate().FieldDisableWhenCreate()
    formList.AddField("Title",   "title",   db.Varchar, form.Text)
    formList.AddField("Content", "content", db.Varchar, form.RichText).FieldEnableFileUpload()
    formList.AddField("Date",    "date",    db.Varchar, form.Datetime)
    formList.EnableAjax("Saved!", "Save failed")
    formList.SetTable("posts").SetTitle("Posts").SetDescription("Blog posts")

    return postsTable
}
// Register: map[string]table.Generator{"posts": GetPostsTable}
// Accessible at: /admin/info/posts
```

--------------------------------

### Tidy Go Modules

Source: https://github.com/goadmingroup/go-admin/blob/main/CONTRIBUTING.md

Update and synchronize the go.mod and go.sum files after adding or removing dependencies. It's also recommended to run 'go mod vendor' to create a vendor directory.

```bash
go mod tidy
go mod vendor
git add go.mod go.sum vendor
git commit
```

--------------------------------

### Load GoAdmin Configuration from JSON File

Source: https://context7.com/goadmingroup/go-admin/llms.txt

Externalize your GoAdmin configuration by loading it from a JSON file. This approach avoids hardcoding configuration details in your Go code.

```json
// config.json
// {
//   "database": { "default": { "driver":"sqlite", "file":"./admin.db" } },
//   "prefix":   "admin",
//   "language": "en",
//   "debug":    true
// }
```

```go
eng := engine.Default()
if err := eng.AddConfigFromJSON("./config.json").
    AddGenerators(myGenerators).
    Use(r); err != nil {
    panic(err)
}
```

--------------------------------

### Create Custom Dashboard with HTML Components in GoAdmin

Source: https://context7.com/goadmingroup/go-admin/llms.txt

Register custom HTML routes using `eng.HTML`. The handler should return a `types.Panel` constructed from GoAdmin's template components. Ensure chart components are registered at startup if used.

```go
// Register the route
eng.HTML("GET", "/admin/dashboard", GetDashboardContent)

// Handler using template components
func GetDashboardContent(ctx *context.Context) (types.Panel, error) {
    components := template.Default(ctx)

    // Chart (requires template.AddComp(chartjs.NewChart()) at startup)
    lineChart := chartjs.Line().
        SetID("saleschart").SetHeight(180).
        SetTitle("Monthly Sales").
        SetLabels([]string{"Jan", "Feb", "Mar", "Apr", "May"}).
        AddDataSet("Revenue").
        DSData([]float64{120, 200, 180, 340, 290}).
        DSBorderColor("rgba(60,141,188,1)").
        DSFill(false).
        GetContent()

    box := components.Box().
        WithHeadBorder().
        SetHeader("Sales Overview").
        SetBody(lineChart).
        GetContent()

    col := components.Col().SetSize(types.SizeMD(12)).SetContent(box).GetContent()
    row := components.Row().SetContent(col).GetContent()

    return types.Panel{
        Content:     row,
        Title:       "Dashboard",
        Description: "Sales overview",
    }, nil
}
```

--------------------------------

### Add Navigation Bar Buttons

Source: https://context7.com/goadmingroup/go-admin/llms.txt

Enhance the navigation bar with icon buttons that trigger actions or open new tabs. Use `icon` package for icons and `action` types for defining behavior like jumping to a URL or showing a popup.

```go
import (
    "github.com/GoAdminGroup/go-admin/template/icon"
    "github.com/GoAdminGroup/go-admin/template/types/action"
)

eng.AddNavButtons("Docs", icon.Book,
    action.JumpInNewTab("https://book.go-admin.cn", "Documentation"))

eng.AddNavButtons("Alerts", icon.Bell,
    action.PopUp("/admin/alerts", "System Alerts",
        func(ctx *context.Context) (bool, string, interface{}) {
            return true, "", "<ul><li>Disk usage > 90%</li></ul>"
        }))
```

--------------------------------

### Load GoAdmin Configuration from INI File

Source: https://context7.com/goadmingroup/go-admin/llms.txt

Load GoAdmin configuration from an INI file using `AddConfigFromINI`. This provides another option for externalizing configuration settings.

```go
// INI equivalent
// eng.AddConfigFromINI("./config.ini")
```

--------------------------------

### Implement Custom Authentication Service in GoAdmin

Source: https://context7.com/goadmingroup/go-admin/llms.txt

Replace the default authentication with a custom `Processor` function using `eng.AddAuthService`. This function should return a `models.UserModel`, a boolean indicating success, and an error message if authentication fails. It allows integration with custom authentication backends.

```go
eng.AddAuthService(func(ctx *context.Context) (models.UserModel, bool, string) {
    token := ctx.FormValue("api_token")
    user := models.User().SetConn(eng.DefaultConnection()).
        Where("api_token", "=", token).First()
    if user.IsEmpty() {
        return models.UserModel{}, false, "invalid token"
    }
    return user.WithRoles().WithPermissions().WithMenus(), true, ""
})
```

--------------------------------

### Add Row-Level and Toolbar Action Buttons in GoAdmin

Source: https://context7.com/goadmingroup/go-admin/llms.txt

Use `AddActionButton` for row-level actions and `AddButton` for toolbar actions. Supports Ajax, popups, and URL jumps. Ensure context is properly handled for callbacks.

```go
info := userTable.GetInfo()

// Row-level: Ajax call
info.AddActionButton(ctx, "Audit", action.Ajax("/admin/audit",
    func(ctx *context.Context) (success bool, msg string, data interface{}) {
        fmt.Println("auditing record", ctx.PostForm())
        return true, "Audit successful", ""
    }))

// Row-level: Popup with custom HTML response
info.AddActionButton(ctx, "Preview", action.PopUp("/admin/preview", "Preview",
    func(ctx *context.Context) (success bool, msg string, data interface{}) {
        return true, "", "<h2>Record Detail</h2>"
    }))

// Row-level: jump to external URL
info.AddActionButton(ctx, "Google", action.Jump("https://google.com"))

// Toolbar: open a popup form
info.AddButton(ctx, "Bulk Action", icon.Android, action.PopUpWithForm(action.PopUpData{
    Id: "/admin/bulk", Title: "Bulk Action", Width: "600px", Height: "300px",
}, func(panel *types.FormPanel) *types.FormPanel {
    panel.AddField("Reason", "reason", db.Varchar, form.Text)
    panel.EnableAjax("Done", "Failed")
    return panel
}, "/admin/bulk"))

// Toolbar: select box filter
info.AddSelectBox(ctx, "gender", types.FieldOptions{
    {Value: "0", Text: "men"},
    {Value: "1", Text: "women"},
}, action.FieldFilter("gender"))
```

--------------------------------

### Configure Image Column in Table

Source: https://github.com/goadmingroup/go-admin/wiki/table-components.md

Set up a table column to display images. The 'avatar' field is configured to use an image component, specifying height, width, and source from the model's value.

```go
// 列显示配置
userTable.Info.FieldList = []FieldStruct{
    {
        Head:     "头像",
        Field:    "avatar",
        TypeName: "tinyint",
        ExcuFun: func(model RowModel) string {
            return components.GetImage().SetHeight("50")
                    .SetWidth("50").SetSrc(model.Value).GetContent()
        },
    },
}
```

--------------------------------

### Define Custom Routes with Auth Middleware in GoAdmin

Source: https://context7.com/goadmingroup/go-admin/llms.txt

Register low-level routes using `eng.Data`. These routes are protected by GoAdmin's auth middleware by default. The handler function receives the GoAdmin `context.Context`. A third boolean argument can be set to `true` to skip authentication.

```go
eng.Data("POST", "/admin/api/users/:id/approve",
    func(ctx *context.Context) {
        id := ctx.Query("id")
        // perform business logic...
        ctx.JSON(http.StatusOK, map[string]interface{}{
            "status": "approved",
            "id":     id,
        })
    })

// Skip auth (public endpoint inside the admin prefix)
eng.Data("GET", "/admin/health", func(ctx *context.Context) {
    ctx.JSON(http.StatusOK, map[string]interface{}{"ok": true})
}, true)
```

--------------------------------

### FormPanel Field Options

Source: https://context7.com/goadmingroup/go-admin/llms.txt

Configure create/edit form fields with various input types, options, custom HTML, and post hooks. Supports dependent selects via Ajax and tabbed group layouts.

```go
formList := userTable.GetForm()

formList.AddField("ID", "id", db.Int, form.Default).
    FieldDisplayButCanNotEditWhenUpdate().FieldDisableWhenCreate()

formList.AddField("Gender", "gender", db.Tinyint, form.Radio).
    FieldOptions(types.FieldOptions{
        {Text: "men",   Value: "0"},
        {Text: "women", Value: "1"},
    })

// Dependent select: choosing Country triggers an Ajax call to populate City
formList.AddField("Country", "country", db.Tinyint, form.SelectSingle).
    FieldOptions(types.FieldOptions{
        {Text: "China",   Value: "0"},
        {Text: "America", Value: "1"},
    }).
    FieldOnChooseAjax("city", "/choose/country",
        func(ctx *context.Context) (bool, string, interface{}) {
            country := ctx.FormValue("value")
            if country == "0" {
                return true, "ok", selection.Options{
                    {Text: "Beijing",  ID: "beijing"},
                    {Text: "Shanghai", ID: "shanghai"},
                }
            }
            return true, "ok", selection.Options{}
        }, "", "")

// Custom HTML field
formList.AddField("Phone", "phone", db.Varchar, form.Custom).
    FieldCustomContent(`<input type="text" name="{{.Field}}" value="{{.Value}}" class="form-control">`)

// Tab groups
formList.SetTabGroups(types.
    NewTabGroups("id", "name", "gender", "country").
    AddGroup("phone", "city")).
    SetTabHeaders("Basic Info", "Contact")

// Post hook (runs after form submission)
formList.SetPostHook(func(values form2.Values) error {
    fmt.Println("form submitted:", values)
    return nil
})

formList.SetTable("users").SetTitle("Users")
```

--------------------------------

### Configure Label Column in Table

Source: https://github.com/goadmingroup/go-admin/wiki/table-components.md

Configure a table column to display labels. The 'label' field uses a label component to render the value from the model.

```go
// 列显示配置
userTable.Info.FieldList = []FieldStruct{
    {
        Head:     "标签",
        Field:    "label",
        TypeName: "tinyint",
        ExcuFun: func(model RowModel) string {
            return components.Label.GetContent(model.Value)
        },
    },
}
```

--------------------------------

### InfoPanel Field Options

Source: https://context7.com/goadmingroup/go-admin/llms.txt

Configure list view fields with options for sorting, filtering, editing, and custom display logic. Use FieldJoin for LEFT JOINs and FieldFilterable with specific form types for date ranges.

```go
info := userTable.GetInfo().SetFilterFormLayout(form.LayoutThreeCol)

// Sortable integer ID
info.AddField("ID", "id", db.Int).FieldSortable()

// Inline edit + LIKE filter
info.AddField("Name", "name", db.Varchar).
    FieldEditAble(editType.Text).
    FieldFilterable(types.FilterType{Operator: types.FilterOperatorLike})

// Custom display function (value transform)
info.AddField("Gender", "gender", db.Tinyint).
    FieldDisplay(func(model types.FieldModel) interface{} {
        switch model.Value {
        case "0":  return "men"
        case "1":  return "women"
        default:   return "unknown"
        }
    }).
    FieldFilterable(types.FilterType{FormType: form.SelectSingle}).
    FieldFilterOptions(types.FieldOptions{
        {Value: "0", Text: "men"},
        {Value: "1", Text: "women"},
    })

// LEFT JOIN from another table
info.AddField("AuthorName", "first_name", db.Varchar).
    FieldJoin(types.Join{Field: "author_id", JoinField: "id", Table: "authors"})

// DateTime range filter
info.AddField("CreatedAt", "created_at", db.Timestamp).
    FieldFilterable(types.FilterType{FormType: form.DatetimeRange})

info.SetTable("users").SetTitle("Users").SetDescription("Users")
```

--------------------------------

### Retrieve Authenticated User Outside GoAdmin Context

Source: https://context7.com/goadmingroup/go-admin/llms.txt

When working outside of a GoAdmin handler, such as in a Gin middleware, use `engine.User(ginCtx)` to retrieve the authenticated `UserModel`. Ensure to handle the case where the user is not found.

```go
// Outside GoAdmin context (e.g., in a Gin middleware)
user, ok := engine.User(ginCtx)
if !ok {
    ginCtx.AbortWithStatus(http.StatusUnauthorized)
    return
}
```

--------------------------------

### Add Fork Remote

Source: https://github.com/goadmingroup/go-admin/blob/main/CONTRIBUTING.md

Add your fork as a remote repository to the original GoAdmin clone. This is necessary for submitting pull requests.

```bash
go get github.com/GoAdminGroup/go-admin
cd $GOPATH/src/github.com/GoAdminGroup/go-admin # GOPATH is $HOME/go by default.

git remote add <FORK_NAME> <FORK_URL>
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.