// Handle message activity in 1:1 chat
private async Task OnMessageActivityInPersonalChatAsync(IMessageActivity message, ITurnContext <IMessageActivity> turnContext, CancellationToken cancellationToken)
{
if (!string.IsNullOrEmpty(message.ReplyToId) && (message.Value != null) && ((JObject)message.Value).HasValues)
{
this.telemetryClient.TrackTrace("Card submit in 1:1 chat");
await this.OnAdaptiveCardSubmitInPersonalChatAsync(message, turnContext, cancellationToken);
return;
}
string text = (message.Text ?? string.Empty).Trim().ToLower();
switch (text)
{
case AskAnExpert:
this.telemetryClient.TrackTrace("Sending user ask an expert card");
await turnContext.SendActivityAsync(MessageFactory.Attachment(AskAnExpertCard.GetCard()));
break;
case ShareFeedback:
this.telemetryClient.TrackTrace("Sending user feedback card");
await turnContext.SendActivityAsync(MessageFactory.Attachment(ShareFeedbackCard.GetCard()));
break;
case TakeATour:
this.telemetryClient.TrackTrace("Sending user tour card");
var userTourCards = TourCarousel.GetUserTourCards(this.appBaseUri);
await turnContext.SendActivityAsync(MessageFactory.Carousel(userTourCards));
break;
default:
this.telemetryClient.TrackTrace("Sending input to QnAMaker");
var queryResult = await this.GetAnswerFromQnAMakerAsync(text, turnContext, cancellationToken);
if (queryResult != null)
{
string answer = this.ReplaceWildCard(message, turnContext, queryResult.Answer);
await turnContext.SendActivityAsync(MessageFactory.Attachment(ResponseCard.GetCard(queryResult.Questions[0], answer, queryResult.Source, text)));
}
else
{
await turnContext.SendActivityAsync(MessageFactory.Attachment(UnrecognizedInputCard.GetCard(text)));
}
// Save conversation
var saveConversations = await this.configurationProvider.GetSavedEntityDetailAsync(ConfigurationEntityTypes.SaveConversations);
if (bool.Parse(saveConversations))
{
var userDetails = await this.GetUserDetailsInPersonalChatAsync(turnContext, cancellationToken);
ConversationEntity newConversation = await this.CreateConversationAsync(message, queryResult, userDetails);
}
break;
}
}
/// <summary>
/// Helps to get the expert submit card.
/// </summary>
/// <param name="message">A message in a conversation.</param>
/// <param name="turnContext">Context object containing information cached for a single turn of conversation with a user.</param>
/// <param name="cancellationToken">Propagates notification that operations should be canceled.</param>
/// <returns>A task that represents the work queued to execute.</returns>
public static async Task <Attachment> ShareFeedbackSubmitText(
IMessageActivity message,
ITurnContext <IMessageActivity> turnContext,
CancellationToken cancellationToken)
{
var shareFeedbackSubmitTextPayload = ((JObject)message.Value).ToObject <ShareFeedbackCardPayload>();
// Validate required fields.
if (!Enum.TryParse(shareFeedbackSubmitTextPayload?.Rating, out FeedbackRating rating))
{
var updateCardActivity = new Activity(ActivityTypes.Message)
{
Id = turnContext.Activity.ReplyToId,
Conversation = turnContext.Activity.Conversation,
Attachments = new List <Attachment> {
ShareFeedbackCard.GetCard(shareFeedbackSubmitTextPayload)
},
};
await turnContext.UpdateActivityAsync(updateCardActivity, cancellationToken).ConfigureAwait(false);
return(null);
}
var teamsUserDetails = await GetUserDetailsInPersonalChatAsync(turnContext, cancellationToken).ConfigureAwait(false);
return(SmeFeedbackCard.GetCard(shareFeedbackSubmitTextPayload, teamsUserDetails, message?.LocalTimestamp));
}
// Handle message activity in 1:1 chat
private async Task OnMessageActivityInPersonalChatAsync(IMessageActivity message, ITurnContext <IMessageActivity> turnContext, CancellationToken cancellationToken)
{
if (!string.IsNullOrEmpty(message.ReplyToId) && (message.Value != null) && ((JObject)message.Value).HasValues)
{
this.telemetryClient.TrackTrace("Card submit in 1:1 chat");
await this.OnAdaptiveCardSubmitInPersonalChatAsync(message, turnContext, cancellationToken);
return;
}
string text = (message.Text ?? string.Empty).Trim().ToLower();
if (text.Equals(Resource.ResourceManager.GetString("AskAnExpertDisplayText", CultureInfo.CurrentCulture), StringComparison.InvariantCultureIgnoreCase))
{
this.telemetryClient.TrackTrace("Sending user ask an expert card");
await turnContext.SendActivityAsync(MessageFactory.Attachment(AskAnExpertCard.GetCard()));
}
else if (text.Equals(Resource.ResourceManager.GetString("ShareFeedbackDisplayText", CultureInfo.CurrentCulture), StringComparison.InvariantCultureIgnoreCase))
{
this.telemetryClient.TrackTrace("Sending user feedback card");
await turnContext.SendActivityAsync(MessageFactory.Attachment(ShareFeedbackCard.GetCard()));
}
else if (text.Equals(Resource.ResourceManager.GetString("TakeATourButtonText", CultureInfo.CurrentCulture), StringComparison.InvariantCultureIgnoreCase))
{
this.telemetryClient.TrackTrace("Sending user tour card");
var userTourCards = TourCarousel.GetUserTourCards(this.appBaseUri);
await turnContext.SendActivityAsync(MessageFactory.Carousel(userTourCards));
}
else
{
this.telemetryClient.TrackTrace("Sending input to QnAMaker");
var queryResult = await this.GetAnswerFromQnAMakerAsync(text, turnContext, cancellationToken);
if (queryResult != null)
{
this.telemetryClient.TrackTrace("Sending user QnAMaker card");
await turnContext.SendActivityAsync(MessageFactory.Attachment(ResponseCard.GetCard(queryResult.Questions[0], queryResult.Answer, text)));
}
else
{
var tileList = await this.MatchTagsWithMessageAsync(text);
if (tileList != null)
{
this.telemetryClient.TrackTrace("Sending user tags card");
await turnContext.SendActivityAsync(SuggestedLinkCard.GetTagsCarouselCards(text, tileList, Resource.CustomMessage));
}
else
{
this.telemetryClient.TrackTrace("Sending user with no matched tags result");
await turnContext.SendActivityAsync(MessageFactory.Attachment(UnrecognizedInputCard.GetCard(text, Resource.NoMatchedTagsMessage)));
}
}
}
}
/// <summary>
/// Handle message activity in 1:1 chat.
/// </summary>
/// <param name="message">A message in a conversation.</param>
/// <param name="turnContext">Context object containing information cached for a single turn of conversation with a user.</param>
/// <param name="cancellationToken">Propagates notification that operations should be canceled.</param>
/// <returns>A task that represents the work queued to execute.</returns>
private async Task OnMessageActivityInPersonalChatAsync(
IMessageActivity message,
ITurnContext <IMessageActivity> turnContext,
CancellationToken cancellationToken)
{
if (!string.IsNullOrEmpty(message.ReplyToId) && (message.Value != null) && ((JObject)message.Value).HasValues)
{
this.logger.LogInformation("Card submit in 1:1 chat");
await this.OnAdaptiveCardSubmitInPersonalChatAsync(message, turnContext, cancellationToken).ConfigureAwait(false);
return;
}
string text = message.Text?.ToLower()?.Trim() ?? string.Empty;
switch (text)
{
case Constants.AskAnExpert:
this.logger.LogInformation("Sending user ask an expert card");
await turnContext.SendActivityAsync(MessageFactory.Attachment(AskAnExpertCard.GetCard())).ConfigureAwait(false);
break;
case Constants.ShareFeedback:
this.logger.LogInformation("Sending user feedback card");
await turnContext.SendActivityAsync(MessageFactory.Attachment(ShareFeedbackCard.GetCard())).ConfigureAwait(false);
break;
case Constants.TakeATour:
this.logger.LogInformation("Sending user tour card");
var userTourCards = TourCarousel.GetUserTourCards(this.appBaseUri);
await turnContext.SendActivityAsync(MessageFactory.Carousel(userTourCards)).ConfigureAwait(false);
break;
default:
this.logger.LogInformation("Sending input to QnAMaker");
await this.GetQuestionAnswerReplyAsync(turnContext, message).ConfigureAwait(false);
break;
}
}
/// <summary>
/// Resolve bot command in 1:1 chat.
/// </summary>
/// <param name="message">A message in a conversation.</param>
/// <param name="turnContext">Context object containing information cached for a single turn of conversation with a user.</param>
/// <param name="cancellationToken">Propagates notification that operations should be canceled.</param>
/// <returns>A task that represents the work queued to execute.</returns>
public async Task ResolveBotCommandInPersonalChatAsync(
IMessageActivity message,
ITurnContext <IMessageActivity> turnContext,
CancellationToken cancellationToken)
{
if (!string.IsNullOrEmpty(message.ReplyToId) && (message.Value != null) && ((JObject)message.Value).HasValues)
{
this.logger.LogInformation("Card submit in 1:1 chat");
await this.conversationService.SendAdaptiveCardInPersonalChatAsync(message, turnContext, cancellationToken).ConfigureAwait(false);
return;
}
string text = (message.Text ?? string.Empty).Trim();
if (text.Equals(Strings.BotCommandAskExpert, StringComparison.CurrentCultureIgnoreCase) ||
text.Equals(Constants.AskAnExpert, StringComparison.InvariantCultureIgnoreCase))
{
this.logger.LogInformation("Sending user ask an expert card");
await turnContext.SendActivityAsync(MessageFactory.Attachment(AskAnExpertCard.GetCard())).ConfigureAwait(false);
}
else if (text.Equals(Strings.BotCommandFeedback, StringComparison.CurrentCultureIgnoreCase) ||
text.Equals(Constants.ShareFeedback, StringComparison.InvariantCultureIgnoreCase))
{
this.logger.LogInformation("Sending user feedback card");
await turnContext.SendActivityAsync(MessageFactory.Attachment(ShareFeedbackCard.GetCard())).ConfigureAwait(false);
}
else if (text.Equals(Strings.BotCommandTour, StringComparison.CurrentCultureIgnoreCase) ||
text.Equals(Constants.TakeATour, StringComparison.InvariantCultureIgnoreCase))
{
this.logger.LogInformation("Sending user tour card");
var userTourCards = TourCarousel.GetUserTourCards(this.appBaseUri);
await turnContext.SendActivityAsync(MessageFactory.Carousel(userTourCards)).ConfigureAwait(false);
}
else
{
this.logger.LogInformation("Sending input to QnAMaker");
await this.qnaPairService.GetReplyToQnAAsync(turnContext, message).ConfigureAwait(false);
}
}
/// <summary>
/// Helps to get the expert submit card.
/// </summary>
/// <param name="message">A message in a conversation.</param>
/// <param name="appBaseUri">The base URI where the app is hosted.</param>
/// <param name="turnContext">Context object containing information cached for a single turn of conversation with a user.</param>
/// <param name="cancellationToken">Propagates notification that operations should be canceled.</param>
/// <param name="feedbackProvider">Feedback Provider.</param>
/// <returns>A task that represents the work queued to execute.</returns>
public static async Task <FeedbackEntity> ShareFeedbackSubmitText(
IMessageActivity message,
string appBaseUri,
ITurnContext <IMessageActivity> turnContext,
CancellationToken cancellationToken,
IFeedbackProvider feedbackProvider)
{
var shareFeedbackSubmitTextPayload = ((JObject)message.Value).ToObject <ShareFeedbackCardPayload>();
// Validate required fields.
if (!Enum.TryParse(shareFeedbackSubmitTextPayload?.Rating, out FeedbackRating rating) || shareFeedbackSubmitTextPayload.DescriptionHelpful?.Length > 500 || shareFeedbackSubmitTextPayload.DescriptionNeedsImprovement?.Length > 500 || shareFeedbackSubmitTextPayload.DescriptionNotHelpful?.Length > 500)
{
var updateCardActivity = new Activity(ActivityTypes.Message)
{
Id = turnContext.Activity.ReplyToId,
Conversation = turnContext.Activity.Conversation,
Attachments = new List <Attachment> {
ShareFeedbackCard.GetCard(shareFeedbackSubmitTextPayload, appBaseUri)
},
};
try
{
await turnContext.UpdateActivityAsync(updateCardActivity, cancellationToken).ConfigureAwait(false);
}
catch (ErrorResponseException)
{
await turnContext.SendActivityAsync(Strings.InputTooLongWarning).ConfigureAwait(false);
}
return(null);
}
var teamsUserDetails = await GetUserDetailsInPersonalChatAsync(turnContext, cancellationToken).ConfigureAwait(false);
return(await CreateFeedbackAsync(message, shareFeedbackSubmitTextPayload, teamsUserDetails, feedbackProvider).ConfigureAwait(false));
}
// Handle adaptive card submit in 1:1 chat
// Submits the question or feedback to the SME team
private async Task OnAdaptiveCardSubmitInPersonalChatAsync(IMessageActivity message, ITurnContext <IMessageActivity> turnContext, CancellationToken cancellationToken)
{
Attachment smeTeamCard = null; // Notification to SME team
Attachment userCard = null; // Acknowledgement to the user
TicketEntity newTicket = null; // New ticket
this.telemetryClient.TrackTrace($"Otro envio: {message.Text}");
switch (message.Text)
{
case AskAnExpert:
{
this.telemetryClient.TrackTrace("Sending user ask an expert card (from answer)");
var responseCardPayload = ((JObject)message.Value).ToObject <ResponseCardPayload>();
await turnContext.SendActivityAsync(MessageFactory.Attachment(AskAnExpertCard.GetCard(responseCardPayload)));
break;
}
case ShareFeedback:
{
this.telemetryClient.TrackTrace("Sending user share feedback card (from answer)");
var responseCardPayload = ((JObject)message.Value).ToObject <ResponseCardPayload>();
await turnContext.SendActivityAsync(MessageFactory.Attachment(ShareFeedbackCard.GetCard(responseCardPayload)));
break;
}
case WelcomeMsg:
this.telemetryClient.TrackTrace("The user as required the Welcome screen");
var welcomeText = await this.configurationProvider.GetSavedEntityDetailAsync(ConfigurationEntityTypes.WelcomeMessageText);
var userWelcomeCardAttachment = WelcomeCard.GetCard(welcomeText);
await turnContext.SendActivityAsync(MessageFactory.Attachment(userWelcomeCardAttachment));
break;
case AskAnExpertCard.AskAnExpertSubmitText:
{
this.telemetryClient.TrackTrace($"Received question for expert");
var askAnExpertPayload = ((JObject)message.Value).ToObject <AskAnExpertCardPayload>();
// Validate required fields
if (string.IsNullOrWhiteSpace(askAnExpertPayload.Title))
{
var updateCardActivity = new Activity(ActivityTypes.Message)
{
Id = turnContext.Activity.ReplyToId,
Conversation = turnContext.Activity.Conversation,
Attachments = new List <Attachment> {
AskAnExpertCard.GetCard(askAnExpertPayload)
},
};
await turnContext.UpdateActivityAsync(updateCardActivity, cancellationToken);
return;
}
var userDetails = await this.GetUserDetailsInPersonalChatAsync(turnContext, cancellationToken);
newTicket = await this.CreateTicketAsync(message, askAnExpertPayload, userDetails);
smeTeamCard = new SmeTicketCard(newTicket).ToAttachment(message.LocalTimestamp);
userCard = new UserNotificationCard(newTicket).ToAttachment(Resource.NotificationCardContent, message.LocalTimestamp);
break;
}
case ShareFeedbackCard.ShareFeedbackSubmitText:
{
this.telemetryClient.TrackTrace($"Received app feedback");
var shareFeedbackPayload = ((JObject)message.Value).ToObject <ShareFeedbackCardPayload>();
// Validate required fields
if (!Enum.TryParse(shareFeedbackPayload.Rating, out FeedbackRating rating))
{
var updateCardActivity = new Activity(ActivityTypes.Message)
{
Id = turnContext.Activity.ReplyToId,
Conversation = turnContext.Activity.Conversation,
Attachments = new List <Attachment> {
ShareFeedbackCard.GetCard(shareFeedbackPayload)
},
};
await turnContext.UpdateActivityAsync(updateCardActivity, cancellationToken);
return;
}
var userDetails = await this.GetUserDetailsInPersonalChatAsync(turnContext, cancellationToken);
smeTeamCard = SmeFeedbackCard.GetCard(shareFeedbackPayload, userDetails);
await turnContext.SendActivityAsync(MessageFactory.Text(Resource.ThankYouTextContent));
break;
}
default:
this.telemetryClient.TrackTrace($"Unexpected text in submit payload: {message.Text}", SeverityLevel.Warning);
break;
}
// Send message to SME team
if (smeTeamCard != null)
{
var channelId = await this.configurationProvider.GetSavedEntityDetailAsync(ConfigurationEntityTypes.TeamId);
var resourceResponse = await this.SendCardToTeamAsync(turnContext, smeTeamCard, channelId, cancellationToken);
// If a ticket was created, update the ticket with the conversation info
if (newTicket != null)
{
newTicket.SmeCardActivityId = resourceResponse.ActivityId;
newTicket.SmeThreadConversationId = resourceResponse.Id;
await this.ticketsProvider.SaveOrUpdateTicketAsync(newTicket);
}
}
// Send acknowledgment to the user
if (userCard != null)
{
await turnContext.SendActivityAsync(MessageFactory.Attachment(userCard), cancellationToken);
}
}
// Handle message activity in 1:1 chat
private async Task OnMessageActivityInPersonalChatAsync(IMessageActivity message, ITurnContext <IMessageActivity> turnContext, CancellationToken cancellationToken)
{
if (!string.IsNullOrEmpty(message.ReplyToId) && (message.Value != null) && ((JObject)message.Value).HasValues)
{
this.telemetryClient.TrackTrace("Card submit in 1:1 chat");
await this.OnAdaptiveCardSubmitInPersonalChatAsync(message, turnContext, cancellationToken);
return;
}
string text = (message.Text ?? string.Empty).Trim().ToLower();
this.telemetryClient.TrackTrace($"Se ha enviado esta solicitud: {text}");
switch (text)
{
case AskAnExpert:
this.telemetryClient.TrackTrace("Sending user ask an expert card");
await turnContext.SendActivityAsync(MessageFactory.Attachment(AskAnExpertCard.GetCard()));
break;
case ShareFeedback:
this.telemetryClient.TrackTrace("Sending user feedback card");
await turnContext.SendActivityAsync(MessageFactory.Attachment(ShareFeedbackCard.GetCard()));
break;
case TakeATour:
this.telemetryClient.TrackTrace("Sending user tour card");
var userTourCards = TourCarousel.GetUserTourCards(this.appBaseUri);
await turnContext.SendActivityAsync(MessageFactory.Carousel(userTourCards));
break;
case WelcomeMsg:
this.telemetryClient.TrackTrace("The user as required the Welcome screen");
var welcomeText = await this.configurationProvider.GetSavedEntityDetailAsync(ConfigurationEntityTypes.WelcomeMessageText);
var userWelcomeCardAttachment = WelcomeCard.GetCard(welcomeText);
var userWelcomeCardAttachment2 = WelcomeCardPreguntas.GetCard(Resource.WelcomeTeamCardContent);
await turnContext.SendActivityAsync(MessageFactory.Attachment(userWelcomeCardAttachment));
await turnContext.SendActivityAsync(MessageFactory.Attachment(userWelcomeCardAttachment2));
break;
default:
this.telemetryClient.TrackTrace("Sending input to QnAMaker");
var queryResult = await this.GetAnswerFromQnAMakerAsync(text, turnContext, cancellationToken);
if (queryResult != null)
{
this.telemetryClient.TrackTrace("Sending user QnAMaker card");
await turnContext.SendActivityAsync(MessageFactory.Attachment(ResponseCard.GetCard(queryResult.Questions[0], queryResult.Answer, text)));
}
else
{
var tileList = await this.MatchTagsWithMessageAsync(text);
if (tileList != null)
{
this.telemetryClient.TrackTrace("Sending user tags card");
await turnContext.SendActivityAsync(SuggestedLinkCard.GetTagsCarouselCards(text, tileList, Resource.CustomMessage));
}
else
{
this.telemetryClient.TrackTrace("Sending user with no matched tags result");
await turnContext.SendActivityAsync(MessageFactory.Attachment(UnrecognizedInputCard.GetCard(text, Resource.NoMatchedTagsMessage)));
}
}
break;
}
}
private async Task <DialogTurnResult> StartDialogAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
{
string text = stepContext.Context.Activity.Text?.ToLower()?.Trim() ?? string.Empty;
switch (text)
{
case Constants.ChangeLanguage:
case "language changes":
case "changes language":
case "changes the language":
this._telemetryClient.TrackEvent("User wants to change language");
return(await stepContext.BeginDialogAsync(nameof(ChangeLanguageDialog)));
case Constants.AskAnExpert:
this._telemetryClient.TrackEvent("Sending user ask an expert card");
await stepContext.Context.SendActivityAsync(MessageFactory.Attachment(AskAnExpertCard.GetCard())).ConfigureAwait(false);
break;
case Constants.ShareFeedback:
this._telemetryClient.TrackEvent("Sending user feedback card");
await stepContext.Context.SendActivityAsync(MessageFactory.Attachment(ShareFeedbackCard.GetCard())).ConfigureAwait(false);
break;
case Constants.TakeATour:
this._telemetryClient.TrackEvent("Sending user tour card");
var userTourCards = TourCarousel.GetUserTourCards(this._appBaseUri);
await stepContext.Context.SendActivityAsync(MessageFactory.Carousel(userTourCards)).ConfigureAwait(false);
break;
default:
this._telemetryClient.TrackEvent("Sending input to QnAMaker");
var message = stepContext.Context.Activity.AsMessageActivity();
await this.GetQuestionAnswerReplyAsync(stepContext.Context, message).ConfigureAwait(false);
break;
}
return(await stepContext.EndDialogAsync(null, cancellationToken));
}
/// <summary>
/// Handle adaptive card submit in 1:1 chat.
/// Submits the question or feedback to the SME team.
/// </summary>
/// <param name="message">A message in a conversation.</param>
/// <param name="turnContext">Context object containing information cached for a single turn of conversation with a user.</param>
/// <param name="cancellationToken">Propagates notification that operations should be canceled.</param>
/// <returns>A task that represents the work queued to execute.</returns>
public async Task SendAdaptiveCardInPersonalChatAsync(
IMessageActivity message,
ITurnContext <IMessageActivity> turnContext,
CancellationToken cancellationToken)
{
Attachment smeTeamCard = null; // Notification to SME team
Attachment userCard = null; // Acknowledgement to the user
TicketEntity newTicket = null; // New ticket
string text = (message.Text ?? string.Empty).Trim();
switch (text)
{
// Sends user ask an expert card from the answer card.
case Constants.AskAnExpert:
this.logger.LogInformation("Sending user ask an expert card (from answer)");
var askAnExpertPayload = ((JObject)message.Value).ToObject <ResponseCardPayload>();
await this.SendActivityInChatAsync(turnContext, MessageFactory.Attachment(AskAnExpertCard.GetCard(askAnExpertPayload)), cancellationToken);
break;
// Sends user the feedback card from the answer card.
case Constants.ShareFeedback:
this.logger.LogInformation("Sending user share feedback card (from answer)");
var shareFeedbackPayload = ((JObject)message.Value).ToObject <ResponseCardPayload>();
await this.SendActivityInChatAsync(turnContext, MessageFactory.Attachment(ShareFeedbackCard.GetCard(shareFeedbackPayload)), cancellationToken);
break;
// User submits the ask an expert card.
case Constants.AskAnExpertSubmitText:
this.logger.LogInformation("Received question for expert");
newTicket = await AdaptiveCardHelper.AskAnExpertSubmitText(message, turnContext, cancellationToken, this.ticketsProvider).ConfigureAwait(false);
if (newTicket != null)
{
smeTeamCard = new SmeTicketCard(newTicket).ToAttachment();
userCard = new UserNotificationCard(newTicket).ToAttachment(Strings.NotificationCardContent);
}
break;
// User submits the share feedback card.
case Constants.ShareFeedbackSubmitText:
this.logger.LogInformation("Received app feedback");
smeTeamCard = await AdaptiveCardHelper.ShareFeedbackSubmitText(message, turnContext, cancellationToken).ConfigureAwait(false);
if (smeTeamCard != null)
{
await this.SendActivityInChatAsync(turnContext, MessageFactory.Text(Strings.ThankYouTextContent), cancellationToken);
}
break;
default:
var payload = ((JObject)message.Value).ToObject <ResponseCardPayload>();
if (payload.IsPrompt)
{
this.logger.LogInformation("Sending input to QnAMaker for prompt");
await this.qnaPairServiceFacade.GetReplyToQnAAsync(turnContext, message).ConfigureAwait(false);
}
else
{
this.logger.LogWarning($"Unexpected text in submit payload: {message.Text}");
}
break;
}
string expertTeamId = await this.configurationProvider.GetSavedEntityDetailAsync(ConfigurationEntityTypes.TeamId).ConfigureAwait(false);
// Send message to SME team.
if (smeTeamCard != null)
{
await this.SendTicketCardToSMETeamAsync(turnContext, smeTeamCard, expertTeamId, cancellationToken, newTicket);
}
// Send acknowledgment to the user
if (userCard != null)
{
await this.SendActivityInChatAsync(turnContext, MessageFactory.Attachment(userCard), cancellationToken);
}
}
// Handle message activity in 1:1 chat
private async Task OnMessageActivityInPersonalChatAsync(IMessageActivity message, ITurnContext <IMessageActivity> turnContext, CancellationToken cancellationToken)
{
if (!string.IsNullOrEmpty(message.ReplyToId) && (message.Value != null) && ((JObject)message.Value).HasValues)
{
this.telemetryClient.TrackTrace("Card submit in 1:1 chat");
await this.OnAdaptiveCardSubmitInPersonalChatAsync(message, turnContext, cancellationToken);
return;
}
string text = (message.Text ?? string.Empty).Trim().ToLower();
switch (text)
{
case AskAnExpert:
this.telemetryClient.TrackTrace("Mandando tarjeta pregunta a un experto al usuario");
await turnContext.SendActivityAsync(MessageFactory.Attachment(AskAnExpertCard.GetCard()));
break;
case ShareFeedback:
this.telemetryClient.TrackTrace("Sending user feedback card");
await turnContext.SendActivityAsync(MessageFactory.Attachment(ShareFeedbackCard.GetCard()));
break;
case TakeATour:
this.telemetryClient.TrackTrace("Sending user tour card");
var userTourCards = TourCarousel.GetUserTourCards(this.appBaseUri);
await turnContext.SendActivityAsync(MessageFactory.Carousel(userTourCards));
break;
default:
this.telemetryClient.TrackTrace("Sending input to QnAMaker");
var queryResult = await this.GetAnswerFromQnAMakerAsync(text, turnContext, cancellationToken);
if (queryResult != null)
{
this.telemetryClient.TrackTrace("Sending user QnAMaker card");
await turnContext.SendActivityAsync(MessageFactory.Attachment(ResponseCard.GetCard(queryResult.Questions[0], queryResult.Answer, text)));
}
else
{
var tileList = await this.MatchTagsWithMessageAsync(text);
if (tileList != null)
{
this.telemetryClient.TrackTrace("Sending user tags card");
await turnContext.SendActivityAsync(SuggestedLinkCard.GetTagsCarouselCards(text, tileList, Resource.CustomMessage));
}
else
{
this.telemetryClient.TrackTrace("Sending user with no matched tags result");
await turnContext.SendActivityAsync(MessageFactory.Attachment(UnrecognizedInputCard.GetCard(text, Resource.NoMatchedTagsMessage)));
}
}
break;
}
}
/// <summary>
/// Handle adaptive card submit in 1:1 chat.
/// Submits the question or feedback to the SME team.
/// </summary>
/// <param name="message">A message in a conversation.</param>
/// <param name="turnContext">Context object containing information cached for a single turn of conversation with a user.</param>
/// <param name="cancellationToken">Propagates notification that operations should be canceled.</param>
/// <returns>A task that represents the work queued to execute.</returns>
private async Task OnAdaptiveCardSubmitInPersonalChatAsync(
IMessageActivity message,
ITurnContext <IMessageActivity> turnContext,
CancellationToken cancellationToken)
{
Attachment smeTeamCard = null; // Notification to SME team
Attachment userCard = null; // Acknowledgement to the user
TicketEntity newTicket = null; // New ticket
switch (message?.Text)
{
case Constants.AskAnExpert:
this.logger.LogInformation("Sending user ask an expert card (from answer)");
var askAnExpertPayload = ((JObject)message.Value).ToObject <ResponseCardPayload>();
await turnContext.SendActivityAsync(MessageFactory.Attachment(AskAnExpertCard.GetCard(askAnExpertPayload))).ConfigureAwait(false);
break;
case Constants.ShareFeedback:
this.logger.LogInformation("Sending user share feedback card (from answer)");
var shareFeedbackPayload = ((JObject)message.Value).ToObject <ResponseCardPayload>();
await turnContext.SendActivityAsync(MessageFactory.Attachment(ShareFeedbackCard.GetCard(shareFeedbackPayload))).ConfigureAwait(false);
break;
case AskAnExpertCard.AskAnExpertSubmitText:
this.logger.LogInformation("Received question for expert");
newTicket = await AdaptiveCardHelper.AskAnExpertSubmitText(message, turnContext, cancellationToken, this.ticketsProvider).ConfigureAwait(false);
if (newTicket != null)
{
smeTeamCard = new SmeTicketCard(newTicket).ToAttachment(message?.LocalTimestamp);
userCard = new UserNotificationCard(newTicket).ToAttachment(Strings.NotificationCardContent, message?.LocalTimestamp);
}
break;
case ShareFeedbackCard.ShareFeedbackSubmitText:
this.logger.LogInformation("Received app feedback");
smeTeamCard = await AdaptiveCardHelper.ShareFeedbackSubmitText(message, turnContext, cancellationToken).ConfigureAwait(false);
if (smeTeamCard != null)
{
await turnContext.SendActivityAsync(MessageFactory.Text(Strings.ThankYouTextContent)).ConfigureAwait(false);
}
break;
default:
var payload = ((JObject)message.Value).ToObject <ResponseCardPayload>();
if (payload.IsPrompt)
{
this.logger.LogInformation("Sending input to QnAMaker for prompt");
await this.GetQuestionAnswerReplyAsync(turnContext, message).ConfigureAwait(false);
}
else
{
this.logger.LogWarning($"Unexpected text in submit payload: {message.Text}");
}
break;
}
string expertTeamId = await this.configurationProvider.GetSavedEntityDetailAsync(ConfigurationEntityTypes.TeamId).ConfigureAwait(false);
// Send message to SME team.
if (smeTeamCard != null)
{
var resourceResponse = await this.SendCardToTeamAsync(turnContext, smeTeamCard, expertTeamId, cancellationToken).ConfigureAwait(false);
// If a ticket was created, update the ticket with the conversation info.
if (newTicket != null)
{
newTicket.SmeCardActivityId = resourceResponse.ActivityId;
newTicket.SmeThreadConversationId = resourceResponse.Id;
await this.ticketsProvider.UpsertTicketAsync(newTicket).ConfigureAwait(false);
}
}
// Send acknowledgment to the user
if (userCard != null)
{
await turnContext.SendActivityAsync(MessageFactory.Attachment(userCard), cancellationToken).ConfigureAwait(false);
}
}