model

Nov 7, 2018

Changes in this version

+ const TableRefreshToken

+ const TableRefreshTokenColumnCreatedAt

+ const TableRefreshTokenColumnCreatedBy

+ const TableRefreshTokenColumnExpireAt

+ const TableRefreshTokenColumnLastUsedAt

+ const TableRefreshTokenColumnNotes

+ const TableRefreshTokenColumnRevoked

+ const TableRefreshTokenColumnToken

+ const TableRefreshTokenColumnUpdatedAt

+ const TableRefreshTokenColumnUpdatedBy

+ const TableRefreshTokenColumnUserID

+ const TableRefreshTokenConstraintCreatedByForeignKey

+ const TableRefreshTokenConstraintTokenUnique

+ const TableRefreshTokenConstraintUpdatedByForeignKey

+ const TableRefreshTokenConstraintUserIDForeignKey

+ var RetryTransaction = errors.New("retry transaction")

+ var TableRefreshTokenColumns = []string

+ func RefreshTokenCriteriaWhereClause(comp *Composer, c *RefreshTokenCriteria, id int) error

+ func RunInTransaction(ctx context.Context, db *sql.DB, f func(tx *sql.Tx) error, attempts int) (err error)

type GroupCriteria

+ func GroupAnd(operands ...*GroupCriteria) *GroupCriteria

+ func GroupOperand(operator string, operands ...*GroupCriteria) *GroupCriteria

+ func GroupOr(operands ...*GroupCriteria) *GroupCriteria

type GroupPermissionsCriteria

+ func GroupPermissionsAnd(operands ...*GroupPermissionsCriteria) *GroupPermissionsCriteria

+ func GroupPermissionsOperand(operator string, operands ...*GroupPermissionsCriteria) *GroupPermissionsCriteria

+ func GroupPermissionsOr(operands ...*GroupPermissionsCriteria) *GroupPermissionsCriteria

type GroupPermissionsRepositoryBase

+ func (r *GroupPermissionsRepositoryBase) BeginTx(ctx context.Context) (*GroupPermissionsRepositoryBaseTx, error)

+ func (r *GroupPermissionsRepositoryBase) Tx(tx *sql.Tx) (*GroupPermissionsRepositoryBaseTx, error)

+ func (r GroupPermissionsRepositoryBase) RunInTransaction(ctx context.Context, fn func(rtx *GroupPermissionsRepositoryBaseTx) error, ...) (err error)

+ type GroupPermissionsRepositoryBaseTx struct

+ func (r *GroupPermissionsRepositoryBaseTx) Count(ctx context.Context, exp *GroupPermissionsCountExpr) (int64, error)

+ func (r *GroupPermissionsRepositoryBaseTx) Find(ctx context.Context, fe *GroupPermissionsFindExpr) ([]*GroupPermissionsEntity, error)

+ func (r *GroupPermissionsRepositoryBaseTx) FindIter(ctx context.Context, fe *GroupPermissionsFindExpr) (*GroupPermissionsIterator, error)

+ func (r *GroupPermissionsRepositoryBaseTx) Insert(ctx context.Context, e *GroupPermissionsEntity) (*GroupPermissionsEntity, error)

+ func (r *GroupPermissionsRepositoryBaseTx) UpdateOneByGroupIDAndPermissionSubsystemAndPermissionModuleAndPermissionAction(ctx context.Context, groupPermissionsGroupID int64, ...) (*GroupPermissionsEntity, error)

+ func (r *GroupPermissionsRepositoryBaseTx) Upsert(ctx context.Context, e *GroupPermissionsEntity, p *GroupPermissionsPatch, ...) (*GroupPermissionsEntity, error)

+ func (r GroupPermissionsRepositoryBaseTx) Commit() error

+ func (r GroupPermissionsRepositoryBaseTx) Rollback() error

type GroupRepository

+ UserGroups UserGroupsRepositoryBase

type GroupRepositoryBase

+ func (r *GroupRepositoryBase) BeginTx(ctx context.Context) (*GroupRepositoryBaseTx, error)

+ func (r *GroupRepositoryBase) FindOneByIDAndUpdate(ctx context.Context, pk int64, p *GroupPatch) (before, after *GroupEntity, err error)

+ func (r *GroupRepositoryBase) Tx(tx *sql.Tx) (*GroupRepositoryBaseTx, error)

+ func (r GroupRepositoryBase) RunInTransaction(ctx context.Context, fn func(rtx *GroupRepositoryBaseTx) error, attempts int) (err error)

+ type GroupRepositoryBaseTx struct

+ func (r *GroupRepositoryBaseTx) Count(ctx context.Context, exp *GroupCountExpr) (int64, error)

+ func (r *GroupRepositoryBaseTx) DeleteOneByID(ctx context.Context, pk int64) (int64, error)

+ func (r *GroupRepositoryBaseTx) Find(ctx context.Context, fe *GroupFindExpr) ([]*GroupEntity, error)

+ func (r *GroupRepositoryBaseTx) FindIter(ctx context.Context, fe *GroupFindExpr) (*GroupIterator, error)

+ func (r *GroupRepositoryBaseTx) FindOneByID(ctx context.Context, pk int64) (*GroupEntity, error)

+ func (r *GroupRepositoryBaseTx) Insert(ctx context.Context, e *GroupEntity) (*GroupEntity, error)

+ func (r *GroupRepositoryBaseTx) UpdateOneByID(ctx context.Context, pk int64, p *GroupPatch) (*GroupEntity, error)

+ func (r *GroupRepositoryBaseTx) UpdateOneByName(ctx context.Context, groupName string, p *GroupPatch) (*GroupEntity, error)

+ func (r *GroupRepositoryBaseTx) Upsert(ctx context.Context, e *GroupEntity, p *GroupPatch, inf ...string) (*GroupEntity, error)

+ func (r GroupRepositoryBaseTx) Commit() error

+ func (r GroupRepositoryBaseTx) Rollback() error

type JoinType

+ func (jt JoinType) Actionable() bool

type PermissionCriteria

+ func PermissionAnd(operands ...*PermissionCriteria) *PermissionCriteria

+ func PermissionOperand(operator string, operands ...*PermissionCriteria) *PermissionCriteria

+ func PermissionOr(operands ...*PermissionCriteria) *PermissionCriteria

type PermissionRepositoryBase

+ func (r *PermissionRepositoryBase) BeginTx(ctx context.Context) (*PermissionRepositoryBaseTx, error)

+ func (r *PermissionRepositoryBase) FindOneByIDAndUpdate(ctx context.Context, pk int64, p *PermissionPatch) (before, after *PermissionEntity, err error)

+ func (r *PermissionRepositoryBase) Tx(tx *sql.Tx) (*PermissionRepositoryBaseTx, error)

+ func (r PermissionRepositoryBase) RunInTransaction(ctx context.Context, fn func(rtx *PermissionRepositoryBaseTx) error, ...) (err error)

+ type PermissionRepositoryBaseTx struct

+ func (r *PermissionRepositoryBaseTx) Count(ctx context.Context, exp *PermissionCountExpr) (int64, error)

+ func (r *PermissionRepositoryBaseTx) DeleteOneByID(ctx context.Context, pk int64) (int64, error)

+ func (r *PermissionRepositoryBaseTx) Find(ctx context.Context, fe *PermissionFindExpr) ([]*PermissionEntity, error)

+ func (r *PermissionRepositoryBaseTx) FindIter(ctx context.Context, fe *PermissionFindExpr) (*PermissionIterator, error)

+ func (r *PermissionRepositoryBaseTx) FindOneByID(ctx context.Context, pk int64) (*PermissionEntity, error)

+ func (r *PermissionRepositoryBaseTx) Insert(ctx context.Context, e *PermissionEntity) (*PermissionEntity, error)

+ func (r *PermissionRepositoryBaseTx) UpdateOneByID(ctx context.Context, pk int64, p *PermissionPatch) (*PermissionEntity, error)

+ func (r *PermissionRepositoryBaseTx) UpdateOneBySubsystemAndModuleAndAction(ctx context.Context, permissionSubsystem string, permissionModule string, ...) (*PermissionEntity, error)

+ func (r *PermissionRepositoryBaseTx) Upsert(ctx context.Context, e *PermissionEntity, p *PermissionPatch, inf ...string) (*PermissionEntity, error)

+ func (r PermissionRepositoryBaseTx) Commit() error

+ func (r PermissionRepositoryBaseTx) Rollback() error

+ type RefreshTokenCountExpr struct

+ JoinAuthor *UserJoin

+ JoinModifier *UserJoin

+ JoinUser *UserJoin

+ Where *RefreshTokenCriteria

+ type RefreshTokenCriteria struct

+ CreatedAt *qtypes.Timestamp

+ CreatedBy *qtypes.Int64

+ ExpireAt *qtypes.Timestamp

+ LastUsedAt *qtypes.Timestamp

+ Notes *qtypes.String

+ Revoked ntypes.Bool

+ Token *qtypes.String

+ UpdatedAt *qtypes.Timestamp

+ UpdatedBy *qtypes.Int64

+ UserID *qtypes.Int64

+ func RefreshTokenAnd(operands ...*RefreshTokenCriteria) *RefreshTokenCriteria

