mirror of
https://github.com/usememos/memos.git
synced 2026-11-19 10:29:11 +01:00
266 lines
8.9 KiB
Go
266 lines
8.9 KiB
Go
package api
|
|
|
|
import (
|
|
"context"
|
|
stderrors "errors"
|
|
"log/slog"
|
|
|
|
"github.com/pkg/errors"
|
|
"google.golang.org/grpc/codes"
|
|
"google.golang.org/grpc/status"
|
|
|
|
"github.com/usememos/memos/internal/ratelimit"
|
|
apipb "github.com/usememos/memos/proto/gen/api"
|
|
storepb "github.com/usememos/memos/proto/gen/store"
|
|
"github.com/usememos/memos/store"
|
|
)
|
|
|
|
// CreateMemoComment creates a comment on an existing memo.
|
|
func (s *APIService) CreateMemoComment(ctx context.Context, request *apipb.CreateMemoCommentRequest) (*apipb.Memo, error) {
|
|
memoUID, err := ExtractMemoUIDFromName(request.Parent)
|
|
if err != nil {
|
|
return nil, status.Errorf(codes.InvalidArgument, "invalid memo name: %v", err)
|
|
}
|
|
relatedMemo, err := s.Store.GetMemo(ctx, &store.FindMemo{UID: &memoUID})
|
|
if err != nil {
|
|
return nil, status.Errorf(codes.Internal, "failed to get memo")
|
|
}
|
|
if relatedMemo == nil {
|
|
return nil, status.Errorf(codes.NotFound, "memo not found")
|
|
}
|
|
|
|
// Check memo visibility before allowing comment.
|
|
user, err := s.fetchCurrentUser(ctx)
|
|
if err != nil {
|
|
return nil, status.Errorf(codes.Internal, "failed to get user")
|
|
}
|
|
if user == nil {
|
|
return nil, status.Errorf(codes.Unauthenticated, "user not authenticated")
|
|
}
|
|
if err := s.throttleAndCharge(ratelimit.ScopeWriteUser, userKey(user.ID), 1); err != nil {
|
|
return nil, err
|
|
}
|
|
if err := s.checkMemoReadAccess(ctx, relatedMemo); err != nil {
|
|
return nil, err
|
|
}
|
|
if relatedMemo.RowStatus != store.Normal {
|
|
return nil, status.Errorf(codes.FailedPrecondition, "cannot comment on an archived memo")
|
|
}
|
|
if request.Comment == nil {
|
|
return nil, status.Errorf(codes.InvalidArgument, "comment is required")
|
|
}
|
|
|
|
memoUID, err = ValidateAndGenerateUID(request.CommentId)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if memoUID == relatedMemo.UID {
|
|
return nil, status.Error(codes.InvalidArgument, "a memo cannot comment on itself")
|
|
}
|
|
prepared, err := s.prepareMemoCreate(ctx, user, request.Comment, memoUID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
// A comment is a memo row, so it counts against the memo limit too.
|
|
if err := s.checkMemoQuota(ctx, user.ID); err != nil {
|
|
return nil, err
|
|
}
|
|
if err := s.createMemoWithMutation(ctx, user, prepared.memo, &relatedMemo.ID, prepared.attachments, prepared.requiredAttachmentIDs, prepared.referenceRelations); err != nil {
|
|
return nil, mapMemoCreateError(err, memoUID, "failed to create memo comment")
|
|
}
|
|
memo := prepared.memo
|
|
attachments, err := s.Store.ListAttachments(ctx, &store.FindAttachment{MemoID: &memo.ID})
|
|
if err != nil {
|
|
return nil, status.Errorf(codes.Internal, "failed to load memo comment attachments")
|
|
}
|
|
relations, err := s.loadMemoRelations(ctx, memo)
|
|
if err != nil {
|
|
return nil, status.Errorf(codes.Internal, "failed to load memo relations")
|
|
}
|
|
memoComment, err := s.convertMemoFromStore(ctx, memo, nil, attachments, relations)
|
|
if err != nil {
|
|
return nil, status.Errorf(codes.Internal, "failed to convert memo comment")
|
|
}
|
|
|
|
s.createMemoCommentNotification(ctx, user.ID, memo, relatedMemo)
|
|
|
|
if err := s.DispatchMemoCommentCreatedWebhook(ctx, memo, relatedMemo, relatedMemo.CreatorID); err != nil {
|
|
slog.Warn("Failed to dispatch memo comment created webhook", slog.Any("err", err))
|
|
}
|
|
|
|
s.dispatchMemoMentionNotificationsBestEffort(ctx, memo, relatedMemo, "")
|
|
|
|
s.SSEHub.publishMemoChanged()
|
|
|
|
return memoComment, nil
|
|
}
|
|
|
|
// createMemoCommentNotification records the comment in the related memo
|
|
// creator's inbox. The comment itself is already persisted, so a failure here
|
|
// only loses the notification and is logged instead of failing the request;
|
|
// failing it would make clients retry and create a duplicate comment.
|
|
func (s *APIService) createMemoCommentNotification(ctx context.Context, creatorID int32, memo *store.Memo, relatedMemo *store.Memo) {
|
|
if creatorID == relatedMemo.CreatorID {
|
|
return
|
|
}
|
|
relatedCreator, err := s.Store.GetUser(ctx, &store.FindUser{ID: &relatedMemo.CreatorID})
|
|
if err != nil {
|
|
slog.Warn("Failed to get related memo creator for comment notification",
|
|
slog.Any("err", err),
|
|
slog.Int64("memo_id", int64(memo.ID)))
|
|
return
|
|
}
|
|
if !s.canUserAccessMentionMemos(ctx, relatedCreator, memo, relatedMemo) {
|
|
return
|
|
}
|
|
if _, err := s.createInboxWithEmailNotification(ctx, &store.Inbox{
|
|
SenderID: creatorID,
|
|
ReceiverID: relatedMemo.CreatorID,
|
|
Status: store.UNREAD,
|
|
Message: &storepb.InboxMessage{
|
|
Type: storepb.InboxMessage_MEMO_COMMENT,
|
|
Payload: &storepb.InboxMessage_MemoComment{
|
|
MemoComment: &storepb.InboxMessage_MemoCommentPayload{
|
|
MemoId: memo.ID,
|
|
RelatedMemoId: relatedMemo.ID,
|
|
},
|
|
},
|
|
},
|
|
}); err != nil {
|
|
slog.Warn("Failed to create memo comment notification",
|
|
slog.Any("err", err),
|
|
slog.Int64("memo_id", int64(memo.ID)),
|
|
slog.Int64("receiver_id", int64(relatedMemo.CreatorID)))
|
|
}
|
|
}
|
|
|
|
func (s *APIService) ListMemoComments(ctx context.Context, request *apipb.ListMemoCommentsRequest) (*apipb.ListMemoCommentsResponse, error) {
|
|
memoUID, err := ExtractMemoUIDFromName(request.Parent)
|
|
if err != nil {
|
|
return nil, status.Errorf(codes.InvalidArgument, "invalid memo name: %v", err)
|
|
}
|
|
memo, err := s.Store.GetMemo(ctx, &store.FindMemo{UID: &memoUID})
|
|
if err != nil {
|
|
return nil, status.Errorf(codes.Internal, "failed to get memo")
|
|
}
|
|
if memo == nil {
|
|
return nil, status.Errorf(codes.NotFound, "memo not found")
|
|
}
|
|
if err := s.checkMemoReadAccess(ctx, memo); err != nil {
|
|
return nil, err
|
|
}
|
|
accessScope, _, err := s.resolveMemoAccessScope(ctx)
|
|
if err != nil {
|
|
return nil, status.Errorf(codes.Internal, "%v", err)
|
|
}
|
|
|
|
var limit, offset int
|
|
if request.PageToken != "" {
|
|
var pageToken apipb.PageToken
|
|
if err := unmarshalPageToken(request.PageToken, &pageToken); err != nil {
|
|
return nil, status.Errorf(codes.InvalidArgument, "invalid page token: %v", err)
|
|
}
|
|
limit = normalizePageSize(pageToken.Limit)
|
|
offset = max(int(pageToken.Offset), 0)
|
|
} else {
|
|
limit = normalizePageSize(request.PageSize)
|
|
}
|
|
limitPlusOne := limit + 1
|
|
normal := store.Normal
|
|
memos, err := s.Store.ListMemos(ctx, &store.FindMemo{
|
|
CommentContextMemoID: &memo.ID,
|
|
RowStatus: &normal,
|
|
Access: accessScope,
|
|
Limit: &limitPlusOne,
|
|
Offset: &offset,
|
|
})
|
|
if err != nil {
|
|
return nil, status.Errorf(codes.Internal, "failed to list memo comments")
|
|
}
|
|
|
|
nextPageToken := ""
|
|
if len(memos) == limitPlusOne {
|
|
memos = memos[:limit]
|
|
nextPageToken, err = getPageToken(limit, offset+limit)
|
|
if err != nil {
|
|
return nil, status.Errorf(codes.Internal, "failed to get next page token, error: %v", err)
|
|
}
|
|
}
|
|
|
|
if len(memos) == 0 {
|
|
response := &apipb.ListMemoCommentsResponse{
|
|
Comments: []*apipb.Memo{},
|
|
NextPageToken: nextPageToken,
|
|
}
|
|
return response, nil
|
|
}
|
|
|
|
memoIDs := make([]int32, 0, len(memos))
|
|
|
|
for _, memo := range memos {
|
|
memoIDs = append(memoIDs, memo.ID)
|
|
}
|
|
reactions, err := s.Store.ListReactions(ctx, &store.FindReaction{MemoIDList: memoIDs})
|
|
if err != nil {
|
|
return nil, status.Errorf(codes.Internal, "failed to list reactions")
|
|
}
|
|
|
|
memoReactionsMap := make(map[int32][]*store.Reaction)
|
|
for _, reaction := range reactions {
|
|
memoReactionsMap[reaction.MemoID] = append(memoReactionsMap[reaction.MemoID], reaction)
|
|
}
|
|
|
|
attachments, err := s.Store.ListAttachments(ctx, &store.FindAttachment{MemoIDList: memoIDs})
|
|
if err != nil {
|
|
return nil, status.Errorf(codes.Internal, "failed to list attachments")
|
|
}
|
|
attachmentMap := make(map[int32][]*store.Attachment)
|
|
for _, attachment := range attachments {
|
|
attachmentMap[*attachment.MemoID] = append(attachmentMap[*attachment.MemoID], attachment)
|
|
}
|
|
|
|
// RELATIONS (batch load to avoid N+1)
|
|
relationMap, err := s.batchConvertMemoRelations(ctx, memos, false)
|
|
if err != nil {
|
|
return nil, status.Errorf(codes.Internal, "failed to batch load memo relations")
|
|
}
|
|
creatorIDs := make([]int32, 0, len(memos)+len(reactions))
|
|
for _, memo := range memos {
|
|
creatorIDs = append(creatorIDs, memo.CreatorID)
|
|
}
|
|
for _, reaction := range reactions {
|
|
creatorIDs = append(creatorIDs, reaction.CreatorID)
|
|
}
|
|
creatorMap, err := s.listUsersByID(ctx, creatorIDs)
|
|
if err != nil {
|
|
return nil, status.Errorf(codes.Internal, "failed to list memo creators: %v", err)
|
|
}
|
|
var memosResponse []*apipb.Memo
|
|
for _, m := range memos {
|
|
reactions := memoReactionsMap[m.ID]
|
|
attachments := attachmentMap[m.ID]
|
|
relations := relationMap[m.ID]
|
|
|
|
memoMessage, err := s.convertMemoFromStoreWithCreators(ctx, m, reactions, attachments, relations, creatorMap)
|
|
if err != nil {
|
|
if stderrors.Is(err, errMemoCreatorNotFound) {
|
|
slog.Warn("Skipping memo comment with missing creator",
|
|
slog.Int64("memo_id", int64(m.ID)),
|
|
slog.String("memo_uid", m.UID),
|
|
slog.Int64("creator_id", int64(m.CreatorID)),
|
|
slog.String("parent", request.Parent),
|
|
)
|
|
continue
|
|
}
|
|
return nil, errors.Wrap(err, "failed to convert memo")
|
|
}
|
|
memosResponse = append(memosResponse, memoMessage)
|
|
}
|
|
|
|
response := &apipb.ListMemoCommentsResponse{
|
|
Comments: memosResponse,
|
|
NextPageToken: nextPageToken,
|
|
}
|
|
return response, nil
|
|
}
|