repository

package
v0.0.0-...-1561e87 Latest Latest
Warning

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

 Go to latest Published: Apr 23, 2024 License: GPL-3.0 Imports: 7 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func InitRepository 

func InitRepository()

Types

type CategoryRepository 

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

func (*CategoryRepository) Create 

func (t *CategoryRepository) Create(category model.Category) (err error)

func (*CategoryRepository) Delete 

func (t *CategoryRepository) Delete(id uint) (err error)

func (*CategoryRepository) Find 

func (t *CategoryRepository) Find(req request.CategoryFindRequest) (categories []model.Category, err error)

func (*CategoryRepository) Update 

func (t *CategoryRepository) Update(category model.Category) (err error)

type ChallengeRepository 

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

func (*ChallengeRepository) Create 

func (t *ChallengeRepository) Create(challenge model.Challenge) (c model.Challenge, err error)

func (*ChallengeRepository) Delete 

func (t *ChallengeRepository) Delete(id uint) (err error)

func (*ChallengeRepository) Find 

func (t *ChallengeRepository) Find(req request.ChallengeFindRequest) (challenges []model.Challenge, total int64, err error)

func (*ChallengeRepository) Update 

func (t *ChallengeRepository) Update(challenge model.Challenge) (c model.Challenge, err error)

type EnvRepository 

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

func (*EnvRepository) Create 

func (t *EnvRepository) Create(env model.Env) (e model.Env, err error)

type FlagGenRepository 

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

func (*FlagGenRepository) Create 

func (t *FlagGenRepository) Create(flag model.FlagGen) (f model.FlagGen, err error)

func (*FlagGenRepository) FindByPodID 

func (t *FlagGenRepository) FindByPodID(podIDs []uint) (flags []model.FlagGen, err error)

type FlagRepository 

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

func (*FlagRepository) Create 

func (t *FlagRepository) Create(flag model.Flag) (f model.Flag, err error)

func (*FlagRepository) Delete 

func (t *FlagRepository) Delete(flag model.Flag) (err error)

func (*FlagRepository) Update 

func (t *FlagRepository) Update(flag model.Flag) (f model.Flag, err error)

type GameChallengeRepository 

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

func (*GameChallengeRepository) Create 

func (t *GameChallengeRepository) Create(gameChallenge model.GameChallenge) (err error)

func (*GameChallengeRepository) Delete 

func (t *GameChallengeRepository) Delete(gameChallenge model.GameChallenge) (err error)

func (*GameChallengeRepository) Find 

func (t *GameChallengeRepository) Find(req request.GameChallengeFindRequest) (gameChallenges []model.GameChallenge, err error)

func (*GameChallengeRepository) Update 

func (t *GameChallengeRepository) Update(gameChallenge model.GameChallenge) (err error)

type GameRepository 

type GameRepository struct {
	Db *gorm.DB
}

func (*GameRepository) Create 

func (t *GameRepository) Create(game model.Game) (g model.Game, err error)

func (*GameRepository) Delete 

func (t *GameRepository) Delete(req request.GameDeleteRequest) (err error)

func (*GameRepository) Find 

func (t *GameRepository) Find(req request.GameFindRequest) (games []model.Game, count int64, err error)

func (*GameRepository) Update 

func (t *GameRepository) Update(game model.Game) (err error)

type GameTeamRepository 

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

func (*GameTeamRepository) Create 

func (g *GameTeamRepository) Create(gameTeam model.GameTeam) (err error)

func (*GameTeamRepository) Delete 

func (g *GameTeamRepository) Delete(gameTeam model.GameTeam) (err error)

func (*GameTeamRepository) Find 

func (g *GameTeamRepository) Find(gameTeam model.GameTeam) (gameTeams []model.GameTeam, err error)

func (*GameTeamRepository) Update 

func (g *GameTeamRepository) Update(gameTeam model.GameTeam) (err error)

type HintRepository 

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

func (*HintRepository) Create 

func (t *HintRepository) Create(hint model.Hint) (h model.Hint, err error)

func (*HintRepository) Delete 

func (t *HintRepository) Delete(hint model.Hint) (err error)

func (*HintRepository) Update 

func (t *HintRepository) Update(hint model.Hint) (h model.Hint, err error)

type ICategoryRepository 

type ICategoryRepository interface {
	Create(category model.Category) (err error)
	Update(category model.Category) (err error)
	Find(req request.CategoryFindRequest) (categories []model.Category, err error)
	Delete(id uint) (err error)
}

func NewCategoryRepositoryImpl 

func NewCategoryRepositoryImpl(db *gorm.DB) ICategoryRepository

type IChallengeRepository 

type IChallengeRepository interface {
	Create(challenge model.Challenge) (c model.Challenge, err error)
	Update(challenge model.Challenge) (c model.Challenge, err error)
	Delete(id uint) (err error)
	Find(req request.ChallengeFindRequest) (challenges []model.Challenge, total int64, err error)
}