+ func RefreshTokenOperand(operator string, operands ...*RefreshTokenCriteria) *RefreshTokenCriteria

+ func RefreshTokenOr(operands ...*RefreshTokenCriteria) *RefreshTokenCriteria

+ type RefreshTokenEntity struct

+ Author *UserEntity

+ CreatedAt time.Time

+ CreatedBy ntypes.Int64

+ ExpireAt pq.NullTime

+ LastUsedAt pq.NullTime

+ Modifier *UserEntity

+ Notes ntypes.String

+ Revoked bool

+ Token string

+ UpdatedAt pq.NullTime

+ UpdatedBy ntypes.Int64

+ User *UserEntity

+ UserID int64

+ func ScanRefreshTokenRows(rows Rows) (entities []*RefreshTokenEntity, err error)

+ func (e *RefreshTokenEntity) Prop(cn string) (interface{}, bool)

+ func (e *RefreshTokenEntity) Props(cns ...string) ([]interface{}, error)

+ type RefreshTokenFindExpr struct

+ Columns []string

+ JoinAuthor *UserJoin

+ JoinModifier *UserJoin

+ JoinUser *UserJoin

+ Limit int64

+ Offset int64

+ OrderBy []RowOrder

+ Where *RefreshTokenCriteria

+ type RefreshTokenIterator struct

+ func (i *RefreshTokenIterator) Close() error

+ func (i *RefreshTokenIterator) Columns() ([]string, error)

+ func (i *RefreshTokenIterator) Ent() (interface{}, error)

+ func (i *RefreshTokenIterator) Err() error

+ func (i *RefreshTokenIterator) Next() bool

+ func (i *RefreshTokenIterator) RefreshToken() (*RefreshTokenEntity, error)

+ type RefreshTokenJoin struct

+ Fetch bool

+ JoinAuthor *UserJoin

+ JoinModifier *UserJoin

+ JoinUser *UserJoin

+ Kind JoinType

+ On *RefreshTokenCriteria

+ Where *RefreshTokenCriteria

+ type RefreshTokenPatch struct

+ CreatedAt pq.NullTime

+ CreatedBy ntypes.Int64

+ ExpireAt pq.NullTime

+ LastUsedAt pq.NullTime

+ Notes ntypes.String

+ Revoked ntypes.Bool

+ Token ntypes.String

+ UpdatedAt pq.NullTime

+ UpdatedBy ntypes.Int64

+ UserID ntypes.Int64

+ type RefreshTokenProvider interface

+ Create func(context.Context, *RefreshTokenEntity) (*RefreshTokenEntity, error)

+ Find func(context.Context, *RefreshTokenFindExpr) ([]*RefreshTokenEntity, error)

+ FindOneByToken func(context.Context, string) (*RefreshTokenEntity, error)

+ FindOneByTokenAndUserID func(ctx context.Context, token string, userID int64) (*RefreshTokenEntity, error)

+ UpdateOneByToken func(context.Context, string, *RefreshTokenPatch) (*RefreshTokenEntity, error)

+ func NewRefreshTokenRepository(dbPool *sql.DB) RefreshTokenProvider

+ type RefreshTokenRepository struct

+ func (rtr *RefreshTokenRepository) Create(ctx context.Context, ent *RefreshTokenEntity) (*RefreshTokenEntity, error)

+ func (rtr *RefreshTokenRepository) FindOneByTokenAndUserID(ctx context.Context, token string, userID int64) (*RefreshTokenEntity, error)

+ type RefreshTokenRepositoryBase struct

+ Columns []string

+ DB *sql.DB

+ Log LogFunc

+ Table string

+ func (r *RefreshTokenRepositoryBase) BeginTx(ctx context.Context) (*RefreshTokenRepositoryBaseTx, error)

+ func (r *RefreshTokenRepositoryBase) Count(ctx context.Context, exp *RefreshTokenCountExpr) (int64, error)

+ func (r *RefreshTokenRepositoryBase) Find(ctx context.Context, fe *RefreshTokenFindExpr) ([]*RefreshTokenEntity, error)

+ func (r *RefreshTokenRepositoryBase) FindIter(ctx context.Context, fe *RefreshTokenFindExpr) (*RefreshTokenIterator, error)

+ func (r *RefreshTokenRepositoryBase) FindOneByToken(ctx context.Context, refreshTokenToken string) (*RefreshTokenEntity, error)

+ func (r *RefreshTokenRepositoryBase) FindQuery(fe *RefreshTokenFindExpr) (string, []interface{}, error)

+ func (r *RefreshTokenRepositoryBase) Insert(ctx context.Context, e *RefreshTokenEntity) (*RefreshTokenEntity, error)

+ func (r *RefreshTokenRepositoryBase) InsertQuery(e *RefreshTokenEntity, read bool) (string, []interface{}, error)

+ func (r *RefreshTokenRepositoryBase) Tx(tx *sql.Tx) (*RefreshTokenRepositoryBaseTx, error)

+ func (r *RefreshTokenRepositoryBase) UpdateOneByToken(ctx context.Context, refreshTokenToken string, p *RefreshTokenPatch) (*RefreshTokenEntity, error)

+ func (r *RefreshTokenRepositoryBase) UpdateOneByTokenQuery(refreshTokenToken string, p *RefreshTokenPatch) (string, []interface{}, error)

+ func (r *RefreshTokenRepositoryBase) Upsert(ctx context.Context, e *RefreshTokenEntity, p *RefreshTokenPatch, ...) (*RefreshTokenEntity, error)

+ func (r *RefreshTokenRepositoryBase) UpsertQuery(e *RefreshTokenEntity, p *RefreshTokenPatch, inf ...string) (string, []interface{}, error)

+ func (r RefreshTokenRepositoryBase) RunInTransaction(ctx context.Context, fn func(rtx *RefreshTokenRepositoryBaseTx) error, ...) (err error)

+ type RefreshTokenRepositoryBaseTx struct

+ func (r *RefreshTokenRepositoryBaseTx) Count(ctx context.Context, exp *RefreshTokenCountExpr) (int64, error)

+ func (r *RefreshTokenRepositoryBaseTx) Find(ctx context.Context, fe *RefreshTokenFindExpr) ([]*RefreshTokenEntity, error)

+ func (r *RefreshTokenRepositoryBaseTx) FindIter(ctx context.Context, fe *RefreshTokenFindExpr) (*RefreshTokenIterator, error)

+ func (r *RefreshTokenRepositoryBaseTx) Insert(ctx context.Context, e *RefreshTokenEntity) (*RefreshTokenEntity, error)

+ func (r *RefreshTokenRepositoryBaseTx) UpdateOneByToken(ctx context.Context, refreshTokenToken string, p *RefreshTokenPatch) (*RefreshTokenEntity, error)

+ func (r *RefreshTokenRepositoryBaseTx) Upsert(ctx context.Context, e *RefreshTokenEntity, p *RefreshTokenPatch, ...) (*RefreshTokenEntity, error)

+ func (r RefreshTokenRepositoryBaseTx) Commit() error

+ func (r RefreshTokenRepositoryBaseTx) Rollback() error

+ type RowOrder struct

+ Descending bool

+ Name string

type UserCriteria

+ func UserAnd(operands ...*UserCriteria) *UserCriteria

+ func UserOperand(operator string, operands ...*UserCriteria) *UserCriteria

+ func UserOr(operands ...*UserCriteria) *UserCriteria

type UserGroupsCriteria

+ func UserGroupsAnd(operands ...*UserGroupsCriteria) *UserGroupsCriteria

+ func UserGroupsOperand(operator string, operands ...*UserGroupsCriteria) *UserGroupsCriteria

+ func UserGroupsOr(operands ...*UserGroupsCriteria) *UserGroupsCriteria

type UserGroupsRepositoryBase

+ func (r *UserGroupsRepositoryBase) BeginTx(ctx context.Context) (*UserGroupsRepositoryBaseTx, error)

+ func (r *UserGroupsRepositoryBase) Tx(tx *sql.Tx) (*UserGroupsRepositoryBaseTx, error)

+ func (r UserGroupsRepositoryBase) RunInTransaction(ctx context.Context, fn func(rtx *UserGroupsRepositoryBaseTx) error, ...) (err error)

+ type UserGroupsRepositoryBaseTx struct

+ func (r *UserGroupsRepositoryBaseTx) Count(ctx context.Context, exp *UserGroupsCountExpr) (int64, error)

+ func (r *UserGroupsRepositoryBaseTx) Find(ctx context.Context, fe *UserGroupsFindExpr) ([]*UserGroupsEntity, error)

+ func (r *UserGroupsRepositoryBaseTx) FindIter(ctx context.Context, fe *UserGroupsFindExpr) (*UserGroupsIterator, error)

+ func (r *UserGroupsRepositoryBaseTx) Insert(ctx context.Context, e *UserGroupsEntity) (*UserGroupsEntity, error)

+ func (r *UserGroupsRepositoryBaseTx) UpdateOneByUserIDAndGroupID(ctx context.Context, userGroupsUserID int64, userGroupsGroupID int64, ...) (*UserGroupsEntity, error)

