core

package module
v0.0.0-...-829e17e Latest Latest
Warning

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

 Go to latest Published: Nov 25, 2016 License: MIT Imports: 51 Imported by: 0

README

gopypi

Gopypi is private pypi repository implemented in go language. Gopypi can store your private packages and support pip install. Gopypi supports distutils/setuptools setup.py uploading of packages. And it does more thant this. Gopypi supports management of active users, maintainers of packages and lot more.

This project is under development and should NOT be used in production for now. I am working to implement all features and bring alpha version in short time. Stay tuned!

Features

If you install gopypi you will get out of the box following features:

  • auth module - maintain users with access permissions, maintainers access to packages
  • packages - uploading of packages, versions, files (directly from setup.py)
  • Licenses - list of licenses for uploaded packages
  • Clean admin interface - Simple but powerful modern SPA admin interface (written in vue.js)
  • Embedded static data - all static files are embedded directly into binary

Gopypi has some optional features that can be enabled in administration, such as:

  • download stats - stats about downloaded packages
  • automatically assign maintainers - reads information from python packages and assigns users

Admin

Gopypi has modern SPA admin interface where you can browse information about packages, maintain user credentials etc. Currently only admin can login into this administration, but that will change in near future, so all active users can log into admin and see information about packages they maintain.

Command line interface

gopypi is single binary which has multiple subcommands, you can see them by typing gopypi -h

Installation

The easiest way is to download precompiled binaries from github repository releases. Current version ccan be found here:

https://github.com/phonkee/gopypi/releases/tag/0.5.3

Otherwise you can type

go get github.com/phonkee/gopypi/...

After you have installed gopypi you need to create config file. You can use gopypi command makeconfig that helps you with generating new configuration interactively.

./gopypi makeconfig
Database

Gopypi currently supports postgres, mysql databases. To correctly setup database dsn refer to

Now it's time to run database migrations:

./gopypi migrate --config gopypi.conf

This will apply all database migrations automaticaly. For every new gopypi release migrate command is needed to be run.

After you have applied all database migrations it's time to create new admin user, so you can access admin interface:

./gopypi createadmin --config gopypi.conf

After you have succesfully created admin user you can now run server.

./gopypi runserver --config gopypi.conf

Future features

Gopypi has following features planned:

  • list of package classifiers with stats
  • only admin can login into admin interface
  • enable registration from python setup.py register
  • email notifications about package changes
  • classifiers - create page in admin groupping packages by classifier

Upload package

For instructions how to write setup.py you can find more information in admin interface HOWTO.

Screenshots

Here are some screenshots from gopypi admin

Admin dashboard

Dashboard

Admin user list

User list

Admin add user

Add user

Admin package detail

Package detail

Admin download stats

Download stats

Contributors

You are welcome!

Author

phonkee

Documentation

Overview

Set of commands that can be run from command line.

Various database (gorm) helpers

Features

gopypi provides optional features that can be enabled/disabled directly from administration

List of features:

* auto_maintainers - automatically assign maintainers from package emails (users must exist in database) * download_stats - enable download statistics for downloads

filter provides set of FilterFunc functions.

Filter maintains various filters from http forms (get/post)

Managers is set of manager structs that provide querying methods

parser package handles parsing of submitted packages.

Various string helpers

tasks is set of background tasks

timeutil is set of functions to work with time.Time such as: alignment, stripping of time values etc..

Index

Constants

