commit ca09895a7e83fe0c20a9501247810ee17d9a4a35 · bretton.dev/coves

+60 -14
internal/core/comments/comment_service.go
···

       1
       1
        
       package comments

     

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
       -
       	"Coves/internal/core/communities"

     

       5
       5
       -
       	"Coves/internal/core/posts"

     

       6
       6
       -
       	"Coves/internal/core/users"

     

       7
       4
        
       	"context"

     

       8
       5
        
       	"errors"

     

       9
       6
        
       	"fmt"

     

       10
       7
        
       	"log"

     

       11
       8
        
       	"strings"

     

       12
       9
        
       	"time"

     

       10
       10
       +
       

     

       11
       11
       +
       	"Coves/internal/core/communities"

     

       12
       12
       +
       	"Coves/internal/core/posts"

     

       13
       13
       +
       	"Coves/internal/core/users"

     

       14
       14
       +
       )

     

       15
       15
       +
       

     

       16
       16
       +
       const (

     

       17
       17
       +
       	// DefaultRepliesPerParent defines how many nested replies to load per parent comment

     

       18
       18
       +
       	// This balances UX (showing enough context) with performance (limiting query size)

     

       19
       19
       +
       	// Can be made configurable via constructor if needed in the future

     

       20
       20
       +
       	DefaultRepliesPerParent = 5

     

       13
       21
        
       )

     

       14
       22
        
       

     

       15
       23
        
       // Service defines the business logic interface for comment operations

     
···

       129
       137
        
       		return result

     

       130
       138
        
       	}

     

       131
       139
        
       

     

       140
       140
       +
       	// Batch fetch vote states for all comments at this level (Phase 2B)

     

       141
       141
       +
       	var voteStates map[string]interface{}

     

       142
       142
       +
       	if viewerDID != nil {

     

       143
       143
       +
       		commentURIs := make([]string, 0, len(comments))

     

       144
       144
       +
       		for _, comment := range comments {

     

       145
       145
       +
       			if comment.DeletedAt == nil {

     

       146
       146
       +
       				commentURIs = append(commentURIs, comment.URI)

     

       147
       147
       +
       			}

     

       148
       148
       +
       		}

     

       149
       149
       +
       

     

       150
       150
       +
       		if len(commentURIs) > 0 {

     

       151
       151
       +
       			var err error

     

       152
       152
       +
       			voteStates, err = s.commentRepo.GetVoteStateForComments(ctx, *viewerDID, commentURIs)

     

       153
       153
       +
       			if err != nil {

     

       154
       154
       +
       				// Log error but don't fail the request - vote state is optional

     

       155
       155
       +
       				log.Printf("Warning: Failed to fetch vote states for comments: %v", err)

     

       156
       156
       +
       			}

     

       157
       157
       +
       		}

     

       158
       158
       +
       	}

     

       159
       159
       +
       

     

       132
       160
        
       	// Build thread views for current level

     

       133
       161
        
       	threadViews := make([]*ThreadViewComment, 0, len(comments))

     

       134
       162
        
       	commentsByURI := make(map[string]*ThreadViewComment)

     
