probo/store/file/quiz.go

package file

import (
	"bufio"
	"bytes"
	"errors"
	"io"
	"os"
	"path/filepath"
	"strings"
	"time"

	"git.andreafazzi.eu/andrea/probo/models"
	"git.andreafazzi.eu/andrea/probo/store"
	"gopkg.in/yaml.v2"
)

func NewQuizFileStore() (*FileStore[*models.Quiz, *store.QuizStore], error) {
	return NewFileStore[*models.Quiz, *store.QuizStore](
		store.NewQuizStore(),
		filepath.Join(BaseDir, QuizzesDir),
		"quiz",
		".md",
		func(s *store.QuizStore, filepath string, content []byte) (*models.Quiz, error) {
			quiz, meta, err := models.MarkdownToQuiz(string(content))
			if err != nil {
				return nil, err
			}

			var errQuizAlreadyPresent *store.ErrQuizAlreadyPresent

			q, err := s.Create(quiz)
			if err != nil && !errors.As(err, &errQuizAlreadyPresent) {
				return nil, err
			}

			if meta == nil {
				writeQuizHeader(filepath, &models.Meta{
					ID:        q.ID,
					CreatedAt: time.Now(),
				})
			}

			return q, nil
		},
		func(s *store.QuizStore, filePath string, quiz *models.Quiz) error {
			markdown, err := models.QuizToMarkdown(quiz)
			if err != nil {
				return err
			}

			file, err := os.Create(filePath)
			if err != nil {
				return err
			}

			defer file.Close()

			markdownWithMetaHeader, err := addMetaHeaderToMarkdown(markdown, &quiz.Meta)
			if err != nil {
				return err
			}

			_, err = file.Write([]byte(markdownWithMetaHeader))
			if err != nil {
				return err
			}

			return nil
		},
	)
}

func writeQuizHeader(path string, meta *models.Meta) (*models.Meta, error) {
	readMeta, err := readQuizHeader(path)
	if err != nil {
		return nil, err
	}
	if readMeta == nil {
		file, err := os.Open(path)
		if err != nil {
			return nil, err
		}
		defer file.Close()

		var buffer bytes.Buffer

		header, err := yaml.Marshal(meta)
		if err != nil {
			return nil, err
		}

		_, err = buffer.WriteString("---\n" + string(header) + "---\n")
		if err != nil {
			return nil, err
		}

		_, err = io.Copy(&buffer, file)
		if err != nil {
			return nil, err
		}

		file, err = os.Create(path)
		if err != nil {
			return nil, err
		}
		defer file.Close()

		_, err = io.Copy(file, &buffer)
		if err != nil {
			return nil, err
		}
	}

	return meta, nil
}

func readQuizHeader(path string) (*models.Meta, error) {
	data, err := os.ReadFile(path)
	if err != nil {
		return nil, err
	}
	meta, _, err := models.ParseMetaHeaderFromMarkdown(string(data))
	if err != nil {
		return nil, err
	}
	return meta, nil
}

func addMetaHeaderToMarkdown(content string, meta *models.Meta) (string, error) {
	var buffer bytes.Buffer

	header, err := yaml.Marshal(meta)
	if err != nil {
		return "", err
	}
	_, err = buffer.WriteString("---\n" + string(header) + "---\n")
	if err != nil {
		return "", err
	}

	_, err = buffer.WriteString(content)
	if err != nil {
		return "", err
	}

	return buffer.String(), nil
}

func removeQuizHeader(path string) (*models.Meta, error) {
	file, err := os.Open(path)
	if err != nil {
		return nil, err
	}
	defer file.Close()

	var buffer bytes.Buffer

	reader := bufio.NewReader(file)

	var meta models.Meta
	var line string
	var sb strings.Builder
	for {
		line, err = reader.ReadString('\n')
		if err != nil {
			if err == io.EOF {
				break
			}
			return nil, err
		}

		if strings.TrimSpace(line) == "---" {
			break
		}
	}

	for {
		line, err = reader.ReadString('\n')
		if err != nil {
			if err == io.EOF {
				break
			}
			return nil, err
		}

		if strings.TrimSpace(line) == "---" {
			break
		}

		sb.WriteString(line)
	}

	err = yaml.Unmarshal([]byte(sb.String()), &meta)
	if err != nil {
		return nil, err
	}

	_, err = io.Copy(&buffer, reader)
	if err != nil {
		return nil, err
	}

	file, err = os.Create(path)
	if err != nil {
		return nil, err
	}
	defer file.Close()

	_, err = io.Copy(file, &buffer)
	if err != nil {
		return nil, err
	}

	return &meta, nil
}