core

package
v1.8.6 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Dec 13, 2021 License: MIT Imports: 52 Imported by: 0

Documentation

Overview

Copyright (c) 2019 RetailDriver LLC Use of this source code is governed by a MIT

Package core provides different functions like error-reporting, logging, localization, etc. in order to make it easier to create transports. Usage: 

package main

import (
    "os"
    "fmt"
    "html/template"

    "github.com/gin-gonic/gin"
    "github.com/retailcrm/mg-transport-core/core"
)

func main() {
    app := core.New()
    app.Config = core.NewConfig("config.yml")
    app.DefaultError = "unknown_error"
    app.TranslationsPath = "./translations"

    app.ConfigureRouter(func(engine *gin.Engine) {
        engine.Static("/static", "./static")
        engine.HTMLRender = app.CreateRenderer(
            func(renderer *core.Renderer) {
                // insert templates here. Example:
                r.Push("home", "templates/layout.html", "templates/home.html")
            },
            template.FuncMap{},
        )
    })

    if err := app.Prepare().Run(); err != nil {
        fmt.Printf("Fatal error: %s", err.Error())
        os.Exit(1)
    }
}

Resource embedding

packr can be used to provide resource embedding, see: 

https://github.com/gobuffalo/packr/tree/master/v2

In order to use packr you must follow instruction, and provide boxes with templates, translations and assets to library. You can find instruction here: 

https://github.com/gobuffalo/packr/tree/master/v2#library-installation

Example of usage: 

package main

import (
    "os"
    "fmt"
    "html/template"
	"net/http"

    "github.com/gin-gonic/gin"
    "github.com/retailcrm/mg-transport-core/core"
)

//go:embed static
var Static fs.FS

//go:embed translations
var Translate fs.FS

//go:embed templates
var Templates fs.FS

func main() {
	staticFS, err := fs.Sub(Static, "static")
	if err != nil {
		panic(err)
	}

	translateFS, err := fs.Sub(Translate, "translate")
	if err != nil {
		panic(err)
	}

	templatesFS, err := fs.Sub(Templates, "templates")
	if err != nil {
		panic(err)
	}

    app := core.New()
    app.Config = core.NewConfig("config.yml")
    app.DefaultError = "unknown_error"
    app.TranslationsFS = translateFS

    app.ConfigureRouter(func(engine *gin.Engine) {
        engine.StaticFS("/static", http.FS(staticFS))
        engine.HTMLRender = app.CreateRendererFS(
            templatesFS,
            func(renderer *core.Renderer) {
                // insert templates here. Example:
                r.Push("home", "layout.html", "home.html")
            },
            template.FuncMap{},
        )
    })

    if err := app.Prepare().Run(); err != nil {
        fmt.Printf("Fatal error: %s", err.Error())
        os.Exit(1)
    }
}

Migration generator

This library contains helper tool for transports. You can install it via go: 

$ go get -u github.com/retailcrm/mg-transport-core/cmd/transport-core-tool

Currently, it only can generate new migrations for your transport.

Index

Constants

View Source 
const LocalizerContextKey = "localizer"

LocalizerContextKey is a key which is used to store localizer in gin.Context key-value storage.

Variables

View Source 
var (
	DefaultScopes = []string{
		"integration_read",
		"integration_write",
	}
	DefaultCredentials = []string{
		"/api/integration-modules/{code}",
		"/api/integration-modules/{code}/edit",
	}
)
View Source 
var DefaultCSRFTokenGetter = func(c *gin.Context) string {
	r := c.Request

	if t := r.URL.Query().Get("csrf_token"); len(t) > 0 {
		return t
	} else if t := r.Header.Get("X-CSRF-Token"); len(t) > 0 {
		return t
	} else if t := r.Header.Get("X-XSRF-Token"); len(t) > 0 {
		return t
	} else if c.Request.Body != nil {
		data, _ := ioutil.ReadAll(c.Request.Body)
		c.Request.Body = ioutil.NopCloser(bytes.NewReader(data))
		t := r.FormValue("csrf_token")
		c.Request.Body = ioutil.NopCloser(bytes.NewReader(data))

		if len(t) > 0 {
			return t
		}
	}

	return ""
}

DefaultCSRFTokenGetter default getter.

View Source 
var DefaultClient = http.DefaultClient

DefaultClient stores original http.DefaultClient.

View Source 
var DefaultHTTPClientConfig = &HTTPClientConfig{
	Timeout:         30,
	SSLVerification: &boolTrue,
}

DefaultHTTPClientConfig is a default config for HTTP client. It will be used by Engine for building HTTP client if HTTP client config is not present in the configuration.

View Source 
var DefaultIgnoredMethods = []string{"GET", "HEAD", "OPTIONS"}

DefaultIgnoredMethods ignored methods for CSRF verifier middleware.

View Source 
var DefaultLanguage = language.English

DefaultLanguage is a base language which will be chosen if current language is unspecified.

View Source 
var DefaultLanguages = []language.Tag{
	language.English,
	language.Russian,
	language.Spanish,
}

DefaultLanguages for transports.

View Source 
var DefaultTransport = http.DefaultTransport

DefaultTransport stores original http.DefaultTransport.

View Source 
var ErrInsufficientScopes = errors.New("insufficient scopes")

ErrInsufficientScopes is wrapped by the insufficientScopesErr. If errors.Is(err, ErrInsufficientScopes) returns true then error implements ScopesList.

Functions

func BadRequest 

func BadRequest(error string) (int, interface{})

BadRequest returns ErrorResponse with code 400 Usage (with gin): 

context.JSON(BadRequest("invalid data"))

func ConnectionConfig added in v1.8.5 

func ConnectionConfig(registerURL string, scopes []string) gin.HandlerFunc

ConnectionConfig returns middleware for the one-step connection configuration route.

func DefaultCurrencies 

func DefaultCurrencies() map[string]string

DefaultCurrencies will return default currencies list for all bots.

func DefaultLocalizerBundle 

func DefaultLocalizerBundle() *i18n.Bundle

DefaultLocalizerBundle returns new localizer bundle with English as default language.

func DefaultLocalizerMatcher 

func DefaultLocalizerMatcher() language.Matcher

DefaultLocalizerMatcher returns matcher with English, Russian and Spanish tags.

func DefaultLogFormatter 

func DefaultLogFormatter() logging.Formatter

DefaultLogFormatter will return default formatter for logs.

func ErrorCollector 

func ErrorCollector(errorsList ...error) error

ErrorCollector can be used to group several error calls into one call. It is mostly useful in GORM migrations, where you should return only one errors, but several can occur. Error messages are composed into one message. For example: 

