models

type Bout struct {
	gorm.Model
	MatchID         uint      `gorm:"not_null"`
	Position        uint      `gorm:"not_null"`
	FencerIDLeft    uint      `gorm:"not_null"`
	FencerIDRight   uint      `gorm:"not_null"`
	ByeLeft         bool      `gorm:"-"`
	ByeRight        bool      `gorm:"-"`
	FencerNameLeft  string    `gorm:"-"`
	FencerNameRight string    `gorm:"-"`
	SquadNameLeft   string    `gorm:"-"`
	SquadNameRight  string    `gorm:"-"`
	SquadIDLeft     uint      `gorm:"-"`
	SquadIDRight    uint      `gorm:"-"`
	ScoreLeft       int       `gorm:"not_null"`
	ScoreRight      int       `gorm:"not_null"`
	EventName       string    `gorm:"-"`
	Date            time.Time `gorm:"-"`
	Round           uint      `gorm:"-"`
}

type BoutDB interface {
	// All returns a slice of all Bouts in the bouts table and a nil error;
	// or an empty slice and any error encountered.
	All() ([]Bout, error)
	// AllWithNames does the same as All, except that each bout has the fencer's names set and bye status.
	AllWithNames() ([]Bout, error)
	// ByID is used to look up a bout by its ID.
	// If the bout is found, it returns the bout and a nil error; otherwise it returns a nil bout and ErrNotFound.
	ByID(id uint) (*Bout, error)
	// ByIDWithNames is used to look up a bout by its ID in contexts where fencer names or bye status are important.
	// If the bout is found, it returns the bout and a nil error; otherwise it returns a nil bout and ErrNotFound.
	ByIDWithNames(id uint) (*Bout, error)

	// Create is used to make a new bout.
	Create(bout *Bout) error
	// Update is used to update a bout.
	Update(bout *Bout) error
}

type BoutService interface {
	BoutDB
}

type Category string

type Event struct {
	gorm.Model
	Name   string    `gorm:"not_null"`
	Date   time.Time `gorm:"not_null"`
	Rounds uint      `gorm:"not_null"`
}

type EventDB interface {
	// All returns a slice of all Events in the events table and a nil error;
	// or an empty slice and any error encountered.
	All() ([]Event, error)
	// CurrentSeason returns a slice of all Events in the events table which are part of the current season, and
	// a nil error; or an empty slice and any error encountered.
	CurrentSeason() ([]Event, error)
	// PastSeasons returns a slice of all Events in the events table which are older than the current season, and a
	// nil error; or an empty slice and any error encountered.
	PastSeasons() ([]Event, error)

	// ByID is used to look up a event by its ID.
	// If the event is found, it returns the event and a nil error; otherwise it returns a nil event and ErrNotFound.
	ByID(id uint) (*Event, error)

	// MatchesByID is used to find all matches which are part of the event corresponding to id.
	MatchesByID(id uint) ([]Match, error)

	// Create is used to make a new event.
	Create(event *Event) error
	// Update is used to update an event.
	Update(event *Event) error
	// Delete is used to delete an event.
	Delete(id uint) error
}

type EventService interface {
	EventDB
}

type Fencer struct {
	gorm.Model
	Name       string   `gorm:"not_null"`
	SquadID    uint     `gorm:"not_null"`
	Bye        bool     `gorm:"not_null;<-:create;DEFAULT:false"`
	Category   Category `gorm:"-"`
	SchoolID   uint     `gorm:"-"`
	SchoolName string   `gorm:"-"`
	Wins       int      `gorm:"-"`
	Losses     int      `gorm:"-"`
	TotalBouts int      `gorm:"-"`
}