+ func (r *UserGroupsRepositoryBaseTx) Upsert(ctx context.Context, e *UserGroupsEntity, p *UserGroupsPatch, inf ...string) (*UserGroupsEntity, error)

+ func (r UserGroupsRepositoryBaseTx) Commit() error

+ func (r UserGroupsRepositoryBaseTx) Rollback() error

type UserPermissionsCriteria

+ func UserPermissionsAnd(operands ...*UserPermissionsCriteria) *UserPermissionsCriteria

+ func UserPermissionsOperand(operator string, operands ...*UserPermissionsCriteria) *UserPermissionsCriteria

+ func UserPermissionsOr(operands ...*UserPermissionsCriteria) *UserPermissionsCriteria

type UserPermissionsRepositoryBase

+ func (r *UserPermissionsRepositoryBase) BeginTx(ctx context.Context) (*UserPermissionsRepositoryBaseTx, error)

+ func (r *UserPermissionsRepositoryBase) Tx(tx *sql.Tx) (*UserPermissionsRepositoryBaseTx, error)

+ func (r UserPermissionsRepositoryBase) RunInTransaction(ctx context.Context, fn func(rtx *UserPermissionsRepositoryBaseTx) error, ...) (err error)

+ type UserPermissionsRepositoryBaseTx struct

+ func (r *UserPermissionsRepositoryBaseTx) Count(ctx context.Context, exp *UserPermissionsCountExpr) (int64, error)

+ func (r *UserPermissionsRepositoryBaseTx) Find(ctx context.Context, fe *UserPermissionsFindExpr) ([]*UserPermissionsEntity, error)

+ func (r *UserPermissionsRepositoryBaseTx) FindIter(ctx context.Context, fe *UserPermissionsFindExpr) (*UserPermissionsIterator, error)

+ func (r *UserPermissionsRepositoryBaseTx) Insert(ctx context.Context, e *UserPermissionsEntity) (*UserPermissionsEntity, error)

+ func (r *UserPermissionsRepositoryBaseTx) UpdateOneByUserIDAndPermissionSubsystemAndPermissionModuleAndPermissionAction(ctx context.Context, userPermissionsUserID int64, ...) (*UserPermissionsEntity, error)

+ func (r *UserPermissionsRepositoryBaseTx) Upsert(ctx context.Context, e *UserPermissionsEntity, p *UserPermissionsPatch, ...) (*UserPermissionsEntity, error)

+ func (r UserPermissionsRepositoryBaseTx) Commit() error

+ func (r UserPermissionsRepositoryBaseTx) Rollback() error

type UserRepositoryBase

+ func (r *UserRepositoryBase) BeginTx(ctx context.Context) (*UserRepositoryBaseTx, error)

+ func (r *UserRepositoryBase) FindOneByIDAndUpdate(ctx context.Context, pk int64, p *UserPatch) (before, after *UserEntity, err error)

+ func (r *UserRepositoryBase) Tx(tx *sql.Tx) (*UserRepositoryBaseTx, error)

+ func (r UserRepositoryBase) RunInTransaction(ctx context.Context, fn func(rtx *UserRepositoryBaseTx) error, attempts int) (err error)

+ type UserRepositoryBaseTx struct

+ func (r *UserRepositoryBaseTx) Count(ctx context.Context, exp *UserCountExpr) (int64, error)

+ func (r *UserRepositoryBaseTx) DeleteOneByID(ctx context.Context, pk int64) (int64, error)

+ func (r *UserRepositoryBaseTx) Find(ctx context.Context, fe *UserFindExpr) ([]*UserEntity, error)

+ func (r *UserRepositoryBaseTx) FindIter(ctx context.Context, fe *UserFindExpr) (*UserIterator, error)

+ func (r *UserRepositoryBaseTx) FindOneByID(ctx context.Context, pk int64) (*UserEntity, error)

+ func (r *UserRepositoryBaseTx) Insert(ctx context.Context, e *UserEntity) (*UserEntity, error)

+ func (r *UserRepositoryBaseTx) UpdateOneByID(ctx context.Context, pk int64, p *UserPatch) (*UserEntity, error)

+ func (r *UserRepositoryBaseTx) UpdateOneByUsername(ctx context.Context, userUsername string, p *UserPatch) (*UserEntity, error)

+ func (r *UserRepositoryBaseTx) Upsert(ctx context.Context, e *UserEntity, p *UserPatch, inf ...string) (*UserEntity, error)

+ func (r UserRepositoryBaseTx) Commit() error

+ func (r UserRepositoryBaseTx) Rollback() error

Oct 4, 2017

Changes in this version

type MockPermissionProvider

+ func (_m *MockPermissionProvider) Count(ctx context.Context, criteria *PermissionCountExpr) (int64, error)

+ func (_m *MockPermissionProvider) InsertMissing(ctx context.Context, permissions charon.Permissions) (int64, error)

type PermissionProvider

+ InsertMissing func(ctx context.Context, permissions charon.Permissions) (int64, error)

type PermissionRepository

+ func (pr *PermissionRepository) InsertMissing(ctx context.Context, permissions charon.Permissions) (int64, error)

Aug 16, 2017

Changes in this version

type MockRows

+ func (_m *MockRows) Close() error

Jul 21, 2017

Changes in this version

+ var ErrEmptySliceOfPermissions = errors.New("empty slice, permissions cannot be registered")

+ var ErrEmptySubsystem = errors.New("subsystem name is empty string, permissions cannot be registered")

+ var ErrorInconsistentSubsystem = errors.New(...)

May 25, 2017

Changes in this version

type CompositionOpts

+ PlaceholderCast string

+ PlaceholderFuncs []string

+ SelectorCast string

+ SelectorFuncs []string

+ type LogFunc func(err error, ent, fnc, sql string, args ...interface{})

+ type MockRows struct

+ func (_m *MockRows) ColumnTypes() ([]*sql.ColumnType, error)

+ func (_m *MockRows) Columns() ([]string, error)

+ func (_m *MockRows) Err() error

+ func (_m *MockRows) Next() bool

+ func (_m *MockRows) NextResultSet() bool

+ func (_m *MockRows) Scan(dest ...interface{}) error

+ type Rows interface

+ ColumnTypes func() ([]*sql.ColumnType, error)

+ Columns func() ([]string, error)

+ Err func() error

+ Next func() bool

+ NextResultSet func() bool

+ Scan func(dest ...interface{}) error

Feb 19, 2017

Changes in this version

+ const JoinCross

+ const JoinDoNot

+ const JoinInner

+ const JoinLeft

+ const JoinRight

+ func GroupCriteriaWhereClause(comp *Composer, c *GroupCriteria, id int) error

+ func GroupPermissionsCriteriaWhereClause(comp *Composer, c *GroupPermissionsCriteria, id int) error

+ func PermissionCriteriaWhereClause(comp *Composer, c *PermissionCriteria, id int) error

+ func UserCriteriaWhereClause(comp *Composer, c *UserCriteria, id int) error

+ func UserGroupsCriteriaWhereClause(comp *Composer, c *UserGroupsCriteria, id int) error

+ func UserPermissionsCriteriaWhereClause(comp *Composer, c *UserPermissionsCriteria, id int) error

type Composer

+ func (c *Composer) WriteAlias(i int) error

type CompositionOpts

+ IsDynamic bool

+ type GroupCountExpr struct

+ JoinAuthor *UserJoin

+ JoinModifier *UserJoin

+ Where *GroupCriteria

+ type GroupFindExpr struct

+ Columns []string

+ JoinAuthor *UserJoin

+ JoinModifier *UserJoin

+ Limit int64

+ Offset int64

+ OrderBy map[string]bool

+ Where *GroupCriteria

+ type GroupJoin struct

+ Fetch bool

+ JoinAuthor *UserJoin

+ JoinModifier *UserJoin

+ Kind JoinType

+ On *GroupCriteria

+ Where *GroupCriteria

+ type GroupPermissionsCountExpr struct

+ JoinAuthor *UserJoin

+ JoinGroup *GroupJoin

+ JoinModifier *UserJoin

+ Where *GroupPermissionsCriteria

+ type GroupPermissionsFindExpr struct

+ Columns []string

+ JoinAuthor *UserJoin

+ JoinGroup *GroupJoin

+ JoinModifier *UserJoin

+ Limit int64

+ Offset int64

+ OrderBy map[string]bool

+ Where *GroupPermissionsCriteria

+ type GroupPermissionsJoin struct

+ Fetch bool

+ JoinAuthor *UserJoin

+ JoinGroup *GroupJoin

+ JoinModifier *UserJoin

+ Kind JoinType

+ On *GroupPermissionsCriteria

+ Where *GroupPermissionsCriteria

+ type JoinType int

+ func (jt JoinType) String() string

+ type PermissionCountExpr struct

+ Where *PermissionCriteria

+ type PermissionFindExpr struct

+ Columns []string

+ Limit int64

+ Offset int64

+ OrderBy map[string]bool

+ Where *PermissionCriteria

+ type PermissionJoin struct

+ Fetch bool

+ Kind JoinType

+ On *PermissionCriteria

+ Where *PermissionCriteria

+ type UserCountExpr struct

+ JoinAuthor *UserJoin

+ JoinModifier *UserJoin

