gopherbouncedb

type AmbiguousCredentials string

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

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

type NoSuchSession string

type NoSuchUser string

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

type PasswordVerifier func(pw string) bool

type RetryInsertErr []error

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

type RuneClass func(r rune) bool

type SQLBridge interface {
	// TimeScanType should return the type that is used to retrieve
	// time.Time objects from the database.
	// When we retrieve for example a user a variable is created with this function
	// and then passed to the scan method to retrieve a time from the database.
	// Thus it should return a pointer s.t. the database Scan method can
	// assign it the actual value.
	//
	// After the retrieving with Scan is done this object is converted to a time.Time
	// with ConvertTimeScanType.
	//
	// The easiest implementation is to just return a *time.Time.
	TimeScanType() interface{}
	// ConvertTimeScanType is used to transform the values that were processed with
	// a variable from TimeScanType, thus this function can assume that val is of
	// the type returned by TimeScanType.
	// However, type checking should be done and an error returned if this is not the case.
	// Thus the workflow for retrieving time.Time elements from the database is as followś:
	// Call database Scan method with the value retrieved from TimeScanType.
	// This value is then converted to an actual time.Time with this function.
	//
	// For example if TimeScanType returns x = *time.Time this method can just return
	// *x.
	ConvertTimeScanType(val interface{}) (time.Time, error)
	// IsDuplicateInsert checks if the error is an error that was caused by inserting
	// a duplicate entry.
	//
	// Various database drivers have their own way of defining such a key error, for
	// example by an error code or a specific error type.
	IsDuplicateInsert(err error) bool
	// IsDuplicateUpdate is used the same way as IsDuplicateInsert, but is used in
	// update operations.
	// Usually database drivers don't distinguish between different key errors
	// on insert/update and thus in most cases it works the same way as IsDuplicateInsert.
	IsDuplicateUpdate(err error) bool
	// ConvertTime has the same idea as TimeScanType: Transform an entry of time.Time
	// to a driver specific time that can be used for this driver.
	// Whereas TimeScanType is used for Scan the value returned by ConvertTime
	// is used on inserts and updates.
	// For example a driver may not be able to insert a time.Time value into the database
	// directly. Instead it may have to be converted to a string instead.
	//
	// In contrast to TimeScanType it should however (in general) not return a pointer.
	// A driver that can insert time.Time directly should simply returned the supplied
	// argument of time.Time.
	ConvertTime(t time.Time) interface{}
}

type SQLSessionStorage struct {
	SessionDB      *sql.DB
	SessionQueries SessionSQL
	SessionBridge  SQLBridge
}

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

type SQLUserIterator struct {
	Rows   *sql.Rows
	Bridge SQLBridge
}

type SQLUserStorage struct {
	UserDB      *sql.DB
	UserQueries UserSQL
	UserBridge  SQLBridge
}

type SessionEntry struct {
	Key        string
	User       UserID
	ExpireDate time.Time
}

type SessionExists string

type SessionSQL interface {
	InitSessions() []string
	GetSession() string
	InsertSession() string
	DeleteSession() string
	CleanUpSession() string
	DeleteForUserSession() string
}

type SessionStorage interface {
	// InitSessions is called once to make sure all tables and indexes exist in the database.
	InitSessions() error
	// InsertSession inserts a new session to the datastore.
	// If the session key already exists it should an error of type SessionExists.
	InsertSession(session *SessionEntry) error
	// GetSession returns the session with the given key.
	// If no such session exists it should return an error of type NoSuchSession
	GetSession(key string) (*SessionEntry, error)
	// DeleteSession deletes the session with the given key.
	// If no such session exists this will not be considered an error.
	DeleteSession(key string) error
	// CleanUp should remove all entries that are not valid any more given the
	// reference date.
	// If a session is valid should be checked with SessionEntry.IsValid.
	// It returns the number of deletes entries.
	// If the cleanup worked successfully but the driver doesn't support the number of
	// affected entries it should return an error of type NotSupported.
	CleanUp(referenceDate time.Time) (int64, error)
	// DeleteForUser deletes all session for the given user id.
	// It returns the number of deleted entries.
	// If the delete worked successfully but the driver doesn't support the number of
	// affected entries it should return an error of type NotSupported.
	DeleteForUser(user UserID) (int64, error)
}

type Storage interface {
	UserStorage
	SessionStorage
}

type UserExists string

type UserID int64

type UserIterator interface {
	HasNext() bool
	Next() (*UserModel, error)
	Err() error
	Close() error
}

type UserModel struct {
	ID          UserID
	FirstName   string
	LastName    string
	Username    string
	EMail       string
	Password    string
	IsActive    bool
	IsSuperUser bool
	IsStaff     bool
	DateJoined  time.Time
	LastLogin   time.Time
}

