public Game1()
{
graphics = new GraphicsDeviceManager(this);
graphics.IsFullScreen = true;
graphics.SupportedOrientations = DisplayOrientation.LandscapeRight;
Content.RootDirectory = "Content";
Statistics.maxMushrooms = 0;
Statistics.maxBloobs = 0;
Statistics.maxSpecials = 0;
Statistics.maxCombo = 0;
Statistics.maxJumps = 0;
Statistics.maxPoints = 0;
infoCard = new InfoCard();
statisticCard = new StatisticsCard();
devInfoCard = new DevelopInfoCard();
helpCard = new HelpCard();
// var wbt = new WebBrowserTask();
// wbt.URL = "http://stackoverflow.com/";
// wbt.Show();
// Facebook.HttpMethod
// Facebook.FacebookClient face = new Facebook.FacebookClient();
// face.
}
/// <summary>
/// Send help card containing commands recognized by bot.
/// </summary>
/// <param name="stepContext">Context object passed in to a WaterfallStep.</param>
/// <returns>A task that represents the work queued to execute.</returns>
private async Task ShowHelpCardAsync(WaterfallStepContext stepContext)
{
var reply = stepContext.Context.Activity.CreateReply();
reply.AttachmentLayout = AttachmentLayoutTypes.Carousel;
reply.Attachments = HelpCard.GetHelpAttachments();
await stepContext.Context.SendActivityAsync(reply).ConfigureAwait(false);
}
protected void RelationClickedHandler(object sender, DynamicCardControl.RelationClickedEventArgs e)
{
TeplatesFilters.Visible = false;
SaveObjects.Visible = false;
DeleteImage.Visible = false;
DeleteInstance.Visible = false;
ListEntity.Visible = false;
RecordsNumberLabel.Visible = false;
var relation = e.Relation;
var reader = new DatabaseReader(Teleform.ProjectMonitoring.HttpApplication.Global.ConnectionString);
var entID = int.Parse(e.Relation.Entity.ID.ToString());
var instanceID = reader.GetInstanceID(relation);
InitializeDynamicCards(HelpCard, entID, instanceID, null);
HelpCard.Recreate();
AdditionalViews.SetActiveView(ObjectView);
}
/// <inheritdoc/>
protected override async Task OnMessageActivityAsync(ITurnContext <IMessageActivity> turnContext, CancellationToken cancellationToken)
{
try
{
await this.SendTypingIndicatorAsync(turnContext);
var conversationType = turnContext.Activity.Conversation.ConversationType;
string conversationId = turnContext.Activity.Conversation.Id;
if (string.Compare(conversationType, "groupChat", StringComparison.OrdinalIgnoreCase) == 0)
{
if (turnContext.Activity.Type.Equals(ActivityTypes.Message))
{
turnContext.Activity.RemoveRecipientMention();
switch (turnContext.Activity.Text.Trim().ToLower())
{
case Constants.Start:
this.telemetryClient.TrackTrace($"scrum {conversationId} started by {turnContext.Activity.From.Id}");
var scrum = await this.scrumProvider.GetScrumAsync(conversationId);
if (scrum != null && scrum.IsScrumRunning)
{
// check if member in scrum exists.
// A user is added during a running scrum and tries to start a new scrum.
var activityId = this.GetActivityIdToMatch(scrum.MembersActivityIdMap, turnContext.Activity.From.Id);
if (activityId == null)
{
await turnContext.SendActivityAsync(string.Format(Resources.NoPartOfScrumStartText, turnContext.Activity.From.Name));
this.telemetryClient.TrackTrace($"Member who is updating the scrum is not the part of scrum for : {conversationId}");
}
else
{
this.telemetryClient.TrackTrace($"Scrum is already running for conversation id {conversationId}");
await turnContext.SendActivityAsync(Resources.RunningScrumMessage);
}
}
else
{
// start a new scrum
this.telemetryClient.TrackTrace($"Scrum start for : {conversationId}");
await this.StartScrumAsync(turnContext, cancellationToken);
}
break;
case Constants.TakeATour:
var tourCards = TourCard.GetTourCards(this.configuration["AppBaseURL"]);
await turnContext.SendActivityAsync(MessageFactory.Carousel(tourCards));
break;
case Constants.CompleteScrum:
var scrumInfo = await this.scrumProvider.GetScrumAsync(conversationId);
if (scrumInfo.IsScrumRunning)
{
var activityId = this.GetActivityIdToMatch(scrumInfo.MembersActivityIdMap, turnContext.Activity.From.Id);
// check if member in scrum exists.
// A user is added during a running scrum and tries to complete the running scrum.
if (activityId == null)
{
await turnContext.SendActivityAsync(string.Format(Resources.NoPartOfCompleteScrumText, turnContext.Activity.From.Name));
this.telemetryClient.TrackTrace($"Member who is updating the scrum is not the part of scrum for : {conversationId}");
}
else
{
var cardId = scrumInfo.ScrumStartActivityId;
var activity = MessageFactory.Attachment(ScrumCompleteCard.GetScrumCompleteCard());
activity.Id = cardId;
activity.Conversation = turnContext.Activity.Conversation;
await turnContext.UpdateActivityAsync(activity, cancellationToken);
// Update the trail card
var dateString = string.Format("{{{{TIME({0})}}}}", DateTime.UtcNow.ToString("yyyy'-'MM'-'dd'T'HH':'mm':'ss'Z'"));
string cardTrailMessage = string.Format(Resources.ScrumCompletedByText, turnContext.Activity.From.Name, dateString);
await this.UpdateTrailCard(cardTrailMessage, turnContext, cancellationToken);
scrumInfo.IsScrumRunning = false;
scrumInfo.ThreadConversationId = conversationId;
var savedData = await this.scrumProvider.SaveOrUpdateScrumAsync(scrumInfo);
if (!savedData)
{
await turnContext.SendActivityAsync(Resources.ErrorMessage);
return;
}
this.telemetryClient.TrackTrace($"Scrum completed by: {turnContext.Activity.From.Name} for {conversationId}");
}
}
else
{
await turnContext.SendActivityAsync(Resources.CompleteScrumErrorText);
}
break;
default:
await turnContext.SendActivityAsync(MessageFactory.Attachment(HelpCard.GetHelpCard()), cancellationToken);
break;
}
}
}
else
{
await turnContext.SendActivityAsync(Resources.ScopeErrorMessage);
}
}
catch (Exception ex)
{
this.telemetryClient.TrackTrace($"For {turnContext.Activity.Conversation.Id} : Message Activity failed: {ex.Message}");
this.telemetryClient.TrackException(ex);
}
}
/// <summary>
/// Handle when a message is addressed to the bot.
/// </summary>
/// <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 resolving to either a login card or the adaptive card of the Reddit post.</returns>
/// <remarks>
/// For more information on bot messaging in Teams, see the documentation
/// https://docs.microsoft.com/en-us/microsoftteams/platform/bots/how-to/conversations/conversation-basics?tabs=dotnet#receive-a-message .
/// </remarks>
protected override async Task OnMessageActivityAsync(ITurnContext <IMessageActivity> turnContext, CancellationToken cancellationToken)
{
turnContext = turnContext ?? throw new ArgumentNullException(nameof(turnContext));
this.RecordEvent(nameof(this.OnMessageActivityAsync), turnContext);
var activity = turnContext.Activity;
var command = activity.Text.ToUpperInvariant().Trim();
await this.SendTypingIndicatorAsync(turnContext);
if (activity.Conversation.ConversationType == CardConstants.PersonalConversationType)
{
var userGraphAccessToken = await this.tokenHelper.GetUserTokenAsync(activity.From.Id);
if (userGraphAccessToken == null)
{
await this.dialog.RunAsync(turnContext, this.conversationState.CreateProperty <DialogState>(nameof(DialogState)), cancellationToken);
return;
}
// Command to send feedback card.
if (command.Equals(this.localizer.GetString("ShareFeedbackText").ToString(), StringComparison.InvariantCultureIgnoreCase))
{
var shareFeedbackCardActivity = MessageFactory.Attachment(FeedbackCard.GetFeedbackCardAttachment(this.localizer));
await turnContext.SendActivityAsync(shareFeedbackCardActivity, cancellationToken);
return;
}
// Command to save feedback.
else if (command.Equals(this.localizer.GetString("SubmitFeedbackCommandText").ToString(), StringComparison.InvariantCultureIgnoreCase))
{
await this.activityHelper.SubmitFeedbackAsync(turnContext);
return;
}
// Command to send on-boarding checklist card.
else if (command.Equals(this.localizer.GetString("OnBoardingCheckListText").ToString(), StringComparison.InvariantCultureIgnoreCase))
{
var userDetail = await this.userStorageProvider.GetUserDetailAsync(activity.From.AadObjectId);
bool isNewHire = userDetail?.UserRole == (int)UserRole.NewHire;
// Learning plan bot command supports only for new hire.
if (!isNewHire)
{
await turnContext.SendActivityAsync(MessageFactory.Attachment(OnBoardingCheckListCard.GetCard(this.localizer, this.botOptions.Value.ManifestId)));
return;
}
await this.learningPlanHelper.GetWeeklyLearningPlanCardAsync(turnContext, userDetail.BotInstalledOn);
}
// Bot sign-out command.
else if (command.Equals(this.localizer.GetString("LogoutText").ToString(), StringComparison.InvariantCultureIgnoreCase))
{
await this.dialog.RunAsync(turnContext, this.conversationState.CreateProperty <DialogState>(nameof(DialogState)), cancellationToken);
return;
}
// Command to send more info card to new hire employee.
else if (command.Equals(this.localizer.GetString("RequestMoreInfoText").ToString(), StringComparison.InvariantCultureIgnoreCase))
{
var valuesfromCard = ((JObject)activity.Value).ToObject <AdaptiveSubmitActionData>();
await this.activityHelper.RequestMoreInfoActionAsync(turnContext, valuesfromCard, cancellationToken);
return;
}
// Command to send user tour based on his role.
else if (command.Equals(this.localizer.GetString("HelpText").ToString(), StringComparison.InvariantCultureIgnoreCase))
{
var userDetail = await this.userStorageProvider.GetUserDetailAsync(activity.From.AadObjectId);
bool isManager = userDetail?.UserRole == (int)UserRole.HiringManager;
// Send help cards based on their role.
await turnContext.SendActivityAsync(MessageFactory.Carousel(CarouselCard.GetUserHelpCards(
this.botOptions.Value.AppBaseUri,
this.localizer,
this.botOptions.Value.ManifestId,
isManager)));
return;
}
// Command to send pending review introduction list card.
else if (command.Equals(this.localizer.GetString("ReviewIntroductionText").ToString(), StringComparison.InvariantCultureIgnoreCase))
{
var user = await this.userStorageProvider.GetUserDetailAsync(activity.From.AadObjectId);
if (user != null && user.UserRole != (int)UserRole.HiringManager)
{
await turnContext.SendActivityAsync(MessageFactory.Attachment(HelpCard.GetCard(this.localizer)));
return;
}
var introductionEntities = await this.introductionStorageProvider.GetFilteredIntroductionsAsync(activity.From.AadObjectId);
if (!introductionEntities.Any())
{
await turnContext.SendActivityAsync(this.localizer.GetString("NoPendingIntroductionText"));
return;
}
var batchCount = (int)Math.Ceiling((double)introductionEntities.Count() / ListCardItemsLimit);
for (int batchIndex = 0; batchIndex < batchCount; batchIndex++)
{
var batchWiseIntroductionEntities = introductionEntities
.Skip(batchIndex * ListCardItemsLimit)
.Take(ListCardItemsLimit);
var listCardAttachment = await this.introductionCardHelper.GetReviewIntroductionListCardAsync(batchWiseIntroductionEntities, userGraphAccessToken);
await turnContext.SendActivityAsync(MessageFactory.Attachment(listCardAttachment));
}
return;
}
// Command to send week wise learning plan cards.
else if (command.Equals(this.localizer.GetString("ViewLearningText").ToString(), StringComparison.InvariantCultureIgnoreCase))
{
var userDetail = await this.userStorageProvider.GetUserDetailAsync(activity.From.AadObjectId);
await this.learningPlanHelper.GetWeeklyLearningPlanCardAsync(turnContext, userDetail.BotInstalledOn);
}
// Command to resume/pause all matches.
else if (command.Equals(BotCommandConstants.ResumeAllMatches, StringComparison.InvariantCultureIgnoreCase) ||
command.Equals(BotCommandConstants.PauseAllMatches, StringComparison.InvariantCultureIgnoreCase))
{
await this.activityHelper.GetUpdatedMatchesStatusAsync(turnContext, command, cancellationToken);
}
else
{
// If message is from complete learning plan list item tap event.
if (command.StartsWith(this.localizer.GetString("ViewWeeklyLearningPlanCommandText"), StringComparison.InvariantCultureIgnoreCase))
{
// Get learning plan card selected from complete learning plan list card.
var learningCard = await this.learningPlanHelper.GetLearningPlanCardAsync(command);
// Send learning plan data card.
await turnContext.SendActivityAsync(MessageFactory.Attachment(learningCard));
}
else if (command.StartsWith(this.localizer.GetString("ReviewIntroductionCommandText"), StringComparison.InvariantCultureIgnoreCase))
{
// Get all Introductions for given Azure Active directory id.
if (command.Split(":").Length != 2 || string.IsNullOrWhiteSpace(command.Split(":")[1]))
{
await turnContext.SendActivityAsync(this.localizer.GetString("ReviewIntroductionInvalidCommandText"));
return;
}
var result = await this.introductionStorageProvider.GetAllIntroductionsAsync(activity.From.AadObjectId);
var introductionEntity = result.Where(entity => entity.NewHireName.ToUpperInvariant() == command.Split(":")[1].ToUpperInvariant()).FirstOrDefault();
if (introductionEntity != null && (introductionEntity.ApprovalStatus == (int)IntroductionStatus.Approved))
{
// Send already approved message to hiring manager.
await turnContext.SendActivityAsync(this.localizer.GetString("ManagerApprovalValidationText"));
}
else
{
await turnContext.SendActivityAsync(MessageFactory.Attachment(HiringManagerNotificationCard.GetNewEmployeeIntroductionCard(this.botOptions.Value.AppBaseUri, this.localizer, introductionEntity)));
}
}
else
{
// Send help card for un supported bot command.
await turnContext.SendActivityAsync(MessageFactory.Attachment(HelpCard.GetCard(this.localizer)));
}
return;
}
}
else
{
await turnContext.SendActivityAsync(this.localizer.GetString("UnSupportedBotCommand"));
}
}
/// <summary>
/// Handle message activity in channel.
/// </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 OnMessageActivityInChannelAsync(
IMessageActivity message,
ITurnContext <IMessageActivity> turnContext,
CancellationToken cancellationToken)
{
try
{
if (message.Type.Equals(ActivityTypes.Message, StringComparison.OrdinalIgnoreCase))
{
string actionType = message.Value != null?JObject.Parse(message.Value.ToString())["AdaptiveActionType"]?.ToString() : null;
string scrumMembers = message.Value != null?JObject.Parse(message.Value.ToString())["ScrumMembers"]?.ToString() : null;
message.RemoveRecipientMention();
string text = string.IsNullOrEmpty(message.Text) ? actionType : message.Text;
switch (text.ToUpperInvariant().Trim())
{
case Constants.EndScrum:
string conversationId = message.Conversation.Id;
string scrumMasterId = JObject.Parse(message.Value.ToString())["ScrumMasterId"].ToString();
var scrumInfo = await this.scrumHelper.GetActiveScrumAsync(scrumMasterId);
var activitySummary = await this.activityHelper.GetEndScrumSummaryActivityAsync(scrumInfo, conversationId, scrumMembers, turnContext, cancellationToken);
if (activitySummary != null)
{
this.logger.LogInformation($"Scrum completed by: {turnContext.Activity.From.Name} for {conversationId} with ScrumStartCardResponseId: {scrumInfo.ScrumStartCardResponseId}");
await turnContext.UpdateActivityAsync(activitySummary, cancellationToken);
await turnContext.SendActivityAsync(this.localizer.GetString("SuccessMessageAfterEndingScrum"), cancellationToken : cancellationToken);
}
break;
case Constants.Help:
this.logger.LogInformation("Sending help card");
var helpAttachment = HelpCard.GetHelpCard(this.localizer);
await turnContext.SendActivityAsync(MessageFactory.Attachment(helpAttachment), cancellationToken);
break;
case Constants.Settings:
this.logger.LogInformation("Sending settings button card");
var settingsAttachment = SettingsCard.GetSettingsCard(this.localizer);
await turnContext.SendActivityAsync(MessageFactory.Attachment(settingsAttachment), cancellationToken);
break;
default:
this.logger.LogInformation("Invalid command text entered in channel. Sending help card");
var helpAttachmentcard = HelpCard.GetHelpCard(this.localizer);
await turnContext.SendActivityAsync(MessageFactory.Attachment(helpAttachmentcard), cancellationToken);
break;
}
}
else
{
await turnContext.SendActivityAsync(this.localizer.GetString("InformationAboutBotInstallationLimitation"), cancellationToken : cancellationToken);
}
}
catch (Exception ex)
{
await turnContext.SendActivityAsync(this.localizer.GetString("ErrorMessage"), cancellationToken : cancellationToken);
this.logger.LogError(ex, $"Error processing message: {ex.Message}", SeverityLevel.Error);
}
}
/// <summary>
/// When OnTurn method receives a message activity on bot turn, it calls this method.
/// </summary>
/// <param name="turnContext">Provides context for a turn of a bot.</param>
/// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
/// <returns>A task that represents the work queued to execute.</returns>
protected override async Task OnMessageActivityAsync(ITurnContext <IMessageActivity> turnContext, CancellationToken cancellationToken)
{
try
{
var activity = turnContext.Activity;
// if card from messaging extension is sent to the bot conversation.
if (activity.Attachments != null)
{
return;
}
else
{
var command = activity.Text;
await this.SendTypingIndicatorAsync(turnContext).ConfigureAwait(false);
if (activity.Text == null && activity.Value != null && activity.Type == ActivityTypes.Message)
{
command = JToken.Parse(activity.Value.ToString()).SelectToken("command").ToString();
}
switch (command.ToUpperInvariant().Trim())
{
case Constants.MyProfile:
await this.dialog.RunAsync(turnContext, this.conversationState.CreateProperty <DialogState>(nameof(DialogState)), cancellationToken).ConfigureAwait(false);
break;
case Constants.Search:
await this.dialog.RunAsync(turnContext, this.conversationState.CreateProperty <DialogState>(nameof(DialogState)), cancellationToken).ConfigureAwait(false);
break;
default:
await turnContext.SendActivityAsync(MessageFactory.Attachment(HelpCard.GetHelpCard())).ConfigureAwait(false);
break;
}
}
}
catch (Exception ex)
{
this.logger.LogError(ex, $"Error in message activity of bot for {turnContext.Activity.Conversation.Id}");
}
}
/// <summary>
/// Check for unknown input, and show the help prompt.
/// </summary>
/// <param name="stepContext">Provides context for a step in a bot dialog.</param>
/// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
/// <returns>Tracking task.</returns>
private async Task <DialogTurnResult> CheckForUnknownInputAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
{
var activity = stepContext.Context.Activity;
if (activity.Type == ActivityTypes.Message)
{
if (activity.Text == null)
{
return(await stepContext.NextAsync());
}
else if (activity.Text.Trim().Equals(Strings.BotCommandMyProfile, StringComparison.CurrentCultureIgnoreCase) ||
activity.Text.Trim().Equals(Strings.BotCommandSearch, StringComparison.CurrentCultureIgnoreCase))
{
return(await stepContext.NextAsync());
}
else
{
await stepContext.Context.SendActivityAsync(MessageFactory.Attachment(HelpCard.GetHelpCard())).ConfigureAwait(false);
return(await stepContext.EndDialogAsync().ConfigureAwait(false));
}
}
return(await stepContext.NextAsync());
}
/// <summary>
/// Get user profile or search or edit profile based on activity type.
/// </summary>
/// <param name="stepContext">Provides context for a step in a bot dialog.</param>
/// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
/// <returns>Tracking task.</returns>
private async Task <DialogTurnResult> MyProfileAndSearchAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
{
var activity = stepContext.Context.Activity;
var tokenResponse = (TokenResponse)stepContext.Result;
if (tokenResponse == null)
{
this.logger.LogInformation($"User is not authenticated and token is null for: {activity.Conversation.Id}.");
await stepContext.Context.SendActivityAsync(Strings.NotLoggedInText).ConfigureAwait(false);
return(await stepContext.EndDialogAsync().ConfigureAwait(false));
}
var token = tokenResponse.Token;
// signin/verifyState activity name used here to send my profile card after successful sign in.
if ((activity.Type == MessageActivityType) || (activity.Name == SignInActivityName))
{
var command = ((string)stepContext.Values["command"]).Trim();
if (command.Equals(Strings.BotCommandMyProfile, StringComparison.CurrentCultureIgnoreCase) || command.Equals(Constants.MyProfile))
{
this.logger.LogInformation("My profile command triggered", new Dictionary <string, string>()
{
{ "User", activity.From.Id }, { "AADObjectId", activity.From.AadObjectId }
});
await this.MyProfileAsync(token, stepContext, cancellationToken).ConfigureAwait(false);
}
else if (command.Equals(Strings.BotCommandSearch, StringComparison.CurrentCultureIgnoreCase) || command.Equals(Constants.Search))
{
this.logger.LogInformation("Search command triggered", new Dictionary <string, string>()
{
{ "User", activity.From.Id }, { "AADObjectId", activity.From.AadObjectId }
});
await stepContext.Context.SendActivityAsync(MessageFactory.Attachment(SearchCard.GetSearchCard())).ConfigureAwait(false);
}
else
{
await stepContext.Context.SendActivityAsync(MessageFactory.Attachment(HelpCard.GetHelpCard())).ConfigureAwait(false);
}
}
// submit-invoke request at edit profile
else if (activity.Type == InvokeActivityType)
{
await this.EditProfileAsync(token, stepContext, cancellationToken).ConfigureAwait(false);
}
return(await stepContext.EndDialogAsync().ConfigureAwait(false));
}
/// <summary>
/// Check for unknown input, and show the help prompt.
/// </summary>
/// <param name="stepContext">Provides context for a step in a bot dialog.</param>
/// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
/// <returns>Tracking task.</returns>
private async Task <DialogTurnResult> CheckForUnknownInputAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
{
var activity = stepContext.Context.Activity;
if (activity.Type == ActivityTypes.Message)
{
switch (activity.Text?.Trim())
{
case Constants.MyProfile:
case Constants.Search:
case null:
return(await stepContext.NextAsync());
default:
await stepContext.Context.SendActivityAsync(MessageFactory.Attachment(HelpCard.GetHelpCard())).ConfigureAwait(false);
return(await stepContext.EndDialogAsync().ConfigureAwait(false));
}
}
return(await stepContext.NextAsync());
}
/// <summary>
/// Handle message activity in channel.
/// </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 OnMessageActivityInChannelAsync(
IMessageActivity message,
ITurnContext <IMessageActivity> turnContext,
CancellationToken cancellationToken)
{
string actionType = message.Value != null?JObject.Parse(message.Value.ToString())["AdaptiveActionType"]?.ToString() : null;
string scrumMembers = message.Value != null?JObject.Parse(message.Value.ToString())["ScrumMembers"]?.ToString() : null;
message.RemoveRecipientMention();
string text = string.IsNullOrEmpty(message.Text) ? actionType : message.Text;
switch (text.ToUpperInvariant().Trim())
{
case Constants.EndScrum: // command to handle end scrum.
string conversationId = message.Conversation.Id;
string scrumTeamConfigId = JObject.Parse(message.Value.ToString())["ScrumTeamConfigId"].ToString();
string aadGroupId = await this.activityHelper.GetTeamAadGroupIdAsync(turnContext, cancellationToken);
var scrumInfo = await this.scrumHelper.GetActiveScrumAsync(scrumTeamConfigId, aadGroupId);
if (scrumInfo == null || scrumInfo.IsCompleted)
{
await turnContext.SendActivityAsync(string.Format(CultureInfo.CurrentCulture, this.localizer.GetString("ErrorScrumDoesNotExist"), turnContext.Activity.From.Name), cancellationToken : cancellationToken);
break;
}
scrumInfo.IsCompleted = true;
scrumInfo.ThreadConversationId = conversationId;
var scrumSaveResponse = await this.scrumStorageProvider.CreateOrUpdateScrumAsync(scrumInfo);
if (!scrumSaveResponse)
{
this.logger.LogError("Error in saving scrum information in storage.");
await turnContext.SendActivityAsync(this.localizer.GetString("ErrorSavingScrumData"), cancellationToken : cancellationToken);
break;
}
var activitySummary = await this.activityHelper.GetEndScrumSummaryActivityAsync(scrumInfo, conversationId, scrumMembers, turnContext, cancellationToken);
if (activitySummary != null)
{
this.logger.LogInformation($"Scrum completed by: {turnContext.Activity.From.AadObjectId} for {conversationId} with ScrumStartCardResponseId: {scrumInfo.ScrumStartCardResponseId}");
await turnContext.UpdateActivityAsync(activitySummary, cancellationToken);
await turnContext.SendActivityAsync(this.localizer.GetString("SuccessMessageAfterEndingScrum"), cancellationToken : cancellationToken);
}
break;
case Constants.Help: // command to show help card.
this.logger.LogInformation("Sending help card");
var helpAttachment = HelpCard.GetHelpCard(this.localizer);
await turnContext.SendActivityAsync(MessageFactory.Attachment(helpAttachment), cancellationToken);
break;
case Constants.Settings: // Command to show adaptive card with settings CTA button.
this.logger.LogInformation("Sending settings button card");
var settingsAttachment = SettingsCard.GetSettingsCard(this.localizer);
await turnContext.SendActivityAsync(MessageFactory.Attachment(settingsAttachment), cancellationToken);
break;
default:
this.logger.LogInformation("Invalid command text entered in channel. Sending help card");
var helpAttachmentcard = HelpCard.GetHelpCard(this.localizer);
await turnContext.SendActivityAsync(MessageFactory.Attachment(helpAttachmentcard), cancellationToken);
break;
}
}