err := core.ErrorCollector(
	errors.New("first"),
	errors.New("second")
)

// Will output `first < second`
fmt.Println(err.Error())

Example with GORM migration, returns one migration error with all error messages: 

return core.ErrorCollector(
	db.CreateTable(models.Account{}, models.Connection{}).Error,
	db.Table("account").AddUniqueIndex("account_key", "channel").Error,
)

func FormatCurrencyValue added in v1.8.2 

func FormatCurrencyValue(value float32) string

func GetCSRFErrorMessage 

func GetCSRFErrorMessage(r CSRFErrorReason) string

GetCSRFErrorMessage returns generic error message for CSRFErrorReason in English (useful for logs).

func GetCurrencySymbol added in v1.7.0 

func GetCurrencySymbol(code string) string

GetCurrencySymbol returns currency symbol by it's ISO 4127 code. It returns provided currency code in uppercase if currency symbol cannot be found.

func GetEntitySHA1 

func GetEntitySHA1(v interface{}) (hash string, err error)

GetEntitySHA1 will serialize any value to JSON and return SHA1 hash of this JSON.

func GetErrorResponse 

func GetErrorResponse(statusCode int, error string) (int, interface{})

GetErrorResponse returns ErrorResponse with specified status code Usage (with gin): 

context.JSON(GetErrorResponse(http.StatusPaymentRequired, "Not enough money"))

func GetMGItemData 

func GetMGItemData(client *v1.MgClient, url string, caption string) (v1.Item, int, error)

GetMGItemData will upload file to MG by URL and return information about attachable item.

func InternalServerError 

func InternalServerError(error string) (int, interface{})

InternalServerError returns ErrorResponse with code 500 Usage (with gin): 

context.JSON(BadRequest("invalid data"))

func LocalizerBundle added in v1.5.0 

func LocalizerBundle(tag language.Tag) *i18n.Bundle

LocalizerBundle returns new localizer bundle provided language as default.

func MustGetConnectRequest added in v1.8.5 

func MustGetConnectRequest(c *gin.Context) retailcrm.ConnectRequest

MustGetConnectRequest will extract retailcrm.ConnectRequest from the request context.

func NewInsufficientScopesErr added in v1.8.4 

func NewInsufficientScopesErr(scopes []string) error

NewInsufficientScopesErr is a insufficientScopesErr constructor.

func ReplaceMarkdownSymbols 

func ReplaceMarkdownSymbols(s string) string

ReplaceMarkdownSymbols will remove markdown symbols from text.

func VerifyConnectRequest added in v1.8.5 

func VerifyConnectRequest(secret string) gin.HandlerFunc

VerifyConnectRequest will verify ConnectRequest and place it into the "request" context field.

Types

type Account 

type Account struct {
	ID                  int    `gorm:"primary_key"`
	ConnectionID        int    `gorm:"column:connection_id" json:"connectionId,omitempty"`
	Channel             uint64 `gorm:"column:channel; not null; unique" json:"channel,omitempty"`
	ChannelSettingsHash string `gorm:"column:channel_settings_hash; type:varchar(70)" binding:"max=70"`
	Name                string `gorm:"column:name; type:varchar(100)" json:"name,omitempty" binding:"max=100"`
	Lang                string `gorm:"column:lang; type:varchar(2)" json:"lang,omitempty" binding:"max=2"`
	CreatedAt           time.Time
	UpdatedAt           time.Time
}

Account model.

type Accounts 

type Accounts []Account

Accounts list.

type CSRF 

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

CSRF struct. Provides CSRF token verification.

func NewCSRF 

func NewCSRF(salt, secret, sessionName string, store sessions.Store, abortFunc CSRFAbortFunc, csrfTokenGetter CSRFTokenGetter) *CSRF

NewCSRF creates CSRF struct with specified configuration and session store. GenerateCSRFMiddleware and VerifyCSRFMiddleware returns CSRF middlewares. Salt must be different every time (pass empty salt to use random), secret must be provided, sessionName is optional - pass empty to use default, store will be used to store sessions, abortFunc will be called to return error if token is invalid, csrfTokenGetter will be used to obtain token. Usage (with random salt): 

core.NewCSRF("", "super secret", "csrf_session", store, func (c *gin.Context, reason core.CSRFErrorReason) {
	c.AbortWithStatusJSON(http.StatusBadRequest, gin.H{"error": "Invalid CSRF token"})
}, core.DefaultCSRFTokenGetter)

Note for csrfTokenGetter: if you want to read token from request body (for example, from form field) - don't forget to restore Body data! Body in http.Request is io.ReadCloser instance. Reading CSRF token from form like that: 

if t := r.FormValue("csrf_token"); len(t) > 0 {
	return t
}

will close body - and all next middlewares won't be able to read body at all! Use DefaultCSRFTokenGetter as example to implement your own token getter. CSRFErrorReason will be passed to abortFunc and can be used for better error messages.

func (*CSRF) CSRFFromContext 

func (x *CSRF) CSRFFromContext(c *gin.Context) string

CSRFFromContext returns csrf token or random token. It shouldn't return empty string because it will make csrf protection useless. e.g. any request without token will work fine, which is inacceptable.

func (*CSRF) GenerateCSRFMiddleware 

func (x *CSRF) GenerateCSRFMiddleware() gin.HandlerFunc

GenerateCSRFMiddleware returns gin.HandlerFunc which will generate CSRF token Usage: 

engine := gin.New()
csrf := NewCSRF("salt", "secret", "not_found", "incorrect", localizer)
engine.Use(csrf.GenerateCSRFMiddleware())

func (*CSRF) VerifyCSRFMiddleware 

func (x *CSRF) VerifyCSRFMiddleware(ignoredMethods []string) gin.HandlerFunc

VerifyCSRFMiddleware verifies CSRF token Usage: 

engine := gin.New()
engine.Use(csrf.VerifyCSRFMiddleware())

type CSRFAbortFunc 

type CSRFAbortFunc func(*gin.Context, CSRFErrorReason)

CSRFAbortFunc is a callback which.

type CSRFErrorReason 

type CSRFErrorReason uint8

CSRFErrorReason is a error reason type. 

const (
	// CSRFErrorNoTokenInSession will be returned if token is not present in session.
	CSRFErrorNoTokenInSession CSRFErrorReason = iota

	// CSRFErrorCannotStoreTokenInSession will be returned if middleware cannot store token in session.
	CSRFErrorCannotStoreTokenInSession

	// CSRFErrorIncorrectTokenType will be returned if data type of token in session is not string.
	CSRFErrorIncorrectTokenType

	// CSRFErrorEmptyToken will be returned if token in session is empty.
	CSRFErrorEmptyToken

	// CSRFErrorTokenMismatch will be returned in case of invalid token.
	CSRFErrorTokenMismatch
)

