private async Task <DialogTurnResult> TitleStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
{
var team = (Models.Team)stepContext.Result;
if (team == null)
{
await stepContext.Context.SendActivityAsync(MessageFactory.Text("No team was selected. Cancelled creating idea."), cancellationToken);
return(await stepContext.EndDialogAsync(cancellationToken : cancellationToken));
}
var createIdeaOptions = (CreateIdeaOptions)stepContext.Options;
if (createIdeaOptions.Title != null)
{
return(await stepContext.NextAsync(createIdeaOptions.Title, cancellationToken));
}
var member = await TeamsInfo.GetMemberAsync(stepContext.Context, stepContext.Context.Activity.From.Id, cancellationToken);
var promptOptions = new PromptOptions
{
Prompt = MessageFactory.Text($"Hi @{member.GivenName}! What is your idea?")
};
return(await stepContext.PromptAsync(nameof(TextPrompt), promptOptions, cancellationToken));
}
private async Task GetSingleMemberAsync(ITurnContext <IMessageActivity> turnContext, CancellationToken cancellationToken)
{
var member = new TeamsChannelAccount();
try
{
member = await TeamsInfo.GetMemberAsync(turnContext, turnContext.Activity.From.Id, cancellationToken);
}
catch (ErrorResponseException e)
{
if (e.Body.Error.Code.Equals("MemberNotFoundInConversation"))
{
await turnContext.SendActivityAsync("Member not found.");
return;
}
else
{
throw e;
}
}
var message = MessageFactory.Text($"You are: {member.Name}.");
var res = await turnContext.SendActivityAsync(message);
}
protected override async Task OnMessageActivityAsync(ITurnContext <IMessageActivity> turnContext, CancellationToken cancellationToken)
{
var input = turnContext.Activity.Text?.Trim();
if (input.ToLower().Contains("raise", StringComparison.InvariantCultureIgnoreCase))
{
serviceName = "Office 365";
imagePath = $"{imageBasePath}/office365_logo.jpg";
if (input.ToLower().Contains("sharepoint", StringComparison.InvariantCultureIgnoreCase))
{
serviceName = "SharePoint";
imagePath = $"{imageBasePath}/sharepoint_logo.png";
}
else if (input.ToLower().Contains("teams", StringComparison.InvariantCultureIgnoreCase))
{
serviceName = "MS Teams";
imagePath = $"{imageBasePath}/teams_logo.png";
}
var member = await TeamsInfo.GetMemberAsync(turnContext, turnContext.Activity.From.Id, cancellationToken);
await SendHttpToTeams(HttpMethod.Post, MessageFactory.Attachment(new CardResource("InitialCard.json").AsAttachment(
new
{
createdByUserID = member.Id,
createdBy = turnContext.Activity.From.Name,
serviceName = serviceName,
imagePath = imagePath
})), turnContext.Activity.Conversation.Id);
}
else
{
await turnContext.SendActivityAsync(MessageFactory.Text("Invalid parameter"), cancellationToken);
}
}
/// <summary>
/// Handle when a message is addressed to the bot.
/// </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 OnMessageActivityAsync(ITurnContext <IMessageActivity> turnContext, CancellationToken cancellationToken)
{
if (turnContext.Activity.Text != null)
{
if (turnContext.Activity.Text.ToLower().Trim() == "staticsearch")
{
string[] path = { ".", "Cards", "StaticSearchCard.json" };
var member = await TeamsInfo.GetMemberAsync(turnContext, turnContext.Activity.From.Id, cancellationToken);
var initialAdaptiveCard = GetFirstOptionsAdaptiveCard(path, turnContext.Activity.From.Name, member.Id);
await turnContext.SendActivityAsync(MessageFactory.Attachment(initialAdaptiveCard), cancellationToken);
}
else if (turnContext.Activity.Text.ToLower().Trim() == "dynamicsearch")
{
string[] path = { ".", "Cards", "DynamicSearchCard.json" };
var member = await TeamsInfo.GetMemberAsync(turnContext, turnContext.Activity.From.Id, cancellationToken);
var initialAdaptiveCard = GetFirstOptionsAdaptiveCard(path, turnContext.Activity.From.Name, member.Id);
await turnContext.SendActivityAsync(MessageFactory.Attachment(initialAdaptiveCard), cancellationToken);
}
}
else if (turnContext.Activity.Value != null)
{
var data = JsonConvert.DeserializeObject <StaticSearchCard>(turnContext.Activity.Value.ToString());
await turnContext.SendActivityAsync(MessageFactory.Text("Selected option is: " + data.choiceSelect), cancellationToken);
}
}
/// <inheritdoc/>
public override async Task <DialogTurnResult> BeginDialogAsync(DialogContext dc, object options = null, CancellationToken cancellationToken = default(CancellationToken))
{
if (options is CancellationToken)
{
throw new ArgumentException($"{nameof(options)} cannot be a cancellation token");
}
if (Disabled != null && Disabled.GetValue(dc.State))
{
return(await dc.EndDialogAsync(cancellationToken : cancellationToken).ConfigureAwait(false));
}
if (dc.Context.Activity.ChannelId != Channels.Msteams)
{
throw new InvalidOperationException($"{Kind} works only on the Teams channel.");
}
string memberId = MemberId.GetValueOrNull(dc.State);
if (string.IsNullOrEmpty(memberId))
{
throw new InvalidOperationException($"Missing {nameof(MemberId)} in {Kind}.");
}
var result = await TeamsInfo.GetMemberAsync(dc.Context, memberId, cancellationToken : cancellationToken).ConfigureAwait(false);
if (Property != null)
{
dc.State.SetValue(Property.GetValue(dc.State), result);
}
return(await dc.EndDialogAsync(result, cancellationToken : cancellationToken).ConfigureAwait(false));
}
protected override async Task OnMessageActivityAsync(ITurnContext <IMessageActivity> turnContext, CancellationToken cancellationToken)
{
if (turnContext.Activity.Text == "Add me")
{
var member = await TeamsInfo.GetMemberAsync(turnContext, turnContext.Activity.From.Id, cancellationToken);
var user = new UserDetailsEntity()
{
Name = (member.Name).Split(" ")[0], //indsert proper name
UserUniqueID = turnContext.Activity.From.Id,
AadId = turnContext.Activity.From.AadObjectId,
EmailId = member.Email,
ProfilePictureURL = string.Empty,
RowKey = Guid.NewGuid().ToString(),
PartitionKey = PartitionKeyNames.UserDetailsDataTable.TableName
};
await _userDetailsRepository.CreateOrUpdateAsync(user);
var reply = MessageFactory.Text("Your data is recorded !");
await turnContext.SendActivityAsync(reply, cancellationToken);
}
else
{
var reply = MessageFactory.Text("Welcome to Task Manager, Try crating new Tasks using Messaging extension");
await turnContext.SendActivityAsync(reply, cancellationToken);
}
}
protected override async Task <MessagingExtensionActionResponse> OnTeamsMessagingExtensionSubmitActionAsync(ITurnContext <IInvokeActivity> turnContext, MessagingExtensionAction action, CancellationToken cancellationToken)
{
var taskModuleOutput = JsonConvert.DeserializeObject <TaskModuleSubmitDataDeserializer>(turnContext.Activity.Value.ToString());
if (taskModuleOutput.data.SubmittedByMail == null)
{
action.CommandId = taskModuleOutput.commandId;
var task = await OnTeamsMessagingExtensionFetchTaskAsync(turnContext, action, cancellationToken);
return(task);
}
if (taskModuleOutput.commandId == Constants.MessageExtensionCommandId)
{
var member = await TeamsInfo.GetMemberAsync(turnContext, taskModuleOutput.data.AssignedTo.objectId, cancellationToken);
taskModuleOutput.data.AssignedTo.objectId = member.Id;
var blobId = await BlobHelper.UploadToBlob(taskModuleOutput, turnContext);
var blobData = BlobHelper.GetBlob(blobId, null).Result;
var cardResponse = CardHelper.CreateAdaptiveCardAttachment(Status.BaseCard, blobData, "msteams", out string cardJsonstring);
var messageResponse = await turnContext.SendActivityAsync(MessageFactory.Attachment(cardResponse), cancellationToken);
string messageId = messageResponse.Id;
BlobHelper.GetBlob(blobId, null, messageId);
//Send Mail
await OutlookConnector.SendMailAsync(Constants.SenderEmail, blobData.assignedToMail, cardJsonstring, Constants.MailSubject);
}
return(new MessagingExtensionActionResponse());
}
protected override async Task OnMessageActivityAsync(ITurnContext <IMessageActivity> turnContext, CancellationToken cancellationToken)
{
string[] path = { ".", "Resources", "initialCard.json" };
var member = await TeamsInfo.GetMemberAsync(turnContext, turnContext.Activity.From.Id, cancellationToken);
var initialAdaptiveCard = CardHelper.GetFirstOptionsAdaptiveCard(path, turnContext.Activity.From.Name, member.Id);
await turnContext.SendActivityAsync(MessageFactory.Attachment(initialAdaptiveCard), cancellationToken);
}
private async Task CallTeamGetMemberAsync(ITurnContext turnContext)
{
var member = await TeamsInfo.GetMemberAsync(turnContext, turnContext.Activity.From.Id);
Assert.AreEqual("id-1", member.Id);
Assert.AreEqual("name-1", member.Name);
Assert.AreEqual("givenName-1", member.GivenName);
Assert.AreEqual("surname-1", member.Surname);
Assert.AreEqual("userPrincipalName-1", member.UserPrincipalName);
}
/// <summary>
/// 查找解决方案
/// </summary>
/// <param name="stepContext"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
private async Task <DialogTurnResult> FindSolutionAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
{
// 创建请求时的标题
var subject = $"From Aden Test Bot：{stepContext.Context.Activity.RemoveRecipientMention().Replace("\r", "").Replace("\n", "")}";
// 获取答案
var results = await _qna.GetAnswersAsync(stepContext.Context);
// 匹配到解决方案
if (results.Any())
{
// QnA Maker 答案中存放的是解决方案 ID
var answer = results.FirstOrDefault();
var data = new TaskFetchValueModel
{
Data = answer.Answer,
Type = TaskFetchTypes.Solution
};
var card = new ThumbnailCard
{
Buttons = new List <CardAction> {
new CardAction("invoke", "查看解决方案", value: new { type = "task/fetch", data })
}
};
var activity = stepContext.Context.Activity.CreateReply("为您找到以下解决方案：");
activity.Attachments.Add(card.ToAttachment());
// 发送找到解决方案的消息，包含“查看解决方案”按钮
await stepContext.Context.SendActivityAsync(activity);
// 并自动发起请求
var member = await TeamsInfo.GetMemberAsync(stepContext.Context, stepContext.Context.Activity.From.Id, cancellationToken);
var requester = member.GetRequesterName();
var request = new AddRequestRequestModel
{
Request = new AddRequestRequest(subject, requester)
};
var result = await _request.AddRequestAsync(request);
if (result.ResponseStatus.StatusCode == 2000)
{
// TODO 记录自动创建的请求，后续可对这个请求追踪状态变化
var reply = MessageFactory.Text($"已自动创建请求【[{subject}](https://helpme.adenservices.com/WorkOrder.do?woMode=viewWO&woID={result.Request.Id})】。");
await stepContext.Context.SendActivityAsync(reply, cancellationToken);
// 15 分钟后自动修改这个请求的状态
BackgroundJob.Schedule <RequestHelper>(r => r.ResolvedRequestAsync(result.Request.Id), TimeSpan.FromMinutes(15));
}
// 结束对话
return(await stepContext.EndDialogAsync(null, cancellationToken).ConfigureAwait(false));
}
return(await stepContext.NextAsync(subject, cancellationToken).ConfigureAwait(false));
}
protected override async Task <MessagingExtensionActionResponse> OnTeamsMessagingExtensionFetchTaskAsync(ITurnContext <IInvokeActivity> turnContext, MessagingExtensionAction action, CancellationToken cancellationToken)
{
string memberName;
try
{
// Check if your app is installed by fetching member information.
var member = await TeamsInfo.GetMemberAsync(turnContext, turnContext.Activity.From.Id, cancellationToken);
memberName = member.Name;
}
catch (ErrorResponseException ex)
{
if (ex.Body.Error.Code == "BotNotInConversationRoster")
{
return(new MessagingExtensionActionResponse
{
Task = new TaskModuleContinueResponse
{
Value = new TaskModuleTaskInfo
{
Card = CardHelper.CreateJustInTimeCard("JITinstallation.json"),
Height = 200,
Width = 400,
Title = "Device Capabilities - App Installation",
},
},
});
}
throw;
}
if (action.CommandId == Constants.MessageExtensionCommandId)
{
var response = new MessagingExtensionActionResponse()
{
Task = new TaskModuleContinueResponse()
{
Value = new TaskModuleTaskInfo()
{
Height = 450,
Width = 350,
Title = "Bar Code Scanner",
Url = Constants.BaseUrl + "/Scanner",
},
},
};
return(response);
}
return(new MessagingExtensionActionResponse());
}
private async Task <AddRequestRequestModel> CreateRequestFromModelAsync(InputWorkOrderModel model, ITurnContext turnContext, CancellationToken cancellationToken)
{
var member = await TeamsInfo.GetMemberAsync(turnContext, turnContext.Activity.From.Id, cancellationToken);
var requester = member.GetRequesterName();
return(new AddRequestRequestModel
{
Request = new AddRequestRequest(model.Subject, requester)
{
Description = model.Description
}
});
}
protected override async Task <MessagingExtensionActionResponse> OnTeamsMessagingExtensionFetchTaskAsync(ITurnContext <IInvokeActivity> turnContext, MessagingExtensionAction action, CancellationToken cancellationToken)
{
// we are handling two cases within try/catch block
//if the bot is installed it will create adaptive card attachment and show card with input fields
string memberName;
try
{
// Check if your app is installed by fetching member information.
var member = await TeamsInfo.GetMemberAsync(turnContext, turnContext.Activity.From.Id, cancellationToken);
memberName = member.Name;
}
catch (ErrorResponseException ex)
{
if (ex.Body.Error.Code == "BotNotInConversationRoster")
{
return(new MessagingExtensionActionResponse
{
Task = new TaskModuleContinueResponse
{
Value = new TaskModuleTaskInfo
{
Card = GetAdaptiveCardAttachmentFromFile("justintimeinstallation.json"),
Height = 200,
Width = 400,
Title = "Adaptive Card - App Installation",
},
},
});
}
throw; // It's a different error.
}
return(new MessagingExtensionActionResponse
{
Task = new TaskModuleContinueResponse
{
Value = new TaskModuleTaskInfo
{
Card = GetAdaptiveCardAttachmentFromFile("adaptiveCard.json"),
Height = 200,
Width = 400,
Title = $"Welcome {memberName}",
},
},
});
}
/// <summary>
/// Process task module fetch request.
/// </summary>
/// <param name="turnContext">Provides context for a turn in a bot.</param>
/// <returns>A task that represents a response.</returns>
public async Task <TaskModuleResponse> OnTaskModuleFetchRequestAsync(ITurnContext <IInvokeActivity> turnContext)
{
turnContext = turnContext ?? throw new ArgumentNullException(nameof(turnContext), "Turn context cannot be null");
var member = await TeamsInfo.GetMemberAsync(turnContext, turnContext.Activity.From.Id, CancellationToken.None);
if (member == null)
{
return(this.GetTaskModuleResponse(new Uri($"{this.botOptions.Value.AppBaseUri}/error"), this.localizer.GetString("ErrorTitle")));
}
var activity = turnContext.Activity as Activity;
var activityValue = JObject.Parse(activity.Value?.ToString())["data"].ToString();
AdaptiveSubmitActionData adaptiveTaskModuleCardAction = JsonConvert.DeserializeObject <AdaptiveSubmitActionData>(activityValue);
if (adaptiveTaskModuleCardAction == null)
{
this.logger.LogInformation("Value obtained from task module fetch action is null");
}
var command = adaptiveTaskModuleCardAction.Command;
Uri taskModuleRequestUrl;
switch (command)
{
case BotCommands.EditEvent:
taskModuleRequestUrl = new Uri($"{this.botOptions.Value.AppBaseUri}/create-event?teamId={adaptiveTaskModuleCardAction.EventId}&eventId={adaptiveTaskModuleCardAction.EventId}");
return(this.GetTaskModuleResponse(taskModuleRequestUrl, this.localizer.GetString("EditEventCardButton")));
case BotCommands.CreateEvent:
taskModuleRequestUrl = new Uri($"{this.botOptions.Value.AppBaseUri}/create-event");
return(this.GetTaskModuleResponse(taskModuleRequestUrl, this.localizer.GetString("CreateEventButtonWelcomeCard")));
case BotCommands.CloseRegistration:
taskModuleRequestUrl = new Uri($"{this.botOptions.Value.AppBaseUri}/close-or-cancel-event?operationType={(int)EventOperationType.CloseRegistration}&eventId={adaptiveTaskModuleCardAction.EventId}&teamId={adaptiveTaskModuleCardAction.TeamId}");
return(this.GetTaskModuleResponse(taskModuleRequestUrl, this.localizer.GetString("CloseRegistrationCardButton")));
case BotCommands.RegisterForEvent:
taskModuleRequestUrl = new Uri($"{this.botOptions.Value.AppBaseUri}/register-remove?eventId={adaptiveTaskModuleCardAction.EventId}&teamId={adaptiveTaskModuleCardAction.TeamId}");
return(this.GetTaskModuleResponse(taskModuleRequestUrl, this.localizer.GetString("RegisterButton")));
default:
return(this.GetTaskModuleResponse(new Uri($"{this.botOptions.Value.AppBaseUri}/error"), this.localizer.GetString("ErrorTitle")));
}
}
private async Task MentionAdaptiveCardActivityAsync(ITurnContext <IMessageActivity> turnContext, CancellationToken cancellationToken)
{
var member = new TeamsChannelAccount();
try
{
member = await TeamsInfo.GetMemberAsync(turnContext, turnContext.Activity.From.Id, cancellationToken);
}
catch (ErrorResponseException e)
{
if (e.Body.Error.Code.Equals("MemberNotFoundInConversation"))
{
await turnContext.SendActivityAsync("Member not found.");
return;
}
else
{
throw e;
}
}
var templateJSON = File.ReadAllText(_adaptiveCardTemplate);
AdaptiveCardTemplate template = new AdaptiveCardTemplate(templateJSON);
var memberData = new
{
userName = member.Name,
userUPN = member.UserPrincipalName,
userAAD = member.AadObjectId
};
string cardJSON = template.Expand(memberData);
var adaptiveCardAttachment = new Attachment
{
ContentType = "application/vnd.microsoft.card.adaptive",
Content = JsonConvert.DeserializeObject(cardJSON),
};
await turnContext.SendActivityAsync(MessageFactory.Attachment(adaptiveCardAttachment), cancellationToken);
}
/// <summary>
/// Provide team members information.
/// </summary>
/// <param name="memoryCache">MemoryCache instance for caching on call expert objectId's.</param>
/// <param name="turnContext">Provides context for a turn of a bot.</param>
/// <param name="userId">Describes a user Id.</param>
/// <param name="teamId">Describes a team Id.</param>
/// <param name="cancellationToken">Propagates notification that operations should be canceled.</param>
/// <returns>Returns team members information from cache.</returns>
public static async Task <TeamsChannelAccount> GetMemberInfoAsync(IMemoryCache memoryCache, ITurnContext turnContext, string userId, string teamId, CancellationToken cancellationToken)
{
bool isCacheEntryExists = memoryCache.TryGetValue(ExpertCollectionCacheKey + userId, out TeamsChannelAccount memberInformation);
if (!isCacheEntryExists)
{
if (teamId != null)
{
memberInformation = await TeamsInfo.GetTeamMemberAsync(turnContext, userId, teamId);
}
else
{
memberInformation = await TeamsInfo.GetMemberAsync(turnContext, userId, cancellationToken);
}
if (memberInformation != null)
{
memoryCache.Set(ExpertCollectionCacheKey + userId, memberInformation, CacheDuration);
}
}
return(memberInformation);
}
protected override async Task <DialogTurnResult> OnBeginDialogAsync(DialogContext innerDc, object options, CancellationToken cancellationToken = default)
{
try
{
var activity = innerDc.Context.Activity;
string message = string.Empty;
var userDetails = await TeamsInfo.GetMemberAsync(innerDc.Context, innerDc.Context.Activity.From.Id);//await GetCurrentUserDetails(activity);
if (userDetails == null)
{
await innerDc.Context.SendActivityAsync(MessageFactory.Text("Failed to read user profile. Please try again."), cancellationToken);//await context.PostAsync("Failed to read user profile. Please try again.");
}
if (!string.IsNullOrEmpty(activity.Text))
{
message = RemoveMention(activity.Text.ToLower());
Attachment card = null;
string crewid = string.Empty;
switch (message)
{
case Constants.NextMonthRoster:
crewid = await graphHelper.GetUserEmployeeIdAsync(userDetails.UserPrincipalName); // ${Debugging}
card = CardHelper.GetMonthlyRosterCard(crewid);
break;
case Constants.NextWeekRoster:
crewid = await graphHelper.GetUserEmployeeIdAsync(userDetails.UserPrincipalName);
card = await CardHelper.GetWeeklyRosterCard(crewid, configuration);
// card = await CardHelper.GetWeeklyRosterCard("10055"); // ${Debugging}
break;
case Constants.UpdateCard:
card = CardHelper.GetUpdateScreen();
break;
case Constants.ShowDetailedRoster:
card = await GetDetailedRoasterCard(activity, userDetails, this.graphHelper, configuration);
break;
default:
card = CardHelper.GetWelcomeScreen(userDetails.GivenName ?? userDetails.Name);
break;
}
await innerDc.Context.SendActivityAsync(MessageFactory.Attachment(card), cancellationToken);
}
else if (activity.Value != null)
{
await HandleActions(innerDc.Context, cancellationToken, activity, userDetails);
}
}
catch (Exception e)
{
await innerDc.Context.SendActivityAsync(MessageFactory.Text(e.ToString()), cancellationToken);// await context.PostAsync(e.ToString()).ConfigureAwait(false);
}
return(await innerDc.EndDialogAsync());
}
protected override async Task OnConversationUpdateActivityAsync(ITurnContext <IConversationUpdateActivity> turnContext, CancellationToken cancellationToken)
{
var activity = turnContext.Activity;
// ConnectorClient connector = new ConnectorClient(new Uri(message.ServiceUrl));
var channelData = activity.GetChannelData <TeamsChannelData>();
// Treat 1:1 add/remove events as if they were add/remove of a team member
if (channelData.EventType == null)
{
if (activity.MembersAdded != null)
{
channelData.EventType = "teamMemberAdded";
}
if (activity.MembersRemoved != null)
{
channelData.EventType = "teamMemberRemoved";
}
}
switch (channelData.EventType)
{
case "teamMemberAdded":
// Team member was added (user or bot)
if (activity.MembersAdded.Any(m => m.Id.Contains(activity.Recipient.Id)))
{
// Bot was added to a team: send welcome message
// activity.Text = "hi";
// await Conversation.SendAsync(activity, () => new RootDialog());
await this.SendTypingIndicatorAsync(turnContext);
await dialog.RunAsync(turnContext, conversationState.CreateProperty <DialogState>("DialogState"), cancellationToken);
var userDetails = await TeamsInfo.GetMemberAsync(turnContext, turnContext.Activity.From.Id);
var card = CardHelper.GetWelcomeScreen(userDetails.GivenName ?? userDetails.Name);
}
break;
case "teamMemberRemoved":
// Add team & channel details
if (activity.MembersRemoved.Any(m => m.Id.Contains(activity.Recipient.Id)))
{
// Bot was removed from a team: remove entry for the team in the database
}
else
{
// Member was removed from a team: update the team member count
}
break;
// Update the team and channel info in the database when the team is rename or when channel are added/removed/renamed
case "teamRenamed":
// Rename team & channel details
break;
case "channelCreated":
break;
case "channelRenamed":
break;
case "channelDeleted":
break;
default:
break;
}
}
private async Task ShowMemberAsync(ITurnContext <IMessageActivity> turnContext, CancellationToken cancellationToken)
{
var account = await TeamsInfo.GetMemberAsync(turnContext, turnContext.Activity.From.Id, cancellationToken).ConfigureAwait(false);
await turnContext.SendActivityAsync(MessageFactory.Text($"Your name is {account.Name}. Your email address is {account.Email}")).ConfigureAwait(false);
}
/// <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 OnMessageActivityAsync(ITurnContext <IMessageActivity> turnContext, CancellationToken cancellationToken)
{
try
{
var member = await TeamsInfo.GetMemberAsync(turnContext, turnContext.Activity.From.Id, cancellationToken);
var username = member.UserPrincipalName;
string message;
Guid postId;
string domainName;
if (!String.IsNullOrEmpty(turnContext.Activity.Text))
{
var connectionString = _config.GetConnectionString("Storage");
var storageAccount = CloudStorageAccount.Parse(connectionString);
var tableClient = storageAccount.CreateCloudTableClient();
var table = tableClient.GetTableReference("users");
var user = (User)table.Execute(TableOperation.Retrieve <User>(username, "")).Result;
if (user == null)
{
await turnContext.SendActivityAsync(MessageFactory.Text("Sorry, I couldn't find your user details. Please remove and re-add the D365 Posts Bot app in Teams and try again"));
return;
}
if (user.LastPostId == null)
{
await turnContext.SendActivityAsync(MessageFactory.Text("Sorry, I couldn't find a message to reply to. Please use the Reply button on the post you want to reply to."));
return;
}
message = turnContext.Activity.Text;
postId = user.LastPostId.Value;
domainName = user.LastDomainName;
}
else
{
dynamic val = turnContext.Activity.Value;
message = val.comment;
postId = val.PostId;
domainName = val.DomainName;
}
await turnContext.SendActivityAsync(new Activity { Type = ActivityTypes.Typing });
try
{
using (var org = new CdsServiceClient(new Uri("https://" + domainName), _config.GetValue <string>("MicrosoftAppId"), _config.GetValue <string>("MicrosoftAppPassword"), true, null))
{
// Find the CDS user details
var userQry = new QueryByAttribute("systemuser")
{
ColumnSet = new ColumnSet("systemuserid")
};
userQry.AddAttributeValue("domainname", username);
var users = org.RetrieveMultiple(userQry);
if (users.Entities.Count == 0)
{
throw new ApplicationException("Could not find your user account in D365");
}
org.CallerId = users.Entities[0].Id;
var postComment = new Entity("postcomment")
{
["postid"] = new EntityReference("post", postId),
["text"] = message
};
org.Create(postComment);
}
await turnContext.SendActivityAsync(MessageFactory.Text("Your reply has been sent"));
}
catch (Exception ex)
{
await turnContext.SendActivityAsync(MessageFactory.Text("There was an error sending your reply back to D365: " + ex.Message));
}
}
catch (Exception ex)
{
await turnContext.SendActivityAsync(MessageFactory.Text(ex.ToString()));
}
}
/// <summary>
/// Gets the account of a single conversation member.
/// This works in one-on-one, group, and teams scoped conversations.
/// </summary>
/// <param name="turnContext"> Turn context. </param>
/// <param name="memberId"> ID of the user in question. </param>
/// <param name="cancellationToken"> cancellation token. </param>
/// <returns>Team Details.</returns>
public virtual async Task <TeamsChannelAccount> GetMemberAsync(ITurnContext turnContext, string memberId, CancellationToken cancellationToken)
{
return(await TeamsInfo.GetMemberAsync(turnContext, memberId, cancellationToken));
}
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);
}