func NewChallengeRepository 

func NewChallengeRepository(db *gorm.DB) IChallengeRepository

type IEnvRepository 

type IEnvRepository interface {
	Create(env model.Env) (e model.Env, err error)
}

func NewEnvRepository 

func NewEnvRepository(db *gorm.DB) IEnvRepository

type IFlagGenRepository 

type IFlagGenRepository interface {
	Create(flag model.FlagGen) (f model.FlagGen, err error)
	FindByPodID(podIDs []uint) (flags []model.FlagGen, err error)
}

func NewFlagGenRepository 

func NewFlagGenRepository(db *gorm.DB) IFlagGenRepository

type IFlagRepository 

type IFlagRepository interface {
	Create(flag model.Flag) (f model.Flag, err error)
	Update(flag model.Flag) (f model.Flag, err error)
	Delete(flag model.Flag) (err error)
}

func NewFlagRepository 

func NewFlagRepository(db *gorm.DB) IFlagRepository

type IGameChallengeRepository 

type IGameChallengeRepository interface {
	Find(req request.GameChallengeFindRequest) (gameChallenges []model.GameChallenge, err error)
	Create(gameChallenge model.GameChallenge) (err error)
	Update(gameChallenge model.GameChallenge) (err error)
	Delete(gameChallenge model.GameChallenge) (err error)
}

func NewGameChallengeRepository 

func NewGameChallengeRepository(db *gorm.DB) IGameChallengeRepository

type IGameRepository 

type IGameRepository interface {
	Create(game model.Game) (g model.Game, err error)
	Update(game model.Game) (err error)
	Delete(req request.GameDeleteRequest) (err error)
	Find(req request.GameFindRequest) (games []model.Game, count int64, err error)
}

func NewGameRepository 

func NewGameRepository(Db *gorm.DB) IGameRepository

type IGameTeamRepository 

type IGameTeamRepository interface {
	Create(gameTeam model.GameTeam) (err error)
	Update(gameTeam model.GameTeam) (err error)
	Delete(gameTeam model.GameTeam) (err error)
	Find(gameTeam model.GameTeam) (gameTeams []model.GameTeam, err error)
}

func NewGameTeamRepository 

func NewGameTeamRepository(db *gorm.DB) IGameTeamRepository

type IHintRepository 

type IHintRepository interface {
	Create(hint model.Hint) (h model.Hint, err error)
	Update(hint model.Hint) (h model.Hint, err error)
	Delete(hint model.Hint) (err error)
}

func NewHintRepository 

func NewHintRepository(db *gorm.DB) IHintRepository

type INatRepository 

type INatRepository interface {
	Create(nat model.Nat) (n model.Nat, err error)
}

func NewNatRepository 

func NewNatRepository(db *gorm.DB) INatRepository

type INoticeRepository 

type INoticeRepository interface {
	Find(req request.NoticeFindRequest) (notices []model.Notice, count int64, err error)
	Create(notice model.Notice) (n model.Notice, err error)
	Update(notice model.Notice) (n model.Notice, err error)
	Delete(notice model.Notice) (err error)
}

func NewNoticeRepository 

func NewNoticeRepository(db *gorm.DB) INoticeRepository

type IPodRepository 

type IPodRepository interface {
	Create(pod model.Pod) (i model.Pod, err error)
	Update(pod model.Pod) (err error)
	Find(req request.PodFindRequest) (pods []model.Pod, count int64, err error)
	FindById(id uint) (pod model.Pod, err error)
}

func NewPodRepository 

func NewPodRepository(db *gorm.DB) IPodRepository

type IPortRepository 

type IPortRepository interface {
	Create(port model.Port) (p model.Port, err error)
	Update(port model.Port) (p model.Port, err error)
	Delete(port model.Port) (err error)
}

func NewPortRepository 

func NewPortRepository(db *gorm.DB) IPortRepository

type ISubmissionRepository 

type ISubmissionRepository interface {
	Create(submission model.Submission) (err error)
	Delete(id uint) (err error)
	Find(req request.SubmissionFindRequest) (submissions []model.Submission, count int64, err error)
}

func NewSubmissionRepository 

func NewSubmissionRepository(db *gorm.DB) ISubmissionRepository

type ITeamRepository 

type ITeamRepository interface {
	Create(team model.Team) (te model.Team, err error)
	Update(team model.Team) (err error)
	Delete(id uint) (err error)
	Find(req request.TeamFindRequest) (teams []model.Team, count int64, err error)
	FindById(id uint) (team model.Team, err error)
}

func NewTeamRepository 

func NewTeamRepository(db *gorm.DB) ITeamRepository

type IUserRepository 