type CSRFTokenGetter 

type CSRFTokenGetter func(*gin.Context) string

CSRFTokenGetter func type.

type Config 

type Config struct {
	Version          string            `yaml:"version"`
	LogLevel         logging.Level     `yaml:"log_level"`
	Database         DatabaseConfig    `yaml:"database"`
	SentryDSN        string            `yaml:"sentry_dsn"`
	HTTPServer       HTTPServerConfig  `yaml:"http_server"`
	Debug            bool              `yaml:"debug"`
	UpdateInterval   int               `yaml:"update_interval"`
	ConfigAWS        ConfigAWS         `yaml:"config_aws"`
	TransportInfo    Info              `yaml:"transport_info"`
	HTTPClientConfig *HTTPClientConfig `yaml:"http_client"`
}

Config struct.

func NewConfig 

func NewConfig(path string) *Config

NewConfig reads configuration file and returns config instance Usage: 

NewConfig("config.yml")

func (Config) GetAWSConfig 

func (c Config) GetAWSConfig() ConfigAWS

GetAWSConfig AWS configuration.

func (*Config) GetConfigData 

func (c *Config) GetConfigData(path string) []byte

GetConfigData returns config file data in form of byte sequence.

func (Config) GetDBConfig 

func (c Config) GetDBConfig() DatabaseConfig

GetDBConfig database configuration.

func (Config) GetHTTPClientConfig 

func (c Config) GetHTTPClientConfig() *HTTPClientConfig

GetHTTPClientConfig returns http client config.

func (Config) GetHTTPConfig 

func (c Config) GetHTTPConfig() HTTPServerConfig

GetHTTPConfig server configuration.

func (Config) GetLogLevel 

func (c Config) GetLogLevel() logging.Level

GetLogLevel log level.

func (Config) GetSentryDSN 

func (c Config) GetSentryDSN() string

GetSentryDSN sentry connection dsn.

func (Config) GetTransportInfo 

func (c Config) GetTransportInfo() InfoInterface

GetTransportInfo transport basic data.

func (Config) GetUpdateInterval 

func (c Config) GetUpdateInterval() int

GetUpdateInterval user data update interval.

func (Config) GetVersion 

func (c Config) GetVersion() string

GetVersion transport version.

func (Config) IsDebug 

func (c Config) IsDebug() bool

IsDebug debug flag.

func (*Config) LoadConfig 

func (c *Config) LoadConfig(path string) *Config

LoadConfig read & load configuration file.

func (*Config) LoadConfigFromData 

func (c *Config) LoadConfigFromData(data []byte) *Config

LoadConfigFromData loads config from byte sequence.

type ConfigAWS 

type ConfigAWS struct {
	AccessKeyID     string `yaml:"access_key_id"`
	SecretAccessKey string `yaml:"secret_access_key"`
	Region          string `yaml:"region"`
	Bucket          string `yaml:"bucket"`
	FolderName      string `yaml:"folder_name"`
	ContentType     string `yaml:"content_type"`
}

ConfigAWS struct.

type ConfigInterface 

type ConfigInterface interface {
	GetVersion() string
	GetSentryDSN() string
	GetLogLevel() logging.Level
	GetHTTPConfig() HTTPServerConfig
	GetDBConfig() DatabaseConfig
	GetAWSConfig() ConfigAWS
	GetTransportInfo() InfoInterface
	GetHTTPClientConfig() *HTTPClientConfig
	GetUpdateInterval() int
	IsDebug() bool
}

ConfigInterface settings data structure.

type Connection 

type Connection struct {
	ID        int    `gorm:"primary_key"`
	ClientID  string `gorm:"column:client_id; type:varchar(70); not null; unique" json:"clientId,omitempty"`
	Key       string `gorm:"column:api_key; type:varchar(100); not null" json:"api_key,omitempty" binding:"required,max=100"`
	URL       string `gorm:"column:api_url; type:varchar(255); not null" json:"api_url,omitempty" binding:"required,validateCrmURL,max=255"` // nolint:lll
	GateURL   string `gorm:"column:mg_url; type:varchar(255); not null;" json:"mg_url,omitempty" binding:"max=255"`
	GateToken string `gorm:"column:mg_token; type:varchar(100); not null; unique" json:"mg_token,omitempty" binding:"max=100"`
	CreatedAt time.Time
	UpdatedAt time.Time
	Active    bool      `json:"active,omitempty"`
	Accounts  []Account `gorm:"foreignkey:ConnectionID"`
}

Connection model.

type CrmDomains added in v1.7.7 

type CrmDomains struct {
	CreateDate string   `json:"createDate"`
	Domains    []Domain `json:"domains"`
}

type DatabaseConfig 

type DatabaseConfig struct {
	Connection         interface{} `yaml:"connection"`
	Logging            bool        `yaml:"logging"`
	TablePrefix        string      `yaml:"table_prefix"`
	MaxOpenConnections int         `yaml:"max_open_connections"`
	MaxIdleConnections int         `yaml:"max_idle_connections"`
	ConnectionLifetime int         `yaml:"connection_lifetime"`
}

DatabaseConfig struct.

type Domain added in v1.7.7 

type Domain struct {
	Domain string `json:"domain"`
}

type Engine 

type Engine struct {
	Localizer
	ORM
	Sentry
	Utils

	PreloadLanguages []language.Tag
	Sessions         sessions.Store
	Config           ConfigInterface
	LogFormatter     logging.Formatter
	// contains filtered or unexported fields
}

Engine struct.

func New 

func New() *Engine

New Engine instance (must be configured manually, gin can be accessed via engine.Router() directly or engine.ConfigureRouter(...) with callback).

func (*Engine) BuildHTTPClient 

func (e *Engine) BuildHTTPClient(certs *x509.CertPool, replaceDefault ...bool) *Engine

BuildHTTPClient builds HTTP client with provided configuration.

func (*Engine) ConfigureRouter 

func (e *Engine) ConfigureRouter(callback func(*gin.Engine)) *Engine

ConfigureRouter will call provided callback with current gin.Engine, or panic if engine is not present.

func (*Engine) CreateRenderer 

func (e *Engine) CreateRenderer(callback func(*Renderer), funcs template.FuncMap) Renderer

CreateRenderer with translation function.

func (*Engine) CreateRendererFS 

func (e *Engine) CreateRendererFS(
	templatesFS fs.FS,
	callback func(*Renderer),
	funcs template.FuncMap,
) Renderer

CreateRendererFS with translation function and embedded files.

func (*Engine) GenerateCSRFMiddleware 

