QOR Admin

To set up a basic QOR Admin interface, initialize a new admin.Admin instance with a GORM database connection, add your models using AddResource, and mount the admin interface to an HTTP multiplexer using MountTo.

package main

import (
  "fmt"
  "net/http"
  "github.com/jinzhu/gorm"
  _ "github.com/mattn/go-sqlite3"
  "github.com/qor/admin"
)

// Create a GORM-backend model
type User struct {
  gorm.Model
  Name string
}

// Create another GORM-backend model
type Product struct {
  gorm.Model
  Name        string
  Description string
}

func main() {
  DB, _ := gorm.Open("sqlite3", "demo.db")
  DB.AutoMigrate(&User{}, &Product{})

  // Initialize
  Admin := admin.New(&admin.AdminConfig{DB: DB})

  // Allow to use Admin to manage User, Product
  Admin.AddResource(&User{})
  Admin.AddResource(&Product{})

  // initialize an HTTP request multiplexer
  mux := http.NewServeMux()

  // Mount admin interface to mux
  Admin.MountTo("/admin", mux)

  fmt.Println("Listening on: 9000")
  http.ListenAndServe(":9000", mux)
}

For a has one relationship (e.g., Factory has one Manager), the 'one' side (Manager) must include resource.CompositePrimaryKeyField. The parent struct must also explicitly include the versioned ID fields (e.g., ManagerID and ManagerVersionName).

Configure the remote selector's ID meta field with a Valuer using resource.GenCompositePrimaryKey. Apply it to the parent resource using admin.SelectOneConfig.

// 1. Define models
type Factory struct {
	gorm.Model
	Name string
	publish2.Version

	ManagerID          uint
	ManagerVersionName string // Required. in "xxxVersionName" format.
	Manager            Manager
}

type Manager struct {
	gorm.Model
	Name string
	publish2.Version

	// github.com/qor/qor/resource
	resource.CompositePrimaryKeyField // Required
}

// 2. Define remote selector
func generateRemoteManagerSelector(adm *admin.Admin) (res *admin.Resource) {
	res = adm.AddResource(&Manager{}, &admin.Config{Name: "ManagerSelector"})
	res.IndexAttrs("ID", "Name")

	res.Meta(&admin.Meta{
	Name: "ID",
	Valuer: func(value interface{}, ctx *qor.Context) interface{} {
		if r, ok := value.(*Manager); ok {
			return resource.GenCompositePrimaryKey(r.ID, r.GetVersionName())
		}
		return ""
	},
	})

	return res
}

// 3. Use in Factory resource
managerSelector := generateRemoteManagerSelector(adm)
factoryRes.Meta(&admin.Meta{
	Name: "Manager",
	Config: &admin.SelectOneConfig{
		RemoteDataResource: managerSelector,
	},
})

When using publish2.version with a has many relationship (e.g., Factory has many Items), you must ensure the 'many' side (Item) includes the resource.CompositePrimaryKeyField.

To implement a remote selector that supports composite primary keys, you must configure an ID meta field using a Valuer that calls resource.GenCompositePrimaryKey(r.ID, r.GetVersionName()). Finally, apply this to the parent resource using admin.SelectManyConfig.

// 1. Define models with CompositePrimaryKeyField on the 'many' side
type Factory struct {
	gorm.Model
	Name string

	publish2.Version
	Items       []Item `gorm:"many2many:factory_items;association_autoupdate:false"`
	ItemsSorter sorting.SortableCollection
}

type Item struct {
	gorm.Model
	Name string
	publish2.Version

	// github.com/qor/qor/resource
	resource.CompositePrimaryKeyField // Required
}

// 2. Define a remote resource selector with a custom ID Valuer
func generateRemoteItemSelector(adm *admin.Admin) (res *admin.Resource) {
	res = adm.AddResource(&Item{}, &admin.Config{Name: "ItemSelector"})
	res.IndexAttrs("ID", "Name")

	res.Meta(&admin.Meta{
	Name: "ID",
	Valuer: func(value interface{}, ctx *qor.Context) interface{} {
		if r, ok := value.(*Item); ok {
			return resource.GenCompositePrimaryKey(r.ID, r.GetVersionName())
		}
		return ""
	},
	})

	return res
}

// 3. Use it in the Factory resource
itemSelector := generateRemoteItemSelector(adm)
factoryRes.Meta(&admin.Meta{
	Name: "Items",
	Config: &admin.SelectManyConfig{
		RemoteDataResource: itemSelector,
	},
})

The Meta struct is the core configuration object used to define how a specific field within a resource is rendered, processed, and handled in the admin interface. It wraps resource.Meta and provides additional controls for labeling, typing, and custom logic.

Key fields include:

• Name: The logical name of the field.
• FieldName: The actual field name on the struct.
• Label: The human-readable label (defaults to humanized Name).
• Type: The UI component type (e.g., string, number, datetime, single_edit, collection_edit).
• Setter: A function to save the value to the record.
• Valuer: A function to retrieve the value from the record.
• FormattedValuer: A function to retrieve a formatted version of the value for display.
• Permission: Role-based access control for this specific field.
• Config: An implementation of MetaConfigInterface for advanced configuration.

// Example of conceptual usage (not a direct API call)
meta := &admin.Meta{
    Name:     "Email",
    FieldName: "Email",
    Type:     "string",
    Setter: func(record interface{}, metaValue *resource.MetaValue, context *qor.Context) {
        // Custom logic to save the email
    },
}