async Task IPostToBot.PostAsync(IActivity activity, CancellationToken token)
{
try
{
await inner.PostAsync(activity, token);
}
catch (Exception ex)
{
trace.WriteLine(ex.Message);
var messageActivity = activity.AsMessageActivity();
if (messageActivity != null)
{
await botToUser.PostAsync(messageProvider.GetMessage("ExceptionMessage"), cancellationToken : token);
await botToUser.PostAsync(messageProvider.GetMessage("WhatMoreCanIDo"), cancellationToken : token);
using (var scope = DialogModule.BeginLifetimeScope(Conversation.Container, messageActivity))
{
var botData = scope.Resolve <IBotData>();
await botData.LoadAsync(default(CancellationToken));
var stack = scope.Resolve <IDialogStack>();
stack.Reset();
botData.ConversationData.Clear();
await botData.FlushAsync(default(CancellationToken));
}
}
}
}
public static string GetMessage(IMessageProvider messages, string messageId, IDictionary <string, object> parameters)
{
string id = messageId;
string result = messages.GetMessage(id);
int splitIndex;
while (result == null && (splitIndex = id.IndexOf('/')) > 0)
{
id = id.Substring(splitIndex + 1);
result = messages.GetMessage(id);
}
return(StringPatternHelper.GetText(result, parameters));
}
public async void Execute()
{
while (true)
{
IssueQueueEntity message = null;
do
{
var channels = await GetChannels();
if (channels.Any())
{
message = await queueProvider.DequeueAsync <IssueQueueEntity>(configurationProvider.GetString("issueQueue"));
if (message != null)
{
await tableStorageProvider.SendToTableAsync("openIssues", message);
foreach (var channel in channels)
{
var messageActivity = Activity.CreateMessageActivity();
messageActivity.Type = ActivityTypes.Message;
messageActivity.Text = string.Format(messageProvider.GetMessage("NewIssue"), message.Text);
await channel.SendToChannel(messageActivity);
}
}
}
} while (message != null);
Thread.Sleep(TimeSpan.FromMinutes(configurationProvider.GetConfiguration <int>("IssuePollInterval")));
}
}
public ActionResult Index()
{
string message = _messageProvider.GetMessage();
ViewData.Add("message", message);
return(View());
}
public void WindowsServiceMsgProvider()
{
messageProvider = new WindowsServiceMsgProvider();
message = messageProvider.GetMessage();
Assert.AreEqual(expectedResult, message);
}
public void StaticValueMsgProvider()
{
messageProvider = new StaticValueMsgProvider();
message = messageProvider.GetMessage();
Assert.AreEqual(expectedResult, message);
}
public void WebAppMsgProvider()
{
messageProvider = new WebAppMsgProvider();
message = messageProvider.GetMessage();
Assert.AreEqual(expectedResult, message);
}
public void ConsoleAppMsgProviderTest()
{
messageProvider = new ConsoleAppMsgProvider();
message = messageProvider.GetMessage();
Assert.AreEqual(expectedResult, message);
}
public void OnGet()
{
// Validate than TypeMessage isn't null or empty
if (!string.IsNullOrWhiteSpace(TypeMessage))
{
// Create Object
Message ms = new Message()
{
Id = UID,
Name = "",
MessageText = TypeMessage
};
// Add message to message List
Messages.Add(ms);
// Serialize Message Object
string msJson = JsonConvert.SerializeObject(ms);
messageProvider.SendMessage(msJson);
}
else
{
var result = messageProvider.GetMessage();
if (result != null)
{
Messages.Add(result);
}
}
}
public async void Execute()
{
while (true)
{
NotificationQueueEntity message = null;
do
{
message = await queueProvider.DequeueAsync <NotificationQueueEntity>(configurationProvider.GetString("notificationsQueue"));
if (message != null)
{
var users = await tableStorageProvider.RetrieveTableAsync <UserEntity>("users");
Parallel.ForEach(users, (user) =>
{
var conversationReference = JsonConvert.DeserializeObject <ConversationReference>(user.ConversationReference);
var client = new ConnectorClient(new Uri(conversationReference.ServiceUrl));
var messageActivity = Activity.CreateMessageActivity();
messageActivity.Conversation = new ConversationAccount(id: conversationReference.Conversation.Id);
messageActivity.Recipient = new ChannelAccount(id: conversationReference.User.Id, name: conversationReference.User.Name);
messageActivity.From = new ChannelAccount(id: conversationReference.Bot.Id, name: conversationReference.Bot.Name);
messageActivity.ChannelId = conversationReference.ChannelId;
messageActivity.Text = string.Format(messageProvider.GetMessage("NewNotification"), message.Text);
client.Conversations.SendToConversation((Activity)messageActivity);
});
}
} while (message != null);
Thread.Sleep(TimeSpan.FromMinutes(configurationProvider.GetConfiguration <int>("NotificationPollInterval")));
}
}
private void HandleSoundMessage(IMessageProvider provider)
{
if (m_sfxPlayer)
{
SoundMessage message = provider.GetMessage <SoundMessage>();
m_sfxPlayer.Play((int)message.sfxId);
}
}
public Task <AddResult> ExecuteAsync(AddCommand command, AddResult previousResult)
{
_logger.Log(LogLevel.Error, _messageProvider.GetMessage());
return(Task.FromResult(new AddResult
{
ValueResultThing = command.ValueOne + command.ValueTwo
}));
}
private void HandleTouchBeganMessage(IMessageProvider provider)
{
TouchBeganMessage message = provider.GetMessage <TouchBeganMessage>();
m_origin = message.touchPosition;
m_time = Time.time;
m_state = SwipeDirection.None;
m_isSwiping = true;
}
/// <summary>
/// Client entry point.
/// </summary>
/// <param name="args">The console arguments.</param>
public static void Main(string[] args)
{
messageProviderService = msgProviderServiceLocator.LocateMessageService(MsgProviderServiceType.StaticValue);
messageWriter = MessageWriter.GetMessageWriter(ConfigurationManager.AppSettings["MessageWriter"]);
var message = messageProviderService.GetMessage();
messageWriter.Write(message);
}
private void HandleTouchBeganMessage(IMessageProvider provider)
{
TouchBeganMessage message = provider.GetMessage <TouchBeganMessage>();
if (!message.isPointerOverUIObject)
{
Vector3 position = UnityHelper.ConvertScreenToWorldPoint(message.touchPosition, Camera.main);
GameContext.ballFactory.CreateBall(position);
GameHelper.PlaySound(SfxId.Touch);
}
}
private void HandleTouchMovedMessage(IMessageProvider provider)
{
if (m_isSwiping)
{
TouchMovedMessage message = provider.GetMessage <TouchMovedMessage>();
if (DetectSwipe(message.touchPosition, message.deltaPosition))
{
m_isSwiping = false;
}
}
}
/// <summary>
/// Main Entry Point
/// </summary>
/// <param name="args"></param>
public static void Main(string[] args)
{
messageProviderService = msgProviderServiceLocator.LocateMessageService(ConfigurationManager.AppSettings["InputType"]);
messageWriter = MessageWriter.GetMessageWriter(ConfigurationManager.AppSettings["OutputType"]);
var message = messageProviderService.GetMessage();
//Console.Write(message);
messageWriter.Write(message);
}
public void WindowsServiceMsgProvider()
{
//arrange
string expectedResult = "Hello Window Service Application";
//act
messageProvider = new WindowsServiceMsgProvider();
message = messageProvider.GetMessage();
//assert
Assert.AreEqual(expectedResult, message);
}
public void StaticValueMsgProvider()
{
//arrange
string expectedResult = "Hello World!! ";
//act
messageProvider = new StaticValueMsgProvider();
message = messageProvider.GetMessage();
//assert
Assert.AreEqual(expectedResult, message);
}
public void MobileAppMsgProvider()
{
//arrange
string expectedResult = "Hello Mobile application";
//act
messageProvider = new MobileAppMsgProvider();
message = messageProvider.GetMessage();
//assert
Assert.AreEqual(expectedResult, message);
}
public Task PublishAsync <TEvent>(TEvent @event)
where TEvent : Event
{
using var channel = connectionProvider.GetConnection().CreateModel();
var exchangeName = nameProvider.GetExchangeName <TEvent>();
channel.ExchangeDeclare(exchangeName, ExchangeType.Fanout);
channel.BasicPublish(exchangeName, string.Empty, null, messageProvider.GetMessage(@event));
channel.Close();
return(Task.CompletedTask);
}
public string GetHeaderMessage() => $"internal-{_messageProvider.GetMessage()}";
public string GetHeaderMessage() => $"public-{_messageProvider.GetMessage()}";
public async void Execute()
{
while (true)
{
MessageEntity message = null;
var channels = await GetChannels();
var runTime = DateTime.UtcNow;
do
{
if (channels.Any())
{
message = await queueProvider.DequeueAsync <MessageEntity>("usertoexpert");
if (message != null)
{
NormalizeQuestion(message);
await tableStorageProvider.SendToTableAsync("unansweredquestions", message);
var eventToSend = new NewQuestionEvent()
{
MessageType = message.MessageType,
Question = message.Question,
OriginalAnswer = message.OriginalAnswer,
QuestionCorrelationId = message.QuestionCorrelationId
};
await eventProvider.SendEventAsync(eventToSend);
try
{
foreach (var channel in channels)
{
var messageActivity = Activity.CreateMessageActivity();
messageActivity.Type = ActivityTypes.Message;
if (message.MessageType == MessageType.NOANSWER)
{
messageActivity.Text = string.Format(messageProvider.GetMessage("PostMessageToExpertsNoAnswer"), message.Question);
var conversationId = await channel.SendToChannel(messageActivity);
eventToSend.ConversationId = conversationId;
await channel.SendToConverstionData(conversationId, messageActivity, new Dictionary <string, string>() { { "question", message.Question } });
}
else
{
var actions = new List <CardAction>();
actions.Add(new CardAction
{
Title = messageProvider.GetMessage("KeepOriginalWrong"),
Type = "imBack",
Value = messageProvider.GetMessage("KeepOriginalWrong"),
});
actions.Add(new CardAction
{
Title = messageProvider.GetMessage("KeepNewWrong"),
Value = messageProvider.GetMessage("KeepNewWrong"),
Type = "imBack"
});
var normalizedQuestion = MessageHelper.NormalizeString(message.Question);
var normalizedMatchingQuestion = MessageHelper.NormalizeString(message.OriginalQuestion);
if (string.Compare(normalizedQuestion, normalizedMatchingQuestion, StringComparison.InvariantCultureIgnoreCase) != 0)
{
actions.Add(new CardAction
{
Title = messageProvider.GetMessage("KeepBothWrong"),
Value = messageProvider.GetMessage("KeepBothWrong"),
Type = "imBack"
});
}
var card = new HeroCard()
{
Text = string.Format(messageProvider.GetMessage("PostMessageToExpertsWrongAnswerCard"), normalizedQuestion, message.OriginalAnswer, normalizedMatchingQuestion),
Buttons = actions
};
messageActivity.Attachments.Add(card.ToAttachment());
var conversationId = await channel.SendToChannel(messageActivity);
eventToSend.ConversationId = conversationId;
await channel.SendToConverstionData(conversationId, messageActivity, new Dictionary <string, string>() {
{ "question", message.Question },
{ "originalQuestion", message.OriginalQuestion },
{ "originalAnswer", message.OriginalAnswer }
});
}
}
}
catch (Exception e)
{
await eventProvider.SendEventAsync(new TechnicalErrorEvent()
{
Exception = JsonConvert.SerializeObject(e),
ChannelId = string.Empty,
ConversationId = string.Empty
});
continue;
}
}
}
} while (message != null && (DateTime.UtcNow - runTime).TotalMinutes < configurationProvider.GetConfiguration <int>("expertBotChannelsPoll"));
Thread.Sleep((int)TimeSpan.FromMinutes(configurationProvider.GetConfiguration <int>("ExpertBotQueuePoll")).TotalMilliseconds);
}
}
public Task Invoke(HttpContext context)
{
context.Response.Headers.Add("X-DEFAULT-HEADER", _messageProvider.GetMessage());
return(_next(context));
}
private async Task LoadInfosAndRolesMenuMessages(IDictionary <DiscordChannelId, ExpectedChannelMessages> expectedChannelMessages)
{
if (!_provideStaticMessages)
{
return;
}
var l = new List <ExpectedChannelMessage>
{
new(await _messageProvider.GetMessage(Constants.MessageNames.FriendOrGuestMenuMessage)),
new(await _messageProvider.GetMessage(Constants.MessageNames.GameInterestMenuMessage))
};
AddFriendOrGuestMenuComponents(l);
expectedChannelMessages[(DiscordChannelId)_dynamicConfiguration.DiscordMapping["InfoAndRolesChannelId"]] = new ExpectedChannelMessages(l);
}
private void HandleDummyMessage(IMessageProvider provider)
{
DummyMessage message = provider.GetMessage <DummyMessage>();
Debug.Log("Dummy Message: " + message.text);
}
public ActionResult About()
{
ViewBag.Message = _messageProvider.GetMessage();
return(View());
}
private void HandleScoreMessage(IMessageProvider provider)
{
ScoreMessage message = provider.GetMessage <ScoreMessage>();
m_score += message.score;
}
/// <summary>
/// Liefert den Text zu einer bestimmten Nachricht.
/// </summary>
/// <param name="messageId">Bezeichner der Nachricht.</param>
/// <returns>Text zu der Nachricht.</returns>
public virtual string GetMessage(string messageId)
{
return(parent.GetMessage(name + "." + messageId));
}
