337 lines
8.7 KiB
Go
337 lines
8.7 KiB
Go
package usecase
|
|
|
|
import (
|
|
"archive/zip"
|
|
"bytes"
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"strings"
|
|
|
|
"git.sch9.ru/new_gate/ms-tester/internal/models"
|
|
"git.sch9.ru/new_gate/ms-tester/internal/tester"
|
|
"git.sch9.ru/new_gate/ms-tester/pkg"
|
|
"github.com/microcosm-cc/bluemonday"
|
|
)
|
|
|
|
type ProblemUseCase struct {
|
|
problemRepo tester.ProblemPostgresRepository
|
|
pandocClient pkg.PandocClient
|
|
}
|
|
|
|
func NewProblemUseCase(
|
|
problemRepo tester.ProblemPostgresRepository,
|
|
pandocClient pkg.PandocClient,
|
|
) *ProblemUseCase {
|
|
return &ProblemUseCase{
|
|
problemRepo: problemRepo,
|
|
pandocClient: pandocClient,
|
|
}
|
|
}
|
|
|
|
func (u *ProblemUseCase) CreateProblem(ctx context.Context, title string) (int32, error) {
|
|
return u.problemRepo.CreateProblem(ctx, u.problemRepo.DB(), title)
|
|
}
|
|
|
|
func (u *ProblemUseCase) ReadProblemById(ctx context.Context, id int32) (*models.Problem, error) {
|
|
return u.problemRepo.ReadProblemById(ctx, u.problemRepo.DB(), id)
|
|
}
|
|
|
|
func (u *ProblemUseCase) DeleteProblem(ctx context.Context, id int32) error {
|
|
return u.problemRepo.DeleteProblem(ctx, u.problemRepo.DB(), id)
|
|
}
|
|
|
|
func (u *ProblemUseCase) ListProblems(ctx context.Context, filter models.ProblemsFilter) (*models.ProblemsList, error) {
|
|
return u.problemRepo.ListProblems(ctx, u.problemRepo.DB(), filter)
|
|
}
|
|
|
|
func (u *ProblemUseCase) UpdateProblem(ctx context.Context, id int32, problemUpdate models.ProblemUpdate) error {
|
|
if isEmpty(problemUpdate) {
|
|
return pkg.Wrap(pkg.ErrBadInput, nil, "UpdateProblem", "empty problem update")
|
|
}
|
|
|
|
tx, err := u.problemRepo.BeginTx(ctx)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
problem, err := u.problemRepo.ReadProblemById(ctx, tx, id)
|
|
if err != nil {
|
|
return errors.Join(err, tx.Rollback())
|
|
}
|
|
|
|
statement := models.ProblemStatement{
|
|
Legend: problem.Legend,
|
|
InputFormat: problem.InputFormat,
|
|
OutputFormat: problem.OutputFormat,
|
|
Notes: problem.Notes,
|
|
Scoring: problem.Scoring,
|
|
}
|
|
|
|
if problemUpdate.Legend != nil {
|
|
statement.Legend = *problemUpdate.Legend
|
|
}
|
|
if problemUpdate.InputFormat != nil {
|
|
statement.InputFormat = *problemUpdate.InputFormat
|
|
}
|
|
if problemUpdate.OutputFormat != nil {
|
|
statement.OutputFormat = *problemUpdate.OutputFormat
|
|
}
|
|
if problemUpdate.Notes != nil {
|
|
statement.Notes = *problemUpdate.Notes
|
|
}
|
|
if problemUpdate.Scoring != nil {
|
|
statement.Scoring = *problemUpdate.Scoring
|
|
}
|
|
|
|
builtStatement, err := build(ctx, u.pandocClient, trimSpaces(statement))
|
|
if err != nil {
|
|
return errors.Join(err, tx.Rollback())
|
|
}
|
|
|
|
if builtStatement.LegendHtml != problem.LegendHtml {
|
|
problemUpdate.LegendHtml = &builtStatement.LegendHtml
|
|
}
|
|
if builtStatement.InputFormatHtml != problem.InputFormatHtml {
|
|
problemUpdate.InputFormatHtml = &builtStatement.InputFormatHtml
|
|
}
|
|
if builtStatement.OutputFormatHtml != problem.OutputFormatHtml {
|
|
problemUpdate.OutputFormatHtml = &builtStatement.OutputFormatHtml
|
|
}
|
|
if builtStatement.NotesHtml != problem.NotesHtml {
|
|
problemUpdate.NotesHtml = &builtStatement.NotesHtml
|
|
}
|
|
if builtStatement.ScoringHtml != problem.ScoringHtml {
|
|
problemUpdate.ScoringHtml = &builtStatement.ScoringHtml
|
|
}
|
|
|
|
err = u.problemRepo.UpdateProblem(ctx, tx, id, problemUpdate)
|
|
if err != nil {
|
|
return errors.Join(err, tx.Rollback())
|
|
}
|
|
|
|
err = tx.Commit()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
type ProblemProperties struct {
|
|
Title string `json:"name"`
|
|
TimeLimit int32 `json:"timeLimit"`
|
|
MemoryLimit int32 `json:"memoryLimit"`
|
|
}
|
|
|
|
func (u *ProblemUseCase) UploadProblem(ctx context.Context, id int32, data []byte) error {
|
|
|
|
locale := "russian"
|
|
defaultLocale := "english"
|
|
var localeProblem, defaultProblem string
|
|
var localeProperties, defaultProperties ProblemProperties
|
|
|
|
r := bytes.NewReader(data)
|
|
rc, err := zip.NewReader(r, int64(r.Len()))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
testsZipBuf := new(bytes.Buffer)
|
|
w := zip.NewWriter(testsZipBuf)
|
|
|
|
for _, f := range rc.File {
|
|
if f.FileInfo().IsDir() {
|
|
continue
|
|
}
|
|
if f.Name == fmt.Sprintf("statements/%s/problem.tex", locale) {
|
|
localeProblem, err = readProblem(f)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if f.Name == fmt.Sprintf("statements/%s/problem.tex", defaultLocale) {
|
|
defaultProblem, err = readProblem(f)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if f.Name == fmt.Sprintf("statements/%s/problem-properties.json", locale) {
|
|
localeProperties, err = readProperties(f)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if f.Name == fmt.Sprintf("statements/%s/problem-properties.json", defaultLocale) {
|
|
defaultProperties, err = readProperties(f)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if strings.HasPrefix(f.Name, "tests/") {
|
|
if err := w.Copy(f); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
}
|
|
|
|
if err := w.Close(); err != nil {
|
|
return err
|
|
}
|
|
// testsZipBuf contains test files; this is for s3
|
|
|
|
localeProperties.MemoryLimit /= 1024 * 1024
|
|
defaultProperties.MemoryLimit /= 1024 * 1024
|
|
|
|
var problemUpdate models.ProblemUpdate
|
|
if localeProblem != "" {
|
|
problemUpdate.Legend = &localeProblem
|
|
problemUpdate.Title = &localeProperties.Title
|
|
problemUpdate.TimeLimit = &localeProperties.TimeLimit
|
|
problemUpdate.MemoryLimit = &localeProperties.MemoryLimit
|
|
} else {
|
|
problemUpdate.Legend = &defaultProblem
|
|
problemUpdate.Title = &defaultProperties.Title
|
|
problemUpdate.TimeLimit = &defaultProperties.TimeLimit
|
|
problemUpdate.MemoryLimit = &defaultProperties.MemoryLimit
|
|
}
|
|
if err := u.UpdateProblem(ctx, id, problemUpdate); err != nil {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func readProblem(f *zip.File) (string, error) {
|
|
rc, err := f.Open()
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
defer rc.Close()
|
|
problemData, err := io.ReadAll(rc)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
return string(problemData), nil
|
|
}
|
|
|
|
func readProperties(f *zip.File) (ProblemProperties, error) {
|
|
rc, err := f.Open()
|
|
if err != nil {
|
|
return ProblemProperties{}, err
|
|
}
|
|
defer rc.Close()
|
|
var properties ProblemProperties
|
|
if err := json.NewDecoder(rc).Decode(&properties); err != nil {
|
|
return ProblemProperties{}, err
|
|
}
|
|
return properties, nil
|
|
}
|
|
|
|
func isEmpty(p models.ProblemUpdate) bool {
|
|
return p.Title == nil &&
|
|
p.Legend == nil &&
|
|
p.InputFormat == nil &&
|
|
p.OutputFormat == nil &&
|
|
p.Notes == nil &&
|
|
p.Scoring == nil &&
|
|
p.MemoryLimit == nil &&
|
|
p.TimeLimit == nil
|
|
}
|
|
|
|
func wrap(s string) string {
|
|
return fmt.Sprintf("\\begin{document}\n%s\n\\end{document}\n", s)
|
|
}
|
|
|
|
func trimSpaces(statement models.ProblemStatement) models.ProblemStatement {
|
|
return models.ProblemStatement{
|
|
Legend: strings.TrimSpace(statement.Legend),
|
|
InputFormat: strings.TrimSpace(statement.InputFormat),
|
|
OutputFormat: strings.TrimSpace(statement.OutputFormat),
|
|
Notes: strings.TrimSpace(statement.Notes),
|
|
Scoring: strings.TrimSpace(statement.Scoring),
|
|
}
|
|
}
|
|
|
|
func sanitize(statement models.Html5ProblemStatement) models.Html5ProblemStatement {
|
|
p := bluemonday.UGCPolicy()
|
|
|
|
p.AllowAttrs("class").Globally()
|
|
p.AllowAttrs("style").Globally()
|
|
p.AllowStyles("text-align").MatchingEnum("center", "left", "right").Globally()
|
|
p.AllowStyles("display").MatchingEnum("block", "inline", "inline-block").Globally()
|
|
|
|
p.AllowStandardURLs()
|
|
p.AllowAttrs("cite").OnElements("blockquote", "q")
|
|
p.AllowAttrs("href").OnElements("a", "area")
|
|
p.AllowAttrs("src").OnElements("img")
|
|
|
|
if statement.LegendHtml != "" {
|
|
statement.LegendHtml = p.Sanitize(statement.LegendHtml)
|
|
}
|
|
if statement.InputFormatHtml != "" {
|
|
statement.InputFormatHtml = p.Sanitize(statement.InputFormatHtml)
|
|
}
|
|
if statement.OutputFormatHtml != "" {
|
|
statement.OutputFormatHtml = p.Sanitize(statement.OutputFormatHtml)
|
|
}
|
|
if statement.NotesHtml != "" {
|
|
statement.NotesHtml = p.Sanitize(statement.NotesHtml)
|
|
}
|
|
if statement.ScoringHtml != "" {
|
|
statement.ScoringHtml = p.Sanitize(statement.ScoringHtml)
|
|
}
|
|
|
|
return statement
|
|
}
|
|
|
|
func build(ctx context.Context, pandocClient pkg.PandocClient, p models.ProblemStatement) (models.Html5ProblemStatement, error) {
|
|
p = trimSpaces(p)
|
|
|
|
latex := models.ProblemStatement{}
|
|
|
|
if p.Legend != "" {
|
|
latex.Legend = wrap(p.Legend)
|
|
}
|
|
if p.InputFormat != "" {
|
|
latex.InputFormat = wrap(p.InputFormat)
|
|
}
|
|
if p.OutputFormat != "" {
|
|
latex.OutputFormat = wrap(p.OutputFormat)
|
|
}
|
|
if p.Notes != "" {
|
|
latex.Notes = wrap(p.Notes)
|
|
}
|
|
if p.Scoring != "" {
|
|
latex.Scoring = wrap(p.Scoring)
|
|
}
|
|
|
|
req := []string{
|
|
latex.Legend,
|
|
latex.InputFormat,
|
|
latex.OutputFormat,
|
|
latex.Notes,
|
|
latex.Scoring,
|
|
}
|
|
|
|
res, err := pandocClient.BatchConvertLatexToHtml5(ctx, req)
|
|
if err != nil {
|
|
return models.Html5ProblemStatement{}, err
|
|
}
|
|
|
|
if len(res) != len(req) {
|
|
return models.Html5ProblemStatement{}, fmt.Errorf("wrong number of fieilds returned: %d", len(res))
|
|
}
|
|
|
|
sanitizedStatement := sanitize(models.Html5ProblemStatement{
|
|
LegendHtml: res[0],
|
|
InputFormatHtml: res[1],
|
|
OutputFormatHtml: res[2],
|
|
NotesHtml: res[3],
|
|
ScoringHtml: res[4],
|
|
})
|
|
|
|
return sanitizedStatement, nil
|
|
}
|