plugin

Documentation

Index

• Variables
• func MakePlugin[T Base](super bool) (CallFn[T], RegisterFn[T])
• func Register(p Base)
• func Translate(ctx *GinContext, key string) string
• type Base
• type Cache
• type CallFn
• type Caller
• type Config
• type ConfigField
• type ConfigFieldOption
• type ConfigFieldUIOptions
• type ConfigType
• type Connector
• type ExternalLoginUserInfo
• type Filter
• type GinContext
• type Info
• type InputType
• type Parser
• type RegisterFn
• type Stack
• type Storage
• type TranslateFn
• type Translator
  • func MakeTranslator(key string) Translator
  • func (t Translator) Translate(ctx *GinContext) string
• type UploadFileResponse
• type UploadSource

Variables

var (
	// CallBase is a function that calls all registered base plugins
	CallBase, _ = MakePlugin[Base](true)
)

var (
	// CallCache is a function that calls all registered cache
	CallCache, _ = MakePlugin[Cache](false)
)

var (
	// CallConfig is a function that calls all registered config plugins
	CallConfig, _ = MakePlugin[Config](true)
)

var (
	// CallConnector is a function that calls all registered connectors
	CallConnector, _ = MakePlugin[Connector](false)
)

var (
	// CallFilter is a function that calls all registered parsers
	CallFilter, _ = MakePlugin[Filter](false)
)

var (
	// CallParser is a function that calls all registered parsers
	CallParser, _ = MakePlugin[Parser](false)
)

var (
	// CallStorage is a function that calls all registered storage
	CallStorage, _ = MakePlugin[Storage](false)
)

var (
	DefaultFileTypeCheckMapping = map[UploadSource]map[string]bool{
		UserAvatar: {
			".jpg":  true,
			".jpeg": true,
			".png":  true,
		},
		UserPost: {
			".jpg":  true,
			".jpeg": true,
			".png":  true,
		},
		AdminBranding: {
			".ico": true,
		},
	}
)

var StatusManager = statusManager{
	// contains filtered or unexported fields
}

StatusManager is a manager that manages the status of plugins Init Plugins: json.Unmarshal([]byte(`{"plugin1": true, "plugin2": false}`), &plugin.StatusManager) Dump Status: json.Marshal(plugin.StatusManager)

Functions

func MakePlugin

func MakePlugin[T Base](super bool) (CallFn[T], RegisterFn[T])

MakePlugin creates a plugin caller and register stack manager The parameter super presents if the plugin can be disabled. It returns a register function and a caller function The register function is used to register a plugin, it will be called in the plugin's init function The caller function is used to call all registered plugins

func Register

func Register(p Base)

Register registers a plugin

func Translate

func Translate(ctx *GinContext, key string) string

Translate translates the key to the current language of the context

Types

type Base

type Base interface {
	// Info returns the plugin information
	Info() Info
}

Base is the base plugin

type Cache

type Cache interface {
	Base

	GetString(ctx context.Context, key string) (string, error)
	SetString(ctx context.Context, key, value string, ttl time.Duration) error
	GetInt64(ctx context.Context, key string) (int64, error)
	SetInt64(ctx context.Context, key string, value int64, ttl time.Duration) error
	Del(ctx context.Context, key string) error
	Flush(ctx context.Context) error
}

type CallFn

type CallFn[T Base] func(fn Caller[T]) error

type Caller

type Caller[T Base] func(p T) error

type Config

type Config interface {
	Base

	// ConfigFields returns the list of config fields
	ConfigFields() []ConfigField

	// ConfigReceiver receives the config data, it calls when the config is saved or initialized.
	// We recommend to unmarshal the data to a struct, and then use the struct to do something.
	// The config is encoded in JSON format.
	// It depends on the definition of ConfigFields.
	ConfigReceiver(config []byte) error
}

type ConfigField

type ConfigField struct {
	Name        string               `json:"name"`
	Type        ConfigType           `json:"type"`
	Title       Translator           `json:"title"`
	Description Translator           `json:"description"`
	Required    bool                 `json:"required"`
	Value       any                  `json:"value"`
	UIOptions   ConfigFieldUIOptions `json:"ui_options"`
	Options     []ConfigFieldOption  `json:"options,omitempty"`
}

type ConfigFieldOption

type ConfigFieldOption struct {
	Label Translator `json:"label"`
	Value string     `json:"value"`
}

type ConfigFieldUIOptions

type ConfigFieldUIOptions struct {
	Placeholder Translator `json:"placeholder,omitempty"`
	Rows        string     `json:"rows,omitempty"`
	InputType   InputType  `json:"input_type,omitempty"`
	Label       Translator `json:"label,omitempty"`
}

