Basic Usage

Use the command line to generate a data table type for the sql table, such as:

CREATE TABLE `users` (
  `id` int(11) unsigned NOT NULL AUTO_INCREMENT,
  `name` varchar(50) COLLATE utf8mb4_unicode_ci DEFAULT NULL,
  `gender` tinyint(4) DEFAULT NULL,
  `city` varchar(50) COLLATE utf8mb4_unicode_ci DEFAULT NULL,
  `ip` varchar(20) COLLATE utf8mb4_unicode_ci DEFAULT NULL,
  `phone` varchar(10) COLLATE utf8mb4_unicode_ci DEFAULT NULL,
  `created_at` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
  `updated_at` timestamp NULL DEFAULT NULL,
  PRIMARY KEY (`id`)


package datamodel

import (

func GetUserTable(ctx *context.Context) (userTable table.Table) {

    // config the table model.
    userTable = table.NewDefaultTable(table.Config{...})

    info := userTable.GetInfo()

    // set id sortable.
    info.AddField("ID", "id", db.Int).FieldSortable(true)
    info.AddField("Name", "name", db.Varchar)


    // set the title and description of table page.
        SetAction(template.HTML(`<a href=""><i class="fa fa-google"></i></a>`))  // custom operation button


Add Field

// Add a field with the field title ID, field name id, field type int
info.AddField("ID", "id", db.Int)

// Add the second field, the field title is Name, the field name is name, and the field type is varchar
info.AddField("Name", "name", db.Varchar)

// Add a third field, a field that does not exist in the sql table
info.AddField("Custom", "custom", db.Varchar)

Modify display output

// Output the corresponding content according to the value of the field
info.AddField("Gender", "gender", db.Tinyint).FieldDisplay(func(model types.FieldModel) interface{} {
    if model.Value == "0" {
        return "men"
    if model.Value == "1" {
        return "women"
    return "unknown"

// Output html
info.AddField("Name", "name", db.Varchar).FieldDisplay(func(model types.FieldModel) interface{} {    
    return "<span class='label'>" +  model.Value + "</span>"

The anonymous function received by the FieldDisplay method binds the data object of the current row, and can call other field data of the current row in it.

info.AddField("First Name", "first_name", db.Varchar).FieldHide()
info.AddField("Last Name", "last_name", db.Varchar).FieldHide()

// non-existing field columns
info.AddField("Full Name", "full_name", db.Varchar).FieldDisplay(func(model types.FieldModel) interface{} {    
    return model.Row["first_name"].(string) + " " + model.Row["last_name"].(string)

Hide create button


Hide edit button


Hide export button


Hide delete button


Hide detail button


Hide Row Selector


Hide filter area by default


Pre query

// field, operator, argument
info.Where("type", "=", 0)
// raw sql
info.WhereRaw("type = 0 or sex = 1")
// or statement, the following will generate: type = 3 or type = 0
info.Where("type", "=", 3).WhereOr("type", "=", 0) 

Set export value

// Set the export handled without display native value, the default value to show the process

Set filter area form layout

info.SetFilterFormLayout(layout form.Layout)

Set selection form item width

// Set the title width, 1 to 12, the default is 2
info.SetFilterFormHeadWidth(w int)
// Set input box width, 1 to 12, the default is 10, the sum of two value is 12
info.SetFilterFormInputWidth(w int)

Set default order rule

// increase
// decrease

Set default sort field


Join Table

The table needs to set the table name and the table field

info.AddField("Role Name", "role_name", db.Varchar).FieldJoin(types.Join{
    Table: "role",         // table name which you want to join 
    Field: "id",           // table field name of your own 
    JoinField: "user_id",  // table field name of the table which you want to join 

It will generate a sql statement like this:

select ..., role.`role_name` from users left join role on users.`id` = role.`user_id` where ...

Add Button

If you want to add some function button, then you can do like this:

info.AddButton(title template.HTML, icon string, action Action, color ...template.HTML)

title is the title of Button, iconis the icon of Button, actionis a set of operations of Button and color are the background color and text color.

For example:

import (

info.AddButton("Today Data", icon.Save, action.PopUp("/admin/data/analyze", "Data Analysis"))

Added a popup operation, will go to request the corresponding routing, corresponding routing return is the content of the popup, "data analysis" as the title for the popup.

Operation of class Action as an interface, as follows:

type Action interface {
    // Returns the corresponding JS
    Js() template.JS
    // Access to the class
    BtnClass() template.HTML
    // Returns the button properties
    BtnAttribute() template.HTML
    // Returns the extra HTML
    ExtContent() template.HTML
    // The set up button ID, supply Js () method call
    SetBtnId(btnId string)
    // SetData
    SetBtnData(data interface{})
    // Return request node, including routing method and the corresponding controller
    GetCallbacks() context.Node

You can implement a Action yourself or use the Action provided of framework. There are three default Action: PopUp, Ajax and Jump.

import (

// Return a Jump Action,parameter one is the url,two is the extra html.
// Jump Action is a link jump operation. If you need to carry the id  of operation row, you can do like this:
// action.Jump("/admin/info/manager?id={{.Id}}")
// {{.Id}} is the placeholder of id.
action.JumpInNewTab("/admin/info/manager", "管理员")

// Return a PopUp Action, parameter one is the url, two is the title, three is handler method.
// When user click the button, the request will be sent to the handler with the row id.
action.PopUp("/admin/popup", "Popup Example", func(ctx *context.Context) (success bool, msg string, data interface{}) {
    // Access to the paramters:
    // ctx.FormValue["id"]
    // ctx.FormValue["ids"]

    // The data return is the content of popup.
    return true, "", "<h2>hello world</h2>"

// Return a Ajax Action, parameter one is the url, two is the handler method.
func(ctx *context.Context) (success bool, msg string, data interface{}) {
    // Access to the paramters:
    // ctx.FormValue["id"]
    // ctx.FormValue["ids"]
    return true, "success", ""

New drop-down filter button

// Parameters, first is the title, the second is options, third is the action
info.AddSelectBox("gender", types.FieldOptions{
        {Value: "", Text: ""},
        {Value: "0", Text: "men"},
        {Value: "1", Text: "women"},
    }, action.FieldFilter("gender"))

Parameter of FieldFilter is the field name for filter.

Add column button

Sometimes want to add a column of action buttons, you can use:

info.AddColumnButtons(head string, buttons ...Button)

Add a column

If you simply want to increase a column, with database field is not a one to one, you can use this API.

info.AddColumn(head string, fn FieldFilterFn)

Configure Detail Page

You can customize details page display content.

package datamodel

import (

func GetUserTable(ctx *context.Context) (userTable table.Table) {

    userTable = table.NewDefaultTable(table.Config{...})

    detail := userTable.GetDetail()

    detail.AddField("ID", "id", db.Int)
    detail.AddField("Name", "name", db.Varchar)

        SetTitle("Users Detail").
        SetDescription("Users Detail")


If you want to copy list page fields to detail, and add external fields.

detail := userTable.GetDetailFromInfo()
detail.AddField("External", "external", db.Varchar)

Notice: if it is not set, the default Settings display using list page.

Custom data source

If you want to define a data source, don't want to read automatically from the SQL database, you have two ways:

Writing a custom data source function

package main

import (

func GetUserTable(ctx *context.Context) (userTable table.Table) {

    userTable = table.NewDefaultTable(table.Config{

    info := externalTable.GetInfo()
    info.AddField("ID", "id", db.Int).FieldSortable()
    info.AddField("Title", "title", db.Varchar)

        // Return values: the first is the list of data, the second for the amount of data
        SetGetDataFn(func(param parameter.Parameters) (data []map[string]interface{}, size int) {
            // Pay attention to the need to deal with the following two cases

            // Case 1: return all data

            // Situation 2: returns the data corresponding to the specified primary key 

            // Parameter specification
            // param.SortField     
            // param.Fields        
            // param.SortType      
            // param.Columns       
            // param.PageSize      
            // param.Page          

            return []map[string]interface{}{
                        "id":    10,
                        "title": "this is a title",
                    }, {
                        "id":    11,
                        "title": "this is a title2",
                    }, {
                        "id":    12,
                        "title": "this is a title3",
                    }, {
                        "id":    13,
                        "title": "this is a title4",
                }, 10


By setting the data source URL

Set up the data source link, GoAdmin will automatically pull data from the data source link. As follows:

package main

import (

func GetUserTable(ctx *context.Context) (userTable table.Table) {

    // Initialization data table model, and set up the data source url
    userTable = table.NewDefaultTable(table.Config{
        SourceURL: "http://xx.xx.xx.xx/xxx",

    info := userTable.GetInfo()

    info.AddField("ID", "id", db.Int).FieldSortable(true)
    info.AddField("Name", "name", db.Varchar)


After setting up the data source url, need to satisfy the returned as JSON data format, data source and return according to the following structure:

    "data": [
            "id": 1,
            "id": 2,
    "size": 10


data: For the data table data is an array, each array item said a row, the key of a data item said the field name, the corresponding value indicates that the field values.

size: is the amount of all the data

In the data source url corresponding interface, will receive the following url parameters:

__page: the page number

__pageSize: size of per page data

__sort: sort field name

__sort_type: sort type

__columns: hidden fields

Interfaces need to take the corresponding URL parameters for processing returns the corresponding JSON format data, GoAdmin data will be displayed.