func (e *Engine) GenerateCSRFMiddleware() gin.HandlerFunc

GenerateCSRFMiddleware returns CSRF generator middleware Usage: 

engine.Router().Use(engine.GenerateCSRFMiddleware())

func (*Engine) GetCSRFToken 

func (e *Engine) GetCSRFToken(c *gin.Context) string

GetCSRFToken returns CSRF token from provided context.

func (*Engine) GetHTTPClientConfig added in v1.7.4 

func (e *Engine) GetHTTPClientConfig() *HTTPClientConfig

GetHTTPClientConfig returns configuration for HTTP client.

func (*Engine) HTTPClient 

func (e *Engine) HTTPClient() *http.Client

HTTPClient returns inner http client or default http client.

func (*Engine) InitCSRF 

func (e *Engine) InitCSRF(secret string, abortFunc CSRFAbortFunc, getter CSRFTokenGetter) *Engine

InitCSRF initializes CSRF middleware. engine.Sessions must be already initialized, use engine.WithCookieStore or engine.WithFilesystemStore for that. Syntax is similar to core.NewCSRF, but you shouldn't pass sessionName, store and salt.

func (*Engine) JobManager added in v1.2.0 

func (e *Engine) JobManager() *JobManager

JobManager will return singleton JobManager from Engine.

func (*Engine) Logger 

func (e *Engine) Logger() LoggerInterface

Logger returns current logger.

func (*Engine) Prepare 

func (e *Engine) Prepare() *Engine

Prepare engine for start.

func (*Engine) Router 

func (e *Engine) Router() *gin.Engine

Router will return current gin.Engine or panic if it's not present.

func (*Engine) Run 

func (e *Engine) Run() error

Run gin.Engine loop, or panic if engine is not present.

func (*Engine) SetHTTPClient 

func (e *Engine) SetHTTPClient(client *http.Client) *Engine

SetHTTPClient sets HTTP client to engine.

func (*Engine) SetLogger added in v1.3.0 

func (e *Engine) SetLogger(l LoggerInterface) *Engine

SetLogger sets provided logger instance to engine.

func (*Engine) TemplateFuncMap 

func (e *Engine) TemplateFuncMap(functions template.FuncMap) template.FuncMap

TemplateFuncMap combines func map for templates.

func (*Engine) VerifyCSRFMiddleware 

func (e *Engine) VerifyCSRFMiddleware(ignoredMethods []string) gin.HandlerFunc

VerifyCSRFMiddleware returns CSRF verifier middleware Usage: 

engine.Router().Use(engine.VerifyCSRFMiddleware(core.DefaultIgnoredMethods))

func (*Engine) WithCookieSessions 

func (e *Engine) WithCookieSessions(keyLength ...int) *Engine

WithCookieSessions generates new CookieStore with optional key length. Default key length is 32 bytes.

func (*Engine) WithFilesystemSessions 

func (e *Engine) WithFilesystemSessions(path string, keyLength ...int) *Engine

WithFilesystemSessions generates new FilesystemStore with optional key length. Default key length is 32 bytes.

type ErrorHandlerFunc 

type ErrorHandlerFunc func(recovery interface{}, c *gin.Context)

ErrorHandlerFunc will handle errors.

type ErrorResponse 

type ErrorResponse struct {
	Error string `json:"error"`
}

ErrorResponse struct.

type ErrorsResponse added in v1.6.0 

type ErrorsResponse struct {
	Error []string `json:"error"`
}

ErrorsResponse struct.

type HTTPClientBuilder 

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

HTTPClientBuilder builds http client with mocks (if necessary) and timeout. Example: 

// Build HTTP client with timeout = 10 sec, without SSL certificates verification and with mocked google.com
client, err := NewHTTPClientBuilder().
	SetTimeout(10).
	SetMockAddress("api_mock:3004").
	AddMockedDomain("google.com").
	SetSSLVerification(false).
	Build()

if err != nil {
	fmt.Print(err)
}

// Actual response will be returned from "api_mock:3004" (it should provide any ssl certificate)
if resp, err := client.Get("https://google.com"); err == nil {
	if data, err := ioutil.ReadAll(resp.Body); err == nil {
		fmt.Printf("Data: %s", string(data))
	} else {
		fmt.Print(err)
	}
} else {
	fmt.Print(err)
}

func NewHTTPClientBuilder 

func NewHTTPClientBuilder() *HTTPClientBuilder

NewHTTPClientBuilder returns HTTPClientBuilder with default values.

func (*HTTPClientBuilder) AddMockedDomain 

func (b *HTTPClientBuilder) AddMockedDomain(domain string) *HTTPClientBuilder

AddMockedDomain adds new mocked domain.

func (*HTTPClientBuilder) Build 

func (b *HTTPClientBuilder) Build(replaceDefault ...bool) (*http.Client, error)

Build builds client, pass true to replace http.DefaultClient with generated one.

func (*HTTPClientBuilder) FromConfig 

func (b *HTTPClientBuilder) FromConfig(config *HTTPClientConfig) *HTTPClientBuilder

FromConfig fulfills mock configuration from HTTPClientConfig.

func (*HTTPClientBuilder) FromEngine 

func (b *HTTPClientBuilder) FromEngine(engine *Engine) *HTTPClientBuilder

FromEngine fulfills mock configuration from ConfigInterface inside Engine.

func (*HTTPClientBuilder) ReplaceDefault 

func (b *HTTPClientBuilder) ReplaceDefault() *HTTPClientBuilder

ReplaceDefault replaces default client and transport with generated ones.

func (*HTTPClientBuilder) RestoreDefault 

func (b *HTTPClientBuilder) RestoreDefault() *HTTPClientBuilder

RestoreDefault restores default client and transport after replacement.

func (*HTTPClientBuilder) SetCertPool added in v1.7.3 

func (b *HTTPClientBuilder) SetCertPool(pool *x509.CertPool) *HTTPClientBuilder

SetSSLVerification enables or disables SSL certificates verification in client.

func (*HTTPClientBuilder) SetLogging 

func (b *HTTPClientBuilder) SetLogging(flag bool) *HTTPClientBuilder

SetLogging enables or disables logging in mocks.

func (*HTTPClientBuilder) SetMockAddress 

func (b *HTTPClientBuilder) SetMockAddress(address string) *HTTPClientBuilder

SetMockAddress sets mock address.

func (*HTTPClientBuilder) SetMockedDomains 

func (b *HTTPClientBuilder) SetMockedDomains(domains []string) *HTTPClientBuilder

SetMockedDomains sets mocked domains from slice.

func (*HTTPClientBuilder) SetSSLVerification 

func (b *HTTPClientBuilder) SetSSLVerification(enabled bool) *HTTPClientBuilder