+ Where *UserCriteria

+ type UserFindExpr struct

+ Columns []string

+ JoinAuthor *UserJoin

+ JoinModifier *UserJoin

+ Limit int64

+ Offset int64

+ OrderBy map[string]bool

+ Where *UserCriteria

+ type UserGroupsCountExpr struct

+ JoinAuthor *UserJoin

+ JoinGroup *GroupJoin

+ JoinModifier *UserJoin

+ JoinUser *UserJoin

+ Where *UserGroupsCriteria

+ type UserGroupsFindExpr struct

+ Columns []string

+ JoinAuthor *UserJoin

+ JoinGroup *GroupJoin

+ JoinModifier *UserJoin

+ JoinUser *UserJoin

+ Limit int64

+ Offset int64

+ OrderBy map[string]bool

+ Where *UserGroupsCriteria

+ type UserGroupsJoin struct

+ Fetch bool

+ JoinAuthor *UserJoin

+ JoinGroup *GroupJoin

+ JoinModifier *UserJoin

+ JoinUser *UserJoin

+ Kind JoinType

+ On *UserGroupsCriteria

+ Where *UserGroupsCriteria

+ type UserJoin struct

+ Fetch bool

+ JoinAuthor *UserJoin

+ JoinModifier *UserJoin

+ Kind JoinType

+ On *UserCriteria

+ Where *UserCriteria

+ type UserPermissionsCountExpr struct

+ JoinAuthor *UserJoin

+ JoinModifier *UserJoin

+ JoinUser *UserJoin

+ Where *UserPermissionsCriteria

+ type UserPermissionsFindExpr struct

+ Columns []string

+ JoinAuthor *UserJoin

+ JoinModifier *UserJoin

+ JoinUser *UserJoin

+ Limit int64

+ Offset int64

+ OrderBy map[string]bool

+ Where *UserPermissionsCriteria

+ type UserPermissionsJoin struct

+ Fetch bool

+ JoinAuthor *UserJoin

+ JoinModifier *UserJoin

+ JoinUser *UserJoin

+ Kind JoinType

+ On *UserPermissionsCriteria

+ Where *UserPermissionsCriteria

Jan 12, 2017

Changes in this version

+ var And = &CompositionOpts

+ var Comma = &CompositionOpts

+ var Or = &CompositionOpts

+ var Space = &CompositionOpts

+ func ErrorConstraint(err error) string

+ func QueryFloat64WhereClause(i *qtypes.Float64, sel string, com *Composer, opt *CompositionOpts) (err error)

+ func QueryInt64WhereClause(i *qtypes.Int64, sel string, com *Composer, opt *CompositionOpts) (err error)

+ func QueryStringWhereClause(s *qtypes.String, sel string, com *Composer, opt *CompositionOpts) (err error)

+ func QueryTimestampWhereClause(t *qtypes.Timestamp, sel string, com *Composer, opt *CompositionOpts) error

+ type Composer struct

+ Dirty bool

+ func NewComposer(size int64) *Composer

+ func (c *Composer) Add(arg interface{})

+ func (c *Composer) Args() []interface{}

+ func (c *Composer) Len() int

+ func (c *Composer) Read(b []byte) (int, error)

+ func (c *Composer) ResetBuf()

+ func (c *Composer) String() string

+ func (c *Composer) Write(b []byte) (int, error)

+ func (c *Composer) WritePlaceholder() error

+ func (c *Composer) WriteString(s string) (int, error)

+ type CompositionOpts struct

+ Cast string

+ IsJSON bool

+ Joint string

+ PlaceholderFunc string

+ SelectorFunc string

+ type CompositionWriter interface

+ WriteComposition func(string, *Composer, *CompositionOpts) error

type GroupPermissionsRepositoryBase

+ Columns []string

+ DB *sql.DB

+ Debug bool

+ Log log.Logger

+ Table string

+ func (r *GroupPermissionsRepositoryBase) FindQuery(s []string, c *GroupPermissionsCriteria) (string, []interface{}, error)

+ func (r *GroupPermissionsRepositoryBase) InsertQuery(e *GroupPermissionsEntity) (string, []interface{}, error)

+ func (r *GroupPermissionsRepositoryBase) UpdateOneByGroupIDAndPermissionSubsystemAndPermissionModuleAndPermissionActionQuery(groupPermissionsGroupID int64, groupPermissionsPermissionSubsystem string, ...) (string, []interface{}, error)

+ func (r *GroupPermissionsRepositoryBase) UpsertQuery(e *GroupPermissionsEntity, p *GroupPermissionsPatch, inf ...string) (string, []interface{}, error)

type GroupRepositoryBase

+ Columns []string

+ DB *sql.DB

+ Debug bool

+ Log log.Logger

+ Table string

+ func (r *GroupRepositoryBase) FindQuery(s []string, c *GroupCriteria) (string, []interface{}, error)

+ func (r *GroupRepositoryBase) InsertQuery(e *GroupEntity) (string, []interface{}, error)

+ func (r *GroupRepositoryBase) UpdateOneByIDQuery(pk int64, p *GroupPatch) (string, []interface{}, error)

+ func (r *GroupRepositoryBase) UpdateOneByNameQuery(groupName string, p *GroupPatch) (string, []interface{}, error)

+ func (r *GroupRepositoryBase) UpsertQuery(e *GroupEntity, p *GroupPatch, inf ...string) (string, []interface{}, error)

+ type JSONArrayFloat64 []float64

+ func (a *JSONArrayFloat64) Scan(src interface{}) error

+ func (a JSONArrayFloat64) Value() (driver.Value, error)

+ type JSONArrayInt64 []int64

+ func (a *JSONArrayInt64) Scan(src interface{}) error

+ func (a JSONArrayInt64) Value() (driver.Value, error)

+ type JSONArrayString []string

+ func (a *JSONArrayString) Scan(src interface{}) error

+ func (a JSONArrayString) Value() (driver.Value, error)

+ type MockCompositionWriter struct

+ func (_m *MockCompositionWriter) WriteComposition(_a0 string, _a1 *Composer, _a2 *CompositionOpts) error

+ type NullBoolArray struct

+ Valid bool

+ func (n *NullBoolArray) Scan(value interface{}) error

+ type NullByteaArray struct

+ Valid bool

+ func (n *NullByteaArray) Scan(value interface{}) error

+ type NullFloat64Array struct

+ Valid bool

+ func (n *NullFloat64Array) Scan(value interface{}) error

+ type NullInt64Array struct

+ Valid bool

+ func (n *NullInt64Array) Scan(value interface{}) error

+ type NullStringArray struct

+ Valid bool

+ func (n *NullStringArray) Scan(value interface{}) error

type PermissionRepositoryBase

+ Columns []string

+ DB *sql.DB

+ Debug bool

+ Log log.Logger

+ Table string

+ func (r *PermissionRepositoryBase) FindQuery(s []string, c *PermissionCriteria) (string, []interface{}, error)

+ func (r *PermissionRepositoryBase) InsertQuery(e *PermissionEntity) (string, []interface{}, error)

+ func (r *PermissionRepositoryBase) UpdateOneByIDQuery(pk int64, p *PermissionPatch) (string, []interface{}, error)

+ func (r *PermissionRepositoryBase) UpdateOneBySubsystemAndModuleAndActionQuery(permissionSubsystem string, permissionModule string, permissionAction string, ...) (string, []interface{}, error)

+ func (r *PermissionRepositoryBase) UpsertQuery(e *PermissionEntity, p *PermissionPatch, inf ...string) (string, []interface{}, error)

type UserGroupsRepositoryBase

+ Columns []string

+ DB *sql.DB

+ Debug bool

+ Log log.Logger

+ Table string

+ func (r *UserGroupsRepositoryBase) FindQuery(s []string, c *UserGroupsCriteria) (string, []interface{}, error)

+ func (r *UserGroupsRepositoryBase) InsertQuery(e *UserGroupsEntity) (string, []interface{}, error)

+ func (r *UserGroupsRepositoryBase) UpdateOneByUserIDAndGroupIDQuery(userGroupsUserID int64, userGroupsGroupID int64, p *UserGroupsPatch) (string, []interface{}, error)

+ func (r *UserGroupsRepositoryBase) UpsertQuery(e *UserGroupsEntity, p *UserGroupsPatch, inf ...string) (string, []interface{}, error)

type UserPermissionsRepositoryBase

+ Columns []string

+ DB *sql.DB

+ Debug bool

+ Log log.Logger

+ Table string

+ func (r *UserPermissionsRepositoryBase) FindQuery(s []string, c *UserPermissionsCriteria) (string, []interface{}, error)

+ func (r *UserPermissionsRepositoryBase) InsertQuery(e *UserPermissionsEntity) (string, []interface{}, error)

+ func (r *UserPermissionsRepositoryBase) UpdateOneByUserIDAndPermissionSubsystemAndPermissionModuleAndPermissionActionQuery(userPermissionsUserID int64, userPermissionsPermissionSubsystem string, ...) (string, []interface{}, error)

+ func (r *UserPermissionsRepositoryBase) UpsertQuery(e *UserPermissionsEntity, p *UserPermissionsPatch, inf ...string) (string, []interface{}, error)

