[Core] Implemented GetC2CMessage

Author: Linwenxuan04

Lagrange.Core/Common/Interface/MessageExt.cs

@@ -22,7 +22,9 @@ public static Task<List<BotMessage>> GetRoamMessage(this BotContext context, Bot
         uint timestamp = (uint)new DateTimeOffset(target.Time).ToUnixTimeSeconds();
         return context.EventContext.GetLogic<MessagingLogic>().GetRoamMessage(target.Contact.Uin, timestamp, count);
     }
-
+    
+    public static Task<List<BotMessage>> GetC2CMessage(this BotContext context, string friendUid, uint startSequence, uint endSequence)
+        => context.EventContext.GetLogic<MessagingLogic>().GetC2CMessage(friendUid, 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/GetC2CMessageEvent.cs

@@ -0,0 +1,17 @@
+using Lagrange.Core.Internal.Packets.Message;
+
+namespace Lagrange.Core.Internal.Events.Message;
+
+internal class GetC2CMessageEventReq(string peerUid, uint startSequence, uint endSequence) : ProtocolEvent
+{
+    public string PeerUid { get; } = peerUid;
+
+    public uint StartSequence { get; } = startSequence;
+
+    public uint EndSequence { get; } = endSequence;
+}
+
+internal class GetC2CMessageEventResp(List<CommonMessage> chains) : ProtocolEvent
+{
+    public List<CommonMessage> Chains { get; } = chains;
+}

Lagrange.Core/Internal/Logic/MessagingLogic.cs

@@ -30,6 +30,14 @@ public async Task<List<BotMessage>> GetRoamMessage(long peerUin, uint time, uint
         foreach (var chain in result.Chains) messages.Add(await Parse(chain));
         return messages;
     }
+    
+    public async Task<List<BotMessage>> GetC2CMessage(string friendUid, uint startSequence, uint endSequence)
+    {
+        var result = await context.EventContext.SendEvent<GetC2CMessageEventResp>(new GetC2CMessageEventReq(friendUid, 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)
     {

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

@@ -0,0 +1,31 @@
+using Lagrange.Proto;
+
+namespace Lagrange.Core.Internal.Packets.Message;
+
+#pragma warning disable CS8618
+
+[ProtoPackable]
+internal partial class SsoGetC2CMsgReq
+{
+    [ProtoMember(1)] public long? PeerUin { get; set; }
+    
+    [ProtoMember(2)] public string? PeerUid { get; set; }
+
+    [ProtoMember(3)] public uint StartSequence { get; set; }
+
+    [ProtoMember(4)] public uint EndSequence { get; set; }
+}
+
+[ProtoPackable]
+internal partial class SsoGetC2CMsgRsp
+{
+    [ProtoMember(1)] public uint Retcode { get; set; }
+
+    [ProtoMember(2)] public string Message { get; set; }
+    
+    [ProtoMember(3)] public uint StartSequence { get; set; }
+
+    [ProtoMember(4)] public uint EndSequence { get; set; }
+    
+    [ProtoMember(7)] public List<CommonMessage> Messages { get; set; }
+}

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

@@ -0,0 +1,36 @@
+using Lagrange.Core.Common;
+using Lagrange.Core.Exceptions;
+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;
+
+[Service("trpc.msg.register_proxy.RegisterProxy.SsoGetC2cMsg")]
+[EventSubscribe<GetC2CMessageEventReq>(Protocols.All)]
+internal class GetC2CMessageService : BaseService<GetC2CMessageEventReq, GetC2CMessageEventResp>
+{
+    protected override ValueTask<ReadOnlyMemory<byte>> Build(GetC2CMessageEventReq input, BotContext context)
+    {
+        var request = new SsoGetC2CMsgReq
+        {
+            PeerUid = input.PeerUid,
+            StartSequence = input.StartSequence,
+            EndSequence = input.EndSequence
+        };
+
+        return ValueTask.FromResult(ProtoHelper.Serialize(request));
+    }
+
+    protected override ValueTask<GetC2CMessageEventResp> Parse(ReadOnlyMemory<byte> input, BotContext context)
+    {
+        var response = ProtoHelper.Deserialize<SsoGetC2CMsgRsp>(input.Span);
+        if (response.Retcode != 0)
+        {
+            throw new OperationException((int)response.Retcode, response.Message);
+        }
+
+        return ValueTask.FromResult(new GetC2CMessageEventResp(response.Messages));
+    }
+}