SetSSLVerification enables or disables SSL certificates verification in client.

func (*HTTPClientBuilder) SetTimeout 

func (b *HTTPClientBuilder) SetTimeout(seconds time.Duration) *HTTPClientBuilder

SetTimeout sets timeout for http client.

func (*HTTPClientBuilder) WithLogger 

func (b *HTTPClientBuilder) WithLogger(logger LoggerInterface) *HTTPClientBuilder

WithLogger sets provided logger into HTTPClientBuilder.

type HTTPClientConfig 

type HTTPClientConfig struct {
	Timeout         time.Duration `yaml:"timeout"`
	SSLVerification *bool         `yaml:"ssl_verification"`
	MockAddress     string        `yaml:"mock_address"`
	MockedDomains   []string      `yaml:"mocked_domains"`
}

HTTPClientConfig struct.

func (*HTTPClientConfig) IsSSLVerificationEnabled 

func (h *HTTPClientConfig) IsSSLVerificationEnabled() bool

IsSSLVerificationEnabled returns SSL verification flag (default is true).

type HTTPServerConfig 

type HTTPServerConfig struct {
	Host   string `yaml:"host"`
	Listen string `yaml:"listen"`
}

HTTPServerConfig struct.

type Info 

type Info struct {
	Name     string `yaml:"name"`
	Code     string `yaml:"code"`
	LogoPath string `yaml:"logo_path"`
	Secret   string `yaml:"secret"`
}

Info struct.

func (Info) GetCode 

func (t Info) GetCode() string

GetCode transport code.

func (Info) GetLogoPath 

func (t Info) GetLogoPath() string

GetLogoPath transport logo.

func (Info) GetName 

func (t Info) GetName() string

GetName transport name.

func (Info) GetSecret added in v1.8.5 

func (t Info) GetSecret() string

GetSecret returns secret.

type InfoInterface 

type InfoInterface interface {
	GetName() string
	GetCode() string
	GetLogoPath() string
	GetSecret() string
}

InfoInterface transport settings data structure.

type Job added in v1.2.0 

type Job struct {
	Command      JobFunc
	ErrorHandler JobErrorHandler
	PanicHandler JobPanicHandler
	Interval     time.Duration

	Regular bool
	// contains filtered or unexported fields
}

Job represents single job. Regular job will be executed every Interval.

type JobErrorHandler added in v1.2.0 

type JobErrorHandler func(string, error, JobLogFunc)

JobErrorHandler is a function to handle jobs errors. First argument is a job name.

func DefaultJobErrorHandler added in v1.2.0 

func DefaultJobErrorHandler() JobErrorHandler

DefaultJobErrorHandler returns default error handler for a job.

type JobFunc added in v1.2.0 

type JobFunc func(JobLogFunc) error

JobFunc is empty func which should be executed in a parallel goroutine.

type JobLogFunc added in v1.2.0 

type JobLogFunc func(string, logging.Level, ...interface{})

JobLogFunc is a function which logs data from job.

type JobManager added in v1.2.0 

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

JobManager controls jobs execution flow. Jobs can be added just for later use (e.g. JobManager can be used as singleton), or jobs can be executed as regular jobs. Example initialization: 

    manager := NewJobManager().
		SetLogger(logger).
		SetLogging(false)
	_ = manager.RegisterJob("updateTokens", &Job{
		Command: func(logFunc JobLogFunc) error {
			// logic goes here...
			logFunc("All tokens were updated successfully", logging.INFO)
			return nil
		},
		ErrorHandler: DefaultJobErrorHandler(),
		PanicHandler: DefaultJobPanicHandler(),
		Interval:     time.Hour * 3,
		Regular:      true,
	})
	manager.Start()

func NewJobManager added in v1.2.0 

func NewJobManager() *JobManager

NewJobManager is a JobManager constructor.

func (*JobManager) FetchJob added in v1.2.0 

func (j *JobManager) FetchJob(name string) (value *Job, ok bool)

FetchJob fetches already exist job.

func (*JobManager) RegisterJob added in v1.2.0 

func (j *JobManager) RegisterJob(name string, job *Job) error

RegisterJob registers new job.

func (*JobManager) RunJob added in v1.2.0 

func (j *JobManager) RunJob(name string) error

RunJob starts provided regular job if it's exists. It's async operation and error returns only of job wasn't executed at all.

func (*JobManager) RunJobOnce added in v1.2.0 

func (j *JobManager) RunJobOnce(name string) error

RunJobOnce starts provided job once if it exists. It's also async.

func (*JobManager) RunJobOnceSync added in v1.2.0 

func (j *JobManager) RunJobOnceSync(name string) error

RunJobOnceSync starts provided job once in current goroutine if job exists. Will wait for job to end it's work.

func (*JobManager) SetLogger added in v1.2.0 

func (j *JobManager) SetLogger(logger LoggerInterface) *JobManager

SetLogger sets logger into JobManager.

func (*JobManager) SetLogging added in v1.2.0 

func (j *JobManager) SetLogging(enableLogging bool) *JobManager

SetLogging enables or disables JobManager logging.

func (*JobManager) Start added in v1.2.0 

func (j *JobManager) Start()

Start all jobs in the manager.

func (*JobManager) StopJob added in v1.2.0 

func (j *JobManager) StopJob(name string) error

StopJob stops provided regular regular job if it's exists.

func (*JobManager) UnregisterJob added in v1.2.0 

func (j *JobManager) UnregisterJob(name string) error

UnregisterJob unregisters job if it's exists. Returns error if job doesn't exist.

func (*JobManager) UpdateJob added in v1.2.0 

func (j *JobManager) UpdateJob(name string, job *Job) error

UpdateJob updates job.

type JobPanicHandler added in v1.2.0 

type JobPanicHandler func(string, interface{}, JobLogFunc)

JobPanicHandler is a function to handle jobs panics. First argument is a job name.

func DefaultJobPanicHandler added in v1.2.0 

func DefaultJobPanicHandler() JobPanicHandler

DefaultJobPanicHandler returns default panic handler for a job.

type Localizer 

type Localizer struct {
	TranslationsFS fs.FS

	LocaleMatcher    language.Matcher
	LanguageTag      language.Tag
	TranslationsPath string
	// contains filtered or unexported fields
}

Localizer struct.

func GetContextLocalizer added in v1.5.0 

func GetContextLocalizer(c *gin.Context) (*Localizer, bool)

GetContextLocalizer returns localizer from context if it exist there.

func MustGetContextLocalizer added in v1.5.0 

func MustGetContextLocalizer(c *gin.Context) *Localizer

