GoAdmin

GoAdmin is a framework for building data visualization and management platforms in Golang. Key features include:

• High Productivity: Build a functional admin backend in under 10 minutes.
• Theming: Default theme is adminlte, with more themes in development.
• Plugin System: Extensible architecture via plugins.
• Authentication: Out-of-the-box RBAC (Role-Based Access Control) system.
• Framework Support: Compatible with most major Go frameworks for easy integration and extension.

You can quickly bootstrap a new GoAdmin project using the adm command-line tool. Follow these steps to initialize a web-based project:

1. Create and enter a new project directory.
2. Install the adm tool using go install.
3. Initialize the project with the web template.

This process sets up the basic structure required to start building your admin panel.

$ mkdir new_project && cd new_project
$ go install github.com/GoAdminGroup/adm@latest
$ adm init web

GoAdmin uses Go modules for dependency management. This requires Go version > 1.11 and git to be installed.

To add or update dependencies, use go get. After modifying dependencies, you must tidy the module files and vendor them to ensure the go.mod, go.sum, and vendor directory are consistent before committing.

# 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

# Clean up and vendor dependencies
go mod tidy
go mod vendor
git add go.mod go.sum vendor
git commit

To contribute to GoAdmin, fork the master branch and clone it into your $GOPATH/src/github.com/GoAdminGroup/go-admin directory.

Note: Running go get github.com/GoAdminGroup/go-admin may return a warning stating no Go files in ..., which is expected behavior.

Before submitting any code, you must run the test suite using the provided Makefile.

GoAdmin provides several example repositories depending on your preferred architecture and frontend stack:

• Pure Golang: A simple implementation with minimal dependencies.
• Golang with Frontend Template: Allows you to customize the frontend templates yourself.
• Golang with Vue: Designed for developers with Vue.js experience.

Refer to these examples to understand how to integrate GoAdmin into your specific application structure.

When using the Docker Compose setup, the following service configurations are exposed:

goadmin service

• Image: josingcjx/goadmin:1.1
• Volume Mount: The local directory . is mounted to /home/goadmin inside the container.
• Command: Defaults to /bin/bash.

Database services

• MySQL:
  • Port: 3306:3306
  • Environment Variable: MYSQL_ROOT_PASSWORD (default: goadmin)
• PostgreSQL:
  • Port: 5432:5432
  • Environment Variable: POSTGRES_PASSWORD (default: goadmin)

Portainer service

• Port: 9000:9000
• Volume Mounts:
  • /var/run/docker.sock:/var/run/docker.sock (required for Docker management)
  • portainer:/data

The template includes a built-in gallery system. When an element with the class .gallery contains an anchor <a> tag pointing to an image file (ending in .jpg, .gif, .png, or .mp4), clicking the link will open the image in a modal.

Behavior:

• Clicking an image link opens a modal and sets the image src to the link's href.
• Clicking inside the .modal or pressing the Escape key closes the modal.
• The modal includes a loading state (.loaded class) and handles focus management.

To create a custom plugin in go-admin, define a struct that embeds *plugins.Base. You must export a variable (conventionally named Plugin) that initializes your struct with a plugins.Base instance containing a unique PlugName.

Implement the InitPlugin(srv service.List) method to handle plugin initialization. Inside this method, call example.InitBase(srv, "plugname") to set up the base plugin functionality and use the provided service.List to access system services.

type Example struct {
	*plugins.Base
}

var Plugin = &Example{
	Base: &plugins.Base{PlugName: "example"},
}

func (example *Example) InitPlugin(srv service.List) {
	example.InitBase(srv, "example")
	// Perform further initialization here
}

The scroll zone feature (which allows scrolling by hovering over screen edges) can be manually paused or unpaused by triggering a custom event on the #wrapper element.

To pause the scroll zones, trigger the ---pauseScrollZone event. The system will automatically unpause after a 500ms delay.

Custom plugins can define their own routing logic by creating a *context.App instance. Within your plugin's initialization flow, use context.NewApp() to create a new application instance, then use app.Group(prefix) to define route groups.

Routes can be protected using auth.Middleware and can access database connections via db.GetConnection(srv). The resulting *context.App should be assigned to the Plugin.App field so the core system can utilize it.

func (example *Example) initRouter(prefix string, srv service.List) *context.App {
	app := context.NewApp()
	route := app.Group(prefix)
	route.GET("/example", auth.Middleware(db.GetConnection(srv)), example.TestHandler)
	return app
}

// In InitPlugin:
// Plugin.App = example.initRouter(c.Prefix(), srv)