public void StartService()
{
if (_isRun)
{
return;
}
Task.Run(() =>
{
_isRun = true;
while (_isRun)
{
var parameters = new Dictionary <string, string>();
var result = _httpHelper.GetRequest("msg.getUpdates", parameters);
var data = (JObject)result.Data;
GetUpdates updates;
if (result.Status)
{
updates = data.ToObject <GetUpdates>();
}
else
{
throw new BoopRootException(data?.ToObject <Error>()?.Message, (data?.ToObject <Error>()).Code);
}
if (updates.Messages.Count > 0)
{
NewMessageEvent?.Invoke(updates.Messages);
}
}
});
}
public override async Task OnMessage(string inputMessage, NewMessageEvent eventContext)
{
await Task.Delay(0);
if (eventContext.Muted)
{
return;
}
if (eventContext.Message.SenderId == Profile.Id)
{
return;
}
var replaced = RemoveMentionMe(inputMessage
.Replace("吗", "")
.Replace('？', '！')
.Replace('?', '!'));
if (eventContext.Mentioned)
{
replaced += Mention(eventContext.Message.Sender);
}
await Task.Delay(700);
await SendMessage(replaced, eventContext.ConversationId);
}
public void BindFunction(string trigger, NewMessageEvent func, SyncrParamType paramType = SyncrParamType.VOID, string[] enumTypes = null)
{
if (RegisteredFunctions.ContainsKey(trigger))
{
RegisteredFunctions[trigger] += func;
}
else
{
RegisteredFunctions.Add(trigger, func);
}
string eTypes = "";
if (enumTypes != null)
{
foreach (string s in enumTypes)
{
eTypes += s + " ";
}
}
eTypes = eTypes.Trim();
SendMessage("FUNCTION " + GroupName + " " + ProcName + " " + trigger + " " + paramType.ToString() + " " + eTypes);
}
public async Task OnNewMessageEvent(NewMessageEvent typedEvent)
{
string decrypted = AES.OpenSSLDecrypt(typedEvent.Message.Content, typedEvent.AESKey);
BotLogger.LogInfo($"On message from sender `{typedEvent.Message.Sender.NickName}`: {decrypted}");
await OnMessage(decrypted, typedEvent).ConfigureAwait(false);
}
public async Task NewMessageEvent(KahlaUser receiver, Conversation conversation, string content, KahlaUser sender, bool alert)
{
var token = await _appsContainer.AccessToken();
var channel = receiver.CurrentChannel;
var newMessageEvent = new NewMessageEvent
{
ConversationId = conversation.Id,
Sender = sender,
Content = content,
AESKey = conversation.AESKey,
Muted = !alert
};
var pushTasks = new List <Task>();
if (channel != -1)
{
pushTasks.Add(_stargatePushService.PushMessageAsync(token, channel, _Serialize(newMessageEvent), true));
}
if (alert && receiver.Id != sender.Id)
{
pushTasks.Add(_thirdPartyPushService.PushAsync(receiver.Id, sender.Email, _Serialize(newMessageEvent)));
}
await Task.WhenAll(pushTasks);
}
/// <summary>
/// <inheritdoc cref="IBungieClient.AddListener" />
/// </summary>
/// <param name="eventHandler"></param>
public void AddListener(NewMessageEvent eventHandler)
{
if (_logListener is not null)
{
_logListener.OnNewMessage += eventHandler;
}
}
public void Fire(string _text)
{
if (NewMessageEvent != null)
{
NewMessageEvent.Invoke(_text);
}
}
public async Task <IActionResult> PushTestMessage()
{
var user = await GetKahlaUser();
await _dbContext.Entry(user)
.Collection(b => b.HisDevices)
.LoadAsync();
var messageEvent = new NewMessageEvent
{
Message = new Message
{
ConversationId = -1,
Sender = new KahlaUser
{
IconFilePath = "kahla-user-icon/logo.png",
NickName = "Aiursoft Push System",
},
SenderId = "<Example user>",
Content = "U2FsdGVkX1+6kWGFqiSsjuPWX2iS7occQbqXm+PCNDLleTdk5p2UVQgQpu8J4XAYSpz/NT6N5mJMUQIUrNt6Ow==",
SendTime = DateTime.UtcNow,
},
AESKey = "37316f609ebc4e79bd7812a5f2ab37b8",
Muted = false,
Mentioned = false
};
var token = await _appsContainer.AccessToken();
_cannonService.FireAsync <ThirdPartyPushService>(s => s.PushAsync(user.HisDevices, messageEvent));
_cannonService.FireAsync <PushMessageService>(s => s.PushMessageAsync(token, user.CurrentChannel, messageEvent));
return(this.Protocol(ErrorType.Success, "Successfully sent you a test message to all your devices."));
}
public override async Task OnMessage(string inputMessage, NewMessageEvent eventContext)
{
if (eventContext.Message.SenderId != Profile.Id)
{
await SendMessage("Copy.", eventContext.ConversationId, eventContext.AESKey);
}
}
public async Task <IActionResult> PushTestMessage()
{
var user = await GetKahlaUser();
var messageEvent = new NewMessageEvent
{
ConversationId = -1,
Sender = new KahlaUser
{
HeadImgFileKey = 4251,
NickName = "Aiursoft Push System",
},
// This is a test message sent by Aiursoft.
Content = "U2FsdGVkX1+6kWGFqiSsjuPWX2iS7occQbqXm+PCNDLleTdk5p2UVQgQpu8J4XAYSpz/NT6N5mJMUQIUrNt6Ow==",
AESKey = "37316f609ebc4e79bd7812a5f2ab37b8",
Muted = false
};
var payload = JsonConvert.SerializeObject(messageEvent, Formatting.Indented, new JsonSerializerSettings
{
ContractResolver = new CamelCasePropertyNamesContractResolver()
});
await _thirdPartyPushService.PushAsync(user.Id, "*****@*****.**", payload);
return(this.Protocol(ErrorType.Success, "Successfully sent you a test message to all your devices."));
}
public override async Task OnMessage(string inputMessage, NewMessageEvent eventContext)
{
await Task.Delay(0);
if (eventContext.Muted)
{
return;
}
if (eventContext.Message.SenderId == Profile.Id)
{
return;
}
var replaced = inputMessage
.Replace("吗", "")
.Replace('？', '！')
.Replace('?', '!');
if (eventContext.Mentioned)
{
replaced += $" @{eventContext.Message.Sender.NickName.Replace(" ", "")}";
}
replaced.Replace($"@{Profile.NickName.Replace(" ", "")}", "");
await Task.Delay(700);
await SendMessage(replaced, eventContext.Message.ConversationId, eventContext.AESKey);
}
public async Task<IActionResult> PushTestMessage()
{
var user = await GetKahlaUser();
_dbContext.Entry(user)
.Collection(b => b.HisDevices)
.Load();
var messageEvent = new NewMessageEvent
{
Message = new Message
{
ConversationId = -1,
Sender = new KahlaUser
{
IconFilePath = "kahla-user-icon/logo.png",
NickName = "Aiursoft Push System",
},
SenderId = "<Example user>",
Content = "U2FsdGVkX1+6kWGFqiSsjuPWX2iS7occQbqXm+PCNDLleTdk5p2UVQgQpu8J4XAYSpz/NT6N5mJMUQIUrNt6Ow==",
SendTime = DateTime.UtcNow,
},
AESKey = "37316f609ebc4e79bd7812a5f2ab37b8",
Muted = false,
Mentioned = false
};
var payload = JsonConvert.SerializeObject(messageEvent, Formatting.Indented, new JsonSerializerSettings
{
ContractResolver = new CamelCasePropertyNamesContractResolver()
});
var token = await _appsContainer.AccessToken();
await _thirdPartyPushService.PushAsync(user.HisDevices, "*****@*****.**", payload);
await _stargatePushService.PushMessageAsync(token, user.CurrentChannel, payload);
return this.Protocol(ErrorType.Success, "Successfully sent you a test message to all your devices.");
}
public async Task NewMessageEvent(ApplicationUser reciever, Conversation conversation, string content, ApplicationUser sender, bool alert)
{
var token = await _appsContainer.AccessToken();
var channel = reciever.CurrentChannel;
var newEvent = new NewMessageEvent
{
Type = EventType.NewMessage,
ConversationId = conversation.Id,
Sender = sender,
Content = content,
AESKey = conversation.AESKey,
Muted = !alert,
SentByMe = reciever.Id == sender.Id
};
if (channel != -1)
{
await _stargatePushService.PushMessageAsync(token, channel, _Serialize(newEvent), true);
}
if (alert)
{
await _thirdPartyPushService.PushAsync(reciever.Id, sender.Email, _Serialize(newEvent));
}
}
public Task HandleAsync(NewMessageEvent @event, CancellationToken token = default)
{
this.Logger.Information(
"New Message {MessageFile} Arrived -- Running Rules",
@event.NewMessage);
Task.Run(
async() =>
{
try
{
await Task.Delay(2000, this._cancellationTokenSource.Token);
await this._rulesRunner.RunAsync(
this.Rules.ToArray(),
@event.NewMessage,
this._cancellationTokenSource.Token);
}
catch (ObjectDisposedException)
{
}
catch (TaskCanceledException)
{
}
catch (Exception ex)
{
Log.Error(ex, "Failure Running Rules");
}
},
this._cancellationTokenSource.Token);
return(Task.CompletedTask);
}
public void OnNext(LogEvent value)
{
string message = value.RenderMessage();
string formatted = value.Level + ": " + message;
NewMessageEvent?.Invoke(value.Level, formatted);
}
public override async Task OnGroupInvitation(int groupId, NewMessageEvent eventContext)
{
var group = await GroupsService.GroupSummaryAsync(groupId);
if (!group.Value.HasPassword)
{
await JoinGroup(group.Value.Name, string.Empty);
}
}
protected virtual async Task OnNewMessageEvent(NewMessageEvent typedEvent)
{
string decrypted = _aes.OpenSSLDecrypt(typedEvent.Message.Content, typedEvent.AESKey);
_botLogger.LogInfo($"On message from sender `{typedEvent.Message.Sender.NickName}`: {decrypted}");
if (decrypted.StartsWith("[group]") && int.TryParse(decrypted.Substring(7), out int groupId))
{
await BuildBot.OnGroupInvitation(groupId, typedEvent);
}
await BuildBot.OnMessage(decrypted, typedEvent).ConfigureAwait(false);
}
public void BindFunction(string trigger, NewMessageEvent func)
{
if (RegisteredFunctions.ContainsKey(trigger))
{
RegisteredFunctions[trigger] += func;
}
else
{
RegisteredFunctions.Add(trigger, func);
}
}
public void Handle(NewMessageEvent @event)
{
_logger.Information(
"New Message {MessageFile} Arrived -- Running Rules",
@event.NewMessage);
Task.Factory.StartNew(
() =>
{
Thread.Sleep(2000);
_rulesRunner.Run(Rules.ToArray(), @event.NewMessage);
});
}
public void MessageProcessor(object sender, MessageEventArgs e)
{
if (!_isStarted)
{
return;
}
var model = new Message();
model.Platform = Enums.MessengerPlatform.Telegam;
model.MessageTG = e.Message;
model.ChatId = e.Message.Chat.Id;
model.Text = e.Message.Text;
NewMessageEvent.Invoke(model);
}
public void Handle(NewMessageEvent @event)
{
_logger.Information(
"New Message {MessageFile} Arrived -- Running Rules",
@event.NewMessage);
Task.Factory.StartNew(
async() =>
{
await Task.Delay(2000);
this._rulesRunner.Run(this.Rules.ToArray(), @event.NewMessage);
});
}
public Task <string> Handle(NewMessageCommand request, CancellationToken cancellationToken)
{
var @event = new NewMessageEvent(
request.From,
request.To,
request.Message,
request.ActionUrl
);
var result = _manager.HandleEvent(@event).FirstOrDefault();
return(Task.FromResult(
result?.ProcessInstanceId.ToString()
));
}
public override async Task OnMessage(string inputMessage, NewMessageEvent eventContext)
{
if (eventContext.Muted)
{
return;
}
if (eventContext.Message.SenderId == Profile.Id)
{
return;
}
inputMessage = inputMessage.Replace($"@{Profile.NickName.Replace(" ", "")}", "");
var translated = _bingTranslator.CallTranslate(inputMessage, "en");
await SendMessage(translated, eventContext.Message.ConversationId, eventContext.AESKey);
}
/// <summary>
/// 接收数据的回调函数
/// </summary>
/// <param name="ar"></param>
private void PipeReadCallback(IAsyncResult ar)
{
this.NamedPipeClientStream = (NamedPipeClientStream)ar.AsyncState;
var count = this.NamedPipeClientStream.EndRead(ar);
if (count > 0)
{
string message = encoding.GetString(data, 0, count);
NewMessageEvent?.Invoke(message); //简化调用方式 等同于if(NewMessageEvent != Null) {NewMessageEvent(message)}
this.NamedPipeClientStream.BeginRead(data, 0, data.Length, new AsyncCallback(PipeReadCallback), this.NamedPipeClientStream);
}
else if (count == 0)
{
ConnectFailEvent?.Invoke();
}
}
private async Task OnNewMessageEvent(NewMessageEvent typedEvent)
{
string decrypted = _aes.OpenSSLDecrypt(typedEvent.Message.Content, typedEvent.AESKey);
_botLogger.LogInfo($"On message from sender `{typedEvent.Message.Sender.NickName}`: {decrypted}");
string sendBack = await _bot.OnMessage(decrypted, typedEvent);
if (!string.IsNullOrWhiteSpace(sendBack))
{
await Task.Run(async() =>
{
await Task.Delay(700);
var encrypted = _aes.OpenSSLEncrypt(sendBack, typedEvent.AESKey);
await _conversationService.SendMessageAsync(encrypted, typedEvent.Message.ConversationId);
}).ConfigureAwait(false);
}
}
public void MapNewMessageEvent()
{
var message = new ChatMessage
{
ChatroomId = 2,
SenderId = 1,
TimeUnixMs = DateTimeOffset.Now.ToUnixTimeMilliseconds(),
Content = new Content {
Text = "Hello!"
}
};
var e = new NewMessageEvent {
ChatroomId = 2, OperatorId = 1, Message = message
};
var m = ChatroomEventMapper.Map(e);
Assert.Equal(message, m);
}
private void GetPendingMessages()
{
FlattiverseMessage message;
bool messagesReceived = false;
messageLock.AcquireWriterLock(100);
while (_connector.NextMessage(out message))
{
_messages.Add(message);
messagesReceived = true;
}
messageLock.ReleaseWriterLock();
if (messagesReceived)
{
NewMessageEvent?.Invoke();
}
}
public override async Task OnMessage(string inputMessage, NewMessageEvent eventContext)
{
if (eventContext.Muted)
{
return;
}
if (eventContext.Message.SenderId == Profile.Id)
{
return;
}
inputMessage = RemoveMentionMe(inputMessage);
var translated = _bingTranslator.CallTranslate(inputMessage, "en");
if (eventContext.Mentioned)
{
translated += Mention(eventContext.Message.Sender);
}
await SendMessage(translated, eventContext.ConversationId);
}
private void HandleNewMessageSavedEvent(NewMessageEvent obj)
{
lock (this)
{
MessageModel task = obj.Message as MessageModel;
if (task != null)
{
DispatcherHelper.InvokeOnUiThread(() =>
{
MessageModel m = DataSync.Instance.GetMessageFromClientId(task.ClientMessageId);
if (m != null)
{
m.LoadTaskList();
this.AddTask(m);
}
});
}
}
}
public async Task NewMessageEvent(string recieverId, int conversationId, string Content, KahlaUser sender)
{
var token = AppsContainer.AccessToken();
var user = await _dbContext.Users.FindAsync(recieverId);
var channel = user.CurrentChannel;
var nevent = new NewMessageEvent
{
Type = EventType.NewMessage,
ConversationId = conversationId,
Sender = sender,
Content = Content
};
if (channel != -1)
{
await _pushMessageService.PushMessageAsync(await token(), channel, _CammalSer(nevent), true);
}
}
