// Get next card.
private AdaptiveCardInvokeResponse GetNextActionCard(string[] path, InitialSequentialCard data)
{
var cardJson = File.ReadAllText(Path.Combine(path));
AdaptiveCardTemplate template = new AdaptiveCardTemplate(cardJson);
var payloadData = new
{
requestTitle = data.action.data.RequestTitle,
requestDescription = data.action.data.RequestDescription,
assignedTo = data.action.data.AssignedTo,
createdBy = data.action.data.CreatedBy,
createdById = data.action.data.CreatedById,
assignedToName = data.action.data.AssignedToName,
userMRI = data.action.data.UserMRI
};
//"Expand" the template -this generates the final Adaptive Card payload
var cardJsonstring = template.Expand(payloadData);
var card = JObject.Parse(cardJsonstring);
var adaptiveCardResponse = new AdaptiveCardInvokeResponse()
{
StatusCode = 200,
Type = "application/vnd.microsoft.card.adaptive",
Value = card
};
return(adaptiveCardResponse);
}
private static InvokeResponse PrepareInvokeResponse(Attachment card)
{
var newCardResponse = new AdaptiveCardInvokeResponse()
{
StatusCode = 200,
Type = card.ContentType,
Value = card.Content
};
return(ActivityHandler.CreateInvokeResponse(newCardResponse));
}
protected override async Task <InvokeResponse> OnInvokeActivityAsync(ITurnContext <IInvokeActivity> turnContext, CancellationToken cancellationToken)
{
// Note: Make sure that the incoming invoke actions are processed <10 seconds to avoid timeouts in Teams clients.
if (turnContext.Activity.Name == "adaptiveCard/action")
{
var actionData = JsonConvert.DeserializeObject <RefreshActionData>(turnContext.Activity.Value.ToString());
// Increase the refresh count.
actionData.action.data.RefreshCount++;
switch (actionData.action.verb)
{
case "me":
// Send an auto refresh user specific view card for the `sender`.
var card = this.cardFactory.GetAutoRefreshForSpecificUserBaseCard(turnContext.Activity.From.Id, MeCardType);
await turnContext.SendActivityAsync(MessageFactory.Attachment(card), cancellationToken);
break;
case "allusers":
// Send an auto refresh user specific card for `all users` in the chat.
card = this.cardFactory.GetAutoRefreshForAllUsersBaseCard(AllUsersCardType);
await turnContext.SendActivityAsync(MessageFactory.Attachment(card), cancellationToken);
break;
case "UpdateBaseCard":
// Update the base card for `all users`.
// Note: We remove the refresh section from the updated base card in this sample. No further refresh invoke actions will be fired for any user.
// You may decide to keep the refresh section and trigger auto-refresh for either all / list of users if required.
card = this.cardFactory.GetFinalBaseCard(actionData);
var activity = MessageFactory.Attachment(card);
activity.Id = turnContext.Activity.ReplyToId;
await turnContext.UpdateActivityAsync(activity, cancellationToken);
break;
case "RefreshUserSpecificView":
// Update the card for the `user` for whom this invoke action was triggered.
card = this.cardFactory.GetUpdatedCardForUser(turnContext.Activity.From.Id, actionData);
return(PrepareInvokeResponse(card));
}
}
var adaptiveCardResponse = new AdaptiveCardInvokeResponse()
{
StatusCode = 200,
Type = "application/vnd.microsoft.activity.message",
Value = "Success!" // Optional message to be shown to the user.
};
return(ActivityHandler.CreateInvokeResponse(adaptiveCardResponse));
}
public void AdaptiveCardInvokeResponse()
{
var statusCode = 200;
var type = "myType";
var value = new { };
var res = new AdaptiveCardInvokeResponse()
{
StatusCode = statusCode,
Type = type,
Value = value,
};
Assert.Equal(statusCode, res.StatusCode);
Assert.Equal(type, res.Type);
Assert.Equal(value, res.Value);
}
private AdaptiveCardInvokeResponse ProcessOrderAction(User user, CardOptions cardOptions)
{
if (cardOptions.option != null && (Card)cardOptions.currentCard == Card.Entre)
{
user.Lunch.Entre = cardOptions.option;
}
else if (cardOptions.option != null && (Card)cardOptions.currentCard == Card.Drink)
{
user.Lunch.Drink = cardOptions.option;
}
AdaptiveCardInvokeResponse responseBody = null;
switch ((Card)cardOptions.nextCardToSend)
{
case Card.Drink:
responseBody = DrinkCardResponse();
break;
case Card.Entre:
responseBody = EntreCardResponse();
break;
case Card.Review:
responseBody = ReviewCardResponse(user);
break;
case Card.ReviewAll:
var latestOrders = _lunchRepository.GetLatestOrders();
// TODO: show all the orders
break;
case Card.Confirmation:
_lunchRepository.UpsertOrder(user);
responseBody = ConfirmationCardResponse();
break;
default:
throw new NotImplementedException("No card matches that nextCardToSend.");
}
return(responseBody);
}
public AdaptiveCardInvokeResponse GetNextActionCard(string[] path, InitialSequentialCard data, List <string> subCategory = null)
{
var cardJson = File.ReadAllText(Path.Combine(path));
AdaptiveCardTemplate template = new AdaptiveCardTemplate(cardJson);
string subCat1 = "";
string subCat2 = "";
if (subCategory != null)
{
subCat1 = subCategory[0];
subCat2 = subCategory[1];
}
var payloadData = new
{
assignees = memberDetails,
incidentTitle = data.action.data.IncidentTitle,
assignedTo = data.action.data.AssignedTo,
category = data.action.data.Category,
subCategory1 = subCat1,
subCategory2 = subCat2,
subCategory = data.action.data.SubCategory,
createdBy = data.action.data.CreatedBy,
assignedToName = data.action.data.AssignedToName,
userMRI = data.action.data.UserMRI,
incidentId = data.action.data.IncidentId
};
//"Expand" the template -this generates the final Adaptive Card payload
var cardJsonstring = template.Expand(payloadData);
var card = JsonConvert.DeserializeObject(cardJsonstring);
var adaptiveCardResponse = new AdaptiveCardInvokeResponse()
{
StatusCode = 200,
Type = AdaptiveCard.ContentType,
Value = card
};
return(adaptiveCardResponse);
}
private async Task <InvokeResponse> CloseIncident(string verb, CancelOrResolveIncidentOptions cardOptions, ITurnContext <IInvokeActivity> turnContext)
{
var cardData = new
{
createdBy = cardOptions.CreatedBy,
createdByUserID = cardOptions.createdByUserID,
createdUtc = DateTime.Now.ToString("dddd, dd MMMM yyyy"),
serviceName = cardOptions.ServiceName,
imagePath = cardOptions.imagePath,
imageAlt = cardOptions.ServiceName,
profileImage = $"{imageBasePath}/profile_image.png",
incidentTitle = cardOptions.incidentTitle,
incidentDescription = cardOptions.incidentDescription,
incidentCategory = cardOptions.incidentCategory,
incidentStatus = cardOptions.incidentStatus
};
string cardJson;
string[] reviewIncidentCard = { ".", "Resources", "ClosedIncident.json" };
var responseAttachment = GetResponseAttachment(reviewIncidentCard, cardData, out cardJson);
Activity pendingActivity = new Activity();
pendingActivity.Type = "message";
pendingActivity.Id = turnContext.Activity.ReplyToId;
pendingActivity.Attachments = new List <Attachment> {
responseAttachment
};
await turnContext.UpdateActivityAsync(pendingActivity);
JObject response = JObject.Parse(cardJson);
AdaptiveCardInvokeResponse adaptiveCardResponse = new AdaptiveCardInvokeResponse()
{
StatusCode = 200,
Type = AdaptiveCard.ContentType,
Value = response
};
return(CreateInvokeResponse(adaptiveCardResponse));
}
private async Task <AdaptiveCardInvokeResponse> ProcessErrAction(User user, CardOptions cardOptions)
{
AdaptiveCardInvokeResponse responseBody = null;
switch ((Card)cardOptions.nextCardToSend)
{
case Card.OkWithString:
responseBody = OkWithMessageResponse();
break;
case Card.OkWithCard:
responseBody = OkWithCardResponse();
break;
case Card.LoginRequest:
responseBody = LoginRequestResponse();
break;
case Card.ThrottleWarning:
responseBody = ThrottleWarningResponse();
break;
case Card.Teapot:
responseBody = TeapotResponse();
break;
case Card.Error:
responseBody = BotErrorResponse();
break;
default:
throw new NotImplementedException("No card matches that nextCardToSend.");
}
return(responseBody);
}
private async Task <AdaptiveCardInvokeResponse> ProcessOrderAction(User user, CardOptions cardOptions)
{
if ((Card)cardOptions.currentCard == Card.Entre)
{
if (!string.IsNullOrEmpty(cardOptions.custom))
{
if (!await _cateringRecognizer.ValidateEntre(cardOptions.custom))
{
return(RedoEntreCardResponse(new Lunch()
{
Entre = cardOptions.custom
}));
}
cardOptions.option = cardOptions.custom;
}
user.Lunch.Entre = cardOptions.option;
}
else if ((Card)cardOptions.currentCard == Card.Drink)
{
if (!string.IsNullOrEmpty(cardOptions.custom))
{
if (!await _cateringRecognizer.ValidateDrink(cardOptions.custom))
{
return(RedoDrinkCardResponse(new Lunch()
{
Drink = cardOptions.custom
}));
}
cardOptions.option = cardOptions.custom;
}
user.Lunch.Drink = cardOptions.option;
}
AdaptiveCardInvokeResponse responseBody = null;
switch ((Card)cardOptions.nextCardToSend)
{
case Card.Drink:
responseBody = DrinkCardResponse();
break;
case Card.Entre:
responseBody = EntreCardResponse();
break;
case Card.Review:
responseBody = ReviewCardResponse(user);
break;
case Card.ReviewAll:
var latestOrders = await _cateringDb.GetRecentOrdersAsync();
responseBody = RecentOrdersCardResponse(latestOrders.Items);
break;
case Card.Confirmation:
await _cateringDb.UpsertOrderAsync(user);
responseBody = ConfirmationCardResponse();
break;
default:
throw new NotImplementedException("No card matches that nextCardToSend.");
}
return(responseBody);
}
/// <summary>
/// Invoked when an invoke activity is received from the connector.
/// </summary>
/// <param name="turnContext">The turn context.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>A task that represents the work queued to execute.</returns>
protected override async Task <InvokeResponse> OnInvokeActivityAsync(ITurnContext <IInvokeActivity> turnContext, CancellationToken cancellationToken)
{
if (turnContext.Activity.Name == "adaptiveCard/action")
{
var data = JsonConvert.DeserializeObject <InitialSequentialCard>(turnContext.Activity.Value.ToString());
string verb = data.action.verb;
AdaptiveCardInvokeResponse adaptiveCardResponse;
string cardJson;
JObject response;
switch (verb)
{
case "initialRefresh":
string[] initialCard = { ".", "Cards", "RequestCard.json" };
adaptiveCardResponse = GetNextActionCard(initialCard, data);
return(CreateInvokeResponse(adaptiveCardResponse));
case "requestCard":
string[] firstCard = { ".", "Cards", "RequestDetailsCardForUser.json" };
var assigneeInfo = await TeamsInfo.GetMemberAsync(turnContext, data.action.data.AssignedTo, cancellationToken);
data.action.data.UserMRI = assigneeInfo.Id;
data.action.data.CreatedById = turnContext.Activity.From.Id;
data.action.data.AssignedToName = assigneeInfo.Name;
var members = new List <TeamsChannelAccount>();
string continuationToken = null;
do
{
var currentPage = await TeamsInfo.GetPagedMembersAsync(turnContext, 100, continuationToken, cancellationToken);
continuationToken = currentPage.ContinuationToken;
members.AddRange(currentPage.Members);
}while (continuationToken != null);
foreach (var member in members)
{
if (member.AadObjectId != turnContext.Activity.From.AadObjectId)
{
var newMemberInfo = member.Id;
memberDetails.Add(newMemberInfo);
}
}
data.action.data.UserId = memberDetails;
var responseAttachment = GetResponseAttachment(firstCard, data, out cardJson);
Activity pendingActivity = new Activity();
pendingActivity.Type = "message";
pendingActivity.Id = turnContext.Activity.ReplyToId;
pendingActivity.Attachments = new List <Attachment> {
responseAttachment
};
await turnContext.UpdateActivityAsync(pendingActivity);
response = JObject.Parse(cardJson);
adaptiveCardResponse = new AdaptiveCardInvokeResponse()
{
StatusCode = 200,
Type = "application/vnd.microsoft.card.adaptive",
Value = response
};
return(CreateInvokeResponse(adaptiveCardResponse));
case "refresh":
if (turnContext.Activity.From.Id == data.action.data.UserMRI)
{
string[] assignedToCard = { ".", "Cards", "AssignedToCard.json" };
adaptiveCardResponse = GetNextActionCard(assignedToCard, data);
return(CreateInvokeResponse(adaptiveCardResponse));
}
else
{
string[] othersCard = { ".", "Cards", "OtherMembersCard.json" };
adaptiveCardResponse = GetNextActionCard(othersCard, data);
return(CreateInvokeResponse(adaptiveCardResponse));
}
case "cancelCard":
string[] cancelCard = { ".", "Cards", "CancelCard.json" };
var cancelCardResponse = GetResponseAttachment(cancelCard, data, out cardJson);
Activity canceledActivity = new Activity();
canceledActivity.Type = "message";
canceledActivity.Id = turnContext.Activity.ReplyToId;
canceledActivity.Attachments = new List <Attachment> {
cancelCardResponse
};
await turnContext.UpdateActivityAsync(canceledActivity);
response = JObject.Parse(cardJson);
adaptiveCardResponse = new AdaptiveCardInvokeResponse()
{
StatusCode = 200,
Type = "application/vnd.microsoft.card.adaptive",
Value = response
};
return(CreateInvokeResponse(adaptiveCardResponse));
case "approved":
string[] approvedCard = { ".", "Cards", "ApprovedCard.json" };
var approvedAttachment = GetResponseAttachment(approvedCard, data, out cardJson);
Activity approvedActivity = new Activity();
approvedActivity.Type = "message";
approvedActivity.Id = turnContext.Activity.ReplyToId;
approvedActivity.Attachments = new List <Attachment> {
approvedAttachment
};
await turnContext.UpdateActivityAsync(approvedActivity);
response = JObject.Parse(cardJson);
adaptiveCardResponse = new AdaptiveCardInvokeResponse()
{
StatusCode = 200,
Type = "application/vnd.microsoft.card.adaptive",
Value = response
};
return(CreateInvokeResponse(adaptiveCardResponse));
case "rejected":
string[] rejectedCard = { ".", "Cards", "RejectedCard.json" };
var rejectedAttachment = GetResponseAttachment(rejectedCard, data, out cardJson);
Activity rejectedActivity = new Activity();
rejectedActivity.Type = "message";
rejectedActivity.Id = turnContext.Activity.ReplyToId;
rejectedActivity.Attachments = new List <Attachment> {
rejectedAttachment
};
await turnContext.UpdateActivityAsync(rejectedActivity);
response = JObject.Parse(cardJson);
adaptiveCardResponse = new AdaptiveCardInvokeResponse()
{
StatusCode = 200,
Type = "application/vnd.microsoft.card.adaptive",
Value = response
};
return(CreateInvokeResponse(adaptiveCardResponse));
}
}
return(null);
}
protected override async Task <InvokeResponse> OnInvokeActivityAsync(ITurnContext <IInvokeActivity> turnContext, CancellationToken cancellationToken)
{
List <IncidentDetails> currentIncidentList = new List <IncidentDetails>();
incidentDetailsList.TryGetValue("incidentList", out currentIncidentList);
if (turnContext.Activity.Name == "composeExtension/submitAction")
{
var asJobject = JObject.FromObject(turnContext.Activity.Value);
var data = (object)asJobject.ToObject <CardTaskFetchValue <object> >()?.Data;
var botInstalled = (object)JObject.Parse(data.ToString()).ToObject <CardTaskFetchValue <object> >()?.MsTeams;
if (botInstalled != null)
{
return(GetIncientListFromMEAction(currentIncidentList));
}
else
{
var incidentId = (string)JObject.Parse(data.ToString()).ToObject <CardTaskFetchValue <string> >()?.IncidentId;
var incidentDetail = currentIncidentList.FirstOrDefault(incident => incident.IncidentId.ToString() == incidentId);
await turnContext.SendActivityAsync(MessageFactory.Attachment(CardHelper.GetIncidentReviewCard(incidentDetail)));
return(CreateInvokeResponse());
}
}
if (turnContext.Activity.Name == "composeExtension/fetchTask")
{
try
{
// Check if your app is installed by fetching member information.
var member = await TeamsInfo.GetMemberAsync(turnContext, turnContext.Activity.From.Id, cancellationToken);
return(GetIncientListFromMEAction(currentIncidentList));
}
catch (ErrorResponseException ex)
{
if (ex.Body.Error.Code == "BotNotInConversationRoster")
{
string[] paths = { ".", "Resources", "justInTimeInstall.json" };
var adaptiveCardJson = File.ReadAllText(Path.Combine(paths));
var adaptiveCardAttachment = new Attachment()
{
ContentType = AdaptiveCard.ContentType,
Content = JsonConvert.DeserializeObject(adaptiveCardJson),
};
return(CreateInvokeResponse(new MessagingExtensionActionResponse
{
Task = new TaskModuleContinueResponse
{
Value = new TaskModuleTaskInfo
{
Card = adaptiveCardAttachment,
Height = 200,
Width = 400,
Title = "Bot is not installed",
},
},
}));
}
}
}
if (turnContext.Activity.Name == "adaptiveCard/action")
{
var data = JsonConvert.DeserializeObject <InitialSequentialCard>(turnContext.Activity.Value.ToString());
string verb = data.action.verb;
AdaptiveCardInvokeResponse adaptiveCardResponse;
string cardJson;
JObject response;
switch (verb)
{
case "initialRefresh":
string[] initialCard = { ".", "Resources", "firstCard.json" };
var members = new List <TeamsChannelAccount>();
string continuationToken = null;
do
{
var currentPage = await TeamsInfo.GetPagedMembersAsync(turnContext, 100, continuationToken, cancellationToken);
continuationToken = currentPage.ContinuationToken;
members.AddRange(currentPage.Members);
}while (continuationToken != null);
foreach (var member in members)
{
if (member.AadObjectId != turnContext.Activity.From.AadObjectId)
{
var newMemberInfo = new Info {
value = member.AadObjectId, title = member.Name
};
memberDetails.Add(newMemberInfo);
}
}
adaptiveCardResponse = GetNextActionCard(initialCard, data);
return(CreateInvokeResponse(adaptiveCardResponse));
case "firstCard":
string[] firstCard = { ".", "Resources", "secondCard.json" };
var assigneeInfo = await TeamsInfo.GetMemberAsync(turnContext, data.action.data.AssignedTo, cancellationToken);
data.action.data.UserMRI = assigneeInfo.Id;
adaptiveCardResponse = GetNextActionCard(firstCard, data);
return(CreateInvokeResponse(adaptiveCardResponse));
case "secondCard":
string[] secondCard = { ".", "Resources", "thirdCard.json" };
if (data.action.data.Category == "Software")
{
adaptiveCardResponse = GetNextActionCard(secondCard, data, Constants.Software);
}
else
{
adaptiveCardResponse = GetNextActionCard(secondCard, data, Constants.Hardware);
}
return(CreateInvokeResponse(adaptiveCardResponse));
case "thirdCard":
var initiator = await TeamsInfo.GetMemberAsync(turnContext, data.action.data.AssignedTo, cancellationToken);
data.action.data.AssignedToName = initiator.Name;
var incidentDetail = new IncidentDetails
{
IncidentId = Guid.NewGuid(),
CreatedBy = turnContext.Activity.From.Name,
AssignedToMRI = data.action.data.UserMRI,
AssignedToName = data.action.data.AssignedToName,
Category = data.action.data.Category,
IncidentTitle = data.action.data.IncidentTitle,
SubCategory = data.action.data.SubCategory
};
data.action.data.IncidentId = incidentDetail.IncidentId;
string[] thirdCard = { ".", "Resources", "reviewCard.json" };
var responseAttachment = CardHelper.GetResponseAttachment(thirdCard, data, out cardJson);
Activity pendingActivity = new Activity();
pendingActivity.Type = "message";
pendingActivity.Id = turnContext.Activity.ReplyToId;
pendingActivity.Attachments = new List <Attachment> {
responseAttachment
};
await turnContext.UpdateActivityAsync(pendingActivity);
response = JObject.Parse(cardJson);
adaptiveCardResponse = new AdaptiveCardInvokeResponse()
{
StatusCode = 200,
Type = AdaptiveCard.ContentType,
Value = response
};
if (currentIncidentList == null)
{
currentIncidentList = new List <IncidentDetails> {
incidentDetail
};
}
else
{
List <IncidentDetails> incidentList = new List <IncidentDetails>();
incidentList = currentIncidentList;
incidentList.Add(incidentDetail);
currentIncidentList = incidentList;
}
incidentDetailsList.AddOrUpdate("incidentList", currentIncidentList, (key, value) => currentIncidentList);
return(CreateInvokeResponse(adaptiveCardResponse));
case "refresh":
string[] assignedToCard = { ".", "Resources", "assignedToCard.json" };
adaptiveCardResponse = GetNextActionCard(assignedToCard, data);
return(CreateInvokeResponse(adaptiveCardResponse));
case "approved":
string[] approvedCard = { ".", "Resources", "approvedCard.json" };
var approvedAttachment = CardHelper.GetResponseAttachment(approvedCard, data, out cardJson);
Activity approvedActivity = new Activity();
approvedActivity.Type = "message";
approvedActivity.Id = turnContext.Activity.ReplyToId;
approvedActivity.Attachments = new List <Attachment> {
approvedAttachment
};
await turnContext.UpdateActivityAsync(approvedActivity);
response = JObject.Parse(cardJson);
adaptiveCardResponse = new AdaptiveCardInvokeResponse()
{
StatusCode = 200,
Type = AdaptiveCard.ContentType,
Value = response
};
return(CreateInvokeResponse(adaptiveCardResponse));
case "rejected":
string[] rejectedCard = { ".", "Resources", "rejectedCard.json" };
var rejectedAttachment = CardHelper.GetResponseAttachment(rejectedCard, data, out cardJson);
Activity rejectedActivity = new Activity();
rejectedActivity.Type = "message";
rejectedActivity.Id = turnContext.Activity.ReplyToId;
rejectedActivity.Attachments = new List <Attachment> {
rejectedAttachment
};
await turnContext.UpdateActivityAsync(rejectedActivity);
response = JObject.Parse(cardJson);
adaptiveCardResponse = new AdaptiveCardInvokeResponse()
{
StatusCode = 200,
Type = AdaptiveCard.ContentType,
Value = response
};
return(CreateInvokeResponse(adaptiveCardResponse));
}
}
return(null);
}
protected override async Task <InvokeResponse> OnInvokeActivityAsync(ITurnContext <IInvokeActivity> turnContext, CancellationToken cancellationToken)
{
if (Constants.ComposeExtensionFetch.Equals(turnContext.Activity.Name))
{
MessagingExtensionAction action = new MessagingExtensionAction();
var actionJson = JsonConvert.DeserializeObject <MessagingExtensionActionDeserializer>(turnContext.Activity.Value.ToString());
action.CommandId = actionJson.commandId;
var task = await this.OnTeamsMessagingExtensionFetchTaskAsync(turnContext, action, cancellationToken);
return(CreateInvokeResponse(task));
}
else if (Constants.ComposeExtensionSubmit.Equals(turnContext.Activity.Name))
{
MessagingExtensionAction action = new MessagingExtensionAction();
var task = await this.OnTeamsMessagingExtensionSubmitActionAsync(turnContext, action, cancellationToken);
return(CreateInvokeResponse(task));
}
else if (Constants.TaskModuleFetch.Equals(turnContext.Activity.Name))
{
var actionJson = JsonConvert.DeserializeObject <ActionBase>(turnContext.Activity.Value.ToString());
var task = await ReturnViewDetails(actionJson.data.reqId);
return(CreateInvokeResponse(task));
}
else if (Constants.AdaptiveCardAction.Equals(turnContext.Activity.Name))
{
var data = JsonConvert.DeserializeObject <ActionType>(turnContext.Activity.Value.ToString());
string channel = turnContext.Activity.ChannelId;
string verb = data.action.verb;
var blobInfo = BlobHelper.GetBlob(data.action.data.reqId, verb).Result;
string cardJsonString;
if (Status.Refresh.Equals(verb) && Status.Pending.Equals(blobInfo.status))
{
CardHelper.CreateAdaptiveCardAttachment(blobInfo.status, blobInfo, channel, out cardJsonString);
var cardResponse = JObject.Parse(cardJsonString);
var res = new AdaptiveCardInvokeResponse()
{
StatusCode = 200,
Type = AdaptiveCard.ContentType,
Value = cardResponse
};
return(CreateInvokeResponse(res));
}
else
{
var adaptiveCardAttachment = CardHelper.CreateAdaptiveCardAttachment(blobInfo.status, blobInfo, channel, out cardJsonString);
UpdateCardInTeams(blobInfo, adaptiveCardAttachment);
var cardResponse = JObject.Parse(cardJsonString);
var res = new AdaptiveCardInvokeResponse()
{
StatusCode = 200,
Type = AdaptiveCard.ContentType,
Value = cardResponse
};
return(CreateInvokeResponse(res));
}
}
return(null);
}