···

       141
       169
        
       		}

     

       142
       170
        
       

     

       143
       171
        
       		// Build the comment view with author info and stats

     

       144
       144
       -
       		commentView := s.buildCommentView(comment, viewerDID)

     

       172
       172
       +
       		commentView := s.buildCommentView(comment, viewerDID, voteStates)

     

       145
       173
        
       

     

       146
       174
        
       		threadView := &ThreadViewComment{

     

       147
       175
        
       			Comment: commentView,

     
···

       160
       188
        
       

     

       161
       189
        
       	// Batch load all replies for this level in a single query

     

       162
       190
        
       	if len(parentsWithReplies) > 0 {

     

       163
       163
       -
       		const repliesPerParent = 5 // Load top 5 replies per comment

     

       164
       164
       -
       

     

       165
       191
        
       		repliesByParent, err := s.commentRepo.ListByParentsBatch(

     

       166
       192
        
       			ctx,

     

       167
       193
        
       			parentsWithReplies,

     

       168
       194
        
       			sort,

     

       169
       169
       -
       			repliesPerParent,

     

       195
       195
       +
       			DefaultRepliesPerParent,

     

       170
       196
        
       		)

     

       171
       197
        
       

     

       172
       198
        
       		// Process replies if batch query succeeded

     
···

       202
       228
        
       

     

       203
       229
        
       // buildCommentView converts a Comment entity to a CommentView with full metadata

     

       204
       230
        
       // Constructs author view, stats, and references to parent post/comment

     

       205
       205
       -
       func (s *commentService) buildCommentView(comment *Comment, viewerDID *string) *CommentView {

     

       231
       231
       +
       // voteStates map contains viewer's vote state for comments (from GetVoteStateForComments)

     

       232
       232
       +
       func (s *commentService) buildCommentView(

     

       233
       233
       +
       	comment *Comment,

     

       234
       234
       +
       	viewerDID *string,

     

       235
       235
       +
       	voteStates map[string]interface{},

     

       236
       236
       +
       ) *CommentView {

     

       206
       237
        
       	// Build author view from comment data

     

       207
       238
        
       	// CommenterHandle is hydrated by ListByParentWithHotRank via JOIN

     

       208
       239
        
       	authorView := &posts.AuthorView{

     

       209
       240
        
       		DID:    comment.CommenterDID,

     

       210
       241
        
       		Handle: comment.CommenterHandle,

     

       211
       211
       -
       		// TODO: Add DisplayName, Avatar, Reputation when user service is integrated (Phase 2B)

     

       242
       242
       +
       		// TODO: Add DisplayName, Avatar, Reputation when user service is integrated (Phase 2C)

     

       212
       243
        
       	}

     

       213
       244
        
       

     

       214
       245
        
       	// Build aggregated statistics

     
···

       235
       266
        
       		}

     

       236
       267
        
       	}

     

       237
       268
        
       

     

       238
       238
       -
       	// Build viewer state (stubbed for now - Phase 2B)

     

       239
       239
       -
       	// Future: Fetch viewer's vote state from GetVoteStateForComments

     

       269
       269
       +
       	// Build viewer state - populate from vote states map (Phase 2B)

     

       240
       270
        
       	var viewer *CommentViewerState

     

       241
       271
        
       	if viewerDID != nil {

     

       242
       242
       -
       		// TODO: Query voter state

     

       243
       243
       -
       		// voteState, err := s.commentRepo.GetVoteStateForComments(ctx, *viewerDID, []string{comment.URI})

     

       244
       244
       -
       		// For now, return empty viewer state to indicate authenticated request

     

       245
       272
        
       		viewer = &CommentViewerState{

     

       246
       273
        
       			Vote:    nil,

     

       247
       274
        
       			VoteURI: nil,

     

       275
       275
       +
       		}

     

       276
       276
       +
       

     

       277
       277
       +
       		// Check if viewer has voted on this comment

     

       278
       278
       +
       		if voteStates != nil {

     

       279
       279
       +
       			if voteData, ok := voteStates[comment.URI]; ok {

     

       280
       280
       +
       				voteMap, isMap := voteData.(map[string]interface{})

     

       281
       281
       +
       				if isMap {

     

       282
       282
       +
       					// Extract vote direction and URI

     

       283
       283
       +
       					// Create copies before taking addresses to avoid pointer to loop variable issues

     

       284
       284
       +
       					if direction, hasDirection := voteMap["direction"].(string); hasDirection {

     

       285
       285
       +
       						directionCopy := direction

     

       286
       286
       +
       						viewer.Vote = &directionCopy

     

       287
       287
       +
       					}

     

       288
       288
       +
       					if voteURI, hasVoteURI := voteMap["uri"].(string); hasVoteURI {

     

       289
       289
       +
       						voteURICopy := voteURI

     

       290
       290
       +
       						viewer.VoteURI = &voteURICopy

     

       291
       291
       +
       					}

     

       292
       292
       +
       				}

     

       293
       293
       +
       			}

     

       248
       294
        
       		}

     

       249
       295
        
       	}

     

       250
       296