MustGetContextLocalizer returns Localizer instance if it exists in provided context. Panics otherwise.

func NewLocalizer 

func NewLocalizer(locale language.Tag, matcher language.Matcher, translationsPath string) *Localizer

NewLocalizer returns localizer instance with specified parameters. Usage: 

NewLocalizer(language.English, DefaultLocalizerMatcher(), "translations")

func NewLocalizerFS added in v1.3.0 

func NewLocalizerFS(
	locale language.Tag, matcher language.Matcher, translationsFS fs.FS,
) *Localizer

NewLocalizerFS returns localizer instance with specified parameters. Usage: 

NewLocalizerFS(language.English, DefaultLocalizerMatcher(), translationsFS)

TODO This code should be covered with tests.

func (*Localizer) BadRequestLocalized 

func (l *Localizer) BadRequestLocalized(err string) (int, interface{})

BadRequestLocalized is same as BadRequest(string), but passed string will be localized.

func (*Localizer) Clone added in v1.7.2 

func (l *Localizer) Clone() *Localizer

Clone *core.Localizer. Clone shares it's translations with the parent localizer. Language tag will not be shared. Because of that you can change clone's language without affecting parent localizer. This method should be used when LocalizationMiddleware is not feasible (outside of *gin.HandlerFunc).

func (*Localizer) FetchLanguage deprecated 

func (l *Localizer) FetchLanguage()

FetchLanguage will load language from tag

Deprecated: Use `(*core.Localizer).LoadTranslations()` instead.

func (*Localizer) GetLocalizedMessage 

func (l *Localizer) GetLocalizedMessage(messageID string) string

GetLocalizedMessage will return localized message by it's ID. It doesn't use `Must` prefix in order to keep BC.

func (*Localizer) GetLocalizedTemplateMessage 

func (l *Localizer) GetLocalizedTemplateMessage(messageID string, templateData map[string]interface{}) string

GetLocalizedTemplateMessage will return localized message with specified data. It doesn't use `Must` prefix in order to keep BC. It uses text/template syntax: https://golang.org/pkg/text/template/

func (*Localizer) LoadTranslations 

func (l *Localizer) LoadTranslations()

LoadTranslations will load all translation files from translations directory or from embedded box.

func (*Localizer) LocalizationFuncMap 

func (l *Localizer) LocalizationFuncMap() template.FuncMap

LocalizationFuncMap returns template.FuncMap (html template is used) with one method - trans Usage in code: 

engine := gin.New()
engine.FuncMap = localizer.LocalizationFuncMap()

or (with multitemplate) 

renderer := multitemplate.NewRenderer()
funcMap := localizer.LocalizationFuncMap()
renderer.AddFromFilesFuncs("index", funcMap, "template/index.html")

funcMap must be passed for every .AddFromFilesFuncs call Usage in templates: 

<p class="info">{{"need_login_msg" | trans}}

You can borrow FuncMap from this method and add your functions to it.

func (*Localizer) LocalizationMiddleware 

func (l *Localizer) LocalizationMiddleware() gin.HandlerFunc

LocalizationMiddleware returns gin.HandlerFunc which will set localizer language by Accept-Language header Result Localizer instance will share it's internal data (translations, bundles, etc) with instance which was used to append middleware to gin. Because of that all Localizer instances from this middleware will share *same* mutex. This mutex is used to wrap i18n.Bundle methods (those aren't goroutine-safe to use). Usage: 

engine := gin.New()
localizer := NewLocalizer("en", DefaultLocalizerMatcher(), "translations")
engine.Use(localizer.LocalizationMiddleware())

func (*Localizer) Localize added in v1.5.0 

func (l *Localizer) Localize(messageID string) (string, error)

Localize will return localized message by it's ID, or error if message wasn't found.

func (*Localizer) LocalizeTemplateMessage added in v1.5.0 

func (l *Localizer) LocalizeTemplateMessage(messageID string, templateData map[string]interface{}) (string, error)

LocalizeTemplateMessage will return localized message with specified data, or error if message wasn't found It uses text/template syntax: https://golang.org/pkg/text/template/

func (*Localizer) Preload added in v1.5.0 

func (l *Localizer) Preload(tags []language.Tag)

Preload provided languages (so they will not be loaded every time in middleware).

func (*Localizer) SetLanguage 

func (l *Localizer) SetLanguage(tag language.Tag)

SetLanguage will change language using language tag.

func (*Localizer) SetLocale 

func (l *Localizer) SetLocale(al string)

SetLocale will change language for current localizer.

type Logger added in v1.3.0 

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

Logger component. Uses github.com/op/go-logging under the hood. This logger can prevent any write operations (disabled by default, use .Exclusive() method to enable).

func NewLogger 

func NewLogger(transportCode string, logLevel logging.Level, logFormat logging.Formatter) *Logger

NewLogger will create new goroutine-safe logger with specified formatter. Usage: 

logger := NewLogger("telegram", logging.ERROR, DefaultLogFormatter())

func (*Logger) Critical added in v1.3.0 

func (l *Logger) Critical(args ...interface{})

Critical logs a message using CRITICAL as log level.

func (*Logger) Criticalf added in v1.3.0 

func (l *Logger) Criticalf(format string, args ...interface{})

Criticalf logs a message using CRITICAL as log level.

func (*Logger) Debug added in v1.3.0 

func (l *Logger) Debug(args ...interface{})

Debug logs a message using DEBUG as log level.

func (*Logger) Debugf added in v1.3.0 

func (l *Logger) Debugf(format string, args ...interface{})

Debugf logs a message using DEBUG as log level.

func (*Logger) Error added in v1.3.0 

func (l *Logger) Error(args ...interface{})

Error logs a message using ERROR as log level.

func (*Logger) Errorf added in v1.3.0 

func (l *Logger) Errorf(format string, args ...interface{})

Errorf logs a message using ERROR as log level.

func (*Logger) Exclusive added in v1.3.0 

func (l *Logger) Exclusive() *Logger

Exclusive makes logger goroutine-safe.

func (*Logger) Fatal added in v1.3.0 

func (l *Logger) Fatal(args ...interface{})

Fatal is equivalent to l.Critical(fmt.Sprint()) followed by a call to os.Exit(1).

func (*Logger) Fatalf added in v1.3.0 

func (l *Logger) Fatalf(format string, args ...interface{})

Fatalf is equivalent to l.Critical followed by a call to os.Exit(1).

func (*Logger) Info added in v1.3.0 

func (l *Logger) Info(args ...interface{})

Info logs a message using INFO as log level.

func (*Logger) Infof added in v1.3.0 

func (l *Logger) Infof(format string, args ...interface{})

Infof logs a message using INFO as log level.

