fix: align backend APIs and upload flow

MessageService.Infrastructure/Reposities/MessageReposity.cs

@@ -18,38 +18,68 @@ namespace MessageService.Infrastructure.Reposities
             db.Messages.Add(message);
         }
 
-        public async Task<Message?> FindByIdAsync(Guid id)
+        public async Task<Message?> FindByIdAsync(Guid id, CancellationToken cancellationToken = default)
         {
-            return await db.Messages.FirstOrDefaultAsync(x => x.Id == id);
+            return await db.Messages.FirstOrDefaultAsync(x => x.Id == id, cancellationToken);
         }
 
-        public async Task<(IEnumerable<Message> messages, bool hasMore)> GetAsync(string streamKey, long? cusor, int direction, int limit)
+        public async Task<(IEnumerable<Message> messages, bool hasMore)> GetAsync(string streamKey, long? cusor, int direction, int limit, CancellationToken cancellationToken = default)
         {
             var query = db.Messages.Where(x => x.StreamKey == streamKey);
-            List<Message> messages = [];
+            List<Message> fetched;
             if (direction == 0) // Before: 找比锚点小的，按倒序排
             {
                 if (cusor.HasValue)
                     query = query.Where(m => m.SequenceId < cusor.Value);
 
-                var list = await query
+                fetched = await query
                     .OrderByDescending(m => m.SequenceId) // 最新消息在最前
                     .Take(limit + 1)
-                    .ToListAsync();
-
-                messages = [.. list.OrderBy(s => s.SequenceId)];
+                    .ToListAsync(cancellationToken);
             }
             else
             {
                 if (cusor is null)
-                    return (messages, false);
+                    return (Array.Empty<Message>(), false);
 
-                messages = await query.OrderBy(o => o.SequenceId)
+                fetched = await query
+                    .Where(m => m.SequenceId > cusor.Value)
+                    .OrderBy(o => o.SequenceId)
                     .Take(limit + 1)
-                    .ToListAsync();
+                    .ToListAsync(cancellationToken);
             }
 
-            return (messages, messages.Count > limit);
+            var hasMore = fetched.Count > limit;
+            var messages = fetched.Take(limit).OrderBy(s => s.SequenceId).ToList();
+            return (messages, hasMore);
+        }
+
+        public async Task<(IEnumerable<Message> messages, bool hasMore)> SearchAsync(
+            string streamKey,
+            string keyword,
+            long? cursor,
+            int limit,
+            CancellationToken cancellationToken = default)
+        {
+            var query = db.Messages
+                .AsNoTracking()
+                .Where(message =>
+                    message.StreamKey == streamKey &&
+                    message.MsgType == Domain.Enums.MessageType.Text &&
+                    message.State == Domain.Enums.MessageState.Sent &&
+                    message.Content.Fallback.Contains(keyword));
+
+            if (cursor.HasValue)
+            {
+                query = query.Where(message => message.SequenceId < cursor.Value);
+            }
+
+            var fetched = await query
+                .OrderByDescending(message => message.SequenceId)
+                .Take(limit + 1)
+                .ToListAsync(cancellationToken);
+
+            return (fetched.Take(limit).ToList(), fetched.Count > limit);
         }
     }
 }