api/database/postgres/chapters.go

package postgres

import (
	"context"
	"database/sql"
	"git.aiterp.net/rpdata/api/database/postgres/psqlcore"
	"git.aiterp.net/rpdata/api/internal/generate"
	"git.aiterp.net/rpdata/api/models"
)

type chapterRepository struct {
	insertWithIDs bool
	db            *sql.DB
}

func (r *chapterRepository) Find(ctx context.Context, id string) (*models.Chapter, error) {
	chapter, err := psqlcore.New(r.db).SelectChapter(ctx, id)
	if err != nil {
		return nil, err
	}

	return r.chapter(chapter), nil
}

func (r *chapterRepository) List(ctx context.Context, filter models.ChapterFilter) ([]*models.Chapter, error) {
	params := psqlcore.SelectChaptersParams{
		StoryID:   "",
		LimitSize: 0,
	}
	if filter.StoryID != nil {
		params.StoryID = *filter.StoryID
	}
	if filter.Limit > 0 {
		params.LimitSize = int32(filter.Limit)
	}

	chapters, err := psqlcore.New(r.db).SelectChapters(ctx, params)
	if err != nil {
		return nil, err
	}

	return r.chapters(chapters), nil
}

func (r *chapterRepository) Insert(ctx context.Context, chapter models.Chapter) (*models.Chapter, error) {
	if !r.insertWithIDs || len(chapter.ID) < 8 {
		chapter.ID = generate.ChapterID()
	}

	err := psqlcore.New(r.db).InsertChapter(ctx, psqlcore.InsertChapterParams{
		ID:             chapter.ID,
		StoryID:        chapter.StoryID,
		Title:          chapter.Title,
		Author:         chapter.Author,
		Source:         chapter.Source,
		CreatedDate:    chapter.CreatedDate.UTC(),
		FictionalDate:  chapter.FictionalDate.UTC(),
		EditedDate:     chapter.EditedDate.UTC(),
		CommentMode:    string(chapter.CommentMode),
		CommentsLocked: chapter.CommentsLocked,
	})
	if err != nil {
		return nil, err
	}

	return &chapter, nil
}

func (r *chapterRepository) Update(ctx context.Context, chapter models.Chapter, update models.ChapterUpdate) (*models.Chapter, error) {
	chapter.ApplyUpdate(update)

	err := psqlcore.New(r.db).UpdateChapter(ctx, psqlcore.UpdateChapterParams{
		Title:          chapter.Title,
		Source:         chapter.Source,
		FictionalDate:  chapter.FictionalDate.UTC(),
		CommentMode:    string(chapter.CommentMode),
		CommentsLocked: chapter.CommentsLocked,
		ID:             chapter.ID,
	})
	if err != nil {
		return nil, err
	}

	return &chapter, nil
}

func (r *chapterRepository) Move(ctx context.Context, chapter models.Chapter, _, to models.Story) (*models.Chapter, error) {
	err := psqlcore.New(r.db).UpdateChapterStoryID(ctx, psqlcore.UpdateChapterStoryIDParams{
		StoryID: to.ID,
		ID:      chapter.ID,
	})
	if err != nil {
		return nil, err
	}

	chapter.StoryID = to.ID

	return &chapter, nil
}

func (r *chapterRepository) Delete(ctx context.Context, chapter models.Chapter) error {
	tx, err := r.db.BeginTx(ctx, nil)
	if err != nil {
		return err
	}
	defer func() { _ = tx.Rollback() }()
	q := psqlcore.New(tx)

	err = q.DeleteCommentsByChapterID(ctx, chapter.ID)
	if err != nil {
		return err
	}

	err = q.DeleteChapter(ctx, chapter.ID)
	if err != nil {
		return err
	}

	return tx.Commit()
}

func (r *chapterRepository) chapter(chapter psqlcore.StoryChapter) *models.Chapter {
	return &models.Chapter{
		ID:             chapter.ID,
		StoryID:        chapter.StoryID,
		Title:          chapter.Title,
		Author:         chapter.Author,
		Source:         chapter.Source,
		CreatedDate:    chapter.CreatedDate,
		FictionalDate:  chapter.FictionalDate,
		EditedDate:     chapter.EditedDate,
		CommentMode:    models.ChapterCommentMode(chapter.CommentMode),
		CommentsLocked: chapter.CommentsLocked,
	}
}

func (r *chapterRepository) chapters(chapters []psqlcore.StoryChapter) []*models.Chapter {
	results := make([]*models.Chapter, 0, len(chapters))
	for _, chapter := range chapters {
		results = append(results, r.chapter(chapter))
	}

	return results
}