type IUserRepository interface {
	Create(user model.User) error
	Update(user model.User) error
	Delete(id uint) error
	FindById(id uint) (user model.User, err error)
	FindByUsername(username string) (user model.User, err error)
	Find(req request.UserFindRequest) (user []model.User, total int64, err error)
}

func NewUserRepository 

func NewUserRepository(db *gorm.DB) IUserRepository

type IUserTeamRepository 

type IUserTeamRepository interface {
	Create(userTeam model.UserTeam) error
	Delete(userTeam model.UserTeam) error
}

func NewUserTeamRepository 

func NewUserTeamRepository(db *gorm.DB) IUserTeamRepository

type NatRepository 

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

func (*NatRepository) Create 

func (t *NatRepository) Create(nat model.Nat) (n model.Nat, err error)

type NoticeRepository 

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

func (*NoticeRepository) Create 

func (t *NoticeRepository) Create(notice model.Notice) (n model.Notice, err error)

func (*NoticeRepository) Delete 

func (t *NoticeRepository) Delete(notice model.Notice) (err error)

func (*NoticeRepository) Find 

func (t *NoticeRepository) Find(req request.NoticeFindRequest) (notices []model.Notice, count int64, err error)

func (*NoticeRepository) Update 

func (t *NoticeRepository) Update(notice model.Notice) (n model.Notice, err error)

type PodRepository 

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

func (*PodRepository) Create 

func (t *PodRepository) Create(pod model.Pod) (i model.Pod, err error)

func (*PodRepository) Find 

func (t *PodRepository) Find(req request.PodFindRequest) (pods []model.Pod, count int64, err error)

func (*PodRepository) FindById 

func (t *PodRepository) FindById(id uint) (pod model.Pod, err error)

func (*PodRepository) Update 

func (t *PodRepository) Update(pod model.Pod) (err error)

type PortRepository 

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

func (*PortRepository) Create 

func (t *PortRepository) Create(port model.Port) (p model.Port, err error)

func (*PortRepository) Delete 

func (t *PortRepository) Delete(port model.Port) (err error)

func (*PortRepository) Update 

func (t *PortRepository) Update(port model.Port) (p model.Port, err error)

type Repository 

type Repository struct {
	UserRepository          IUserRepository
	ChallengeRepository     IChallengeRepository
	TeamRepository          ITeamRepository
	SubmissionRepository    ISubmissionRepository
	PodRepository           IPodRepository
	GameRepository          IGameRepository
	UserTeamRepository      IUserTeamRepository
	GameChallengeRepository IGameChallengeRepository
	CategoryRepository      ICategoryRepository
	FlagRepository          IFlagRepository
	PortRepository          IPortRepository
	NatRepository           INatRepository
	EnvRepository           IEnvRepository
	FlagGenRepository       IFlagGenRepository
	GameTeamRepository      IGameTeamRepository
	HintRepository          IHintRepository
	NoticeRepository        INoticeRepository
}

func R 

func R() *Repository

type SubmissionRepository 

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

func (*SubmissionRepository) Create 

func (t *SubmissionRepository) Create(submission model.Submission) (err error)

func (*SubmissionRepository) Delete 

func (t *SubmissionRepository) Delete(id uint) (err error)

func (*SubmissionRepository) Find 

func (t *SubmissionRepository) Find(req request.SubmissionFindRequest) (submissions []model.Submission, count int64, err error)

type TeamRepository 

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

func (*TeamRepository) Create 

func (t *TeamRepository) Create(team model.Team) (te model.Team, err error)

func (*TeamRepository) Delete 

func (t *TeamRepository) Delete(id uint) (err error)

func (*TeamRepository) Find 

func (t *TeamRepository) Find(req request.TeamFindRequest) (teams []model.Team, count int64, err error)

func (*TeamRepository) FindById 

func (t *TeamRepository) FindById(id uint) (team model.Team, err error)

func (*TeamRepository) Update 

func (t *TeamRepository) Update(team model.Team) (err error)

type UserRepository 

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

func (*UserRepository) Create 

func (t *UserRepository) Create(user model.User) error

func (*UserRepository) Delete 

func (t *UserRepository) Delete(id uint) error

func (*UserRepository) Find 

func (t *UserRepository) Find(req request.UserFindRequest) (users []model.User, total int64, err error)

func (*UserRepository) FindById 

func (t *UserRepository) FindById(id uint) (user model.User, err error)

func (*UserRepository) FindByUsername 

func (t *UserRepository) FindByUsername(username string) (user model.User, err error)

func (*UserRepository) Update 

func (t *UserRepository) Update(user model.User) error

type UserTeamRepository 

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

func (*UserTeamRepository) Create 

func (t *UserTeamRepository) Create(userTeam model.UserTeam) error

func (*UserTeamRepository) Delete 

func (t *UserTeamRepository) Delete(userTeam model.UserTeam) error

Source Files

View all Source files

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.