private async ValueTask <TResult> InvokeEvent <T, TResult>(EventCallBackHandler <T, TResult> handler, T args,
IOneBotApi api, string rawMsg)
where T : System.EventArgs where TResult : BaseEventReturn
{
TResult replay = null;
foreach (var @delegate in handler.GetInvocationList())
{
var func = (EventCallBackHandler <T, TResult>)@delegate;
var code = 0;
try
{
var result = await func(args, api);
if (result == null)
{
continue;
}
replay = result;
code = result.Code;
}
catch (Exception e)
{
_logger.LogError(e, "消息处理出现未知错误：{Msg}", rawMsg);
}
if (code == 1)
{
break;
}
}
return(replay);
}
/// <summary>
/// 事件分发
/// </summary>
/// <param name="messageJson">消息json对象</param>
/// <param name="oneBotApi">客户端链接接口</param>
/// <param name="rawMsg"></param>
internal async ValueTask <object> Adapter(JObject messageJson, IOneBotApi oneBotApi, string rawMsg)
{
var type = GetBaseEventType(messageJson);
try
{
switch (type)
{
//元事件类型
case "meta_event":
await MetaAdapter(messageJson, oneBotApi, rawMsg);
break;
case "message":
return(await MessageAdapter(messageJson, oneBotApi, rawMsg));
default:
_logger.LogWarning("[Event]接收到未知事件[{Msg}]", rawMsg);
break;
}
}
catch (Exception e)
{
_logger.LogError(e, "[Adapter]事件解析出现未知错误：{Msg}", rawMsg);
}
return(null);
}
/// <summary>
/// 消息事件处理和分发
/// </summary>
/// <param name="messageJson">消息</param>
/// <param name="oneBotApi">客户端链接接口</param>
/// <param name="rawMsg"></param>
private async ValueTask <object> MessageAdapter(JObject messageJson, IOneBotApi oneBotApi, string rawMsg)
{
var type = GetMessageType(messageJson);
switch (type)
{
//私聊事件
case "private":
{
var privateMsg = messageJson.ToObject <PrivateMsgEventArgs>();
if (privateMsg != null && OnPrivateMessage != null)
{
return(await InvokeEvent(OnPrivateMessage, privateMsg, oneBotApi, rawMsg));
}
break;
}
//群聊事件
case "group":
{
var groupMsg = messageJson.ToObject <GroupMsgEventArgs>();
if (groupMsg != null && OnGroupMessage != null)
{
return(await InvokeEvent(OnGroupMessage, groupMsg, oneBotApi, rawMsg));
}
break;
}
default:
_logger.LogWarning("[Message Event]接收到未知事件[{MessageEventType}]", type);
break;
}
return(null);
}
/// <summary>
/// 元事件处理和分发
/// </summary>
/// <param name="messageJson">消息</param>
/// <param name="oneBotApi">客户端链接接口</param>
/// <param name="rawMsg"></param>
private async ValueTask MetaAdapter(JObject messageJson, IOneBotApi oneBotApi, string rawMsg)
{
var type = GetMetaEventType(messageJson);
switch (type)
{
//心跳包
case "heartbeat":
{
var heartBeat = messageJson.ToObject <HeartBeatEventArgs>();
if (heartBeat != null && OnHeartBeatEvent != null)
{
await InvokeEvent(OnHeartBeatEvent, heartBeat, oneBotApi, rawMsg);
}
break;
}
//生命周期
case "lifecycle":
{
var lifeCycle = messageJson.ToObject <LifeCycleEventArgs>();
if (lifeCycle != null && OnLifeCycleEvent != null)
{
await InvokeEvent(OnLifeCycleEvent, lifeCycle, oneBotApi, rawMsg);
}
break;
}
default:
_logger.LogWarning("[Meta Event]接收到未知事件[{MetaEventType}]", type);
break;
}
}
private async ValueTask OnConnection(IOneBotApi api)
{
_api = api;
if (!_isStart)
{
foreach (var monitor in _globalService.TwitterSetting.Monitor.Where(monitor => monitor.Value.Enable))
{
if (_manage == null)
{
//_twitterApi = new Lazy<TwitterApi>(() => new TwitterApi(_globalService.HttpClientProxyHandler));
_twitterApi = ActivatorUtilities.CreateInstance <Lazier <TwitterApi> >(_provider);
_manage = ActivatorUtilities.CreateInstance <TweeterMonitorManage>(_provider, _twitterApi);
}
_manage.StartNewMonitor(monitor.Key, CallBack);
}
_isStart = true;
}
}
private async ValueTask <EventResult <BaseMsgQuickOperation> > Handler(BaseMessageEventArgs args, IOneBotApi api)
{
long?groupId = null;
long?userId = null;
if (args is GroupMsgEventArgs groupArgs)
{
groupId = groupArgs.GroupId;
}
else
{
userId = args.UserId;
}
if (args.RawMessage.Equals(_globalService.YandeSetting.HotImg.Command,
StringComparison.CurrentCultureIgnoreCase))
{
var(data, rating) = await _yandeService.Value.GetHotImgAsync(_globalService.YandeSetting.HotImg.Rating);
var replay = CQCode.CQImage("base64://" + Convert.ToBase64String(data));
return(1, replay);
}
foreach (var customTags in _globalService.YandeSetting.CustomTags)
{
if (args.RawMessage.Equals(customTags.Command, StringComparison.CurrentCultureIgnoreCase))
{
var page = await _yandeService.Value.GetTagsPageAsync(customTags.Tag);
for (var i = 0; i < customTags.Count; i++)
{
var _ = Task.Run(async() =>
{
var(data, rating) = await _yandeService.Value.GetImageByTagsAsync(customTags.Tag, page, customTags.Rating);
await api.SendMsg(userId, groupId, new[] { CQCode.CQImage("base64://" + Convert.ToBase64String(data)) });
});
}
return(1);
}
}
return(null);
}
private async ValueTask <EventResult <BaseMsgQuickOperation> > Handler(BaseMessageEventArgs args, IOneBotApi api)
{
if (args.RawMessage.Equals(_globalService.BiliSetting.HotCos.Command,
StringComparison.CurrentCultureIgnoreCase))
{
var result = await BiliApi.GetCosHotAsync();
if (result.Any())
{
_logger.LogDebug("{Command}数量：{Count}", _globalService.BiliSetting.HotCos.Command, result.Length);
var cqCodes = new List <CQCode>();
var tasks = result.Select(url => Task.Run(async() =>
{
try
{
cqCodes.Add(await CQHelper.Image(url, CQFileType.Base64));
}
catch (Exception e)
{
_logger.LogWarning("[SendImage]下载图片失败：{Url}\r\nError: {Error}", e.ToString(), url);
}
}));
await Task.WhenAll(tasks);
return(1, cqCodes.ToArray());
}
}
return(null);
}
private async ValueTask InvokeEvent <T>(EventCallBackHandler <T> handler, T args, IOneBotApi api, string rawMsg)
where T : System.EventArgs
{
foreach (var @delegate in handler.GetInvocationList())
{
var func = (EventCallBackHandler <T>)@delegate;
var code = 0;
try
{
code = await func(args, api);
}
catch (Exception e)
{
_logger.LogError(e, "消息处理出现未知错误：{Msg}", rawMsg);
}
if (code == 1)
{
break;
}
}
}
private async ValueTask <EventResult <GroupMsgQuickOperation> > OnGroupMessage(GroupMsgEventArgs args, IOneBotApi api)
{
return(null);
}
