[Core] Implemented GetGroupMessage

Author: Linwenxuan04

Lagrange.Core/Common/Interface/MessageExt.cs

@@ -10,6 +10,9 @@ public static Task<BotMessage> SendFriendMessage(this BotContext context, long f
 
     public static Task<BotMessage> SendGroupMessage(this BotContext context, long groupUin, MessageChain chain)
         => context.EventContext.GetLogic<MessagingLogic>().SendGroupMessage(groupUin, chain);
+    
+    public static Task<List<BotMessage>> GetGroupMessage(this BotContext context, long groupUin, int startSequence, int endSequence)
+        => context.EventContext.GetLogic<MessagingLogic>().GetGroupMessage(groupUin, startSequence, endSequence);
 
     public static Task<bool> SendFriendFile(this BotContext context, long targetUin, Stream fileStream, string? fileName = null)
         => context.EventContext.GetLogic<OperationLogic>().SendFriendFile(targetUin, fileStream, fileName);

Lagrange.Core/Internal/Events/Message/GetGroupMessageEvent.cs

@@ -0,0 +1,17 @@
+using Lagrange.Core.Internal.Packets.Message;
+
+namespace Lagrange.Core.Internal.Events.Message;
+
+internal class GetGroupMessageEventReq(long groupUin, int startSequence, int endSequence) : ProtocolEvent
+{
+    public long GroupUin { get; } = groupUin;
+
+    public int StartSequence { get; } = startSequence;
+
+    public int EndSequence { get; } = endSequence;
+}
+
+internal class GetGroupMessageEventResp(List<CommonMessage> chains) : ProtocolEvent
+{
+    public List<CommonMessage> Chains { get; } = chains;
+}

Lagrange.Core/Internal/Logic/MessagingLogic.cs

@@ -14,6 +14,14 @@ internal class MessagingLogic(BotContext context) : ILogic
 
     public Task<CommonMessage> BuildFake(BotMessage msg) => _packer.BuildFake(msg);
 
+    public async Task<List<BotMessage>> GetGroupMessage(long groupUin, int startSequence, int endSequence)
+    {
+        var result = await context.EventContext.SendEvent<GetGroupMessageEventResp>(new GetGroupMessageEventReq(groupUin, startSequence, endSequence));
+        var messages = new List<BotMessage>(result.Chains.Count);
+        foreach (var chain in result.Chains) messages.Add(await Parse(chain));
+        return messages;
+    }
+
     public async Task<BotMessage> SendFriendMessage(long friendUin, MessageChain chain)
     {
         var friend = await context.CacheContext.ResolveFriend(friendUin) ?? throw new InvalidTargetException(friendUin);

Lagrange.Core/Internal/Packets/Message/SsoGetGroupMsg.cs

@@ -0,0 +1,52 @@
+using Lagrange.Proto;
+
+namespace Lagrange.Core.Internal.Packets.Message;
+
+#pragma warning disable CS8618
+
+/// <summary>
+/// trpc.msg.register_proxy.RegisterProxy.SsoGetGroupMsg
+/// </summary>
+[ProtoPackable]
+internal partial class SsoGetGroupMsg
+{
+    [ProtoMember(1)] public SsoGetGroupMsgInfo Info { get; set; }
+    
+    [ProtoMember(2)] public bool Direction { get; set; }
+}
+
+[ProtoPackable]
+internal partial class SsoGetGroupMsgInfo
+{
+    [ProtoMember(1)] public long GroupUin { get; set; }
+    
+    [ProtoMember(2)] public int StartSequence { get; set; }
+    
+    [ProtoMember(3)] public int EndSequence { get; set; }
+}
+
+[ProtoPackable]
+internal partial class SsoGetGroupMsgRsp
+{
+    [ProtoMember(1)] public uint RetCode { get; set; }
+    
+    [ProtoMember(2)] public string ErrorMsg { get; set; }
+    
+    [ProtoMember(3)] public SsoGetGroupMsgRspBody Body { get; set; }
+}
+
+[ProtoPackable]
+internal partial class SsoGetGroupMsgRspBody
+{
+    [ProtoMember(1)] public uint Retcode { get; set; }
+
+    [ProtoMember(2)] public string Message { get; set; }
+
+    [ProtoMember(3)] public uint GroupUin { get; set; }
+
+    [ProtoMember(4)] public uint StartSequence { get; set; }
+
+    [ProtoMember(5)] public uint EndSequence { get; set; }
+
+    [ProtoMember(6)] public List<CommonMessage>? Messages { get; set; }
+}

Lagrange.Core/Internal/Services/Message/GetGroupMessageService.cs

@@ -0,0 +1,33 @@
+using Lagrange.Core.Common;
+using Lagrange.Core.Internal.Events;
+using Lagrange.Core.Internal.Events.Message;
+using Lagrange.Core.Internal.Packets.Message;
+using Lagrange.Core.Utility;
+
+namespace Lagrange.Core.Internal.Services.Message;
+
+[EventSubscribe<GetGroupMessageEventReq>(Protocols.All)]
+[Service("trpc.msg.register_proxy.RegisterProxy.SsoGetGroupMsg")]
+internal class GetGroupMessageService : BaseService<GetGroupMessageEventReq, GetGroupMessageEventResp>
+{
+    protected override ValueTask<ReadOnlyMemory<byte>> Build(GetGroupMessageEventReq input, BotContext context)
+    {
+        var packet = new SsoGetGroupMsg
+        {
+            Info = new SsoGetGroupMsgInfo
+            {
+                GroupUin = input.GroupUin,
+                StartSequence = input.StartSequence,
+                EndSequence = input.EndSequence
+            },
+            Direction = true
+        };
+        return ValueTask.FromResult(ProtoHelper.Serialize(packet));
+    }
+
+    protected override ValueTask<GetGroupMessageEventResp> Parse(ReadOnlyMemory<byte> input, BotContext context)
+    {
+        var packet = ProtoHelper.Deserialize<SsoGetGroupMsgRsp>(input.Span);
+        return ValueTask.FromResult(new GetGroupMessageEventResp(packet.Body.Messages ?? []));
+    }
+}