type FencerDB interface {
	// All returns a slice of all Fencers in the fencers table and a nil error;
	// or an empty slice and an error if one is encountered.
	// The fencers returned contain the associated data stored in squads and schools tables. (This is like ByIDWIthSquad for all fencers).
	All() ([]Fencer, error)

	// ByID is used to look up a fencer by their ID.
	// If the fencer is found, it returns the fencer and a nil error; otherwise it returns a nil fencer and ErrNotFound.
	ByID(id uint) (*Fencer, error)
	// ByIDWithSquad looks up a fencer by the id provided and joins with squads and schools tables to get all of the data associated with a fencer in those tables.
	ByIDWithSquad(id uint) (*Fencer, error)
	// ByCategory is used to look up Fencers by their Category.
	ByCategory(category Category) ([]Fencer, error)

	// BoutsByID is used to find all bouts in which a fencer has participated.
	// If the fencer exists and has participated in bouts, it returns a
	// non-empty []Bout and a nil error; otherwise, it will return a empty slice
	// and ErrNotFound.
	BoutsByID(id uint) ([]Bout, error)
	// BoutsByIDWithByes does the same as BoutsByID, but also returns BYEs.
	BoutsByIDWithByes(id uint) ([]Bout, error)
	// BoutsByIDCurrentSeason does the same as BoutsByIDWithByes, but only returns
	// bouts in the current season.
	BoutsByIDCurrentSeason(id uint) ([]Bout, error)
	// BoutsByIDs is used to find all bouts in which any fencer has participated.
	// If all of the fencers exist but have not participated in bouts, it returns a
	// non-empty []Bout and a nil error; otherwise, it will return a empty slice
	// and ErrNotFound.
	BoutsByIDs(ids []uint) ([]Bout, error)

	// Create is used to create a new fencer.
	Create(fencer *Fencer) error
	// Update is used to update an existing fencer.
	Update(fencer *Fencer) error
	// Delete removes an existing fencer from the database.
	Delete(id uint) error
}

type FencerService interface {
	FencerDB
}

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

type Match struct {
	gorm.Model
	EventID        uint   `gorm:"not_null"`
	Round          uint   `gorm:"not_null"`
	SquadIDLeft    uint   `gorm:"not_null"`
	SquadNameLeft  string `gorm:"-"`
	SquadNameRight string `gorm:"-"`
	SquadIDRight   uint   `gorm:"not_null"`
	ScoreLeft      uint
	ScoreRight     uint
	EventName      string    `gorm:"-"`
	Date           time.Time `gorm:"-"`
	Category       Category  `gorm:"-"`
}

type MatchDB interface {
	// ByID is used to look up a match by its ID.
	// If the match is found, it returns the match and a nil error; otherwise it returns a nil match and ErrNotFound.
	ByID(id uint) (*Match, error)

	// BoutsByID returns a slice of bouts associated with a match by the match's ID.
	BoutsByID(id uint) ([]Bout, error)
	// BoutsByIDWithByes does tthe same as BoutsByID and sets the bout.ByeLeft, bout.ByeRight.
	BoutsByIDWithByes(id uint) ([]Bout, error)
	// BoutsByIDWithNames does the same as BoutsByIDWithByes and sets the names of the fencers.
	BoutsByIDWithNames(id uint) ([]Bout, error)

	// Create is used to make a new match.
	Create(match *Match) error
	// Update is used to update a match.
	Update(match *Match) error
	// Delete is used to "soft-delete" a match by its id.
	Delete(id uint) error
	// DeleteBouts is used to "soft-delete" the bouts associated with a bout by the match id.
	DeleteBouts(id uint) error
}

type MatchService interface {
	MatchDB
}

type Pair struct {
	Key   uint
	Value int
}

type PairList []Pair

type Plurality string

type PriorityQueue []*Item

type School struct {
	gorm.Model
	Name string `gorm:"not_null"`
}

type SchoolDB interface {
	// All returns a slice of all Schools in the schools table and a nil error; or an empty slice and an error if one is encountered.
	All() ([]School, error)
	// ByID is used to look up a school by its ID.
	// If the school is found, it returns the school and a nil error; otherwise it returns a nil school and ErrNotFound.
	ByID(id uint) (*School, error)

	// SquadsByID returns a []Squad which enumerates the squads belonging to the school specified by the id parameter, and an error.
	// If the school does not have any squads in it, then SquadsByID will return an empty slice and a nil error.
	// It will return ErrNotFound if no school corresponds to the id, or other errors if the query is malformed.
	SquadsByID(id uint) ([]Squad, error)

	// FencersByID returns a slice of all fencers with school data.
	FencersByID(id uint) ([]Fencer, error)

	// Create is used to make a new school.
	Create(school *School) error
	// Update is used to update a school.
	Update(school *School) error
	// Delete is used to delete a school by its id.
	Delete(id uint) error
}

type SchoolService interface {
	SchoolDB
}

type Seeding struct {
	Plurality    Plurality
	Category     Category
	Names        []string
	SchoolNames  []string
	IDs          []uint
	Elos         []int
	TotalGames   []int
	CurrentGames []int
}