type UserRepositoryBase

+ Columns []string

+ DB *sql.DB

+ Debug bool

+ Log log.Logger

+ Table string

+ func (r *UserRepositoryBase) FindQuery(s []string, c *UserCriteria) (string, []interface{}, error)

+ func (r *UserRepositoryBase) InsertQuery(e *UserEntity) (string, []interface{}, error)

+ func (r *UserRepositoryBase) UpdateOneByIDQuery(pk int64, p *UserPatch) (string, []interface{}, error)

+ func (r *UserRepositoryBase) UpdateOneByUsernameQuery(userUsername string, p *UserPatch) (string, []interface{}, error)

+ func (r *UserRepositoryBase) UpsertQuery(e *UserEntity, p *UserPatch, inf ...string) (string, []interface{}, error)

Nov 23, 2016

Changes in this version

type MockUserGroupsProvider

+ func (_m *MockUserGroupsProvider) DeleteByUserID(id int64) (int64, error)

type MockUserPermissionsProvider

+ func (_m *MockUserPermissionsProvider) DeleteByUserID(id int64) (int64, error)

type UserGroupsProvider

+ DeleteByUserID func(id int64) (int64, error)

type UserGroupsRepository

+ func (ugr *UserGroupsRepository) DeleteByUserID(id int64) (int64, error)

type UserPermissionsProvider

+ DeleteByUserID func(id int64) (int64, error)

type UserPermissionsRepository

+ func (upr *UserPermissionsRepository) DeleteByUserID(id int64) (int64, error)

Nov 14, 2016

Changes in this version

+ const SQL

+ const TableGroup

+ const TableGroupColumnCreatedAt

+ const TableGroupColumnCreatedBy

+ const TableGroupColumnDescription

+ const TableGroupColumnID

+ const TableGroupColumnName

+ const TableGroupColumnUpdatedAt

+ const TableGroupColumnUpdatedBy

+ const TableGroupConstraintCreatedByForeignKey

+ const TableGroupConstraintNameUnique

+ const TableGroupConstraintPrimaryKey

+ const TableGroupConstraintUpdatedByForeignKey

+ const TableGroupPermissions

+ const TableGroupPermissionsColumnCreatedAt

+ const TableGroupPermissionsColumnCreatedBy

+ const TableGroupPermissionsColumnGroupID

+ const TableGroupPermissionsColumnPermissionAction

+ const TableGroupPermissionsColumnPermissionModule

+ const TableGroupPermissionsColumnPermissionSubsystem

+ const TableGroupPermissionsColumnUpdatedAt

+ const TableGroupPermissionsColumnUpdatedBy

+ const TableGroupPermissionsConstraintCreatedByForeignKey

+ const TableGroupPermissionsConstraintGroupIDForeignKey

+ const TableGroupPermissionsConstraintGroupIDPermissionSubsystemPermissionModulePermissionActionUnique

+ const TableGroupPermissionsConstraintPermissionSubsystemPermissionModulePermissionActionForeignKey

+ const TableGroupPermissionsConstraintUpdatedByForeignKey

+ const TablePermission

+ const TablePermissionColumnAction

+ const TablePermissionColumnCreatedAt

+ const TablePermissionColumnID

+ const TablePermissionColumnModule

+ const TablePermissionColumnSubsystem

+ const TablePermissionColumnUpdatedAt

+ const TablePermissionConstraintPrimaryKey

+ const TablePermissionConstraintSubsystemModuleActionUnique

+ const TableUser

+ const TableUserColumnConfirmationToken

+ const TableUserColumnCreatedAt

+ const TableUserColumnCreatedBy

+ const TableUserColumnFirstName

+ const TableUserColumnID

+ const TableUserColumnIsActive

+ const TableUserColumnIsConfirmed

+ const TableUserColumnIsStaff

+ const TableUserColumnIsSuperuser

+ const TableUserColumnLastLoginAt

+ const TableUserColumnLastName

+ const TableUserColumnPassword

+ const TableUserColumnUpdatedAt

+ const TableUserColumnUpdatedBy

+ const TableUserColumnUsername

+ const TableUserConstraintCreatedByForeignKey

+ const TableUserConstraintPrimaryKey

+ const TableUserConstraintUpdatedByForeignKey

+ const TableUserConstraintUsernameUnique

+ const TableUserGroups

+ const TableUserGroupsColumnCreatedAt

+ const TableUserGroupsColumnCreatedBy

+ const TableUserGroupsColumnGroupID

+ const TableUserGroupsColumnUpdatedAt

+ const TableUserGroupsColumnUpdatedBy

+ const TableUserGroupsColumnUserID

+ const TableUserGroupsConstraintCreatedByForeignKey

+ const TableUserGroupsConstraintGroupIDForeignKey

+ const TableUserGroupsConstraintUpdatedByForeignKey

+ const TableUserGroupsConstraintUserIDForeignKey

+ const TableUserGroupsConstraintUserIDGroupIDUnique

+ const TableUserPermissions

+ const TableUserPermissionsColumnCreatedAt

+ const TableUserPermissionsColumnCreatedBy

+ const TableUserPermissionsColumnPermissionAction

+ const TableUserPermissionsColumnPermissionModule

+ const TableUserPermissionsColumnPermissionSubsystem

+ const TableUserPermissionsColumnUpdatedAt

+ const TableUserPermissionsColumnUpdatedBy

+ const TableUserPermissionsColumnUserID

+ const TableUserPermissionsConstraintCreatedByForeignKey

+ const TableUserPermissionsConstraintPermissionSubsystemPermissionModulePermissionActionForeignKey

+ const TableUserPermissionsConstraintUpdatedByForeignKey

+ const TableUserPermissionsConstraintUserIDForeignKey

+ const TableUserPermissionsConstraintUserIDPermissionSubsystemPermissionModulePermissionActionUnique

+ const UserConfirmationTokenUsed

+ var ExternalPassword = []byte("!")

+ var TableGroupColumns = []string

+ var TableGroupPermissionsColumns = []string

+ var TablePermissionColumns = []string

+ var TableUserColumns = []string

+ var TableUserGroupsColumns = []string

+ var TableUserPermissionsColumns = []string

+ type GroupCriteria struct

+ CreatedAt *qtypes.Timestamp

+ CreatedBy *qtypes.Int64

+ Description *qtypes.String

+ ID *qtypes.Int64

+ Limit int64

+ Name *qtypes.String

+ Offset int64

+ Sort map[string]bool

+ UpdatedAt *qtypes.Timestamp

+ UpdatedBy *qtypes.Int64

+ func (c *GroupCriteria) WriteComposition(sel string, com *pqtgo.Composer, opt *pqtgo.CompositionOpts) (err error)

+ type GroupEntity struct

+ Author *UserEntity

+ CreatedAt time.Time

+ CreatedBy *ntypes.Int64

+ Description *ntypes.String

+ ID int64

+ Modifier *UserEntity

+ Name string

+ Permissions []*PermissionEntity

+ UpdatedAt *time.Time

+ UpdatedBy *ntypes.Int64

+ Users []*UserEntity

+ func ScanGroupRows(rows *sql.Rows) ([]*GroupEntity, error)

+ func (e *GroupEntity) Prop(cn string) (interface{}, bool)

+ func (e *GroupEntity) Props(cns ...string) ([]interface{}, error)

+ func (ge *GroupEntity) Message() (*charonrpc.Group, error)

+ type GroupIterator struct

+ func (i *GroupIterator) Close() error

+ func (i *GroupIterator) Columns() ([]string, error)

+ func (i *GroupIterator) Ent() (interface{}, error)

+ func (i *GroupIterator) Err() error

+ func (i *GroupIterator) Group() (*GroupEntity, error)

+ func (i *GroupIterator) Next() bool

+ type GroupPatch struct

+ CreatedAt *time.Time

+ CreatedBy *ntypes.Int64

+ Description *ntypes.String

+ Name *ntypes.String

+ UpdatedAt *time.Time

+ UpdatedBy *ntypes.Int64

+ type GroupPermissionsCriteria struct

+ CreatedAt *qtypes.Timestamp

+ CreatedBy *qtypes.Int64

+ GroupID *qtypes.Int64

+ Limit int64

+ Offset int64

+ PermissionAction *qtypes.String

+ PermissionModule *qtypes.String

+ PermissionSubsystem *qtypes.String

+ Sort map[string]bool

+ UpdatedAt *qtypes.Timestamp

+ UpdatedBy *qtypes.Int64

+ func (c *GroupPermissionsCriteria) WriteComposition(sel string, com *pqtgo.Composer, opt *pqtgo.CompositionOpts) (err error)

+ type GroupPermissionsEntity struct

+ Author *UserEntity

+ CreatedAt time.Time

+ CreatedBy *ntypes.Int64

+ Group *GroupEntity

+ GroupID int64

+ Modifier *UserEntity

+ PermissionAction string

+ PermissionModule string

+ PermissionSubsystem string

+ UpdatedAt *time.Time

+ UpdatedBy *ntypes.Int64

+ func ScanGroupPermissionsRows(rows *sql.Rows) ([]*GroupPermissionsEntity, error)

