[Core & Milky] Implement group_member_decrease Event (#23)

Author: Szzrain

Lagrange.Core/Events/EventArgs/BotGroupMemberDecreaseEvent.cs

@@ -0,0 +1,15 @@
+namespace Lagrange.Core.Events.EventArgs;
+
+public class BotGroupMemberDecreaseEvent(Int64 groupUin, Int64 userUin, Int64 operatorUin) : EventBase
+{
+    public Int64 GroupUin { get; } = groupUin;
+    
+    public Int64 UserUin { get; } = userUin;
+    
+    public Int64 OperatorUin { get; } = operatorUin;
+
+    public override string ToEventMessage()
+    {
+        return $"{nameof(BotGroupNudgeEvent)}: GroupUin={GroupUin}, OperatorUin={OperatorUin}, TargetUin={UserUin}";
+    }
+}

Lagrange.Core/Internal/Context/CacheContext.cs

@@ -90,6 +90,8 @@ public async Task<List<BotFriendCategory>> GetCategories(bool refresh = false)
     }
 
     public string? ResolveCachedUid(long uin) => _uinToUid.GetValueOrDefault(uin);
+    
+    public long? ResolveCachedUin(string uid) => _uinToUid.FirstOrDefault(kvp => kvp.Value == uid).Key;
 
     /// <summary>
     /// Fetches the friends list from the server.

Lagrange.Core/Internal/Logic/PushLogic.cs

@@ -1,3 +1,4 @@
+using System.Text;
 using Lagrange.Core.Common;
 using Lagrange.Core.Events.EventArgs;
 using Lagrange.Core.Internal.Events;
@@ -23,6 +24,30 @@ public async ValueTask Incoming(ProtocolEvent e)
                 var message = await context.EventContext.GetLogic<MessagingLogic>().Parse(messageEvent.MsgPush.CommonMessage);
                 context.EventInvoker.PostEvent(new BotMessageEvent(message, messageEvent.Raw));
                 break;
+            case Type.GroupMemberDecreaseNotice when messageEvent.MsgPush.CommonMessage.MessageBody.MsgContent is { } content:
+                var decrease = ProtoHelper.Deserialize<GroupChange>(content.Span);
+                if (decrease.DecreaseType == 3)
+                {
+                    var op = ProtoHelper.Deserialize<OperatorInfo>(decrease.Operator.AsSpan());
+                    context.EventInvoker.PostEvent(
+                        new BotGroupMemberDecreaseEvent(
+                            decrease.GroupUin,
+                            context.CacheContext.ResolveCachedUin(decrease.MemberUid) ?? 0,
+                            context.CacheContext.ResolveCachedUin(op.Operator.Uid ?? "") ?? 0
+                        )
+                    );
+                }
+                else
+                {
+                    context.EventInvoker.PostEvent(
+                        new BotGroupMemberDecreaseEvent(
+                            decrease.GroupUin,
+                            context.CacheContext.ResolveCachedUin(decrease.MemberUid) ?? 0,
+                            context.CacheContext.ResolveCachedUin(Encoding.UTF8.GetString(decrease.Operator.AsSpan())) ?? 0
+                        )
+                    );
+                }
+                break;
             case Type.Event0x2DC:
                 var pkgType = (Event0x2DCSubType)messageEvent.MsgPush.CommonMessage.ContentHead.SubType;
                 switch (pkgType)
@@ -61,6 +86,8 @@ private enum Type
         TempMessage = 141,
         Event0x210 = 528,  // friend related event
         Event0x2DC = 732,  // group related event
+        
+        GroupMemberDecreaseNotice = 34,
     }
 
     private enum Event0x2DCSubType

Lagrange.Core/Internal/Packets/Notify/GroupChange.cs

@@ -0,0 +1,43 @@
+using Lagrange.Proto;
+
+namespace Lagrange.Core.Internal.Packets.Notify;
+
+#pragma warning disable CS8618
+
+[ProtoPackable]
+internal partial class GroupChange
+{
+    [ProtoMember(1)] public uint GroupUin { get; set; }
+
+    [ProtoMember(2)] public uint Flag { get; set; }
+
+    [ProtoMember(3)] public string MemberUid { get; set; }
+
+    [ProtoMember(4)] public uint DecreaseType { get; set; } // 131 Kick 130 Exit
+
+    [ProtoMember(5)] public byte[]? Operator { get; set; }
+
+    [ProtoMember(6)] public uint IncreaseType { get; set; }
+
+    [ProtoMember(7)] public byte[]? Field7 { get; set; }
+}
+
+[ProtoPackable]
+internal partial class OperatorInfo
+{
+    [ProtoMember(1)] public OperatorField1 Operator { get; set; }
+}
+
+[ProtoPackable]
+internal partial class OperatorField1
+{
+    [ProtoMember(1)] public string? Uid { get; set; }
+
+    [ProtoMember(2)] public uint Field2 { get; set; }
+
+    [ProtoMember(3)] public byte[]? Field3 { get; set; }
+
+    [ProtoMember(4)] public uint Field4 { get; set; }
+
+    [ProtoMember(5)] public byte[]? Field5 { get; set; }
+}