func (*Logger) Notice added in v1.3.0 

func (l *Logger) Notice(args ...interface{})

Notice logs a message using NOTICE as log level.

func (*Logger) Noticef added in v1.3.0 

func (l *Logger) Noticef(format string, args ...interface{})

Noticef logs a message using NOTICE as log level.

func (*Logger) Panic added in v1.3.0 

func (l *Logger) Panic(args ...interface{})

Panic is equivalent to l.Critical(fmt.Sprint()) followed by a call to panic().

func (*Logger) Panicf added in v1.3.0 

func (l *Logger) Panicf(format string, args ...interface{})

Panicf is equivalent to l.Critical followed by a call to panic().

func (*Logger) Warning added in v1.3.0 

func (l *Logger) Warning(args ...interface{})

Warning logs a message using WARNING as log level.

func (*Logger) Warningf added in v1.3.0 

func (l *Logger) Warningf(format string, args ...interface{})

Warningf logs a message using WARNING as log level.

type LoggerInterface added in v1.3.0 

type LoggerInterface interface {
	Fatal(args ...interface{})
	Fatalf(format string, args ...interface{})
	Panic(args ...interface{})
	Panicf(format string, args ...interface{})
	Critical(args ...interface{})
	Criticalf(format string, args ...interface{})
	Error(args ...interface{})
	Errorf(format string, args ...interface{})
	Warning(args ...interface{})
	Warningf(format string, args ...interface{})
	Notice(args ...interface{})
	Noticef(format string, args ...interface{})
	Info(args ...interface{})
	Infof(format string, args ...interface{})
	Debug(args ...interface{})
	Debugf(format string, args ...interface{})
}

LoggerInterface contains methods which should be present in logger implementation.

type Migrate 

type Migrate struct {
	GORMigrate *gormigrate.Gormigrate
	// contains filtered or unexported fields
}

Migrate tool, decorates gormigrate.Migration in order to provide better interface & versioning.

func Migrations 

func Migrations() *Migrate

Migrations returns default migrate.

func (*Migrate) Add 

func (m *Migrate) Add(migration *gormigrate.Migration)

Add GORMigrate to migrate.

func (*Migrate) Close 

func (m *Migrate) Close() error

Close db connection.

func (*Migrate) Current 

func (m *Migrate) Current() string

Current migration version.

func (*Migrate) Migrate 

func (m *Migrate) Migrate() error

Migrate all, including schema initialization.

func (*Migrate) MigrateNextTo 

func (m *Migrate) MigrateNextTo(version string) error

MigrateNextTo migrate to next version from specified version.

func (*Migrate) MigratePreviousTo 

func (m *Migrate) MigratePreviousTo(version string) error

MigratePreviousTo migrate to previous version from specified version.

func (*Migrate) MigrateTo 

func (m *Migrate) MigrateTo(version string) error

MigrateTo specified version.

func (*Migrate) NextFrom 

func (m *Migrate) NextFrom(version string) (string, error)

NextFrom returns next version from passed version.

func (*Migrate) PreviousFrom 

func (m *Migrate) PreviousFrom(version string) (string, error)

PreviousFrom returns previous version from passed version.

func (*Migrate) Rollback 

func (m *Migrate) Rollback() error

Rollback all migrations.

func (*Migrate) RollbackTo 

func (m *Migrate) RollbackTo(version string) error

RollbackTo specified version.

func (*Migrate) SetDB 

func (m *Migrate) SetDB(db *gorm.DB) *Migrate

SetDB to migrate.

type MigrationInfo 

type MigrationInfo struct {
	ID string `gorm:"column:id; type:varchar(255)"`
}

MigrationInfo with migration info.

func (MigrationInfo) TableName 

func (MigrationInfo) TableName() string

TableName for MigrationInfo.

type NewMigrationCommand 

type NewMigrationCommand struct {
	Directory string `short:"d" long:"directory" default:"./migrations" description:"Directory where migration will be created"`
}

NewMigrationCommand struct.

func (*NewMigrationCommand) Execute 

func (x *NewMigrationCommand) Execute(args []string) error

Execute migration generator command.

func (*NewMigrationCommand) FileExists 

func (x *NewMigrationCommand) FileExists(filename string) bool

FileExists returns true if provided file exist and it's not directory.

type ORM 

type ORM struct {
	DB *gorm.DB
}

ORM struct.

func NewORM 

func NewORM(config DatabaseConfig) *ORM

NewORM will init new database connection.

func (*ORM) CloseDB 

func (orm *ORM) CloseDB()

CloseDB close database connection.

type Renderer 

type Renderer struct {
	multitemplate.Renderer
	TemplatesFS fs.FS
	FuncMap     template.FuncMap
	// contains filtered or unexported fields
}

Renderer wraps multitemplate.Renderer in order to make it easier to use.

func NewDynamicRenderer 

func NewDynamicRenderer(funcMap template.FuncMap) Renderer

NewDynamicRenderer is a Renderer constructor with multitemplate.DynamicRender.

func NewRenderer 

func NewRenderer(funcMap template.FuncMap) Renderer

NewRenderer is a Renderer constructor.

func NewStaticRenderer 

func NewStaticRenderer(funcMap template.FuncMap) Renderer

NewStaticRenderer is a Renderer constructor with multitemplate.Render.

func (*Renderer) Push 

func (r *Renderer) Push(name string, files ...string) *template.Template

Push is an AddFromFilesFuncs wrapper.

type ScopesList added in v1.8.4 

type ScopesList interface {
	Scopes() []string
}

ScopesList is a contract for the scopes list.

type Sentry 

type Sentry struct {
	TaggedTypes  SentryTaggedTypes
	Stacktrace   bool
	DefaultError string
	Localizer    *Localizer
	Logger       LoggerInterface
	Client       stacktrace.RavenClientInterface
}

Sentry struct. Holds SentryTaggedStruct list.

func NewSentry 

func NewSentry(sentryDSN string, defaultError string, taggedTypes SentryTaggedTypes, logger LoggerInterface, localizer *Localizer) *Sentry

NewSentry constructor.

func (*Sentry) ErrorCaptureHandler 

func (s *Sentry) ErrorCaptureHandler() ErrorHandlerFunc

ErrorCaptureHandler will generate error data and send it to sentry.

func (*Sentry) ErrorLogger 

func (s *Sentry) ErrorLogger() ErrorHandlerFunc

ErrorLogger logs basic errors.

func (*Sentry) ErrorMiddleware 

func (s *Sentry) ErrorMiddleware() gin.HandlerFunc

ErrorMiddleware returns error handlers, attachable to gin.Engine.

func (*Sentry) ErrorResponseHandler 