+ func (e *GroupPermissionsEntity) Prop(cn string) (interface{}, bool)

+ func (e *GroupPermissionsEntity) Props(cns ...string) ([]interface{}, error)

+ type GroupPermissionsIterator struct

+ func (i *GroupPermissionsIterator) Close() error

+ func (i *GroupPermissionsIterator) Columns() ([]string, error)

+ func (i *GroupPermissionsIterator) Ent() (interface{}, error)

+ func (i *GroupPermissionsIterator) Err() error

+ func (i *GroupPermissionsIterator) GroupPermissions() (*GroupPermissionsEntity, error)

+ func (i *GroupPermissionsIterator) Next() bool

+ type GroupPermissionsPatch struct

+ CreatedAt *time.Time

+ CreatedBy *ntypes.Int64

+ GroupID *ntypes.Int64

+ PermissionAction *ntypes.String

+ PermissionModule *ntypes.String

+ PermissionSubsystem *ntypes.String

+ UpdatedAt *time.Time

+ UpdatedBy *ntypes.Int64

+ type GroupPermissionsProvider interface

+ Insert func(entity *GroupPermissionsEntity) (*GroupPermissionsEntity, error)

+ func NewGroupPermissionsRepository(dbPool *sql.DB) GroupPermissionsProvider

+ type GroupPermissionsRepository struct

+ type GroupPermissionsRepositoryBase struct

+ func (r *GroupPermissionsRepositoryBase) Count(c *GroupPermissionsCriteria) (int64, error)

+ func (r *GroupPermissionsRepositoryBase) Find(c *GroupPermissionsCriteria) ([]*GroupPermissionsEntity, error)

+ func (r *GroupPermissionsRepositoryBase) FindIter(c *GroupPermissionsCriteria) (*GroupPermissionsIterator, error)

+ func (r *GroupPermissionsRepositoryBase) FindOneByGroupIDAndPermissionSubsystemAndPermissionModuleAndPermissionAction(groupPermissionsGroupID int64, groupPermissionsPermissionSubsystem string, ...) (*GroupPermissionsEntity, error)

+ func (r *GroupPermissionsRepositoryBase) Insert(e *GroupPermissionsEntity) (*GroupPermissionsEntity, error)

+ func (r *GroupPermissionsRepositoryBase) UpdateOneByGroupIDAndPermissionSubsystemAndPermissionModuleAndPermissionAction(groupPermissionsGroupID int64, groupPermissionsPermissionSubsystem string, ...) (*GroupPermissionsEntity, error)

+ func (r *GroupPermissionsRepositoryBase) Upsert(e *GroupPermissionsEntity, p *GroupPermissionsPatch, inf ...string) (*GroupPermissionsEntity, error)

+ type GroupProvider interface

+ Create func(createdBy int64, name string, description *ntypes.String) (*GroupEntity, error)

+ DeleteOneByID func(id int64) (int64, error)

+ Find func(c *GroupCriteria) ([]*GroupEntity, error)

+ FindByUserID func(int64) ([]*GroupEntity, error)

+ FindOneByID func(int64) (*GroupEntity, error)

+ Insert func(entity *GroupEntity) (*GroupEntity, error)

+ IsGranted func(id int64, permission charon.Permission) (bool, error)

+ SetPermissions func(id int64, permissions ...charon.Permission) (int64, int64, error)

+ UpdateOneByID func(id, updatedBy int64, name, description *ntypes.String) (*GroupEntity, error)

+ func NewGroupRepository(dbPool *sql.DB) GroupProvider

+ type GroupRepository struct

+ func (gr *GroupRepository) Create(createdBy int64, name string, description *ntypes.String) (ent *GroupEntity, err error)

+ func (gr *GroupRepository) FindByUserID(userID int64) ([]*GroupEntity, error)

+ func (gr *GroupRepository) IsGranted(id int64, p charon.Permission) (bool, error)

+ func (gr *GroupRepository) SetPermissions(id int64, p ...charon.Permission) (int64, int64, error)

+ func (gr *GroupRepository) UpdateOneByID(id, updatedBy int64, name, description *ntypes.String) (*GroupEntity, error)

+ type GroupRepositoryBase struct

+ func (r *GroupRepositoryBase) Count(c *GroupCriteria) (int64, error)

+ func (r *GroupRepositoryBase) DeleteOneByID(id int64) (int64, error)

+ func (r *GroupRepositoryBase) Find(c *GroupCriteria) ([]*GroupEntity, error)

+ func (r *GroupRepositoryBase) FindIter(c *GroupCriteria) (*GroupIterator, error)

+ func (r *GroupRepositoryBase) FindOneByID(id int64) (*GroupEntity, error)

+ func (r *GroupRepositoryBase) FindOneByName(groupName string) (*GroupEntity, error)

+ func (r *GroupRepositoryBase) Insert(e *GroupEntity) (*GroupEntity, error)

+ func (r *GroupRepositoryBase) UpdateOneByID(id int64, patch *GroupPatch) (*GroupEntity, error)

+ func (r *GroupRepositoryBase) UpdateOneByName(groupName string, patch *GroupPatch) (*GroupEntity, error)

+ func (r *GroupRepositoryBase) Upsert(e *GroupEntity, p *GroupPatch, inf ...string) (*GroupEntity, error)

+ type MockGroupPermissionsProvider struct

+ func (_m *MockGroupPermissionsProvider) Insert(entity *GroupPermissionsEntity) (*GroupPermissionsEntity, error)

+ type MockGroupProvider struct

+ func (_m *MockGroupProvider) Create(createdBy int64, name string, description *ntypes.String) (*GroupEntity, error)

+ func (_m *MockGroupProvider) DeleteOneByID(id int64) (int64, error)

+ func (_m *MockGroupProvider) Find(c *GroupCriteria) ([]*GroupEntity, error)

+ func (_m *MockGroupProvider) FindByUserID(_a0 int64) ([]*GroupEntity, error)

+ func (_m *MockGroupProvider) FindOneByID(_a0 int64) (*GroupEntity, error)

+ func (_m *MockGroupProvider) Insert(entity *GroupEntity) (*GroupEntity, error)

+ func (_m *MockGroupProvider) IsGranted(id int64, permission charon.Permission) (bool, error)

+ func (_m *MockGroupProvider) SetPermissions(id int64, permissions ...charon.Permission) (int64, int64, error)

+ func (_m *MockGroupProvider) UpdateOneByID(id int64, updatedBy int64, name *ntypes.String, description *ntypes.String) (*GroupEntity, error)

+ type MockPermissionProvider struct

+ func (_m *MockPermissionProvider) Find(criteria *PermissionCriteria) ([]*PermissionEntity, error)

+ func (_m *MockPermissionProvider) FindByGroupID(groupID int64) ([]*PermissionEntity, error)

+ func (_m *MockPermissionProvider) FindByUserID(userID int64) ([]*PermissionEntity, error)

+ func (_m *MockPermissionProvider) FindOneByID(id int64) (*PermissionEntity, error)

+ func (_m *MockPermissionProvider) Insert(entity *PermissionEntity) (*PermissionEntity, error)

+ func (_m *MockPermissionProvider) Register(permissions charon.Permissions) (int64, int64, int64, error)

+ type MockPermissionRegistry struct

+ func (_m *MockPermissionRegistry) Exists(permission charon.Permission) bool

+ func (_m *MockPermissionRegistry) Register(permissions charon.Permissions) (int64, int64, int64, error)

+ type MockUserGroupsProvider struct

+ func (_m *MockUserGroupsProvider) Exists(userID int64, groupID int64) (bool, error)

+ func (_m *MockUserGroupsProvider) Find(criteria *UserGroupsCriteria) ([]*UserGroupsEntity, error)

+ func (_m *MockUserGroupsProvider) Insert(entity *UserGroupsEntity) (*UserGroupsEntity, error)

+ func (_m *MockUserGroupsProvider) Set(userID int64, groupIDs []int64) (int64, int64, error)

+ type MockUserPermissionsProvider struct

+ func (_m *MockUserPermissionsProvider) Insert(entity *UserPermissionsEntity) (*UserPermissionsEntity, error)

+ type MockUserProvider struct

+ func (_m *MockUserProvider) ChangePassword(id int64, password string) error

+ func (_m *MockUserProvider) Count() (int64, error)

+ func (_m *MockUserProvider) Create(username string, password []byte, FirstName string, LastName string, ...) (*UserEntity, error)

+ func (_m *MockUserProvider) CreateSuperuser(username string, password []byte, FirstName string, LastName string) (*UserEntity, error)

+ func (_m *MockUserProvider) DeleteOneByID(id int64) (int64, error)

+ func (_m *MockUserProvider) Exists(id int64) (bool, error)

+ func (_m *MockUserProvider) Find(criteria *UserCriteria) ([]*UserEntity, error)

+ func (_m *MockUserProvider) FindOneByID(id int64) (*UserEntity, error)

+ func (_m *MockUserProvider) FindOneByUsername(username string) (*UserEntity, error)

+ func (_m *MockUserProvider) Insert(_a0 *UserEntity) (*UserEntity, error)

+ func (_m *MockUserProvider) IsGranted(id int64, permission charon.Permission) (bool, error)