type ConfigType

type ConfigType string

const (
	ConfigTypeInput    ConfigType = "input"
	ConfigTypeTextarea ConfigType = "textarea"
	ConfigTypeCheckbox ConfigType = "checkbox"
	ConfigTypeRadio    ConfigType = "radio"
	ConfigTypeSelect   ConfigType = "select"
	ConfigTypeUpload   ConfigType = "upload"
	ConfigTypeTimezone ConfigType = "timezone"
	ConfigTypeSwitch   ConfigType = "switch"
)

type Connector

type Connector interface {
	Base

	// ConnectorLogoSVG presents the logo in svg format
	ConnectorLogoSVG() string

	// ConnectorName presents the name of the connector
	// e.g. Facebook, Twitter, Instagram
	ConnectorName() Translator

	// ConnectorSlugName presents the slug name of the connector
	// Please use lowercase and hyphen as the separator
	// e.g. facebook, twitter, instagram
	ConnectorSlugName() string

	// ConnectorSender presents the sender of the connector
	// It handles the start endpoint of the connector
	// receiverURL is the whole URL of the receiver
	ConnectorSender(ctx *GinContext, receiverURL string) (redirectURL string)

	// ConnectorReceiver presents the receiver of the connector
	// It handles the callback endpoint of the connector, and returns the
	ConnectorReceiver(ctx *GinContext, receiverURL string) (userInfo ExternalLoginUserInfo, err error)
}

type ExternalLoginUserInfo

type ExternalLoginUserInfo struct {
	// required. The unique user ID provided by the third-party login
	ExternalID string
	// optional. This name is used preferentially during registration
	DisplayName string
	// optional. This username is used preferentially during registration
	Username string
	// optional. If email exist will bind the existing user
	// IMPORTANT: The email must have been verified. If the plugin can't guarantee the email is verified, please leave it empty.
	Email string
	// optional. The avatar URL provided by the third-party login platform
	Avatar string
	// optional. The original user information provided by the third-party login platform
	MetaInfo string
}

ExternalLoginUserInfo external login user info

type Filter

type Filter interface {
	Base
	FilterText(text string) (err error)
}

type GinContext

type GinContext = gin.Context

GinContext is a wrapper of gin.Context We export it to make it easy to use in plugins

type Info

type Info struct {
	Name        Translator
	SlugName    string
	Description Translator
	Author      string
	Version     string
	Link        string
}

Info presents the plugin information

type InputType

type InputType string

const (
	InputTypeText     InputType = "text"
	InputTypeColor    InputType = "color"
	InputTypeDate     InputType = "date"
	InputTypeDatetime InputType = "datetime-local"
	InputTypeEmail    InputType = "email"
	InputTypeMonth    InputType = "month"
	InputTypeNumber   InputType = "number"
	InputTypePassword InputType = "password"
	InputTypeRange    InputType = "range"
	InputTypeSearch   InputType = "search"
	InputTypeTel      InputType = "tel"
	InputTypeTime     InputType = "time"
	InputTypeUrl      InputType = "url"
	InputTypeWeek     InputType = "week"
)

type Parser

type Parser interface {
	Base
	Parse(text string) (string, error)
}

type RegisterFn

type RegisterFn[T Base] func(p T)

type Stack

type Stack[T Base] struct {
	// contains filtered or unexported fields
}

type Storage

type Storage interface {
	Base

	// UploadFile uploads a file to storage.
	// The file is in the Form of the ctx and the key is "file"
	UploadFile(ctx *GinContext, source UploadSource) UploadFileResponse
}

type TranslateFn

type TranslateFn func(ctx *GinContext) string

TranslateFn presents a generator of translated string. We use it to delegate the translation work outside the plugin.

type Translator

type Translator struct {
	// contains filtered or unexported fields
}

Translator contains a function that translates the key to the current language of the context

func MakeTranslator

func MakeTranslator(key string) Translator

MakeTranslator generates a translator from the key

func (Translator) Translate

func (t Translator) Translate(ctx *GinContext) string

Translate translates the key to the current language of the context

type UploadFileResponse

type UploadFileResponse struct {
	// FullURL is the URL that can be used to access the file
	FullURL string
	// OriginalError is the error returned by the storage plugin. It is used for debugging.
	OriginalError error
	// DisplayErrorMsg is the error message that will be displayed to the user.
	DisplayErrorMsg Translator
}

type UploadSource

type UploadSource string

const (
	UserAvatar    UploadSource = "user_avatar"
	UserPost      UploadSource = "user_post"
	AdminBranding UploadSource = "admin_branding"
)