type SeedingService interface {
	Create(category Category, plurality Plurality) (*Seeding, error)
}

type Services struct {
	User    UserService
	Fencer  FencerService
	Squad   SquadService
	School  SchoolService
	Bout    BoutService
	Match   MatchService
	Event   EventService
	Seeding SeedingService
	// contains filtered or unexported fields
}

type ServicesConfig func(*Services) error

type Squad struct {
	gorm.Model
	SchoolID   uint     `gorm:"not_null"`
	SchoolName string   `gorm:"-"`
	Category   Category `gorm:"not_null"`
	Wins       int      `gorm:"-"`
	Losses     int      `gorm:"-"`
	Draws      int      `gorm:"-"`
}

type SquadDB interface {
	// ByID is used to look up a squad by its ID.
	// If the squad is found, it returns the squad and a nil error; otherwise it returns a nil squad and ErrNotFound.
	ByID(id uint) (*Squad, error)
	// ByIDWithSchoolName is used to look up a squad and the name of its school by the squad's ID.
	// If the squad is found, it returns the squad with SchoolName set and a nil error; otherwise it returns a nil squad and ErrNotFound.
	ByIDWithSchoolName(id uint) (*Squad, error)
	// BySchoolIDAndCategory is used to look up a squad by its school ID and category.
	// If the squad is found, it returns the squad and a nil error; otherwise it returns a nil squad and ErrNotFound.
	BySchoolIDAndCategory(schoolID uint, category Category) (*Squad, error)
	// ByCategory is used to look up all squads in a category.
	// If no squads are found, an empty slice is returned.
	ByCategory(category Category) ([]Squad, error)

	// FencersByID is used to look up a squad's fencers by the squad's ID.
	FencersByID(id uint) ([]Fencer, error)
	// FencersByIDWithByes is ued to look up a squad's bye fencers by the squad's ID.
	FencersByIDWithByes(id uint) ([]Fencer, error)
	// MatchesByIDs is used to look up all matches any squad in a slice of squads has participate in.
	MatchesByIDs(ids []uint) ([]Match, error)

	// MatchesByID is used to find all matches in which a squad has participated.
	// If the squad exists and has participated in matches, it returns a non-empty []Match and a nil error; otherwise, it will return
	// an empty slice and ErrNotFound.
	MatchesByID(id uint) ([]Match, error)
	// MatchesByIDCurrentSeason does the same as MatchesByID, but only returns matches in the current season.
	MatchesByIDCurrentSeason(id uint) ([]Match, error)

	// Create is used to make a new squad.
	Create(squad *Squad) error
	// Update is used to update a squad.
	Update(squad *Squad) error
	// Delete is used to update a squad.
	Delete(id uint) error
}

type SquadService interface {
	SquadDB
}

type User struct {
	gorm.Model
	Name          string `gorm:"not null"`
	Email         string `gorm:"not null;unique_index"`
	Password      string `gorm:"-"`
	PasswordHash  string `gorm:"not null"`
	Remember      string `gorm:"-"`
	RememberHash  string `gorm:"not null;unique_index"`
	PermissionLvl int    `gorm:"not null"`
}

type UserDB interface {
	// Methods for retrieving groups of users
	All() ([]User, error)

	// Methods for querying for single users
	ByID(id uint) (*User, error)
	ByEmail(email string) (*User, error)
	ByRemember(token string) (*User, error)

	// Methods for altering users
	Create(user *User) error
	Update(user *User) error
	Delete(id uint) error
}

type UserService interface {
	// Authenticate will verify the provided email address and password are correct. If they are correct,
	// the user corresponding to that email address will be returned. Otherwise, you will receive either
	// ErrLoginInvalid if the details do not match or another error if something went wrong.
	Authenticate(email, password string) (*User, error)
	// InitiateReset will complete all the model-related tasks
	// to start the password reset process for the user with
	// the provided email address. Once completed, it will
	// return the token, or an error if there was one.
	InitiateReset(email string) (string, error)
	// CompleteReset will complete all the model-related tasks
	// to complete the password reset process for the user that
	// the token matches, including updating that user's pw.
	// If the token has expired, or if it is invalid for any
	// other reason the ErrTokenInvalid error will be returned.
	CompleteReset(token, newPw string) (*User, error)
	UserDB
}