+ func (_m *MockUserProvider) RegistrationConfirmation(id int64, confirmationToken string) error

+ func (_m *MockUserProvider) SetPermissions(id int64, permissions ...charon.Permission) (int64, int64, error)

+ func (_m *MockUserProvider) UpdateLastLoginAt(id int64) (int64, error)

+ func (_m *MockUserProvider) UpdateOneByID(_a0 int64, _a1 *UserPatch) (*UserEntity, error)

+ type PermissionCriteria struct

+ Action *qtypes.String

+ CreatedAt *qtypes.Timestamp

+ ID *qtypes.Int64

+ Limit int64

+ Module *qtypes.String

+ Offset int64

+ Sort map[string]bool

+ Subsystem *qtypes.String

+ UpdatedAt *qtypes.Timestamp

+ func (c *PermissionCriteria) WriteComposition(sel string, com *pqtgo.Composer, opt *pqtgo.CompositionOpts) (err error)

+ type PermissionEntity struct

+ Action string

+ CreatedAt time.Time

+ Groups []*GroupEntity

+ ID int64

+ Module string

+ Subsystem string

+ UpdatedAt *time.Time

+ Users []*UserEntity

+ func ScanPermissionRows(rows *sql.Rows) ([]*PermissionEntity, error)

+ func (e *PermissionEntity) Prop(cn string) (interface{}, bool)

+ func (e *PermissionEntity) Props(cns ...string) ([]interface{}, error)

+ func (pe *PermissionEntity) Permission() charon.Permission

+ type PermissionIterator struct

+ func (i *PermissionIterator) Close() error

+ func (i *PermissionIterator) Columns() ([]string, error)

+ func (i *PermissionIterator) Ent() (interface{}, error)

+ func (i *PermissionIterator) Err() error

+ func (i *PermissionIterator) Next() bool

+ func (i *PermissionIterator) Permission() (*PermissionEntity, error)

+ type PermissionPatch struct

+ Action *ntypes.String

+ CreatedAt *time.Time

+ Module *ntypes.String

+ Subsystem *ntypes.String

+ UpdatedAt *time.Time

+ type PermissionProvider interface

+ Find func(criteria *PermissionCriteria) ([]*PermissionEntity, error)

+ FindByGroupID func(groupID int64) (entities []*PermissionEntity, err error)

+ FindByUserID func(userID int64) (entities []*PermissionEntity, err error)

+ FindOneByID func(id int64) (entity *PermissionEntity, err error)

+ Insert func(entity *PermissionEntity) (*PermissionEntity, error)

+ Register func(permissions charon.Permissions) (created, untouched, removed int64, err error)

+ type PermissionReg struct

+ func NewPermissionRegistry(r PermissionProvider) *PermissionReg

+ func (pr *PermissionReg) Exists(permission charon.Permission) (ok bool)

+ func (pr *PermissionReg) Register(permissions charon.Permissions) (created, untouched, removed int64, err error)

+ type PermissionRegistry interface

+ Exists func(permission charon.Permission) (exists bool)

+ Register func(permissions charon.Permissions) (created, untouched, removed int64, err error)

+ type PermissionRepository struct

+ func NewPermissionRepository(dbPool *sql.DB) *PermissionRepository

+ func (pr *PermissionRepository) FindBy(query string, args ...interface{}) ([]*PermissionEntity, error)

+ func (pr *PermissionRepository) FindByGroupID(userID int64) ([]*PermissionEntity, error)

+ func (pr *PermissionRepository) FindByTag(userID int64) ([]*PermissionEntity, error)

+ func (pr *PermissionRepository) FindByUserID(userID int64) ([]*PermissionEntity, error)

+ func (pr *PermissionRepository) Register(permissions charon.Permissions) (created, unt, removed int64, err error)

+ type PermissionRepositoryBase struct

+ func (r *PermissionRepositoryBase) Count(c *PermissionCriteria) (int64, error)

+ func (r *PermissionRepositoryBase) DeleteOneByID(id int64) (int64, error)

+ func (r *PermissionRepositoryBase) Find(c *PermissionCriteria) ([]*PermissionEntity, error)

+ func (r *PermissionRepositoryBase) FindIter(c *PermissionCriteria) (*PermissionIterator, error)

+ func (r *PermissionRepositoryBase) FindOneByID(id int64) (*PermissionEntity, error)

+ func (r *PermissionRepositoryBase) FindOneBySubsystemAndModuleAndAction(permissionSubsystem string, permissionModule string, permissionAction string) (*PermissionEntity, error)

+ func (r *PermissionRepositoryBase) Insert(e *PermissionEntity) (*PermissionEntity, error)

+ func (r *PermissionRepositoryBase) UpdateOneByID(id int64, patch *PermissionPatch) (*PermissionEntity, error)

+ func (r *PermissionRepositoryBase) UpdateOneBySubsystemAndModuleAndAction(permissionSubsystem string, permissionModule string, permissionAction string, ...) (*PermissionEntity, error)

+ func (r *PermissionRepositoryBase) Upsert(e *PermissionEntity, p *PermissionPatch, inf ...string) (*PermissionEntity, error)

+ type UserCriteria struct

+ ConfirmationToken []byte

+ CreatedAt *qtypes.Timestamp

+ CreatedBy *qtypes.Int64

+ FirstName *qtypes.String

+ ID *qtypes.Int64

+ IsActive *ntypes.Bool

+ IsConfirmed *ntypes.Bool

+ IsStaff *ntypes.Bool

+ IsSuperuser *ntypes.Bool

+ LastLoginAt *qtypes.Timestamp

+ LastName *qtypes.String

+ Limit int64

+ Offset int64

+ Password []byte

+ Sort map[string]bool

+ UpdatedAt *qtypes.Timestamp

+ UpdatedBy *qtypes.Int64

+ Username *qtypes.String

+ func (c *UserCriteria) WriteComposition(sel string, com *pqtgo.Composer, opt *pqtgo.CompositionOpts) (err error)

+ type UserEntity struct

+ Author *UserEntity

+ ConfirmationToken []byte

+ CreatedAt time.Time

+ CreatedBy *ntypes.Int64

+ FirstName string

+ Groups []*GroupEntity

+ ID int64

+ IsActive bool

+ IsConfirmed bool

+ IsStaff bool

+ IsSuperuser bool

+ LastLoginAt *time.Time

+ LastName string

+ Modifier *UserEntity

+ Password []byte

+ Permissions []*PermissionEntity

+ UpdatedAt *time.Time

+ UpdatedBy *ntypes.Int64

+ Username string

+ func ScanUserRows(rows *sql.Rows) ([]*UserEntity, error)

+ func (e *UserEntity) Prop(cn string) (interface{}, bool)

+ func (e *UserEntity) Props(cns ...string) ([]interface{}, error)

+ func (ue *UserEntity) Message() (*charonrpc.User, error)

+ func (ue *UserEntity) String() string

+ type UserGroupsCriteria struct

+ CreatedAt *qtypes.Timestamp

+ CreatedBy *qtypes.Int64

+ GroupID *qtypes.Int64

+ Limit int64

+ Offset int64

+ Sort map[string]bool

+ UpdatedAt *qtypes.Timestamp

+ UpdatedBy *qtypes.Int64

+ UserID *qtypes.Int64

+ func (c *UserGroupsCriteria) WriteComposition(sel string, com *pqtgo.Composer, opt *pqtgo.CompositionOpts) (err error)

+ type UserGroupsEntity struct

+ Author *UserEntity

+ CreatedAt time.Time

+ CreatedBy *ntypes.Int64

+ Group *GroupEntity

+ GroupID int64

+ Modifier *UserEntity

+ UpdatedAt *time.Time

+ UpdatedBy *ntypes.Int64

+ User *UserEntity

+ UserID int64

+ func ScanUserGroupsRows(rows *sql.Rows) ([]*UserGroupsEntity, error)

+ func (e *UserGroupsEntity) Prop(cn string) (interface{}, bool)

+ func (e *UserGroupsEntity) Props(cns ...string) ([]interface{}, error)

+ type UserGroupsIterator struct

+ func (i *UserGroupsIterator) Close() error

+ func (i *UserGroupsIterator) Columns() ([]string, error)

+ func (i *UserGroupsIterator) Ent() (interface{}, error)

+ func (i *UserGroupsIterator) Err() error

+ func (i *UserGroupsIterator) Next() bool

+ func (i *UserGroupsIterator) UserGroups() (*UserGroupsEntity, error)

+ type UserGroupsPatch struct

+ CreatedAt *time.Time

+ CreatedBy *ntypes.Int64

+ GroupID *ntypes.Int64

+ UpdatedAt *time.Time

+ UpdatedBy *ntypes.Int64

+ UserID *ntypes.Int64

+ type UserGroupsProvider interface

+ Exists func(userID, groupID int64) (bool, error)

+ Find func(criteria *UserGroupsCriteria) ([]*UserGroupsEntity, error)

+ Insert func(entity *UserGroupsEntity) (*UserGroupsEntity, error)

+ Set func(userID int64, groupIDs []int64) (int64, int64, error)

+ func NewUserGroupsRepository(dbPool *sql.DB) UserGroupsProvider

+ type UserGroupsRepository struct