func (s *Sentry) ErrorResponseHandler() ErrorHandlerFunc

ErrorResponseHandler will be executed in case of any unexpected error.

func (*Sentry) PanicLogger 

func (s *Sentry) PanicLogger() ErrorHandlerFunc

PanicLogger logs panic.

type SentryTagged 

type SentryTagged interface {
	BuildTags(interface{}) (map[string]string, error)
	GetContextKey() string
	GetTags() SentryTags
	GetName() string
}

SentryTagged interface for both tagged scalar and struct.

type SentryTaggedScalar 

type SentryTaggedScalar struct {
	SentryTaggedStruct
	Name string
}

SentryTaggedScalar variable from context.

func NewTaggedScalar 

func NewTaggedScalar(sample interface{}, ginCtxKey string, name string) *SentryTaggedScalar

NewTaggedScalar constructor.

func (*SentryTaggedScalar) BuildTags 

func (t *SentryTaggedScalar) BuildTags(v interface{}) (items map[string]string, err error)

BuildTags returns map with single item in this format: <tag name> => <scalar value>.

func (*SentryTaggedScalar) Get 

func (t *SentryTaggedScalar) Get(v interface{}) (value string, err error)

Get will extract property string representation from specified object. It will be properly formatted.

func (*SentryTaggedScalar) GetContextKey 

func (t *SentryTaggedScalar) GetContextKey() string

GetContextKey is getter for GinContextKey.

func (*SentryTaggedScalar) GetName 

func (t *SentryTaggedScalar) GetName() string

GetName is getter for Name (tag name for scalar).

func (*SentryTaggedScalar) GetTags 

func (t *SentryTaggedScalar) GetTags() SentryTags

GetTags is useless for SentryTaggedScalar.

type SentryTaggedStruct 

type SentryTaggedStruct struct {
	Type          reflect.Type
	GinContextKey string
	Tags          SentryTags
}

SentryTaggedStruct holds information about type, it's key in gin.Context (for middleware), and it's properties.

func NewTaggedStruct 

func NewTaggedStruct(sample interface{}, ginCtxKey string, tags map[string]string) *SentryTaggedStruct

NewTaggedStruct constructor.

func (*SentryTaggedStruct) AddTag 

func (t *SentryTaggedStruct) AddTag(name string, property string) *SentryTaggedStruct

AddTag will add tag with property name which holds tag in object.

func (*SentryTaggedStruct) BuildTags 

func (t *SentryTaggedStruct) BuildTags(v interface{}) (tags map[string]string, err error)

BuildTags will extract tags for Sentry from specified object.

func (*SentryTaggedStruct) GetContextKey 

func (t *SentryTaggedStruct) GetContextKey() string

GetContextKey is GinContextKey getter.

func (*SentryTaggedStruct) GetName 

func (t *SentryTaggedStruct) GetName() string

GetName is useless for SentryTaggedStruct.

func (*SentryTaggedStruct) GetProperty 

func (t *SentryTaggedStruct) GetProperty(v interface{}, property string) (name string, value string, err error)

GetProperty will extract property string representation from specified object. It will be properly formatted.

func (*SentryTaggedStruct) GetTags 

func (t *SentryTaggedStruct) GetTags() SentryTags

GetTags is Tags getter.

type SentryTaggedTypes 

type SentryTaggedTypes []SentryTagged

SentryTaggedTypes list.

type SentryTags 

type SentryTags map[string]string

SentryTags list for SentryTaggedStruct. Format: name => property name.

type TranslationsExtractor 

type TranslationsExtractor struct {
	TranslationsFS   fs.FS
	TranslationsPath string
	// contains filtered or unexported fields
}

TranslationsExtractor is a tool to load raw translations data from files or from box. It is feasible to be used in tests in order to check translation files correctness. The easiest way to check correctness is to check keys in translations. TranslationsExtractor IS NOT supposed to check correctness of translations - it's just an extractor. Translations can be checked manually, or via external library like https://github.com/google/go-cmp

func NewTranslationsExtractor 

func NewTranslationsExtractor(fileNameTemplate string) *TranslationsExtractor

NewTranslationsExtractor constructor. Use "translate.{}.yml" as template if your translations are named like "translate.en.yml".

func (*TranslationsExtractor) GetMapKeys 

func (t *TranslationsExtractor) GetMapKeys(data map[string]interface{}) []string

GetMapKeys returns sorted map keys from map[string]interface{} - useful to check keys in several translation files.

func (*TranslationsExtractor) LoadLocale 

func (t *TranslationsExtractor) LoadLocale(locale string) (map[string]interface{}, error)

LoadLocale returns translation file data with provided locale.

func (*TranslationsExtractor) LoadLocaleKeys 

func (t *TranslationsExtractor) LoadLocaleKeys(locale string) ([]string, error)

LoadLocaleKeys returns only sorted keys from translation file.

type User 

type User struct {
	ID           int    `gorm:"primary_key"`
	ExternalID   string `gorm:"column:external_id; type:varchar(255); not null; unique"`
	UserPhotoURL string `gorm:"column:user_photo_url; type:varchar(255)" binding:"max=255"`
	UserPhotoID  string `gorm:"column:user_photo_id; type:varchar(100)" binding:"max=100"`
	CreatedAt    time.Time
	UpdatedAt    time.Time
}

User model.

func (User) TableName 

func (User) TableName() string

TableName will return table name for User It will not work if User is not embedded, but mapped as another type 

type MyUser User // will not work

but 

type MyUser struct { // will work
    User
}

type Utils 

type Utils struct {
	IsDebug      bool
	TokenCounter uint32
	ConfigAWS    ConfigAWS
	Logger       LoggerInterface
	// contains filtered or unexported fields
}

Utils service object.

func NewUtils 

func NewUtils(awsConfig ConfigAWS, logger LoggerInterface, debug bool) *Utils

NewUtils will create new Utils instance.

func (*Utils) GenerateToken 

func (u *Utils) GenerateToken() string

GenerateToken will generate long pseudo-random string.

func (*Utils) GetAPIClient 

func (u *Utils) GetAPIClient(
	url, key string, scopes []string, credentials ...[]string) (*retailcrm.Client, int, error)

GetAPIClient will initialize RetailCRM api client from url and key. Scopes will be used to determine if client is valid. If there are no scopes - credentials will be used instead.

func (*Utils) RemoveTrailingSlash 

func (u *Utils) RemoveTrailingSlash(crmURL string) string

RemoveTrailingSlash will remove slash at the end of any string.

func (*Utils) UploadUserAvatar 

func (u *Utils) UploadUserAvatar(url string) (picURLs3 string, err error)

UploadUserAvatar will upload avatar for user.

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.