Lagrange.Milky/Entity/Event/GroupMemberDecreaseEvent.cs

@@ -0,0 +1,15 @@
+using System.Text.Json.Serialization;
+
+namespace Lagrange.Milky.Entity.Event;
+
+public class GroupMemberDecreaseEvent(long time, long selfId, GroupMemberDecreaseEventData data) : EventBase<GroupMemberDecreaseEventData>(time, selfId, "group_member_decrease", data) { }
+
+public class GroupMemberDecreaseEventData(long groupId, long userId, long? operatorId)
+{
+    [JsonPropertyName("group_id")]
+    public long GroupId { get; } = groupId;
+    [JsonPropertyName("user_id")]
+    public long UserId { get; } = userId;
+    [JsonPropertyName("operator_id")]
+    public long? OperatorId { get; } = operatorId;
+}

Lagrange.Milky/Event/EventService.cs

@@ -30,6 +30,7 @@ public Task StartAsync(CancellationToken token)
         _bot.EventInvoker.RegisterEvent<LgrEvents.BotOfflineEvent>(HandleOfflineEvent);
         _bot.EventInvoker.RegisterEvent<LgrEvents.BotMessageEvent>(HandleMessageEvent);
         _bot.EventInvoker.RegisterEvent<LgrEvents.BotGroupNudgeEvent>(HandleGroupNudgeEvent);
+        _bot.EventInvoker.RegisterEvent<LgrEvents.BotGroupMemberDecreaseEvent>(HandleGroupMemberDecreaseEvent);
 
         return Task.CompletedTask;
     }
@@ -122,6 +123,31 @@ private void HandleGroupNudgeEvent(BotContext bot, LgrEvents.BotGroupNudgeEvent
             _logger.LogHandleEventException(nameof(LgrEvents.BotGroupNudgeEvent), e);
         }
     }
+    
+    private void HandleGroupMemberDecreaseEvent(BotContext bot, LgrEvents.BotGroupMemberDecreaseEvent @event)
+    {
+        try
+        {
+            _logger.LogGroupMemberDecreaseEvent(
+                @event.GroupUin,
+                @event.UserUin,
+                @event.OperatorUin
+            );
+            var result = _convert.GroupMemberDecreaseEvent(@event);
+            byte[] bytes = JsonUtility.SerializeToUtf8Bytes(result.GetType(), result);
+            using (_lock.UsingReadLock())
+            {
+                foreach (var handler in _handlers)
+                {
+                    handler(bytes);
+                }
+            }
+        }
+        catch (Exception e)
+        {
+            _logger.LogHandleEventException(nameof(LgrEvents.BotGroupMemberDecreaseEvent), e);
+        }
+    }
 
     public Task StopAsync(CancellationToken token)
     {
@@ -161,6 +187,9 @@ public static partial class EventServiceLoggerExtension
 
     [LoggerMessage(EventId = 3, Level = LogLevel.Debug, Message = "BotGroupNudgeEvent {{ group: {group}, sender: {sender} target: {target} }}")]
     public static partial void LogGroupNudgeEvent(this ILogger<EventService> logger, long group, long sender, long target);
+    
+    [LoggerMessage(EventId = 4, Level = LogLevel.Debug, Message = "BotGroupMemberDecreaseEvent {{ group: {group}, user: {user}, operator: {operator} }}")]
+    public static partial void LogGroupMemberDecreaseEvent(this ILogger<EventService> logger, long group, long user, long? @operator);
 
     [LoggerMessage(EventId = 999, Level = LogLevel.Error, Message = "Handle {event} exception")]
     public static partial void LogHandleEventException(this ILogger<EventService> logger, string @event, Exception e);

Lagrange.Milky/Utility/EntityConvert.Event.cs

@@ -23,4 +23,10 @@ public partial class EntityConvert
         _bot.BotUin,
         new GroupNudgeEventData(@event.GroupUin, @event.OperatorUin, @event.TargetUin)
     );
+    
+    public GroupMemberDecreaseEvent GroupMemberDecreaseEvent(LgrEventArgs.BotGroupMemberDecreaseEvent @event) => new(
+        @event.EventTime.ToUnixTimeSeconds(),
+        _bot.BotUin,
+        new GroupMemberDecreaseEventData(@event.GroupUin, @event.UserUin, @event.OperatorUin == 0 ? null : @event.OperatorUin)
+    );
 }

Lagrange.Milky/Utility/JsonUtility.cs

@@ -106,6 +106,8 @@ public static partial class JsonUtility
     [JsonSerializable(typeof(MessageReceiveEvent))]
     // group_nudge
     [JsonSerializable(typeof(GroupNudgeEvent))]
+    // group_member_decrease
+    [JsonSerializable(typeof(GroupMemberDecreaseEvent))]
     private partial class JsonContext : JsonSerializerContext;
 
     public static string Serialize<T>(T value) where T : class