+ func (ugr *UserGroupsRepository) Exists(userID, groupID int64) (bool, error)

+ func (ugr *UserGroupsRepository) Set(userID int64, groupIDs []int64) (int64, int64, error)

+ type UserGroupsRepositoryBase struct

+ func (r *UserGroupsRepositoryBase) Count(c *UserGroupsCriteria) (int64, error)

+ func (r *UserGroupsRepositoryBase) Find(c *UserGroupsCriteria) ([]*UserGroupsEntity, error)

+ func (r *UserGroupsRepositoryBase) FindIter(c *UserGroupsCriteria) (*UserGroupsIterator, error)

+ func (r *UserGroupsRepositoryBase) FindOneByUserIDAndGroupID(userGroupsUserID int64, userGroupsGroupID int64) (*UserGroupsEntity, error)

+ func (r *UserGroupsRepositoryBase) Insert(e *UserGroupsEntity) (*UserGroupsEntity, error)

+ func (r *UserGroupsRepositoryBase) UpdateOneByUserIDAndGroupID(userGroupsUserID int64, userGroupsGroupID int64, patch *UserGroupsPatch) (*UserGroupsEntity, error)

+ func (r *UserGroupsRepositoryBase) Upsert(e *UserGroupsEntity, p *UserGroupsPatch, inf ...string) (*UserGroupsEntity, error)

+ type UserIterator struct

+ func (i *UserIterator) Close() error

+ func (i *UserIterator) Columns() ([]string, error)

+ func (i *UserIterator) Ent() (interface{}, error)

+ func (i *UserIterator) Err() error

+ func (i *UserIterator) Next() bool

+ func (i *UserIterator) User() (*UserEntity, error)

+ type UserPatch struct

+ ConfirmationToken []byte

+ CreatedAt *time.Time

+ CreatedBy *ntypes.Int64

+ FirstName *ntypes.String

+ IsActive *ntypes.Bool

+ IsConfirmed *ntypes.Bool

+ IsStaff *ntypes.Bool

+ IsSuperuser *ntypes.Bool

+ LastLoginAt *time.Time

+ LastName *ntypes.String

+ Password []byte

+ UpdatedAt *time.Time

+ UpdatedBy *ntypes.Int64

+ Username *ntypes.String

+ type UserPermissionsCriteria struct

+ CreatedAt *qtypes.Timestamp

+ CreatedBy *qtypes.Int64

+ Limit int64

+ Offset int64

+ PermissionAction *qtypes.String

+ PermissionModule *qtypes.String

+ PermissionSubsystem *qtypes.String

+ Sort map[string]bool

+ UpdatedAt *qtypes.Timestamp

+ UpdatedBy *qtypes.Int64

+ UserID *qtypes.Int64

+ func (c *UserPermissionsCriteria) WriteComposition(sel string, com *pqtgo.Composer, opt *pqtgo.CompositionOpts) (err error)

+ type UserPermissionsEntity struct

+ Author *UserEntity

+ CreatedAt time.Time

+ CreatedBy *ntypes.Int64

+ Modifier *UserEntity

+ PermissionAction string

+ PermissionModule string

+ PermissionSubsystem string

+ UpdatedAt *time.Time

+ UpdatedBy *ntypes.Int64

+ User *UserEntity

+ UserID int64

+ func ScanUserPermissionsRows(rows *sql.Rows) ([]*UserPermissionsEntity, error)

+ func (e *UserPermissionsEntity) Prop(cn string) (interface{}, bool)

+ func (e *UserPermissionsEntity) Props(cns ...string) ([]interface{}, error)

+ type UserPermissionsIterator struct

+ func (i *UserPermissionsIterator) Close() error

+ func (i *UserPermissionsIterator) Columns() ([]string, error)

+ func (i *UserPermissionsIterator) Ent() (interface{}, error)

+ func (i *UserPermissionsIterator) Err() error

+ func (i *UserPermissionsIterator) Next() bool

+ func (i *UserPermissionsIterator) UserPermissions() (*UserPermissionsEntity, error)

+ type UserPermissionsPatch struct

+ CreatedAt *time.Time

+ CreatedBy *ntypes.Int64

+ PermissionAction *ntypes.String

+ PermissionModule *ntypes.String

+ PermissionSubsystem *ntypes.String

+ UpdatedAt *time.Time

+ UpdatedBy *ntypes.Int64

+ UserID *ntypes.Int64

+ type UserPermissionsProvider interface

+ Insert func(entity *UserPermissionsEntity) (*UserPermissionsEntity, error)

+ func NewUserPermissionsRepository(dbPool *sql.DB) UserPermissionsProvider

+ type UserPermissionsRepository struct

+ type UserPermissionsRepositoryBase struct

+ func (r *UserPermissionsRepositoryBase) Count(c *UserPermissionsCriteria) (int64, error)

+ func (r *UserPermissionsRepositoryBase) Find(c *UserPermissionsCriteria) ([]*UserPermissionsEntity, error)

+ func (r *UserPermissionsRepositoryBase) FindIter(c *UserPermissionsCriteria) (*UserPermissionsIterator, error)

+ func (r *UserPermissionsRepositoryBase) FindOneByUserIDAndPermissionSubsystemAndPermissionModuleAndPermissionAction(userPermissionsUserID int64, userPermissionsPermissionSubsystem string, ...) (*UserPermissionsEntity, error)

+ func (r *UserPermissionsRepositoryBase) Insert(e *UserPermissionsEntity) (*UserPermissionsEntity, error)

+ func (r *UserPermissionsRepositoryBase) UpdateOneByUserIDAndPermissionSubsystemAndPermissionModuleAndPermissionAction(userPermissionsUserID int64, userPermissionsPermissionSubsystem string, ...) (*UserPermissionsEntity, error)

+ func (r *UserPermissionsRepositoryBase) Upsert(e *UserPermissionsEntity, p *UserPermissionsPatch, inf ...string) (*UserPermissionsEntity, error)

+ type UserProvider interface

+ ChangePassword func(id int64, password string) error

+ Count func() (int64, error)

+ Create func(username string, password []byte, FirstName, LastName string, ...) (*UserEntity, error)

+ CreateSuperuser func(username string, password []byte, FirstName, LastName string) (*UserEntity, error)

+ DeleteOneByID func(id int64) (int64, error)

+ Exists func(id int64) (bool, error)

+ Find func(criteria *UserCriteria) ([]*UserEntity, error)

+ FindOneByID func(id int64) (*UserEntity, error)

+ FindOneByUsername func(username string) (*UserEntity, error)

+ Insert func(*UserEntity) (*UserEntity, error)

+ IsGranted func(id int64, permission charon.Permission) (bool, error)

+ RegistrationConfirmation func(id int64, confirmationToken string) error

+ SetPermissions func(id int64, permissions ...charon.Permission) (int64, int64, error)

+ UpdateLastLoginAt func(id int64) (int64, error)

+ UpdateOneByID func(int64, *UserPatch) (*UserEntity, error)

+ type UserRepository struct

+ func NewUserRepository(dbPool *sql.DB) *UserRepository

+ func (ur *UserRepository) ChangePassword(userID int64, password string) error

+ func (ur *UserRepository) Count() (n int64, err error)

+ func (ur *UserRepository) Create(username string, password []byte, firstName, lastName string, ...) (*UserEntity, error)

+ func (ur *UserRepository) CreateSuperuser(username string, password []byte, FirstName, LastName string) (*UserEntity, error)

+ func (ur *UserRepository) Exists(userID int64) (bool, error)

+ func (ur *UserRepository) FindOneBy(fieldName string, value interface{}) (*UserEntity, error)

+ func (ur *UserRepository) FindOneByUsername(username string) (*UserEntity, error)

+ func (ur *UserRepository) IsGranted(id int64, p charon.Permission) (bool, error)

+ func (ur *UserRepository) RegistrationConfirmation(userID int64, confirmationToken string) error

+ func (ur *UserRepository) SetPermissions(id int64, p ...charon.Permission) (int64, int64, error)

+ func (ur *UserRepository) UpdateLastLoginAt(userID int64) (int64, error)

+ type UserRepositoryBase struct

+ func (r *UserRepositoryBase) Count(c *UserCriteria) (int64, error)

+ func (r *UserRepositoryBase) DeleteOneByID(id int64) (int64, error)

+ func (r *UserRepositoryBase) Find(c *UserCriteria) ([]*UserEntity, error)

+ func (r *UserRepositoryBase) FindIter(c *UserCriteria) (*UserIterator, error)

+ func (r *UserRepositoryBase) FindOneByID(id int64) (*UserEntity, error)

+ func (r *UserRepositoryBase) FindOneByUsername(userUsername string) (*UserEntity, error)

+ func (r *UserRepositoryBase) Insert(e *UserEntity) (*UserEntity, error)

+ func (r *UserRepositoryBase) UpdateOneByID(id int64, patch *UserPatch) (*UserEntity, error)

+ func (r *UserRepositoryBase) UpdateOneByUsername(userUsername string, patch *UserPatch) (*UserEntity, error)

+ func (r *UserRepositoryBase) Upsert(e *UserEntity, p *UserPatch, inf ...string) (*UserEntity, error)