services

Documentation

Index

• Constants
• type ChallengeService
  • func NewChallengeService(challengeRepo repositories.ChallengeRepository, sandboxService SandboxService) ChallengeService
• type DockerService
  • func NewDockerservice() DockerService
• type JWTService
  • func NewJWTService(secret string) JWTService
• type KafkaService
  • func NewKafkaMockService() KafkaService
  • func NewKafkaService(host string) KafkaService
• type SandboxService
  • func NewSandboxService(memoryLimit uint, timeLimit uint) SandboxService
• type ServiceKit
  • func CreateServiceKit(db *gorm.DB) *ServiceKit
  • func CreateTestServiceKit(db *gorm.DB) *ServiceKit
• type SubmissionService
  • func NewSubmissionService(submissionRepository repositories.SubmissionRepository, ...) SubmissionService
• type UserService
  • func NewUserService(userRepo repositories.UserRepository) UserService

Constants

const (
	WaitResultSuccess = "success"
	WaitResultTimeout = "timeout"
	WaitResultError   = "error"
)

Types

type ChallengeService

type ChallengeService interface {
	CreateChallenge(challenge *entities.Challenge) (*entities.Challenge, error)
	// UpdateChallenge(challenge *entities.Challenge) (err error)
	DeleteChallenge(challenge *entities.Challenge) (err error)
	FindChallengeByID(challengeID uint) (challenge *entities.Challenge, err error)
	AllChallenges() (challenges []*entities.Challenge, err error)
	AddTestcase(challenge *entities.Challenge, testcase *entities.ChallengeTestcase) (*entities.ChallengeTestcase, error)
	UpdateTestcase(testcase *entities.ChallengeTestcase) (err error)
	DeleteTestcase(testcase *entities.ChallengeTestcase) (err error)
	AllTestcases(challenge *entities.Challenge) (testcases []*entities.ChallengeTestcase, err error)
	FindTestcaseByID(testcaseID uint) (testcase *entities.ChallengeTestcase, err error)
	PaginationChallengesWithStatus(options *entities.ChallengePaginationOptions) (result *entities.PaginationResult[*entities.ChallengeExtended], err error)
	UpdateChallengeWithTestcase(challenge *entities.Challenge) (err error)
	CountAllChallengesByUser(user *entities.User) (total int64, err error)
	ValidateTestcases(testcases []*entities.ChallengeTestcase) (err error)
}

func NewChallengeService

func NewChallengeService(challengeRepo repositories.ChallengeRepository, sandboxService SandboxService) ChallengeService

type DockerService

type DockerService interface {
	PullImage(imageName string) error
	ImageExist(imageName string) (bool, error)
	GetLog(containerID string, showStdout, showStderr bool) (string, error)
	GetContainerExitCode(containerID string) (int, error)
	CreateVolume(name string) (volume.Volume, error)
	DeleteVolume(v volume.Volume) error
	CopyToContainer(containerID, targetPath string, content []byte) error
	CreateContainer(imageName string, command []string, volumes []mount.Mount, memoryLimit int64, containerName string) (response container.CreateResponse, err error)
	StartContainer(containerID string) error
	StopContainer(containerID string) error
	RemoveContainer(containerID string) error
	WaitContainer(containerID string, timeout uint) string
}

func NewDockerservice

func NewDockerservice() DockerService

type JWTService

type JWTService interface {
	GenerateToken(user entities.User) (string, error)
	ValidateToken(token string) (*entities.User, error)
}

func NewJWTService

func NewJWTService(secret string) JWTService

type KafkaService

type KafkaService interface {
	Produce(topic string, message string) error
	Consume(topic string, groupID string) (chan string, chan error)
	IsTopicExist(topic string) bool
	OverriddenHost(host string)
	CreateTopic(topic string, partitions int) error
}

func NewKafkaMockService

func NewKafkaMockService() KafkaService

func NewKafkaService

func NewKafkaService(host string) KafkaService

type SandboxService

type SandboxService interface {
	CreateSandbox(lang, code string) (*entities.SandboxInstance, error)
	CompileSandbox(instance *entities.SandboxInstance) (result *entities.SandboxRunResult)
	Run(instance *entities.SandboxInstance, stdin string, memoryLimit, timeLimit uint) (result *entities.SandboxRunResult)
	CleanUp(instance *entities.SandboxInstance) error
	ValidateMemoryLimit(memoryLimit uint) (err error)
	ValidateTimeLimit(timeLimit uint) (err error)
}

func NewSandboxService

func NewSandboxService(memoryLimit uint, timeLimit uint) SandboxService

type ServiceKit

type ServiceKit struct {
	JWTService        JWTService
	UserService       UserService
	ChallengeService  ChallengeService
	SubmissionService SubmissionService
	SandboxService    SandboxService
	KafkaService      KafkaService
}

func CreateServiceKit

func CreateServiceKit(db *gorm.DB) *ServiceKit

func CreateTestServiceKit

func CreateTestServiceKit(db *gorm.DB) *ServiceKit

type SubmissionService

type SubmissionService interface {
	CreateSubmission(submission *entities.Submission) (*entities.Submission, error)
	DeleteSubmission(submission *entities.Submission) error
	GetSubmissionByID(submissionID uint) (*entities.Submission, error)
	GetSubmissionByUser(user *entities.User) ([]*entities.Submission, error)
	GetSubmissionByChallenge(challenge *entities.Challenge) ([]*entities.Submission, error)
	CreateSubmissionTestcase(submissionTestcase *entities.SubmissionTestcase) (*entities.SubmissionTestcase, error)
	GetSubmissionTestcaseBySubmission(submission *entities.Submission) ([]*entities.SubmissionTestcase, error)
	SubmitSubmission(submission *entities.Submission) (*entities.Submission, error)
	ProcessSubmission(submission *entities.Submission) (*entities.Submission, error)
	Pagination(options *entities.SubmissionPaginationOptions) (result *entities.PaginationResult[*entities.Submission], err error)
}

func NewSubmissionService

func NewSubmissionService(submissionRepository repositories.SubmissionRepository, challengeService ChallengeService, sandboxService SandboxService) SubmissionService

type UserService

type UserService interface {
	Register(email, password, displayname string) (user *entities.User, err error)
	Login(email, password string) (user *entities.User, err error)
	UpdateRole(user *entities.User, role string) (err error)
	FindUserByID(id uint) (user *entities.User, err error)
	Pagination(options *entities.PaginationOptions) (result *entities.PaginationResult[*entities.User], err error)
}

func NewUserService

func NewUserService(userRepo repositories.UserRepository) UserService