type UserSQL interface {
	// InitUsers returns a sequence of init actions.
	// They're all run on one transaction and rolled-back if one fails.
	// In this query als initialization should happen, usually something like
	// "create table if not exists" (or creating an index).
	InitUsers() []string
	// GetUser is the query to return a user with a given id.
	// It must select all fields from the user table in the following order:
	// id, user name, password, email, first name, last name, is superuser,
	// is staff, is active, date joined, last login.
	//
	// Exactly one element is passed to the query and that is the user id to look for.
	GetUser() string
	// GetUserByName does the same as GetUser but instead of an id gets a user name to
	// look for.
	GetUserByName() string
	// GetUserByEmail does the same as GetUser but instead of an id gets an email to
	// look for.
	// If the email is not unique this might lead to errors.
	GetUserByEmail() string
	// InsertUser inserts a new user into the database.
	//
	// The arguments parsed into Execute are the same once (and in the same order)
	// as in GetUser, except the id field (that is automatically generated).
	InsertUser() string
	// UpdateUser is used to update a user.
	// The query might depend on the fields which we want to update.
	// You don't have to support update by fields and just update all fields, even
	// those not given in fields. Just make sure to implement this in the
	// SupportsUserFields function.
	//
	// The sql implementation works as follows: If SupportsUserFields returns false
	// UpdateUser is always called with nil, meaning all fields must be updated.
	// If SupportsUserFields returns true then this function is called with the
	// actual fields and the returned statement updates should only those fields.
	//
	// Concerning in the arguments: In case len(fields) == 0 the same order as in GetUser,
	// except the id (this one can't be updated).
	// If fields is given the order of the arguments are in the same order as the fields.
	// The contents of fields are discussed in more detail in the documentation of the
	// UserStorage interface.
	// In all cases the id is passed as the last element.
	// This is the argument used usually in the WHERE clause and defines the user to
	// update by its id.
	//
	// A small example: If fields is nil: ... SET username=?, ... WHERE id=?.
	// The arguments are given in the order username, ..., id.
	//
	// If fields is given for example as ["LastName", "EMail"]:
	// ... SET last_name=?, email=? WHERE id=?.
	// The arguments are given in the order last_name, email, id.
	UpdateUser(fields []string) string
	// SupportsUserFields returns true if UpdateUser has the additional fields update
	// ability.
	// It's totally okay to return false and always update all values.
	// In this case UpdateUser always gets called with nil.
	SupportsUserFields() bool
	// DeleteUser removes a user from the database.
	// It is given a single argument, the user id.
	DeleteUser() string
	// ListUsers returns all users with a SELECT statement.
	ListUsers() string
}

type UserStorage interface {
	// InitUsers should be called once to make sure all tables in the database exist etc.
	InitUsers() error
	// GetUser returns the user with the given id. If no such user exists it
	// should return nil and an error of type NoSuchUser.
	GetUser(id UserID) (*UserModel, error)
	// GetUserByName returns the user with the given name. If no such user exists
	// it should return nil and an error of type NoSuchUser.
	GetUserByName(username string) (*UserModel, error)
	// GetUserByEmail returns the user with the given email. If no such user
	// exists it should return nil and an error of type NoSuchUser.
	GetUserByEmail(email string) (*UserModel, error)
	// InsertUser inserts a new user to the store. It should set the id of the
	// provided user model to the new id and return that id as well.
	// If an user with the given credentials already exists (name or email, depending on which are enforced to be
	// unique) it should return InvalidUserID and an error of type UserExists.
	// The fields DateJoined is set to the current date (in UTC) and LastLogin is set to
	// the time zero value.
	// If the underlying driver does not support to get the last insert id
	// via LastInsertId InvalidUserID and an error of type NotSupported should be returned.
	// This indicates that the insertion took place but the id could not be obtained.
	InsertUser(user *UserModel) (UserID, error)
	// UpdateUser update the user with the given information, that is it uses
	// the user id to find the user and stores all new information.
	// fields is an optional argument which contains the fields to update.
	// The fields must be a subset of the UserModel attributes.
	// If given only these fields will be updated - user id is not allowed to be changed.
	// If fields is empty (nil or empty slice) all fields will be updated.
	// If the change of values would violate a consistency constraint (email or username already in use) it should not
	// update any fields but instead return an error of type AmbiguousCredentials.
	//
	// Updating a non-existing user should not lead to any error (returns nil).
	//
	// Short summary: If nil is returned everything is okay, but the user may not exist.
	// If any of the new values violates a database constraint (such as unique) AmbiguousCredentials is
	// returned.
	UpdateUser(id UserID, newCredentials *UserModel, fields []string) error
	// DeleteUser deletes the given user.
	// If no such user exists this will not be considered an error.
	DeleteUser(id UserID) error
	// ListUsers returns all users in the storage.
	// At the moment no functionality to sort / filter the users exists, thus this must be done
	// after retrieving them.
	//
	// The iterator must be called in the following way (very similar to sql.Rows):
	// If the iterator is retrieved without an error the Close() method of the iterator must be called
	// (usually as a deferred function call).
	// Before accessing any of the elements with Next(), HasNext() must be called.
	// Finally, a call to Err must be made in order to test if the iteration ended or if there was an
	// error.
	// See the AsUserSlice function for an example.
	ListUsers() (UserIterator, error)
}

type UserVerifier func(u *UserModel) error