public async Task InteractRoute(object sender, ReceivedMessageArgs e)
{
// check user eligibility
if (!Conf.CheckUserEligibility(e))
{
return;
}
Bridge.ALog("规则检查通过，正在朗读用户交互事件");
string result;
switch (e.Message.MsgType)
{
case MsgTypeEnum.UserEnter:
result = ProcessInteract(e.Message, Vars.CurrentConf.OnInteractEnter);
break;
case MsgTypeEnum.LiveShare:
result = ProcessInteract(e.Message, Vars.CurrentConf.OnInteractShare);
break;
default: return;
}
await TTSPlayer.UnifiedPlay(result);
}
private DomainMessagesHandlerBase GetHandler(ReceivedMessageArgs messageObject)
{
if (TransactionMessagesHandler.Actions.Contains(messageObject.Action))
{
return(_transactionHanlder);
}
switch (messageObject.Topic)
{
case Topics.Users:
return(_usersMessagesHandler);
case Topics.Projects:
return(_projectsMessageHandler);
case Topics.ProjectMembers:
return(_projectMembersMessageHandler);
case Topics.Labels:
return(_labelsMessageHandler);
case Topics.Lists:
return(_listsMessageHandler);
default:
throw new NotFoundException($"Topic {messageObject.Topic} is not known");
}
}
private async void Received(object sender, ReceivedMessageArgs e)
{
Interlocked.Increment(ref m_processing);
var body = e.Body;
var json = await DecompressAsync(body);
var jo = JObject.Parse(json);
var entities = jo.SelectToken("$.attached").Select(t => t.ToString().DeserializeFromJson <Entity>()).ToList();
try
{
var tasks = from xc in entities.Where(x => null != x)
let type = xc.GetType()
where !ExcludeTypes.Contains(type.Name)
select ProcessMessageAsync(xc);
await Task.WhenAll(tasks);
m_channel.BasicAck(e.DeliveryTag, false);
}
catch (Exception exc)
{
this.WriteMessage("Error in {0}", this.GetType().Name);
this.WriteError(exc);
m_channel.BasicReject(e.DeliveryTag, false);
}
finally
{
Interlocked.Decrement(ref m_processing);
}
}
public async Task GiftRoute(object sender, ReceivedMessageArgs e)
{
// check user eligibility
if (!Conf.CheckUserEligibility(e))
{
return;
}
// check gift eligibility
if (!Conf.CheckGiftEligibility(e))
{
return;
}
Bridge.ALog("规则检查通过，准备朗读");
if (Vars.CurrentConf.VoiceReplyFirst)
{
var hitAnyRule = await TTSPlayer.PlayVoiceReply(e.Message);
if (!hitAnyRule || !Vars.CurrentConf.IgnoreIfHitVoiceReply)
{
await TTSPlayer.UnifiedPlay(ProcessGift(e));
}
}
else
{
var hitAnyRule = Vars.CurrentConf.VoiceReplyRules.Any(x => x.Matches(e.Message));
if (!hitAnyRule || !Vars.CurrentConf.IgnoreIfHitVoiceReply)
{
await TTSPlayer.UnifiedPlay(ProcessGift(e));
}
await TTSPlayer.PlayVoiceReply(e.Message);
}
}
public static bool CheckKeywordEligibility(ReceivedMessageArgs e)
{
if (!CheckKeywordEligibility(e.Message.CommentText))
{
Bridge.ALog("忽略：弹幕已命中屏蔽规则");
return(false);
}
return(true);
}
public static bool CheckGiftEligibility(ReceivedMessageArgs e)
{
if (!CheckGiftEligibility(e.Message.GiftName))
{
Bridge.ALog("忽略：礼物已命中屏蔽规则");
return(false);
}
return(true);
}
private void HandleUserMessage(ReceivedMessageArgs messageObject)
{
Console.WriteLine($"User message received");
switch (messageObject.Action)
{
case MessageActions.Created:
case MessageActions.Updated:
var message = JsonConvert.DeserializeObject <UserCreatedUpdatedMessage>(messageObject.Message);
var model = _mapper.Map <UserCreatedUpdatedMessage, UserModel>(message);
using (var scope = _serviceProvider.CreateScope())
{
var requestsRepository = scope.ServiceProvider.GetRequiredService <RequestsRepository>();
var usersRepository = scope.ServiceProvider.GetRequiredService <UsersRepository>();
if (!requestsRepository.IsHandledOrSaveRequestAsync(message.Id, GetRequestIdInvalidationDate()).GetAwaiter().GetResult())
{
try
{
usersRepository.CreateOrUpdateUserAsync(model).GetAwaiter().GetResult();
}
catch (Exception)
{
requestsRepository.DeleteRequestIdAsync(message.Id).GetAwaiter().GetResult();
throw;
}
}
else
{
Console.WriteLine($"Already handled: {message.Id}");
}
}
// PerformSafetyOnBgThread(async () =>
// {
// using(var scope = _serviceProvider.CreateScope())
// {
// var requestsRepository = scope.ServiceProvider.GetRequiredService<RequestsRepository>();
// var usersRepository = scope.ServiceProvider.GetRequiredService<UsersRepository>();
// if(!await requestsRepository.IsHandledOrSaveRequestAsync(message.Id, GetRequestIdInvalidationDate()))
// {
// await usersRepository.CreateOrUpdateUserAsync(model);
// }
// else
// {
// Console.WriteLine($"Already handled: {message.Id}");
// }
// }
// }, messageObject, TaskScheduler.FromCurrentSynchronizationContext());
break;
case MessageActions.Deleted:
//do nothing for now...
break;
default:
throw new NotFoundException($"Topic {messageObject.Topic} is not known");
}
}
private void HandleTasksMessage(ReceivedMessageArgs messageObject)
{
Console.WriteLine($"Tasks message received");
switch (messageObject.Action)
{
case MessageActions.Created:
case MessageActions.Updated:
TaskModel model = default(TaskModel);
BaseMessage baseMessage;
if (messageObject.Action == MessageActions.Created)
{
var message = JsonConvert.DeserializeObject <TaskCreatedMessage>(messageObject.Message);
baseMessage = message;
model = _mapper.Map <TaskCreatedMessage, TaskModel>(message);
}
else
{
var message = JsonConvert.DeserializeObject <TaskCreatedMessage>(messageObject.Message);
baseMessage = message;
model = _mapper.Map <TaskCreatedMessage, TaskModel>(message);
}
using (var scope = _serviceProvider.CreateScope())
{
var requestsRepository = scope.ServiceProvider.GetRequiredService <RequestsRepository>();
var projectsRepository = scope.ServiceProvider.GetRequiredService <TasksRepository>();
if (!requestsRepository.IsHandledOrSaveRequestAsync(baseMessage.Id, GetRequestIdInvalidationDate()).GetAwaiter().GetResult())
{
try
{
projectsRepository.CreateOrUpdateTaskAsync(model).GetAwaiter().GetResult();
}
catch (Exception)
{
requestsRepository.DeleteRequestIdAsync(baseMessage.Id).GetAwaiter().GetResult();
throw;
}
}
else
{
Console.WriteLine($"Already handled: {baseMessage.Id}");
}
}
break;
case MessageActions.Deleted:
//do nothing for now...
break;
default:
throw new NotFoundException($"Action {messageObject.Action} is not known");
}
}
public async void OnReceivedDanmaku(object sender, ReceivedMessageArgs e)
{
if (!IsNAudioReady)
{
return;
}
switch (e.Message.MsgType)
{
case MsgTypeEnum.Comment:
await CommentRoute(sender, e);
break;
case MsgTypeEnum.GiftSend:
if (Vars.CurrentConf.GiftsThrottle)
{
ALog($"礼物合并已启用，正在合并礼物: 来自 {e.Message.UserName} ({e.Message.UserID}) 的 {e.Message.GiftCount} 个 {e.Message.GiftName}");
Vars.Debouncer.Add(new UserGift
(
e.Message.UserName,
e.Message.UserID,
e.Message.GiftName,
e.Message.GiftCount
));
}
else
{
await GiftRoute(sender, e);
}
break;
case MsgTypeEnum.LiveStatusToggle:
if (e.Message.LiveStatus == 1)
{
await LiveStartRoute(sender, e);
}
else if (e.Message.LiveStatus == 0)
{
await LiveEndRoute(sender, e);
}
break;
case MsgTypeEnum.UserEnter:
await InteractRoute(sender, e);
break;
case MsgTypeEnum.LiveShare:
await InteractRoute(sender, e);
break;
}
}
protected override void OnMessageReceived(ReceivedMessageArgs messageObject)
{
switch (messageObject.Topic)
{
case Topics.Projects:
HandleProjectMessage(messageObject);
break;
default:
throw new NotFoundException($"Topic {messageObject.Topic} is not known");
}
}
private async void GiftDebouncedEvent(object sender, UserGift e)
{
ALog($"合并礼物: 来自 {e.User} ({e.UserId}) 的 {e.Qty} 个 {e.Gift}，直接路由到礼物路线...");
var constructedArgs = new ReceivedMessageArgs();
constructedArgs.Message = new MessageModel();
constructedArgs.Message.GiftName = e.Gift;
constructedArgs.Message.GiftCount = e.Qty;
constructedArgs.Message.UserName = e.User;
constructedArgs.Message.UserID = e.UserId;
constructedArgs.Message.MsgType = MsgTypeEnum.GiftSend;
await GiftRoute(null, constructedArgs);
}
private void HandleTaskMesasge(ReceivedMessageArgs messageObject)
{
Console.WriteLine($"Tasks message received");
switch (messageObject.Action)
{
case TransactionMessageActions.MoveTask_MoveMembersRequested:
case TransactionMessageActions.MoveTask_Complete:
case TransactionMessageActions.MoveTask_Rollback:
Console.WriteLine("Move task transaction message");
using (var scope = _serviceProvider.CreateScope())
{
var handler = scope.ServiceProvider.GetRequiredService <MoveTaskTransactionHandler>();
string result = handler.HandleMessageAsync(messageObject).GetAwaiter().GetResult();
Console.WriteLine(result);
}
break;
}
}
private DomainMessagesHandlerBase GetHandler(ReceivedMessageArgs messageObject)
{
switch (messageObject.Topic)
{
case Topics.Projects:
return(_projectsMessageHandler);
case Topics.ProjectMembers:
return(_projectMembersMessageHandler);
case Topics.Labels:
return(_labelsMessageHandler);
case Topics.Tasks:
return(_tasksMessageHandler);
default:
throw new NotFoundException($"Topic {messageObject.Topic} is not known");
}
}
public static bool CheckUserEligibility(ReceivedMessageArgs e)
{
if (Vars.CurrentConf.BlockUID)
{
if (!CheckUserEligibility(e.Message.UserID.ToString()))
{
Bridge.ALog("忽略：用户已命中 UID 规则");
return(false);
}
}
else
{
if (!CheckUserEligibility(e.Message.UserName))
{
Bridge.ALog("忽略：用户已命中用户名规则");
return(false);
}
}
return(true);
}
private void MsgQueueMgr_Received(object sender, ReceivedMessageArgs args)
{
switch (args.Message())
{
case HelperLib.NotifMessages.NOTIF_STOP:
Globals.WriteToDebugFile("TaskMonitor: Received shutdown notification");
_shutdown = true;
_resetEvent.Set();
break;
case HelperLib.NotifMessages.NOTIF_SCAN:
Globals.WriteToDebugFile("TaskMonitor: Received rescan notification");
if (!_initDone)
{
Globals.WriteToDebugFile("TaskMonitor: Skiping rescan"); return;
}
LoadTasks();
_resetEvent.Set();
break;
}
}
private void HandleProjectMessage(ReceivedMessageArgs messageObject)
{
Console.WriteLine($"Project message received");
switch (messageObject.Action)
{
case MessageActions.Created:
case MessageActions.Updated:
var message = JsonConvert.DeserializeObject <ProjectCreatedUpdatedMessage>(messageObject.Message);
var model = _mapper.Map <ProjectCreatedUpdatedMessage, ProjectModel>(message);
using (var scope = _serviceProvider.CreateScope())
{
var requestsRepository = scope.ServiceProvider.GetRequiredService <RequestsRepository>();
var projectsRepository = scope.ServiceProvider.GetRequiredService <ProjectsRepository>();
if (!requestsRepository.IsHandledOrSaveRequestAsync(message.Id, GetRequestIdInvalidationDate()).GetAwaiter().GetResult())
{
try
{
projectsRepository.CreateOrUpdateProjectAsync(model).GetAwaiter().GetResult();
}
catch (Exception)
{
requestsRepository.DeleteRequestIdAsync(message.Id).GetAwaiter().GetResult();
throw;
}
}
else
{
Console.WriteLine($"Already handled: {message.Id}");
}
}
break;
case MessageActions.Deleted:
//do nothing for now...
break;
}
}
private void Class1_ReceivedMessage(object sender, ReceivedMessageArgs e)
{
string Info;
string Roomid = RoomId.ToString();
switch (e.Message.MsgType)
{
case MsgTypeEnum.LiveStatusToggle:
{
if (e.Message.LiveStatus == 1)
{
Log(Roomid + "已开播");
}
else if (e.Message.LiveStatus == 0)
{
Log(Roomid + "已下播");
}
break;
}
case MsgTypeEnum.Comment:
{
if (Settings.DanmuLog)
{
Info = "【弹幕】" + DateTime.Now.ToString("HH:mm:ss.fff") + " : " + e.Message.UserName + " 说：" + e.Message.CommentText;
Output("Log", Info, Roomid);
}
else
{
Info = "{\"TimeStamp\":\"" + DateTime.Now.ToString("HH:mm:ss.fff") + "\", \"Uname\":\"" + e.Message.UserName + "\", \"Comment\":\"" + e.Message.CommentText + "\", \"Type\":\"弹幕\", \"SCTime\":0}";
Output("Data", Info, Roomid);
}
break;
}
}
}
public async Task LiveStartRoute(object sender, ReceivedMessageArgs e)
{
await TTSPlayer.UnifiedPlay(Vars.CurrentConf.OnLiveStart, true);
}
public static string ProcessDanmaku(ReceivedMessageArgs e) => ProcessDanmaku(e.Message);
public static bool CheckDanmakuLength(ReceivedMessageArgs e)
{
return(CheckDanmakuLength(e.Message.CommentText));
}
public static string ProcessDanmaku(ReceivedMessageArgs e, string template) => ProcessDanmaku(e.Message, template);
private void HandleTasksMessage(ReceivedMessageArgs messageObject)
{
Console.WriteLine($"Tasks message received");
switch (messageObject.Action)
{
case MessageActions.Created:
case MessageActions.Updated:
TaskModel model = default(TaskModel);
BaseMessage baseMessage;
if (messageObject.Action == MessageActions.Created)
{
var message = JsonConvert.DeserializeObject <TaskCreatedMessage>(messageObject.Message);
baseMessage = message;
model = _mapper.Map <TaskCreatedMessage, TaskModel>(message);
}
else
{
var message = JsonConvert.DeserializeObject <TaskCreatedMessage>(messageObject.Message);
baseMessage = message;
model = _mapper.Map <TaskCreatedMessage, TaskModel>(message);
}
using (var scope = _serviceProvider.CreateScope())
{
var requestsRepository = scope.ServiceProvider.GetRequiredService <RequestsRepository>();
var projectsRepository = scope.ServiceProvider.GetRequiredService <TasksRepository>();
if (!requestsRepository.IsHandledOrSaveRequestAsync(baseMessage.Id, GetRequestIdInvalidationDate()).GetAwaiter().GetResult())
{
try
{
projectsRepository.CreateOrUpdateTaskAsync(model).GetAwaiter().GetResult();
}
catch (Exception)
{
requestsRepository.DeleteRequestIdAsync(baseMessage.Id).GetAwaiter().GetResult();
throw;
}
}
else
{
Console.WriteLine($"Already handled: {baseMessage.Id}");
}
}
break;
case MessageActions.Deleted:
//do nothing for now...
break;
case TransactionMessageActions.MoveTask_HandleHoursRequested:
case TransactionMessageActions.MoveTask_Complete:
case TransactionMessageActions.MoveTask_Rollback:
Console.WriteLine("Move task transaction message");
using (var scope = _serviceProvider.CreateScope())
{
var handler = scope.ServiceProvider.GetRequiredService <MoveTaskTransactionHandler>();
string result = handler.HandleMessageAsync(messageObject).GetAwaiter().GetResult();
Console.WriteLine(result);
}
break;
}
}
public static string Preprocess(string format, ReceivedMessageArgs e) => Preprocess(format, e.Message);
public static string ProcessGift(ReceivedMessageArgs e) => ProcessGift(e.Message, Vars.CurrentConf.OnGift);
public static string ProcessGift(ReceivedMessageArgs e, string template) => ProcessGift(e.Message, template);
protected override void OnMessageReceived(ReceivedMessageArgs messageObject)
{
GetHandler(messageObject)
.HandleMessage(messageObject);
}
