public async Task HandleMessageAsync(IMiraiHttpSession client, IGroupMemberKickedEventArgs e)
{
if (!DataBase.me.IsGroupRelated(e.Member.Group.Id))
{
return;
}
string name = e.Member.Name;
long qq = e.Member.Id;
long gid = e.Member.Group.Id;
string gname = e.Member.Group.Name;
long opid = e.Operator.Id;
string opname = DataBase.me.getAdminName(opid);
try
{
MainHolder.broadcaster.BroadcastToAdminGroup(new IChatMessage[] {
new PlainMessage(name + "被" + opname + "踢出了" + DataBase.me.getGroupName(gid) + "\n已自动拉黑该用户"),
new AtMessage(opid)
});
DataBase.me.recUserLeave(qq, gid, opid);
DataBase.me.removeUser(qq, gid);
DataBase.me.addUserBlklist(qq, "踢出触发的自动拉黑", opid);
}
catch (Exception err)
{
MainHolder.broadcaster.BroadcastToAdminGroup("[Exception]\n这条消息可能意味着机器人发生了错误。它仍在继续运行，但可能不是很稳定。下面的信息用来帮助鸡蛋定位错误，管理不必在意。\n[已退群的处理]" + err.Message + "\n\n堆栈跟踪：\n" + err.StackTrace);
}
return;
}
public Task HandleMessageAsync(IMiraiHttpSession session, INewFriendApplyEventArgs e)
{
_logger.LogWarning($"已自动拒绝加好友请求。来源:{e.FromQQ}");
return(session.HandleNewFriendApplyAsync(e, FriendApplyAction.Deny, "略略略"));
// 把整个事件信息直接作为第一个参数即可, 然后根据自己需要选择一个 FriendApplyAction 枚举去处理请求
// 你也可以暂存 INewFriendApplyEventArgs e, 之后再调用 session 处理
}
public async Task <IActionResult> AddGroupMessageHandlerAsync([Required] int robotQQ, CancellationToken token)
{
IMiraiHttpSession session = await _robotManager.RetriveSessionAsync(robotQQ, token);
session.AddPlugin(new GroupMessageHandler());
return((JsonResult)ResponseModel.CreateSuccess());
}
private async Task <IMiraiHttpSession> InternalRetriveSessionAsync(long robotQQ, CancellationToken token)
{
try
{
if (_robotScopes.TryGetValue(robotQQ, out IServiceScope? dualcheck))
{
return(dualcheck.ServiceProvider.GetRequiredService <IMiraiHttpSession>());
}
IServiceScope scope = _services.CreateScope();
try
{
IMiraiHttpSession session = scope.ServiceProvider.GetRequiredService <IMiraiHttpSession>();
await session.ConnectAsync(robotQQ, token).ConfigureAwait(false);
_robotScopes[robotQQ] = scope;
return(session);
}
catch
{
scope.Dispose();
throw;
}
}
finally
{
_robotInitTasks.TryRemove(robotQQ, out _);
}
}
public async Task HandleMessageAsync(IMiraiHttpSession session, IFriendMessageEventArgs e)
{
if (!CheckPreconditions(e.Sender))
{
return;
}
LogHelper.WriteInfoLog($"收到来自{e.Sender.Id}的私聊消息");
int quoteId = (e.Chain[0] as SourceMessage).Id;
bool isHandle = await MessageHandler.HandleMesage(e.Chain.ToOnionsMessages(e.Sender.Id, e.Sender.Name), null, async outMsg =>
{
if (outMsg != null)
{
int iRevokeTime = outMsg.RevokeTime;
var msg = await outMsg.ToMiraiApiHttpMessages(session, UploadTarget.Friend);
_ = session.SendFriendMessageAsync(e.Sender.Id, msg, outMsg.Reply ? quoteId : null).ContinueWith(async sendedCallBack =>
{
if (iRevokeTime > 0)
{
await Task.Delay(1000 * iRevokeTime);
_ = session.RevokeMessageAsync(sendedCallBack.Result);
}
});
}
});
e.BlockRemainingHandlers = isHandle;
}
public Task HandleMessageAsync(IMiraiHttpSession session, IGroupMemberKickedEventArgs e)
{
if (!CheckPreconditions(e.Member) || !BotInfo.SendMemberBeKickedMessage)
{
return(Task.CompletedTask);
}
return(session.SendGroupMessageAsync(e.Member.Group.Id, ReplaceMessage(session.GetMessageChainBuilder(), BotInfo.MemberBeKickedMessage, e.Member, e.Operator)));
}
private async Task SendPictureAsync2(IMiraiHttpSession session, string path) // 发图, 不同的是使用 IMessageChainBuilder 构造消息链
{
IImageMessage msg = await session.UploadPictureAsync(UploadTarget.Group, path);
Builders.IMessageChainBuilder builder = session.GetMessageChainBuilder();
builder.Add(msg);
await session.SendGroupMessageAsync(0, builder); // 自己填群号, 一般由 IGroupMessageEventArgs 提供
}
public async Task HandleMessageAsync(IMiraiHttpSession session, INewFriendApplyEventArgs e)
{
await session.HandleNewFriendApplyAsync(e, FriendApplyAction.Deny, "略略略");
// 把整个事件信息直接作为第一个参数即可, 然后根据自己需要选择一个 FriendApplyAction 枚举去处理请求
// 你也可以暂存 INewFriendApplyEventArgs e, 之后再调用 session 处理
e.BlockRemainingHandlers = false;
}
public override async Task HandleMessageAsync(IMiraiHttpSession session, IBotInvitedJoinGroupEventArgs e)
{
await session.HandleBotInvitedJoinGroupAsync(e, GroupApplyActions.Allow, "略略略"); // 在这个事件下, 只有 GroupApplyActions.Allow 和
// GroupApplyActions.Deny 有效
// 把整个事件信息直接作为第一个参数即可, 然后根据自己需要选择一个 GroupApplyActions 枚举去处理请求
// 你也可以暂存 IGroupApplyEventArgs e, 之后再调用session处理
e.BlockRemainingHandlers = false;
}
public async Task HandleMessageAsync2(IMiraiHttpSession session, IFriendMessageEventArgs e) // 法2: 使用 params IMessageBase[]
{
IChatMessage plain1 = new PlainMessage($"收到了来自{e.Sender.Name}({e.Sender.Remark})[{e.Sender.Id}]的私聊消息:{string.Join(null, (IEnumerable<IChatMessage>)e.Chain)}");
// / 好友昵称 / / 好友备注 / / 好友QQ号 / / 消息链 /
IChatMessage plain2 = new PlainMessage("嘤嘤嘤"); // 在下边的 SendFriendMessageAsync, 你可以串起n个 IChatMessage
await session.SendFriendMessageAsync(e.Sender.Id, plain1 /*, plain2, /* etc... */); // 向消息来源好友异步发送由以上chain表示的消息
e.BlockRemainingHandlers = false; // 不阻断消息传递。如需阻断请返回true
}
public async Task HandleMessageAsync2(IMiraiHttpSession session, IGroupMessageEventArgs e) // 法2: 使用 params IMessageBase[]
{
IChatMessage plain1 = new PlainMessage($"收到了来自{e.Sender.Name}[{e.Sender.Id}]{{{e.Sender.Permission}}}的群消息:{string.Join(null, (IEnumerable<IChatMessage>)e.Chain)}");
// / 发送者群名片 / / 发送者QQ号 / / 发送者在群内权限 / / 消息链 /
IChatMessage plain2 = new PlainMessage("QAQ"); // 在下边的 SendGroupMessageAsync, 你可以串起n个 IMessageBase
await session.SendGroupMessageAsync(e.Sender.Group.Id, plain1 /*, plain2, /* etc... */); // 向消息来源群异步发送由以上chain表示的消息
e.BlockRemainingHandlers = false; // 不阻断消息传递。如需阻断请返回true
}
public async Task HandleMessageAsync(IMiraiHttpSession client, ITempMessageEventArgs e)
{
MsgReplyTemp r = new MsgReplyTemp()
{
fromGroup = e.Sender.Group.Id, qq = e.Sender.Id
};
ProcessMessage(r, e.Chain);
return;
}
private async Task SendPictureAsync(IMiraiHttpSession session, string path) // 发图
{
// 你也可以使用另一个重载 UploadPictureAsync(PictureTarget, Stream)
// 当 mirai-api-http 在v1.7.0以下时将使用本地的HttpListener做图片中转
// UploadTarget.Friend 对应 IMiraiSession.SendFriendMessageAsync
IImageMessage msg = await session.UploadPictureAsync(UploadTarget.Group, path);
IChatMessage[] chain = new IChatMessage[] { msg }; // 数组里边可以加上更多的 IMessageBase, 以此达到例如图文并发的情况
await session.SendGroupMessageAsync(0, chain); // 自己填群号, 一般由 IGroupMessageEventArgs 提供
}
public async Task HandleMessageAsync(IMiraiHttpSession client, IFriendMessageEventArgs e)
{
MsgReplyFriend r = new MsgReplyFriend()
{
qq = e.Sender.Id
};
ProcessMessage(r, e.Chain);
return;
}
public async Task HandleMessageAsync(IMiraiHttpSession session, IGroupMessageEventArgs e) // 法3: 使用 IMessageBuilder
{
IMessageChainBuilder builder = session.GetMessageChainBuilder();
builder.AddPlainMessage($"收到了来自{e.Sender.Name}[{e.Sender.Id}]{{{e.Sender.Permission}}}的群消息:{string.Join(null, (IEnumerable<IChatMessage>)e.Chain)}");
// / 发送者群名片 / / 发送者QQ号 / / 发送者在群内权限 / / 消息链 /
// builder.AddPlainMessage("QAQ").AddPlainMessage("OvO")/* .AddAtMessage(123456) etc... */;
await session.SendGroupMessageAsync(e.Sender.Group.Id, builder /*, plain2, /* etc... */); // 向消息来源群异步发送由以上chain表示的消息
// e.BlockRemainingHandlers = true; // 默认不阻断消息传递。如需阻断请删除注释
}
public async Task HandleMessageAsync3(IMiraiHttpSession session, IFriendMessageEventArgs e) // 法3: 使用 params IMessageBase[]
{
Builders.IMessageChainBuilder builder = session.GetMessageChainBuilder();
builder.AddPlainMessage($"收到了来自{e.Sender.Name}({e.Sender.Remark})[{e.Sender.Id}]的私聊消息:{string.Join(null, (IEnumerable<IChatMessage>)e.Chain)}");
// / 好友昵称 / / 好友备注 / / 好友QQ号 / / 消息链 /
// builder.AddPlainMessage("QAQ").AddPlainMessage("QwQ")/* .AddAtMessage(123456) etc... */;
// 你甚至可以一开始 new MessageBuilder() 的时候就开始 Chaining
await session.SendFriendMessageAsync(e.Sender.Id, builder); // 向消息来源群异步发送由以上chain表示的消息
e.BlockRemainingHandlers = false; // 不阻断消息传递。如需阻断请返回true
}
public async Task HandleMessageAsync(IMiraiHttpSession session, IFriendMessageEventArgs e) // 法1: 使用 IMessageBase[]
{
IChatMessage[] chain = new IChatMessage[]
{
new PlainMessage($"收到了来自{e.Sender.Name}({e.Sender.Remark})[{e.Sender.Id}]的私聊消息:{string.Join(null, (IEnumerable<IChatMessage>)e.Chain)}")
// / 好友昵称 / / 好友备注 / / 好友QQ号 / / 消息链 /
// 你还可以在这里边加入更多的 IMessageBase
};
await session.SendFriendMessageAsync(e.Sender.Id, chain); // 向消息来源好友异步发送由以上chain表示的消息
e.BlockRemainingHandlers = false; // 不阻断消息传递。如需阻断请返回true
}
public async Task HandleMessageAsync(IMiraiHttpSession session, IGroupMessageEventArgs e) // 法1: 使用 IMessageBase[]
{
// 临时消息和群消息一致, 不多写例子了
IChatMessage[] chain = new IChatMessage[]
{
new PlainMessage($"收到了来自{e.Sender.Name}[{e.Sender.Id}]{{{e.Sender.Permission}}}的群消息:{string.Join(null, (IEnumerable<IChatMessage>)e.Chain)}")
// / 发送者群名片 / / 发送者QQ号 / / 发送者在群内权限 / / 消息链 /
// 你还可以在这里边加入更多的 IMessageBase
};
await session.SendGroupMessageAsync(e.Sender.Group.Id, chain); // 向消息来源群异步发送由以上chain表示的消息
e.BlockRemainingHandlers = false; // 不阻断消息传递。如需阻断请返回true
}
public static async Task Main()
{
// 一套能用的框架, 必须要注册至少一个 Invoker, Parser, Client 和 Handler
// Invoker 负责消息调度
// Parser 负责解析消息到具体接口以便调度器调用相关 Handler 下的处理方法
// Client 负责收发原始数据
IServiceProvider services = new ServiceCollection().AddMiraiBaseFramework() // 表示使用基于基础框架的构建器
.AddHandler <MiraiPlugin>() // 虽然可以把 HttpApiPlugin 作为泛型参数塞入, 但不建议这么做
.Services
.AddDefaultMiraiHttpFramework() // 表示使用 mirai-api-http 实现的构建器
.ResolveParser <DynamicPlugin>() // 只提前解析 DynamicPlugin 将要用到的消息解析器
.AddInvoker <MiraiHttpMessageHandlerInvoker>() // 使用默认的调度器
.AddHandler <HttpApiPlugin>() // 可以如此添加更多消息处理器
.AddClient <MiraiHttpSession>() // 使用默认的客户端
.Services
// 由于 MiraiHttpSession 使用 IOptions<MiraiHttpSessionOptions>, 其作为 Singleton 被注册
// 配置此项将配置基于此 IServiceProvider 全局的连接配置
// 如果你想一个作用域一个配置的话
// 自行做一个实现类, 继承MiraiHttpSession, 构造参数中使用 IOptionsSnapshot<MiraiHttpSessionOptions>
// 并将其传递给父类的构造参数
// 然后在每一个作用域中!先!配置好 IOptionsSnapshot<MiraiHttpSessionOptions>, 再尝试获取 IMiraiHttpSession
.Configure <MiraiHttpSessionOptions>(options =>
{
options.Host = "域名/IP";
options.Port = 12345; // 端口
options.AuthKey = "00000000000000000000000000000000"; // 凭据
})
.AddLogging()
.BuildServiceProvider();
IServiceScope scope = services.CreateScope();
await using var x = (IAsyncDisposable)scope;
//await using AsyncServiceScope scope = services.CreateAsyncScope(); // 自 .NET 6.0 起才可以如此操作代替上边两句
services = scope.ServiceProvider;
IMiraiHttpSession session = services.GetRequiredService <IMiraiHttpSession>(); // 大部分服务都基于接口注册, 请使用接口作为类型解析
DynamicPlugin plugin = new DynamicPlugin();
PluginResistration resistration = session.AddPlugin(plugin); // 实时添加
await session.ConnectAsync(0); // 填入期望连接到的机器人QQ号
while (true)
{
if (Console.ReadLine() == "exit")
{
resistration.Dispose(); // 实时移除
break;
}
}
}
public async Task HandleMessageAsync(IMiraiHttpSession session, IGroupMessageEventArgs e)
{
if (!CheckPreconditions(e.Sender))
{
return;
}
LogHelper.WriteInfoLog($"收到来自{e.Sender.Id}的群消息");
int quoteId = (e.Chain[0] as SourceMessage).Id;
for (int i = 0; i < e.Chain.Length; i++)
{
//获取@群名片
if (e.Chain[i] is IAtMessage atMsg)
{
IGroupMemberInfo[] groupMemberInfos = await session.GetGroupMemberListAsync(e.Sender.Group.Id);
IGroupMemberInfo targetQQ = groupMemberInfos.Where(m => m.Id == atMsg.Target).FirstOrDefault();
string nickName = targetQQ?.Name;
e.Chain[i] = new AtMessage(atMsg.Target, nickName);
}
}
bool isHandle = await MessageHandler.HandleMesage(e.Chain.ToOnionsMessages(e.Sender.Id, e.Sender.Name), e.Sender.Group.Id, async outMsg =>
{
if (outMsg != null)
{
int iRevokeTime = outMsg.RevokeTime;
var msg = await outMsg.ToMiraiApiHttpMessages(session, UploadTarget.Group);
_ = session.SendGroupMessageAsync(e.Sender.Group.Id, msg, outMsg.Reply ? quoteId : null).ContinueWith(async sendedCallBack =>
{
if (iRevokeTime > 0)
{
await Task.Delay(1000 * iRevokeTime);
_ = session.RevokeMessageAsync(sendedCallBack.Result);
}
});
}
});
e.BlockRemainingHandlers = isHandle;
}
public async Task HandleMessageAsync(IMiraiHttpSession client, IFriendMessageEventArgs e)
{
_session = client;
var message = GetMessage(e.Chain, out var command);
try
{
//mirai不支持获取单个用户信息，所以在消息收到时进行添加
UserManager.Add(new QQSourceInfo
{
Id = e.Sender.Id,
Nick = e.Sender.Name,
});
await CommandCenter.Execute(command, message, Core.PlatformModel.MessageSourceType.Friend, qqNo : e.Sender.Id);
}
catch (Exception ex)
{
AnsiConsole.MarkupLine($"[red]{ex.Message}{Environment.NewLine}{ex.StackTrace}[/]");
}
}
public async Task HandleMessageAsync(IMiraiHttpSession session, IDisconnectedEventArgs e)
{
// e.Exception: 引发掉线的响应异常, 按需处理
while (true)
{
try
{
await session.ConnectAsync(e.LastConnectedQQNumber);
e.BlockRemainingHandlers = true;
break;
}
catch (ObjectDisposedException) // session 已被释放
{
break;
}
catch (Exception)
{
await Task.Delay(1000);
}
}
}
public async Task HandleMessageAsync(IMiraiHttpSession client, IGroupMemberPositiveLeaveEventArgs e)
{
if (!DataBase.me.IsGroupRelated(e.Member.Group.Id))
{
return;
}
string name = e.Member.Name;
long qq = e.Member.Id;
long gid = e.Member.Group.Id;
string gname = e.Member.Group.Name;
try
{
MainHolder.broadcaster.BroadcastToAdminGroup(name + "退出了" + DataBase.me.getGroupName(gid) + "\n已删除该用户");
DataBase.me.recUserLeave(qq, gid, null);
DataBase.me.removeUser(qq, gid);
}
catch (Exception err)
{
MainHolder.broadcaster.BroadcastToAdminGroup("[Exception]\n这条消息可能意味着机器人发生了错误。它仍在继续运行，但可能不是很稳定。下面的信息用来帮助鸡蛋定位错误，管理不必在意。\n[已退群的处理]" + err.Message + "\n\n堆栈跟踪：\n" + err.StackTrace);
}
return;
}
public async Task HandleMessageAsync(IMiraiHttpSession session, IDisconnectedEventArgs message)
{
_logger.LogWarning(message.Exception, $"连接被断开。上一次连接的QQ号为:{message.LastConnectedQQNumber}");
while (!session.Connected) // 防止以前的handler未能正确阻断消息传递
{
try
{
await session.ConnectAsync(message.LastConnectedQQNumber);
message.BlockRemainingHandlers = true;
_logger.LogInformation($"重连成功");
break;
}
catch (ObjectDisposedException)
{
break;
}
catch (Exception e)
{
_logger.LogError(e, $"重连失败。上一次连接的QQ号为:{message.LastConnectedQQNumber}");
await Task.Delay(1000);
}
}
}
public async Task HandleMessageAsync(IMiraiHttpSession session, IGroupApplyEventArgs e)
{
if (!DataBase.me.IsGroupRelated(e.FromGroup))
{
return;
}
if (DataBase.me.isUserBlacklisted(e.FromQQ))
{
MainHolder.broadcaster.BroadcastToAdminGroup("入群的用户 " + e.NickName + "(" + e.FromQQ + ") 存在于黑名单中，自动拒绝。");
await MainHolder.session.HandleGroupApplyAsync(e, GroupApplyActions.Deny, "您被设置不能加入任何粉丝群。");
return;
}
switch (DataBase.me.isUserTrusted(e.FromQQ))
{
case 1:
DataBase.me.removeUserTrustlist(e.FromQQ);
MainHolder.broadcaster.BroadcastToAdminGroup("入群的用户 " + e.NickName + "(" + e.FromQQ + ") 受到单次信任，同意入群。\n该次信任已被移除。");
goto case 9; //显式允许直接进入下一个case
case 0:
MainHolder.broadcaster.BroadcastToAdminGroup("入群的用户 " + e.NickName + "(" + e.FromQQ + ") 受到永久信任，同意入群。");
goto case 9; //显式允许直接进入下一个case
case 9:
await MainHolder.session.HandleGroupApplyAsync(e, GroupApplyActions.Allow);
return;
}
int qqlevel = -1;
if (e.FromGroup != 964206367)
{
qqlevel = ThirdPartAPIs.getQQLevel(e.FromQQ, 2);
if (qqlevel < 0)
{
Thread.Sleep(2000);
qqlevel = ThirdPartAPIs.getQQLevel(e.FromQQ, 2);
}
if (qqlevel < 0)
{
MainHolder.broadcaster.BroadcastToAdminGroup("入群的用户 " + e.NickName + "(" + e.FromQQ + ") 等级查询失败(try3,2s,try3),已提示重新申请");
await MainHolder.session.HandleGroupApplyAsync(e, GroupApplyActions.Deny, "等级查询失败,请重新申请入群");
return;
}
else
if (qqlevel < 16)
{
MainHolder.broadcaster.BroadcastToAdminGroup("入群的用户 " + e.NickName + "(" + e.FromQQ + ") 等级过低(" + qqlevel + "<16), 拒绝");
await MainHolder.session.HandleGroupApplyAsync(e, GroupApplyActions.Deny, "您的QQ等级过低, 如有疑问请联系管理");
return;
}
}
if (DataBase.me.isCrewGroup(e.FromGroup))
{ //是舰长群
CrewChecker cr = new CrewChecker();
if (DataBase.me.isUserBoundedUID(e.FromQQ)) //舰长绑定
{
var uid = DataBase.me.getUserBoundedUID(e.FromQQ);
if (DataBase.me.isBiliUserGuard(uid))
{
await MainHolder.session.HandleGroupApplyAsync(e, GroupApplyActions.Allow);
MainHolder.broadcaster.BroadcastToAdminGroup(e.FromQQ + "\n！正在加入舰长群(" + qqlevel + ">=16)\n是舰长，同意");
}
else
{
await MainHolder.session.HandleGroupApplyAsync(e, GroupApplyActions.Deny, "没有您的大航海数据，如有疑问请联系管理。");
MainHolder.broadcaster.BroadcastToAdminGroup(e.FromQQ + "\n！正在加入舰长群\n不是舰长，拒绝");
}
}
else
{
await MainHolder.session.HandleGroupApplyAsync(e, GroupApplyActions.Deny, "您的QQ没有绑定任何UID，如有疑问请联系管理。");
MainHolder.broadcaster.BroadcastToAdminGroup(e.FromQQ + "\n！正在加入舰长群\n未知QQ，拒绝");
}
return;
}
else
{
var groups = DataBase.me.whichGroupsAreTheUserIn(e.FromQQ);
if (groups.Count > 1)
{
string gps = "";
foreach (long group in groups)
{
gps += DataBase.me.getGroupName(group) + "(" + group + ")\n";
}
MainHolder.broadcaster.BroadcastToAdminGroup(e.NickName + "(" + e.FromQQ + ") 加入群 " +
e.FromGroupName + "(" + e.FromGroup + ") \n，自动拒绝。\n该用户同时加入以下群聊：\n" + gps);
await MainHolder.session.HandleGroupApplyAsync(e, GroupApplyActions.Deny, "已加入其它粉丝群 如有疑问请联系管理");
return;
}
}
{
//await MainHolder.session.HandleGroupApplyAsync(e, GroupApplyActions.Allow);
MainHolder.broadcaster.BroadcastToAdminGroup(e.FromQQ + "\n不在黑名单,等级条件满足(" + qqlevel + ">=16)\n等待人工处理");
return;
}
}
public static async Task <IChatMessage[]> ToMiraiApiHttpMessages(this IGreenOnionsMessages greenOnionsMessage, IMiraiHttpSession session, UploadTarget uploadTarget)
{
List <IChatMessage> miraiApiHttpMessages = new List <IChatMessage>();
List <Mirai.CSharp.HttpApi.Models.ChatMessages.ForwardMessageNode> nodes = new List <Mirai.CSharp.HttpApi.Models.ChatMessages.ForwardMessageNode>();
for (int i = 0; i < greenOnionsMessage.Count; i++)
{
if (greenOnionsMessage[i] is IGreenOnionsTextMessage txtMsg)
{
miraiApiHttpMessages.Add(new Mirai.CSharp.HttpApi.Models.ChatMessages.PlainMessage(txtMsg.Text));
}
else if (greenOnionsMessage[i] is IGreenOnionsImageMessage imgMsg)
{
if (!string.IsNullOrEmpty(imgMsg.Url))
{
string url = null;
string path = null;
if (File.Exists(imgMsg.Url))
{
path = imgMsg.Url;
}
else
{
url = imgMsg.Url;
}
miraiApiHttpMessages.Add(new Mirai.CSharp.HttpApi.Models.ChatMessages.ImageMessage(null, url, path));
}
else if (!string.IsNullOrEmpty(imgMsg.Base64Str))
{
using (MemoryStream ms = imgMsg.MemoryStream)
{
miraiApiHttpMessages.Add(await session.UploadPictureAsync(uploadTarget, ms));
}
}
}
else if (greenOnionsMessage[i] is IGreenOnionsAtMessage atMsg)
{
if (atMsg.AtId == -1)
{
miraiApiHttpMessages.Add(new Mirai.CSharp.HttpApi.Models.ChatMessages.AtAllMessage());
}
else
{
miraiApiHttpMessages.Add(new Mirai.CSharp.HttpApi.Models.ChatMessages.AtMessage(atMsg.AtId));
}
}
else if (greenOnionsMessage[i] is IGreenOnionsForwardMessage forwardMsg)
{
for (int j = 0; j < forwardMsg.ItemMessages.Count; j++)
{
Mirai.CSharp.HttpApi.Models.ChatMessages.ForwardMessageNode node = new Mirai.CSharp.HttpApi.Models.ChatMessages.ForwardMessageNode()
{
Id = i * j + j,
Name = forwardMsg.ItemMessages[j].NickName,
QQNumber = forwardMsg.ItemMessages[j].QQid,
Time = DateTime.Now,
Chain = (await ToMiraiApiHttpMessages(forwardMsg.ItemMessages[j].itemMessage, session, uploadTarget)).Select(msg => msg as Mirai.CSharp.HttpApi.Models.ChatMessages.IChatMessage).ToArray(),
};
nodes.Add(node);
}
}
}
if (nodes.Count > 0)
{
Mirai.CSharp.HttpApi.Models.ChatMessages.ForwardMessage forwardMessage = new Mirai.CSharp.HttpApi.Models.ChatMessages.ForwardMessage(nodes.ToArray());
miraiApiHttpMessages.Add(forwardMessage);
}
return(miraiApiHttpMessages.ToArray());
}
public async Task HandleMessageAsync(IMiraiHttpSession session, IGroupApplyEventArgs e)
{
// 把整个事件信息直接作为第一个参数即可, 然后根据自己需要选择一个 GroupApplyActions 枚举去处理请求
// 你也可以暂存 IGroupApplyEventArgs e, 之后再调用session处理
await session.HandleGroupApplyAsync(e, GroupApplyActions.Deny, "略略略");
}
static async Task Main(string[] args)
{
Options opt = null;
Parser.Default.ParseArguments <Options>(args).WithParsed <Options>(o =>
{
opt = o;
});
var bot = new Bot();
IServiceProvider services = new ServiceCollection().AddMiraiBaseFramework() // 表示使用基于基础框架的构建器
.AddHandler <Bot>(p => bot, ServiceLifetime.Singleton)
.Services
.AddDefaultMiraiHttpFramework() // 表示使用 mirai-api-http 实现的构建器
.ResolveParser <Bot>(ServiceLifetime.Singleton)
.AddInvoker <MiraiHttpMessageHandlerInvoker>() // 使用默认的调度器
.AddClient <MiraiHttpSession>() // 使用默认的客户端
.Services
// 由于 MiraiHttpSession 使用 IOptions<MiraiHttpSessionOptions>, 其作为 Singleton 被注册
// 配置此项将配置基于此 IServiceProvider 全局的连接配置
// 如果你想一个作用域一个配置的话
// 自行做一个实现类, 继承MiraiHttpSession, 构造参数中使用 IOptionsSnapshot<MiraiHttpSessionOptions>
// 并将其传递给父类的构造参数
// 然后在每一个作用域中!先!配置好 IOptionsSnapshot<MiraiHttpSessionOptions>, 再尝试获取 IMiraiHttpSession
.Configure <MiraiHttpSessionOptions>(options =>
{
options.Host = "127.0.0.1";
options.Port = 8080; // 端口
options.AuthKey = opt.AuthKey; // 凭据
})
.AddLogging()
.BuildServiceProvider();
IServiceScope scope = services.CreateScope();
await using var x = (IAsyncDisposable)scope;
//await using AsyncServiceScope scope = services.CreateAsyncScope(); // 自 .NET 6.0 起才可以如此操作代替上边两句
services = scope.ServiceProvider;
IMiraiHttpSession session = services.GetRequiredService <IMiraiHttpSession>(); // 大部分服务都基于接口注册, 请使用接口作为类型解析
//session.AddPlugin(bot); // 实时添加
bot.SetSession(session);
await session.ConnectAsync(opt.QQ); // 填入期望连接到的机器人QQ号
await bot.Start();
while (true)
{
var readline = await Console.In.ReadLineAsync();
if (readline == "exit")
{
return;
}
else if (readline.StartsWith("notice ", StringComparison.OrdinalIgnoreCase))
{
var message = $"[通知]{readline.Substring(7)}";
var groups = GensouSakuya.QQBot.Core.QQManager.GroupMemberManager.GroupMembers.Values
.Select(p => p.GroupId).Distinct().ToList();
groups.ForEach(p => { session.SendGroupMessageAsync(p, new PlainMessage(message)); });
}
else if (readline.StartsWith("togroup ", StringComparison.OrdinalIgnoreCase))
{
var splited = readline.Split(" ");
if (!long.TryParse(splited[1], out var groupNo))
{
continue;
}
var message = string.Join(" ", splited.Skip(2));
await session.SendGroupMessageAsync(groupNo, new PlainMessage(message));
}
else if (readline.Equals("save", StringComparison.OrdinalIgnoreCase))
{
await DataManager.Save();
}
else if (readline.Equals("load", StringComparison.OrdinalIgnoreCase))
{
await DataManager.Load();
}
}
}
public async Task HandleMessageAsync(IMiraiHttpSession client, IGroupMemberJoinedEventArgs e)
{
if (!DataBase.me.IsGroupRelated(e.Member.Group.Id))
{
return;
}
string usname = e.Member.Name;
long qq = e.Member.Id;
long groupId = e.Member.Group.Id;
string gname = DataBase.me.getGroupName(groupId);
gname =
gname == "UNDEFINED_IN_DATABASE"
? e.Member.Group.Name : gname;
try
{
if (DataBase.me.isUserBlacklisted(qq))
{
MainHolder.broadcaster.BroadcastToAdminGroup("入群的用户 " + usname + "(" + qq + ") 存在于黑名单中，请三思！");
}
if (DataBase.me.whichGroupsAreTheUserIn(qq).Count > 1)
{
List <long> groups_in = DataBase.me.whichGroupsAreTheUserIn(qq);
if (groups_in.Count > 1)
{
string gps = "";
foreach (long group in groups_in)
{
gps += DataBase.me.getGroupName(group) + "(" + group + ")\n";
}
MainHolder.broadcaster.BroadcastToAdminGroup(usname + "(" + qq + ") 加入群 " +
gname + "(" + groupId + ") \n该用户同时加入以下群聊：\n" + gps);
}
}
if (DataBase.me.isCrewGroup(e.Member.Group.Id))
{
long uid = DataBase.me.getUserBoundedUID(qq);
if (uid <= 0)
{
MainHolder.broadcaster.BroadcastToAdminGroup(usname + "(" + qq + ")加入舰长群 " +
gname + "(" + groupId + ") \n[未能验证舰长记录 该用户未绑定UID]");
MainHolder.broadcaster.SendToGroup(groupId, "欢迎加入舰长群！\n[未绑定B站账号]");
//e.BeingOperateQQ.SendPrivateMessage("欢迎来到舰长群，感谢您对鹿野的支持！\n当前QQ未和Bilibili绑定，可发送#uid [uid]来绑定B站账号。例如：\n#uid 23696210\n不会操作也可以联系鸡蛋🥚");
}
else
{
MainHolder.broadcaster.BroadcastToAdminGroup(usname + "(" + qq + ")<舰长> 加入群 " +
gname + "(" + groupId + ") \nB站信息:https://space.bilibili.com/" + uid + "\n");
PrivMessageSession psession = PrivMessageSession.openSessionWith((int)uid, MainHolder.biliapi);
BiliApi.BiliUser bu = BiliApi.BiliUser.getUser((int)uid, MainHolder.biliapi);
CrewChecker cr = new CrewChecker();
Dictionary <int, CrewMember> crewlist = cr.getAllCrewMembers();
CrewMember thismember = crewlist[(int)uid];
string dpword = "";
switch (thismember.level)
{
case 1:
dpword = "总督";
break;
case 2:
dpword = "提督";
break;
case 3:
dpword = "舰长";
break;
}
MainHolder.broadcaster.SendToGroup(groupId, "欢迎" + dpword + "<" + bu.name + ">加入舰长群！");
IGroupMemberCardInfo iginfo = new GroupMemberCardInfo(dpword + " " + bu.name, null);
await MainHolder.session.ChangeGroupMemberInfoAsync(qq, groupId, iginfo);
MainHolder.broadcaster.SendToQQ(qq, "欢迎来到舰长群，感谢您对奶狗狗的支持！请认准鹿野QQ(1249695750)，可通过舰长群私聊鹿野获取好友位哦\n您的QQ号已和Bilibili账号<" + bu.name + ">绑定，如有疑问请联系鸡蛋🥚(这套系统的开发者，QQ号1250542735)");
psession.sendMessage("您已经成功加入了舰长群。感谢您对大总攻(XNG)的支持！");
}
}
else
{
MainHolder.broadcaster.BroadcastToAdminGroup(usname + "加入了" + gname + "\n已建立用户信息");
}
DataBase.me.addUser(qq, groupId, usname);
}
catch (Exception err)
{
MainHolder.broadcaster.BroadcastToAdminGroup("[Exception]\n这条消息可能意味着机器人发生了错误。它仍在继续运行，但可能不是很稳定。下面的信息用来帮助鸡蛋定位错误，管理不必在意。\n[已入群的处理]" + err.Message + "\n\n堆栈跟踪：\n" + err.StackTrace);
}
return;
}
public virtual Task HandleMessageAsync(IMiraiHttpSession session, IMiraiHttpMessage message)
{
return(base.HandleMessageAsync(client: session, (TMessage)message));
}
