models/issues/comment_code.go - master - uzer_007/Rixea

models/issues/comment_code.go
125 строк4 KB
uzer_007
feat: первая версия Rixea
02 авг 2026, 22:16
02 авг 2026, 22:16d4f7504
// Copyright 2026 Uzer_007. All rights reserved.
// SPDX-License-Identifier: MIT

package issues

import (
	"context"
	"strconv"

	reindexerstore "gitverse.ru/uzer_007/Rixea/models/db/reindexer"
	"gitverse.ru/uzer_007/Rixea/models/renderhelper"
	user_model "gitverse.ru/uzer_007/Rixea/models/user"
	"gitverse.ru/uzer_007/Rixea/modules/markup/markdown"
	"gitverse.ru/uzer_007/Rixea/modules/optional"
)

// CodeComments represents comments on code by using this structure: FILENAME -> LINE (+ == proposed; - == previous) -> COMMENTS
type CodeComments map[string]map[int64][]*Comment

// FetchCodeComments will return a 2d-map: ["Path"]["Line"] = Comments at line
func FetchCodeComments(ctx context.Context, issue *Issue, currentUser *user_model.User, showOutdatedComments bool) (CodeComments, error) {
	return fetchCodeCommentsByReview(ctx, issue, currentUser, nil, showOutdatedComments)
}

func fetchCodeCommentsByReview(ctx context.Context, issue *Issue, currentUser *user_model.User, review *Review, showOutdatedComments bool) (CodeComments, error) {
	pathToLineToComment := make(CodeComments)
	if review == nil {
		review = &Review{ID: 0}
	}
	opts := FindCommentsOptions{
		Type:     CommentTypeCode,
		IssueID:  issue.ID,
		ReviewID: review.ID,
	}

	comments, err := findCodeComments(ctx, opts, issue, currentUser, review, showOutdatedComments)
	if err != nil {
		return nil, err
	}

	for _, comment := range comments {
		if pathToLineToComment[comment.TreePath] == nil {
			pathToLineToComment[comment.TreePath] = make(map[int64][]*Comment)
		}
		pathToLineToComment[comment.TreePath][comment.Line] = append(pathToLineToComment[comment.TreePath][comment.Line], comment)
	}
	return pathToLineToComment, nil
}

func findCodeComments(ctx context.Context, opts FindCommentsOptions, issue *Issue, currentUser *user_model.User, review *Review, showOutdatedComments bool) ([]*Comment, error) {
	if review == nil {
		review = &Review{ID: 0}
	}
	if !showOutdatedComments && review.ID == 0 {
		opts.Invalidated = optional.Some(false)
	}
	comments, err := selectReindexerComments(ctx, &opts)
	if err != nil {
		return nil, err
	}
	return hydrateReindexerCodeComments(ctx, comments, issue, currentUser, review)
}

func hydrateReindexerCodeComments(ctx context.Context, comments CommentList, issue *Issue, currentUser *user_model.User, selectedReview *Review) ([]*Comment, error) {
	if err := issue.LoadRepo(ctx); err != nil {
		return nil, err
	}
	if err := comments.LoadPosters(ctx); err != nil {
		return nil, err
	}
	if err := comments.LoadAttachments(ctx); err != nil {
		return nil, err
	}
	if err := comments.loadResolveDoers(ctx); err != nil {
		return nil, err
	}
	if err := comments.loadReactions(ctx, issue.Repo); err != nil {
		return nil, err
	}
	reviewIDs := make([]int64, 0, len(comments))
	for _, comment := range comments {
		if comment.ReviewID > 0 {
			reviewIDs = append(reviewIDs, comment.ReviewID)
		}
	}
	reviews := make(map[int64]*Review, len(reviewIDs))
	if len(reviewIDs) > 0 {
		loaded, err := selectReindexerReviews(ctx, reindexerstore.SelectOptions{SetFilters: []reindexerstore.EqualFilter{{Index: "id", Value: reviewIDs}}})
		if err != nil {
			return nil, err
		}
		for _, review := range loaded {
			reviews[review.ID] = review
		}
	}
	n := 0
	for _, comment := range comments {
		if review := reviews[comment.ReviewID]; review != nil {
			if selectedReview.ID == 0 && review.Type == ReviewTypePending && (currentUser == nil || currentUser.ID != review.ReviewerID) {
				continue
			}
			comment.Review = review
			comment.Issue = issue
		}
		comments[n] = comment
		n++
		rctx := renderhelper.NewRenderContextRepoComment(ctx, issue.Repo, renderhelper.RepoCommentOptions{FootnoteContextID: strconv.FormatInt(comment.ID, 10)})
		var err error
		if comment.RenderedContent, err = markdown.RenderString(rctx, comment.Content); err != nil {
			return nil, err
		}
	}
	return comments[:n], nil
}

// FetchCodeCommentsByLine fetches the code comments for a given treePath and line number
func FetchCodeCommentsByLine(ctx context.Context, issue *Issue, currentUser *user_model.User, treePath string, line int64, showOutdatedComments bool) (CommentList, error) {
	opts := FindCommentsOptions{
		Type:     CommentTypeCode,
		IssueID:  issue.ID,
		TreePath: treePath,
		Line:     line,
	}
	return findCodeComments(ctx, opts, issue, currentUser, nil, showOutdatedComments)
}