View Source 
const (
	FEATURE_AUTO_MAINTAINERS = "auto_maintainers"
	FEATURE_DOWNLOAD_STATS   = "download_stats"
)
View Source 
const (
	DESCRIPTION_FEATURE_AUTO_MAINTAINERS = "Automatically assign maintainers on uploading package"
	DESCRIPTION_FEATURE_DOWNLOAD_STATS   = "Store download statistics of packages"
)
View Source 
const (
	VERSION = "0.5.3"
                                                              o
                                                            _<|>_

   o__ __o/    o__ __o    \o_ __o     o      o   \o_ __o      o
  /v     |    /v     v\    |    v\   <|>    <|>   |    v\    <|>
 />     / \  />       <\  / \    <\  < >    < >  / \    <\   / \
 \      \o/  \         /  \o/     /   \o    o/   \o/     /   \o/
  o      |    o       o    |     o     v\  /v     |     o     |
  <\__  < >   <\__ __/>   / \ __/>      <\/>     / \ __/>    / \
         |                \o/            /       \o/
 o__     o                 |            o         |
 <\__ __/>                / \        __/>        / \

                                                     v ` + VERSION
)
View Source 
const (
	TOKEN_HEADER_NAME = "Authorization"
	TOKEN_ISSUER      = "gopypi"
	TOKEN_EXPIRATION  = 24 * 3600
)

token related constants

View Source 
const (
	CONTEXT_TOKEN_USER = iota + 1000
	CONTEXT_ROUTE_NAME
)

Context constants

View Source 
const (
	POST_PACKAGE_ACTION_VERIFY = iota + 1
	POST_PACKAGE_ACTION_SUBMIT
	POST_PACKAGE_ACTION_DOC_UPLOAD
	POST_PACKAGE_ACTION_REMOVE_PKG
	POST_PACKAGE_ACTION_FILE_UPLOAD

	// find out how this works
	POST_PACKAGE_ACTION_USER
	POST_PACKAGE_ACTION_PASSWORD_RESET
)

WHen setup.py calls gopypi it can define following actions

View Source 
const (
	PASSWORD_SALT_BYTES = 32
	PASSWORD_HASH_BYTES = 128
	PASSWORD_ITERATIONS = 16384
)

constants for pasword hashing

View Source 
const (
	PASSWORD_MIN_LENGTH = 5
	PASSWORD_MAX_LENGTH = 20

	USERNAME_MIN_LENGTH = 5
	USERNAME_MAX_LENGTH = 20
)

Model related constants

View Source 
const (
	CONFGEN_SECRET_KEY_LENGTH = 64
)

confgen constants

View Source 
const CONF_TEMPLATE = `` /* 215-byte string literal not displayed */

template used for confgen

Variables

View Source 
var (

	// Config
	ErrUnknownDBDriver = errors.New("Unknown database driver")

	// Auth
	ErrInvalidAuthHeader = errors.New("Invalid authorization header")
	ErrLoginUsername     = errors.New("invalid username")
	ErrLoginPassword     = errors.New("invalid password")
	ErrTokenExpired      = errors.New("token expired")
	ErrTokenInvalid      = errors.New("invalid token")
	ErrTokenUserInvalid  = errors.New("invalid user in token")

	// Model errors
	ErrUsernameAlreadyExists = errors.New("user with this username already exists")
	ErrPasswordsMustMatch    = errors.New("passwords must match")
	ErrInvalidEmail          = errors.New("invalid email address")
	ErrEmailAlreadyExists    = errors.New("user with this email already exists")

	ErrLicenseNotFound  = errors.New("license not found")
	ErrPlatformNotFound = errors.New("license not found")

	ErrPackageNotFound = errors.New("package not found")

	// http errors
	ErrUserCannotRetrievePackages = errors.New("user cannot retrieve packages")
	ErrUserCannotDownloadPackages = errors.New("user cannot download packages")

	// Post package errors
	ErrPostPackageInvalidAction  = errors.New("action not recognized")
	ErrPostPackageInvalidName    = errors.New("invalid name")
	ErrPostPackageInvalidVersion = errors.New("invalid version")

	// generic error for all methods that return single object
	ErrObjectNotFound = errors.New("object not found")
)
View Source 
var (
	AVAILABLE_DB_DRIVERS = []string{"postgres", "mysql"}
	DEFAULT_DB_DRIVER    = "postgres"
)
View Source 
var (
	CliApp *cli.App
)
View Source 
var (
	// Prepare common paginator for all api
	CommonPaginator = paginator.NewFactory(
		paginator.PerPage(20, 30),
	)
)
View Source 
var DoNotBypass = func(r *http.Request) bool {
	return false
}

DoNotBypass is function that doesn't bypasses basic auth

View Source 
var (
	// when package is posted following actions can apply
	POST_PACKAGE_ACTIONS = map[string]int{
		"verify":         POST_PACKAGE_ACTION_VERIFY,
		"submit":         POST_PACKAGE_ACTION_SUBMIT,
		"doc_upload":     POST_PACKAGE_ACTION_DOC_UPLOAD,
		"remove_pkg":     POST_PACKAGE_ACTION_REMOVE_PKG,
		"file_upload":    POST_PACKAGE_ACTION_FILE_UPLOAD,
		"user":           POST_PACKAGE_ACTION_USER,
		"password_reset": POST_PACKAGE_ACTION_PASSWORD_RESET,
	}
)
View Source 
var (

	// ValidatePassword validate password
	ValidatePassword = StringMinMaxValidator(PASSWORD_MIN_LENGTH, PASSWORD_MAX_LENGTH)
)

Functions

func ApplyFilterFuncs 

func ApplyFilterFuncs(db *gorm.DB, funcs ...FilterFunc) *gorm.DB

ApplyFilterFuncs applies all FilterFuncs and returns db

func Asset 

func Asset(name string) ([]byte, error)

Asset loads and returns the asset for the given name. It returns an error if the asset could not be found or could not be loaded.

func AssetDir 

func AssetDir(name string) ([]string, error)

AssetDir returns the file names below a certain directory embedded in the file by go-bindata. For example if you run go-bindata on data/... and data contains the following hierarchy: 

data/
  foo.txt
  img/
    a.png
    b.png

then AssetDir("data") would return []string{"foo.txt", "img"} AssetDir("data/img") would return []string{"a.png", "b.png"} AssetDir("foo.txt") and AssetDir("notexist") would return an error AssetDir("") will return []string{"data"}.

func AssetInfo 

func AssetInfo(name string) (os.FileInfo, error)

AssetInfo loads and returns the asset info for the given name. It returns an error if the asset could not be found or could not be loaded.

func AssetNames 

func AssetNames() []string

AssetNames returns the names of the assets.

func Atoui 

func Atoui(value string, def ...uint) uint

Atoui parses string and converts to uint, if error occures either 0 is returned or given default value (optional)

func BasicAuthLoginRequired 

func BasicAuthLoginRequired(cfg Config, bypassAuth func(r *http.Request) bool, permfuncs ...func(User) error) alice.Constructor

LoginRequired checks if username provided correct auth

bypassAuth is function that when returns true, auth is bypassed (!WARNING!)

func Bind 

func Bind(r *http.Request, target interface{}) (err error)

Bind json unmarshals request body to target

func BindFilter 

func BindFilter(r *http.Request, filter Filter) (err error)

BindFilter binds filter to given url values

func CommonMiddleware 

func CommonMiddleware(cfg Config, router *mux.Router) alice.Constructor

func ContextSetTokenUser 

func ContextSetTokenUser(ctx context.Context, user User) (result context.Context)

Return token claims from request context

func CountQueryset 

func CountQueryset(db *gorm.DB, p paginator.Paginator) *gorm.DB

CountQueryset performs count query and sets paginator count

func CreateToken 

func CreateToken(db *gorm.DB, user User, secret string, expiration int) (result string, err error)

CreateToken creates auth token

func Exit 

func Exit(why interface{}, code ...int)

Exit exits with priting error message.

func GenerateSalt 

func GenerateSalt(length int) (result []byte)

GenerateSalt generates salt for hashing passwords

func GetPostAction 

func GetPostAction(r *http.Request) (result int, err error)

Return action from form

func GetRequestToken 

func GetRequestToken(r *http.Request) (result string, err error)

GetRequestToken returns token from request

func InitRouter 

func InitRouter(config Config) (chain alice.Chain, err error)

GetRouter instantiates router with all its registered routes

func IsEnabledOption 

func IsEnabledOption(option []bool) bool

IsEnabledOption returns whether last varargs option is enabled

func LimitQueryset 

func LimitQueryset(db *gorm.DB, p paginator.Paginator) *gorm.DB

LimitQueryset sets limits to queryset and returns it

func MD5 

func MD5(input string) string

MD5 shortcut to create md5 hash

func Migrate 

func Migrate(config Config) (err error)

Migrate runs AutoMigrate on all models.

func MigrateAction 

func MigrateAction(c *cli.Context) (err error)

func MustAsset 

func MustAsset(name string) []byte

MustAsset is like Asset but panics when Asset would return an error. It simplifies safe initialization of global variables.

func NewConfGen 

func NewConfGen() *confgen

NewConfGen returns ConfGen instance

func NormalizePackageName 

func NormalizePackageName(name string) string

NormalizePackageName normalizes package name by PEP 503

func PostEndpointCheckMiddleware 

func PostEndpointCheckMiddleware(cfg Config) alice.Constructor

PostEndpointCheckMiddleware custom middleware just for post package

func RestoreAsset 

func RestoreAsset(dir, name string) error

RestoreAsset restores an asset under the given directory

func RestoreAssets 

func RestoreAssets(dir, name string) error

RestoreAssets restores an asset under the given directory recursively

func RunserverAction 

func RunserverAction(c *cli.Context) (err error)

func StringListContains 

func StringListContains(where []string, what string) bool

StringListContains returns whether string is in stringlist

func StringMinMaxValidator 

func StringMinMaxValidator(min int, max int) func(field string, value *string, vr ValidationResult) bool

StringMinMaxValidator returns validator for length

func StringParseBool 

func StringParseBool(value string) (result *bool)

StringParseBool returns boolean value by given string value

func TerminalGetBoolValue 

func TerminalGetBoolValue(question string, def bool) (result bool)

func TerminalGetIntValue 

func TerminalGetIntValue(question string, def int) (result int)

GetTermIntValue waits for user input for number

func TerminalGetPasswordValue 

func TerminalGetPasswordValue(question string) (result string)

TerminalGetPasswordValue return password

func TerminalGetStringValue 

func TerminalGetStringValue(question string, defs ...string) (result string)

GetTermValue calls user input.

func TerminalGetStringValueChoices 

func TerminalGetStringValueChoices(question string, choices []string, defs ...string) (result string)

func TimeAlignMonth 

func TimeAlignMonth(t time.Time) time.Time

TimeAlignWeek aligns date to first day of month and strips time and timezone

func TimeAlignWeek 

func TimeAlignWeek(t time.Time) time.Time

TimeAlignWeek aligns date to first day of week and strips time and timezone

func TimeAlignYear 

func TimeAlignYear(t time.Time) time.Time

TimeAlignWeek aligns date to first day of year and strips time and timezone

func TimeStripTime 

func TimeStripTime(t time.Time) time.Time

TimeStripTime strips time part from time

func TokenAuthLoginRequired 

func TokenAuthLoginRequired(cfg Config, permissions ...func(User) error) alice.Constructor

TokenAuthLoginRequired is token auth verification. It reads `gopypi-token`from headers

func ValidateEmail 

func ValidateEmail(field string, value *string, vr ValidationResult, required ...bool) bool

ValidateEmail validates whether the value is valid email. Also it supports optional argument required.

func ValidateUsername 

func ValidateUsername(field string, value *string, vr ValidationResult) bool

ValidateUsername validates username and adds error if available

Types

type ChangePasswordCommand 

type ChangePasswordCommand struct {
	Config Config
}

ChangePasswordCommand command line command to change password

func (*ChangePasswordCommand) Run 

func (c *ChangePasswordCommand) Run() (err error)

Run

type Classifier 

type Classifier struct {
	ID       uint   `gorm:"primary_key" json:"id"`
	Approved bool   `json:"approved"`
	Name     string `gorm:"unique_index" json:"name"`
}

Classifier model

We store just values for now, later we can do some sort of tree

type ClassifierManager 

type ClassifierManager struct {
	DB *gorm.DB
}

ClassifierManager database manager

func (*ClassifierManager) ListOrCreate 

func (c *ClassifierManager) ListOrCreate(result *[]Classifier, cd []string) (err error)

ListOrCreate returns list of classifiers from given string list

func (*ClassifierManager) NormalizeName 

func (c *ClassifierManager) NormalizeName(name string) string

NormalizeName normalizes classifier name

type Command 

type Command interface {

	// Run runs command
	Run() error
}

Command interface that all commands use

type Config 

type Config interface {

	// Core returns CoreConfig
	Core() CoreConfig

	// getter for database connection
	DB() *gorm.DB

	// logger instance
	Logger() zap.Logger

	// validates configuration
	Validate() error

	// parse html template
	ParseTemplate(name, filename string) (*gbht.Template, error)

	// parse multiple templates
	ParseTemplateFiles(name string, filenames ...string) (*gbht.Template, error)

	// render template with given data
	RenderTemplate(data interface{}, name, filename string) (string, error)

	// render templates with given data
	RenderTemplateFiles(data interface{}, name string, filenames ...string) (string, error)

	// return router
	Router() *mux.Router

	// DownloadStats return config for download stats
	DownloadStats() DownloadStatsConfig

	// packages returns configuration for packages
	Packages() PackagesConfig

	// Manager returns interface that supplies multiple db managers
	Manager(tx ...*gorm.DB) ManagerConfig
}

Config interface

func NewConfig 

func NewConfig(tree *toml.TomlTree) (result Config, err error)

Return config from string

func NewConfigFromFilename 

func NewConfigFromFilename(filename string) (result Config, err error)

NewConfigFromFilename returns configuration from filename

type CoreConfig 

type CoreConfig interface {
	// Listen returns listen address with port
	Listen() string

	// Host returns host when defined
	Host() string

	// SecretKey returns secret key for hashing and crypto
	SecretKey() string
}

type CreateAdminCommand 

type CreateAdminCommand struct {
	Config Config
}

CreateAdminCommand creates new admin in database

func (*CreateAdminCommand) Run 

func (c *CreateAdminCommand) Run() error

Run is method that runs the command

type DownloadStats 

type DownloadStats struct {
	ID               uint            `gorm:"primary_key" json:"-"`
	PackageVersion   *PackageVersion `gorm:"ForeignKey:PackageVersionID" json:"version,omitempty"`
	PackageVersionID uint            `json:"-"`
	Downloads        int             `json:"downloads"`
	CreatedAt        time.Time       `json:"created_at"`
}

DownloadStats is common structure for all of them

CreatedAt is aligned on every struct that embeds DownloadStats with given aggregation level. This assures that records are groupped correctly and no need to do grouping no database level.

type DownloadStatsConfig 

type DownloadStatsConfig interface {

	// Returns how many weeks we should store weekly statistics
	ArchiveWeekly() int

	// Returns how many months we should store monthly statistics
	ArchiveMonthly() int
}

type DownloadStatsManager 

type DownloadStatsManager struct {
	DB     *gorm.DB
	Config Config
}

DownloadStatsManager database manager for all download stats

func (*DownloadStatsManager) AddDownload 

func (s *DownloadStatsManager) AddDownload(version *PackageVersion) (err error)

AddDownload adds download for given package version

func (*DownloadStatsManager) AddDownloadFile 

func (d *DownloadStatsManager) AddDownloadFile(versionfile *PackageVersionFile) (err error)

AddDownloadFile adds download by PackageVersionFile

func (*DownloadStatsManager) Cleanup 

func (d *DownloadStatsManager) Cleanup()

Cleanup deletes weekly and monthly stats from database, yearly stats will stay forever

func (*DownloadStatsManager) GetAllStats 

func (d *DownloadStatsManager) GetAllStats(target map[string][]StatsDownloadItem, filter ...FilterFunc) (err error)

Returns all download stats

func (*DownloadStatsManager) GetCount 

func (d *DownloadStatsManager) GetCount(target interface{}) (err error)

GetSum returns count of all downloads

func (*DownloadStatsManager) GetStats 

func (d *DownloadStatsManager) GetStats(aggregation StatsAggregation, target *[]StatsDownloadItem, filter ...FilterFunc) *gorm.DB

type DownloadStatsMonthly 

type DownloadStatsMonthly struct {
	DownloadStats
}

DownloadStatsMonthly represents download stats aggregated by month

func (*DownloadStatsMonthly) BeforeCreate 

func (s *DownloadStatsMonthly) BeforeCreate() error

BeforeSave aligns CreatedAt correctly

type DownloadStatsWeekly 

type DownloadStatsWeekly struct {
	DownloadStats
}

DownloadStatsWeekly represents download stats aggregated by week

func (*DownloadStatsWeekly) BeforeCreate 

func (s *DownloadStatsWeekly) BeforeCreate() error

BeforeSave aligns CreatedAt correctly

type DownloadStatsYearly 

type DownloadStatsYearly struct {
	DownloadStats
}

DownloadStatsYearly represents download stats aggregated by year

func (*DownloadStatsYearly) BeforeCreate 

func (s *DownloadStatsYearly) BeforeCreate() error

BeforeSave aligns CreatedAt correctly

type FallbackFileSystem 

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

FallbackFileSystem wraps http Filesystem which checks if requested file is not found, it falls back to given default. This is useful for SPA with html5 mode so it opens any url in index.html

func (*FallbackFileSystem) Open 

func (f *FallbackFileSystem) Open(name string) (result http.File, err error)

Open opens and reads file

type Feature 

type Feature struct {
	ID          string `gorm:"primary_key" json:"id"`
	Description string `json:"description"`
	Value       bool   `json:"value"`
}

Feature is model for enabling/disabling gopypi features

type FeatureAPIViewSet 

type FeatureAPIViewSet struct {
	classy.SlugViewSet

	// config instance to access managers, etc..
	Config Config
}

FeatureAPIViewSet provides rest endpoints for features

func (*FeatureAPIViewSet) List 

func (f *FeatureAPIViewSet) List(w http.ResponseWriter, r *http.Request) response.Response

List returns list of all features

func (*FeatureAPIViewSet) Retrieve 

func (f *FeatureAPIViewSet) Retrieve(w http.ResponseWriter, r *http.Request) response.Response

Retrieve retrieves single feature from database

func (*FeatureAPIViewSet) Update 

func (f *FeatureAPIViewSet) Update(w http.ResponseWriter, r *http.Request) response.Response

Update updates given feature (just value)

type FeatureManager 

type FeatureManager struct {
	*Manager
}

FeatureManager database manager for model Feature

func (*FeatureManager) IsEnabledFeature 

func (f *FeatureManager) IsEnabledFeature(feature string) (result bool, err error)

IsEnabledFeature returns whether given feature is available

type FeatureSerializer 

type FeatureSerializer struct {
	Value bool `json:"value"`
}

FeatureSerializer enables/disables feature

type Filter 

type Filter interface {

	// returns list of filter funcs
	Apply(queryset *gorm.DB) *gorm.DB
}

Filter is interface to filter database querysets

func NewUserListFilter 

func NewUserListFilter(r *http.Request) Filter

NewUserListFilter returns new UserListFilter

type FilterFunc 

type FilterFunc func(*gorm.DB) *gorm.DB

FilterFunc is callback which is called in some methods (Get, List)

func FFDownloadStatsPackage 

func FFDownloadStatsPackage(pack *Package) FilterFunc

FFDownloadStatsPackage filters stats by package

func FFDownloadStatsPackageVersion 

func FFDownloadStatsPackageVersion(pv *PackageVersion) FilterFunc

FFDownloadStatsPackage filters stats by package

func FFID 

func FFID(id interface{}) FilterFunc

FFID adds clause to search by id

func FFOrderBy 

func FFOrderBy(order string) FilterFunc

FFOrderBy orders by

func FFPackagesFor 

func FFPackagesFor(user User) FilterFunc

FFPackagesFor filters packages by given user, user is either author or maintainer

func FFPreload 

func FFPreload(preloads ...string) FilterFunc

FFPreload add preloads to que

func FFUsername 

func FFUsername(username string) FilterFunc

FilterUsername filters user by username

func FFWhere 

func FFWhere(query interface{}, args ...interface{}) FilterFunc

FFWhere is shorthand for gorm Where

type InfoAPIView 

type InfoAPIView struct {
	classy.GenericView

	// store config instance
	Config Config
}

InfoAPIView serves GET request and returns information about gopypi server

func (*InfoAPIView) GET 

func (i *InfoAPIView) GET(w http.ResponseWriter, r *http.Request) response.Response

GET method returns information about gopypi such as version, features, system info

type License 

type License struct {
	ID       uint   `gorm:"primary_key" json:"id"`
	Approved bool   `json:"approved"`
	Code     string `json:"code"`
	Content  string `json:"content"`
	Name     string `json:"name"`
}

License model

Holds informations about available licenses.

type LicenseAPIViewSet 

type LicenseAPIViewSet struct {
	classy.ViewSet

	// configuration
	Config Config
}

LicenseAPIViewSet provides rest apis for handling of license model

func (*LicenseAPIViewSet) List 

func (l *LicenseAPIViewSet) List(w http.ResponseWriter, r *http.Request) response.Response

List all licenses

func (*LicenseAPIViewSet) MetadataList 

func (l *LicenseAPIViewSet) MetadataList(w http.ResponseWriter, r *http.Request) response.Response

Metadata for list endpoints

func (*LicenseAPIViewSet) Retrieve 

func (l *LicenseAPIViewSet) Retrieve(w http.ResponseWriter, r *http.Request) response.Response

Retrieve single license from database

func (*LicenseAPIViewSet) Update 

func (l *LicenseAPIViewSet) Update(w http.ResponseWriter, r *http.Request) response.Response

Update updates license with serializer data

type LicenseManager 

type LicenseManager struct {
	DB *gorm.DB
}

LicenseManager database manager

func (*LicenseManager) GetByCode 

func (l *LicenseManager) GetByCode(code string) (license License, err error)

GetByCode returns license by code, if not exist create new one

type LicenseUpdateSerializer 

type LicenseUpdateSerializer struct {
	ID       uint   `json:"-"`
	Approved bool   `json:"approved"`
	Name     string `json:"name"`
	Content  string `json:"content"`
}

LicenseUpdateSerializer handles license update

func (*LicenseUpdateSerializer) UpdateLicense 

func (l *LicenseUpdateSerializer) UpdateLicense(license *License)

Update license with data form serializer

func (*LicenseUpdateSerializer) Validate 

func (l *LicenseUpdateSerializer) Validate(cfg Config, ID int) (result ValidationResult)

Validate runs validation on serializer fields

type LoginAPIView 

type LoginAPIView struct {
	classy.GenericView

	Config Config
}

LoginAPIView servers single POST method

func (*LoginAPIView) POST 

func (l *LoginAPIView) POST(w http.ResponseWriter, r *http.Request) response.Response

POST checks for username and password in JSON format and returns appropriate json response. If succeeds, Authorization header is added with correct token

type LoginSerializer 

type LoginSerializer struct {
	Username string `json:"username"`
	Password string `json:"password"`
}

LoginSerializer is login form for json

func (*LoginSerializer) Validate 

func (l *LoginSerializer) Validate() (err error)

type Manager 

type Manager struct {
	DB *gorm.DB
}

Generic manager

Should have following methods:

* List * Get

func (*Manager) Get 

func (p *Manager) Get(target interface{}, filter ...FilterFunc) *gorm.DB

Get calls Where method from given pack with filter funcs applied

func (*Manager) List 

func (p *Manager) List(target interface{}, filter ...FilterFunc) *gorm.DB

List calls Where method from given pack with filter funcs applied

type ManagerConfig 

type ManagerConfig interface {
	// ClassifierManager returns new ClassifierManager instance
	Classifier(tx ...*gorm.DB) *ClassifierManager

	// DownloadStatsManager returns new DownloadStatsManager instance
	DownloadStats(tx ...*gorm.DB) *DownloadStatsManager

	// FeatureManager
	Feature(tx ...*gorm.DB) *FeatureManager

	// LicenseManager returns new LicenseManager instance
	License(tx ...*gorm.DB) *LicenseManager

	// PackageManager returns new PackageManager instance
	Package(tx ...*gorm.DB) *PackageManager

	// PackageVersionManager returns new PackageVersionManager instance
	PackageVersion(tx ...*gorm.DB) *PackageVersionManager

	// PackageVersionFileManager
	PackageVersionFile(tx ...*gorm.DB) *PackageVersionFileManager

	// PlatformManager returns new PlatformManager instance
	Platform(tx ...*gorm.DB) *PlatformManager

	// UserManager returns UserManager instance to query user data
	User(tx ...*gorm.DB) *UserManager
}

type MeAPIView 

type MeAPIView struct {
	classy.GenericView

	// store config
	Config Config
}

MeAPIView gives information about currently logged in user

GET method returns information about user from token POST method updates information

func (*MeAPIView) GET 

func (m *MeAPIView) GET(w http.ResponseWriter, r *http.Request) response.Response

GET returns information about user (from auth token)

func (*MeAPIView) POST 

func (m *MeAPIView) POST(w http.ResponseWriter, r *http.Request) response.Response

POST updates user information

type MeChangePasswordAPIView 

type MeChangePasswordAPIView struct {
	classy.GenericView

	// store config
	Config Config
}

MeChangePasswordAPIView provides api to change password for currently logged user

func (*MeChangePasswordAPIView) POST 

func (m *MeChangePasswordAPIView) POST(w http.ResponseWriter, r *http.Request) response.Response

POST method updates password for currently logged user

type MyPackageAPIView 

type MyPackageAPIView struct {
	classy.ListView

	// store config
	Config Config
}

MyPackageAPIView gives information about packages for currently logged in user

func (*MyPackageAPIView) List 

func (m *MyPackageAPIView) List(w http.ResponseWriter, r *http.Request) response.Response

List returns list of packages for given logged user. User must be either author or maintainer of packege to be returned in list.

type Package 

type Package struct {
	ID          uint             `gorm:"primary_key" json:"id"`
	Name        string           `json:"name"`
	Versions    []PackageVersion `gorm:"ForeignKey:PackageID" json:"versions,omitempty"`
	Maintainers []User           `gorm:"many2many:package_maintainers;" json:"maintainers,omitempty"`
	CreatedAt   time.Time        `json:"created_at"`
	UpdatedAt   time.Time        `json:"updated_at"`
	Author      *User            `gorm:"ForeignKey:AuthorID" json:"author,omitempty"`
	AuthorID    uint             `json:"-"`
}

Package model.

func GetPostedPackage 

func GetPostedPackage(cfg Config, r *http.Request) (pack Package, err error)

GetPackage parses request form and returns package

func (*Package) BeforeCreate 

func (p *Package) BeforeCreate() error

BeforeCreate sets CreatedAt

func (*Package) BeforeSave 

func (p *Package) BeforeSave() error

BeforeSave sets UpdatedAt

type PackageAPIViewSet 

type PackageAPIViewSet struct {
	classy.ViewSet

	// store config
	Config Config
}

PackageAPIViewSet provides following methods

List - list packages Retrieve - retrieve single package

func (*PackageAPIViewSet) List 

func (p *PackageAPIViewSet) List(w http.ResponseWriter, r *http.Request) response.Response

List retrieves list of packages

func (*PackageAPIViewSet) Retrieve 

func (p *PackageAPIViewSet) Retrieve(w http.ResponseWriter, r *http.Request) response.Response

Retrieve returns single package

type PackageDetailView 

type PackageDetailView struct {
	classy.SlugDetailView

	// config instance
	Config Config
}

PackageDetailView returns detail of package

func (*PackageDetailView) Retrieve 

func (p *PackageDetailView) Retrieve(w http.ResponseWriter, r *http.Request) response.Response

Retrieve is GET method

type PackageDownloadView 

type PackageDownloadView struct {
	classy.BaseView

	Config Config
}

PackageDownloadView serves download

func (*PackageDownloadView) Download 

func (p *PackageDownloadView) Download(w http.ResponseWriter, r *http.Request) response.Response

Download returns content of requested file.

Aside of that, when download_stats feature is enabled, stats will be recorded to database.

func (*PackageDownloadView) Routes 

func (p *PackageDownloadView) Routes() (result map[string]classy.Mapping)

Routes returns list of routes with predefined method maps

type PackageListView 

type PackageListView struct {
	classy.ListView

	// config instance
	Config Config
}

PackageListView returns list of packages

func (*PackageListView) List 

func (p *PackageListView) List(rw http.ResponseWriter, r *http.Request) response.Response

List (http GET) returns list of all packages

if `format` url query is set to json, json response will be returned

type PackageMaintainerAPIViewSet 

type PackageMaintainerAPIViewSet struct {
	classy.ViewSet

	// config instance
	Config Config
}

PackageMaintainerAPIViewSet provides rest endpoints for maintainers of given package

func (*PackageMaintainerAPIViewSet) Delete 

func (p *PackageMaintainerAPIViewSet) Delete(w http.ResponseWriter, r *http.Request) response.Response

Delete removes association of maintainer to given package

func (*PackageMaintainerAPIViewSet) GetPackage 

func (p *PackageMaintainerAPIViewSet) GetPackage(r *http.Request) (result Package, err error)

GetPackage returns package from request

func (*PackageMaintainerAPIViewSet) List 

func (p *PackageMaintainerAPIViewSet) List(w http.ResponseWriter, r *http.Request) response.Response

List method lists all maintainers for given package

func (*PackageMaintainerAPIViewSet) Update 

func (p *PackageMaintainerAPIViewSet) Update(w http.ResponseWriter, r *http.Request) response.Response

Update association means that when it's not present, it's created, Update method doesn't handle request body.

type PackageManager 

type PackageManager struct {
	DB *gorm.DB
}

PackageManager database manager

func (*PackageManager) Get 

func (p *PackageManager) Get(pack *Package, filter ...FilterFunc) *gorm.DB

Get calls Where method from given pack with preloads

func (*PackageManager) IsMaintainer 

func (p *PackageManager) IsMaintainer(pack *Package, user *User) bool

check if user is maintainer

func (*PackageManager) List 

func (p *PackageManager) List(packages *[]Package, filter ...FilterFunc) *gorm.DB

Get calls Where method from given pack with preloads

func (*PackageManager) UpdateVersionOrder 

func (p *PackageManager) UpdateVersionOrder(pack Package) (err error)

UpdateVersionOrder updates order for all versions

type PackageVersion 

type PackageVersion struct {
	ID           uint                 `gorm:"primary_key" json:"id"`
	PackageID    uint                 `json:"-"`
	CreatedAt    time.Time            `json:"created_at"`
	UpdatedAt    time.Time            `json:"updated_at"`
	Author       *User                `gorm:"ForeignKey:AuthorID" json:"author,omitempty"`
	AuthorID     uint                 `json:"-"`
	Comment      string               `json:"comment"`
	Description  string               `json:"description"`
	Summary      string               `json:"summary"`
	HomePage     string               `json:"home_page"`
	License      *License             `gorm:"ForeignKey:LicenseID" json:"license,omitempty"`
	LicenseID    uint                 `json:"-"`
	Version      string               `gorm:"index" json:"version"`
	VersionOrder int                  `gorm:"index" json:"version_order"`
	Files        []PackageVersionFile `gorm:"ForeignKey:PackageVersionID" json:"files,omitempty"`
	Classifiers  []Classifier         `gorm:"many2many:package_version_classifiers;" json:"classifiers,omitempty"`
}

PackageVersion model that holds information about given package version

func GetPostedPackageVersion 

func GetPostedPackageVersion(cfg Config, pack Package, r *http.Request) (pv PackageVersion, err error)

Return package version

func (*PackageVersion) BeforeCreate 

func (p *PackageVersion) BeforeCreate() error

BeforeCreate sets CreatedAt

func (*PackageVersion) BeforeSave 

func (p *PackageVersion) BeforeSave() error

BeforeSave sets UpdatedAt

type PackageVersionFile 

type PackageVersionFile struct {
	ID               uint      `gorm:"primary_key" json:"id"`
	PackageVersionID uint      `json:"-"`
	Filename         string    `json:"filename"`
	RelativePath     string    `json:"relative_path"`
	MD5Digest        string    `gorm:"column:md5_digest" json:"md5_digest"`
	Author           *User     `gorm:"ForeignKey:AuthorID" json:"author,omitempty"`
	AuthorID         uint      `json:"-"`
	CreatedAt        time.Time `json:"created_at"`

	// this field is used to have pregenearated download url
	DownloadURL string `gorm:"-" json:"download_url,omitempty"`
}

PackageVersionFile model

func GetPostedPackageVersionFile 

func GetPostedPackageVersionFile(config Config, pv PackageVersion, r *http.Request) (result PackageVersionFile, filename string, err error)

Returns PackageVersionFile along with tempfile

func (*PackageVersionFile) BeforeCreate 

func (p *PackageVersionFile) BeforeCreate() error

BeforeCreate sets CreatedAt

func (PackageVersionFile) GenerateRelativePath 

func (p PackageVersionFile) GenerateRelativePath() string

GenerateRelativePath generates random relative path

type PackageVersionFileManager 

type PackageVersionFileManager struct {
	*Manager

	PackagesDir string
	Router      *mux.Router
}

PackageVersionFileManager database manager

func (*PackageVersionFileManager) GetAbsoluteFilename 

func (p *PackageVersionFileManager) GetAbsoluteFilename(pvf *PackageVersionFile) string

GetAbsoluteFilename returns full package filename

func (*PackageVersionFileManager) GetDownloadURL 

func (p *PackageVersionFileManager) GetDownloadURL(pvf *PackageVersionFile) string

GetDownloadURL returns full url for downloading package

func (*PackageVersionFileManager) GetRelativeFilename 

func (p *PackageVersionFileManager) GetRelativeFilename(pvf *PackageVersionFile) string

GetAbsoluteFilename returns full package filename

type PackageVersionManager 

type PackageVersionManager struct {
	*Manager
}

PackageVersionManager database manager

type PackageVersionPathInfo 

type PackageVersionPathInfo struct {
	FullPath         string
	RelativePath     string
	RelativeFilename string
	FullFilename     string
}

func GetPackageVersionFilePath 

func GetPackageVersionFilePath(packagedir, packagename, filename string) (pvi PackageVersionPathInfo, err error)

GetPackageRelativePath returns relative filename with added directory to packages dir

type PackagesConfig 

type PackagesConfig interface {
	// Directory returns full directory containint all packages
	Directory() string

	// JoinDirectory joins given parts with directory
	JoinDirectory(part ...string) string
}

type Platform 

type Platform struct {
	ID          uint   `json:"id"`
	Name        string `json:"name"`
	Description string `json:"description"`
}

Platform model tracks all platforms such as: Linux, Darwin even more esoteric.

type PlatformAPIViewSet 

type PlatformAPIViewSet struct {
	classy.ViewSet

	// configuration
	Config Config
}

PlatformAPIViewSet provides rest endpoints for platform (RU)

func (*PlatformAPIViewSet) List 

func (p *PlatformAPIViewSet) List(w http.ResponseWriter, r *http.Request) response.Response

List returns all platform stored in database

func (*PlatformAPIViewSet) Retrieve 

func (p *PlatformAPIViewSet) Retrieve(w http.ResponseWriter, r *http.Request) response.Response

Retrieve returns single platform

type PlatformManager 

type PlatformManager struct {
	DB *gorm.DB
}

PlatformManager database manager for model Platform

func (*PlatformManager) Get 

func (p *PlatformManager) Get(platform *Platform) *gorm.DB

Get returns platform by set fields

func (*PlatformManager) List 

func (p *PlatformManager) List(platforms *[]Platform, filter ...FilterFunc) *gorm.DB

List returns list of platforms

func (*PlatformManager) ListOrCreate 

func (p *PlatformManager) ListOrCreate(target *[]Platform, platforms []string) error

Return multiple platforms

type PostPackageView 

type PostPackageView struct {
	classy.GenericView

	Config Config
}

PostPackageView handles all methods on package

func (*PostPackageView) ActionFileUpload 

func (p *PostPackageView) ActionFileUpload(r *http.Request) response.Response

ActionFileUpload Handles file upload which is called with 

`python setup.py upload`

func (*PostPackageView) Before 

func (p *PostPackageView) Before(w http.ResponseWriter, r *http.Request) (resp response.Response)

Before every request we need to check permissions

func (*PostPackageView) POST 

func (p *PostPackageView) POST(w http.ResponseWriter, r *http.Request) response.Response

POST method for handling package

type SearchResult 

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

SearchResult item

type SearchService 

type SearchService struct {
	Config Config
}

SearchService xml rpc service for searching packages

func (*SearchService) Dispatch 

func (s *SearchService) Dispatch(method string, root *etree.Element) (doc *etree.Document, err error)

Dispatch dispatches method on service, do not use this method directly. root is params *etree.Element (actually "methodCall/params"

func (*SearchService) ListMethods 

func (s *SearchService) ListMethods() []string

ListMethods returns list of all available methods for given service

func (*SearchService) MethodExists 

func (s *SearchService) MethodExists(method string) (ok bool)

MethodExists returns whether rpc method is available on service

type Server 

type Server interface {
	// Config returns server config
	Config() Config

	// Router returns server router
	Router() *mux.Router

	// ListenAndServe runs http server
	ListenAndServe() error
}

func New 

func New(cfg Config) (result Server, err error)

New returns fresh gopypi server instance bound to config.

type Stats 

type Stats struct {
	Packages    int `json:"packages"`
	ActiveUsers int `json:"active_users"`
	Licenses    int `json:"licenses"`
	Downloads   int `json:"downloads"`
}

Stats result

type StatsAPIView 

type StatsAPIView struct {
	classy.GenericView

	Config Config
}

StatsAPIView returns some statistic information for admin dashboard.

func (*StatsAPIView) GET 

func (s *StatsAPIView) GET(w http.ResponseWriter, r *http.Request) response.Response

GET returns summary statistics about gopypi

type StatsAggregation 

type StatsAggregation int
const (
	STATS_DOWNLOAD_WEEKLY StatsAggregation = iota + 1
	STATS_DOWNLOAD_MONTHLY
	STATS_DOWNLOAD_ALL
)

type StatsDownloadAllAPIView 

type StatsDownloadAllAPIView struct {
	classy.ListView

	// config instance
	Config Config
}

StatsDownloadAllAPIView provides stats of package downloads

func (*StatsDownloadAllAPIView) List 

func (s *StatsDownloadAllAPIView) List(w http.ResponseWriter, r *http.Request) response.Response

List returns download stats about all packages (sums)

type StatsDownloadItem 

type StatsDownloadItem struct {
	PackageVersion   *PackageVersion `gorm:"ForeignKey:PackageVersionID" json:"version,omitempty"`
	PackageVersionID uint            `json:"-"`
	Downloads        int             `json:"downloads"`
	CreatedAt        time.Time       `json:"created_at"`
}

type StatsDownloadPackageAPIView 

type StatsDownloadPackageAPIView struct {
	classy.DetailView

	// config instance
	Config Config
}

StatsDownloadPackageAPIView provides stats of package downloads

func (*StatsDownloadPackageAPIView) Retrieve 

func (s *StatsDownloadPackageAPIView) Retrieve(w http.ResponseWriter, r *http.Request) response.Response

List returns download stats about all packages (sum)

type StatsDownloadPackageVersionAPIView 

type StatsDownloadPackageVersionAPIView struct {
	classy.DetailView

	// config instance
	Config Config
}

StatsDownloadPackageVersionAPIView provides stats of package version downloads

func (*StatsDownloadPackageVersionAPIView) Retrieve 

func (s *StatsDownloadPackageVersionAPIView) Retrieve(w http.ResponseWriter, r *http.Request) response.Response

List returns download stats about all package versions (sum)

type Task 

type Task interface {

	// Run executes task
	Run(config Config) error
}

Task interface for background running tasks

type TemplateView 

type TemplateView struct {
	classy.GenericView

	// configuration
	Config Config

	// Data for template
	Data map[string]interface{}

	// TemplateFilename
	TemplateName string
}

TemplateView can be directly instantiated when registering view. Be careful that template view needs Config and TemplateName.

Example how :: 

classy.New(TemplateView{Config: cfg, TemplateName: "homepage.tpl.html"}).Register(router, "homepage")

func (TemplateView) GET 

func (t TemplateView) GET(w http.ResponseWriter, r *http.Request)

GET handles return rendered template

type TokenClaims 

type TokenClaims struct {
	UserID uint `json:"user_id"`
	jwt.StandardClaims
}

TokenClaims holds information for token

func ParseToken 

func ParseToken(r *http.Request, secret string) (claims *TokenClaims, err error)

ParseToken parses token and returns claims

type User 

type User struct {
	ID        uint   `gorm:"primary_key" json:"id"`
	Username  string `gorm:"type:varchar(20);unique_index" json:"username"`
	Email     string `gorm:"type:varchar(100);index" json:"email"`
	Password  string `gorm:"type:varchar(256)" json:"-"`
	FirstName string `gorm:"type:varchar(40)" json:"first_name"`
	LastName  string `gorm:"type:varchar(40)" json:"last_name"`
	IsActive  bool   `json:"is_active"`
	IsAdmin   bool   `json:"is_admin"`

	// permissions
	CanList     bool `json:"can_list"`
	CanCreate   bool `json:"can_create"`
	CanDownload bool `json:"can_download"`
	CanUpdate   bool `json:"can_update"`

	CreatedAt time.Time `json:"created_at"`
	UpdatedAt time.Time `json:"updated_at"`
}

User model

To set/verify user password please use UserManager

func ContextGetTokenUser 

func ContextGetTokenUser(ctx context.Context) (user User, err error)

Return token claims from request context

func (*User) BeforeCreate 

func (u *User) BeforeCreate() error

BeforeCreate sets CreatedAt

func (*User) BeforeSave 

func (u *User) BeforeSave() error

BeforeSave sets UpdatedAt

type UserAPIViewSet 

type UserAPIViewSet struct {
	classy.ViewSet

	// store config
	Config Config
}

UserAPIViewSet handles basic crud on users

func (*UserAPIViewSet) Create 

func (u *UserAPIViewSet) Create(w http.ResponseWriter, r *http.Request) response.Response

Create is called when new user is created

func (*UserAPIViewSet) List 

func (u *UserAPIViewSet) List(w http.ResponseWriter, r *http.Request) response.Response

List of users

func (*UserAPIViewSet) Retrieve 

func (u *UserAPIViewSet) Retrieve(w http.ResponseWriter, r *http.Request)

Retrieve single user

func (*UserAPIViewSet) Update 

func (u *UserAPIViewSet) Update(w http.ResponseWriter, r *http.Request) response.Response

Update is called when POST is called to update user

type UserAddSerializer 

type UserAddSerializer struct {
	Username    string `json:"username"`
	FirstName   string `json:"first_name"`
	LastName    string `json:"last_name"`
	Email       string `json:"email"`
	Password    string `json:"password"`
	Password2   string `json:"password2"`
	IsActive    bool   `json:"is_active"`
	IsAdmin     bool   `json:"is_admin"`
	CanList     bool   `json:"can_list"`
	CanDownload bool   `json:"can_download"`
	CanCreate   bool   `json:"can_create"`
	CanUpdate   bool   `json:"can_update"`
}

Serializer to create new user

func (*UserAddSerializer) GetUser 

func (u *UserAddSerializer) GetUser(cfg Config) (user User)

return user initialized with serializer values

func (*UserAddSerializer) Validate 

func (u *UserAddSerializer) Validate(cfg Config) (result ValidationResult)

Validate validates information about new user

@TODO: add ValidateUsername and ValidateEmail

type UserChangePasswordSerializer 

type UserChangePasswordSerializer struct {
	Current   string `json:"current"`
	Password  string `json:"password"`
	Password2 string `json:"password2"`
	User      User   `json:"-"`
}

Serializer to change password for currently logged user

func (*UserChangePasswordSerializer) ChangePassword 

func (u *UserChangePasswordSerializer) ChangePassword(config Config, user *User) (err error)

ChangePassword changes password for given user

func (*UserChangePasswordSerializer) Validate 

func (u *UserChangePasswordSerializer) Validate(cfg Config) (result ValidationResult)

Validate validates serializer data

type UserListFilter 

type UserListFilter struct {
	IsActive *bool
}

UserListFilter filters users from url

func (UserListFilter) Apply 

func (u UserListFilter) Apply(queryset *gorm.DB) *gorm.DB

Apply applies filter to queryset

type UserManager 

type UserManager struct {
	DB        *gorm.DB
	SecretKey string
}

UserManager groups functionality to query user model instances

func (*UserManager) ExistsEmail 

func (u *UserManager) ExistsEmail(email string) bool

ExistsEmail returns whether user with given email exists in database

func (*UserManager) ExistsUsername 

func (u *UserManager) ExistsUsername(username string) bool

ExistsUsername returns whether user with given username exists in database

func (*UserManager) Get 

func (u *UserManager) Get(user *User) *gorm.DB

Get

func (*UserManager) SetPassword 

func (u *UserManager) SetPassword(user *User, password string)

SetPassword sets password for given user

func (*UserManager) VerifyPassword 

func (u *UserManager) VerifyPassword(user User, password string) bool

VerifyPassword verifies password for user

type UserProfileSerializer 

type UserProfileSerializer struct {
	FirstName string `json:"first_name"`
	LastName  string `json:"last_name"`
	Email     string `json:"email"`
}

Serializer for updating user profile

func (*UserProfileSerializer) Validate 

func (u *UserProfileSerializer) Validate(cfg Config) (result ValidationResult)

Validate validates serializer

type UserUpdateSerializer 

type UserUpdateSerializer struct {
	ID          uint   `json:"-"`
	Username    string `json:"username"`
	FirstName   string `json:"first_name"`
	LastName    string `json:"last_name"`
	Email       string `json:"email"`
	Password    string `json:"password"`
	Password2   string `json:"password2"`
	IsActive    bool   `json:"is_active"`
	IsAdmin     bool   `json:"is_admin"`
	CanList     bool   `json:"can_list"`
	CanDownload bool   `json:"can_download"`
	CanCreate   bool   `json:"can_create"`
	CanUpdate   bool   `json:"can_update"`
	// contains filtered or unexported fields
}

Serializer to update existing user

func (*UserUpdateSerializer) UpdateUser 

func (u *UserUpdateSerializer) UpdateUser(cfg Config, user *User)

UpdateUser updates user with serializer data

func (*UserUpdateSerializer) Validate 

func (u *UserUpdateSerializer) Validate(cfg Config) (result ValidationResult)

Validate validates data in serializer

type ValidationError 

type ValidationError struct {
	Code  string `json:"code,omitempty"`
	Error string `json:"error"`
}

type ValidationResult 

type ValidationResult interface {
	// add field related error
	AddFieldError(field string, err error, code ...string) ValidationResult

	// add not field related error
	AddUnboundError(err error, code ...string) ValidationResult

	// returns whether result is valid
	IsValid() bool

	// marshals result to json
	MarshalJSON() ([]byte, error)

	// returns whether field has error
	HasFieldError(field string) bool
}

func NewValidationResult 

func NewValidationResult() ValidationResult

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.