/// <summary>
/// When OnTurn method receives a submit invoke activity on bot turn, it calls this method.
/// </summary>
/// <param name="turnContext">Context object containing information cached for a single turn of conversation with a user.</param>
/// <param name="taskModuleRequest">Task module invoke request value payload.</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 a task module response.</returns>
protected override async Task <TaskModuleResponse> OnTeamsTaskModuleSubmitAsync(ITurnContext <IInvokeActivity> turnContext, TaskModuleRequest taskModuleRequest, CancellationToken cancellationToken)
{
try
{
turnContext = turnContext ?? throw new ArgumentNullException(nameof(turnContext));
var activity = (Activity)turnContext.Activity;
this.RecordEvent(nameof(this.OnTeamsTaskModuleFetchAsync), turnContext);
IMessageActivity notificationCard;
Activity mentionActivity;
var valuesfromTaskModule = JsonConvert.DeserializeObject <TaskModuleResponseDetails>(((JObject)activity.Value).GetValue("data", StringComparison.OrdinalIgnoreCase)?.ToString());
switch (valuesfromTaskModule.Command.ToUpperInvariant())
{
case Constants.SaveAdminDetailsAction:
mentionActivity = await CardHelper.GetMentionActivityAsync(valuesfromTaskModule.AdminPrincipalName.Split(",").ToList(), turnContext.Activity.From.AadObjectId, valuesfromTaskModule.TeamId, turnContext, this.localizer, this.logger, MentionActivityType.SetAdmin, cancellationToken);
var cardDetail = (Activity)MessageFactory.Attachment(AdminCard.GetAdminCard(this.localizer, valuesfromTaskModule, this.options.Value.ManifestId));
await this.SendMentionedCardAsync(turnContext, cardDetail, mentionActivity);
this.logger.LogInformation("R&R admin has been configured");
break;
case Constants.CancelCommand:
break;
case Constants.UpdateAdminDetailCommand:
mentionActivity = await CardHelper.GetMentionActivityAsync(valuesfromTaskModule.AdminPrincipalName.Split(",").ToList(), turnContext.Activity.From.AadObjectId, valuesfromTaskModule.TeamId, turnContext, this.localizer, this.logger, MentionActivityType.SetAdmin, cancellationToken);
notificationCard = MessageFactory.Attachment(AdminCard.GetAdminCard(this.localizer, valuesfromTaskModule, this.options.Value.ManifestId));
notificationCard.Id = turnContext.Activity.Conversation.Id.Split(';')[1].Split("=")[1];
notificationCard.Conversation = turnContext.Activity.Conversation;
await turnContext.UpdateActivityAsync(notificationCard);
await turnContext.SendActivityAsync(mentionActivity);
this.logger.LogInformation("Card is updated.");
break;
case Constants.NominateAction:
var awardsList = await this.awardsStorageProvider.GetAwardsAsync(valuesfromTaskModule.TeamId);
await turnContext.SendActivityAsync(MessageFactory.Carousel(NominateCarouselCard.GetAwardsCard(this.appBaseUrl, awardsList, this.localizer, valuesfromTaskModule)));
break;
case Constants.SaveNominatedDetailsAction:
turnContext.Activity.Conversation.Id = valuesfromTaskModule.TeamId;
var result = (Activity)MessageFactory.Attachment(EndorseCard.GetEndorseCard(this.appBaseUrl, this.localizer, valuesfromTaskModule));
mentionActivity = await CardHelper.GetMentionActivityAsync(valuesfromTaskModule.NominatedToPrincipalName.Split(",").Select(row => row.Trim()).ToList(), turnContext.Activity.From.AadObjectId, valuesfromTaskModule.TeamId, turnContext, this.localizer, this.logger, MentionActivityType.Nomination, cancellationToken);
await this.SendMentionedCardAsync(turnContext, result, mentionActivity);
this.logger.LogInformation("Nominated an award");
break;
case Constants.OkCommand:
return(null);
default:
this.logger.LogInformation($"Invalid command for task module submit activity.Command is : {valuesfromTaskModule.Command} ");
await turnContext.SendActivityAsync(this.localizer.GetString("ErrorMessage"));
break;
}
return(null);
}
catch (Exception ex)
{
this.logger.LogError(ex, $"Error at OnTeamsTaskModuleSubmitAsync(): {ex.Message}", SeverityLevel.Error);
await turnContext.SendActivityAsync(this.localizer.GetString("ErrorMessage"));
throw;
}
}
/// <summary>
/// Send the given attachment to the specified team.
/// </summary>
/// <param name="rewardCycleEntity">Reward cycle model object.</param>
/// <returns>A task that sends notification card in channel.</returns>
private async Task SendCardToTeamAsync(RewardCycleEntity rewardCycleEntity)
{
try
{
var awardsList = await this.awardsStorageProvider.GetAwardsAsync(rewardCycleEntity.TeamId);
var valuesfromTaskModule = new TaskModuleResponseDetails()
{
RewardCycleStartDate = rewardCycleEntity.RewardCycleStartDate,
RewardCycleEndDate = rewardCycleEntity.RewardCycleEndDate,
RewardCycleId = rewardCycleEntity.CycleId,
};
var teamDetails = await this.teamStorageProvider.GetTeamDetailAsync(rewardCycleEntity.TeamId);
string serviceUrl = teamDetails.ServiceUrl;
MicrosoftAppCredentials.TrustServiceUrl(serviceUrl);
string teamsChannelId = rewardCycleEntity.TeamId;
var conversationReference = new ConversationReference()
{
ChannelId = Channel,
Bot = new ChannelAccount()
{
Id = this.microsoftAppCredentials.MicrosoftAppId
},
ServiceUrl = serviceUrl,
Conversation = new ConversationAccount()
{
ConversationType = ChannelConversationType, IsGroup = true, Id = teamsChannelId, TenantId = teamsChannelId
},
};
this.logger.LogInformation($"sending notification to channelId- {teamsChannelId}");
await retryPolicy.ExecuteAsync(async() =>
{
try
{
var conversationParameters = new ConversationParameters()
{
ChannelData = new TeamsChannelData()
{
Team = new TeamInfo()
{
Id = rewardCycleEntity.TeamId
}, Channel = new ChannelInfo()
{
Id = rewardCycleEntity.TeamId
}
},
Activity = (Activity)MessageFactory.Carousel(NominateCarouselCard.GetAwardsCard(this.options.Value.AppBaseUri, awardsList, this.localizer, valuesfromTaskModule)),
Bot = new ChannelAccount()
{
Id = this.microsoftAppCredentials.MicrosoftAppId
},
IsGroup = true,
TenantId = this.options.Value.TenantId,
};
await((BotFrameworkAdapter)this.adapter).CreateConversationAsync(
Channel,
serviceUrl,
this.microsoftAppCredentials,
conversationParameters,
async(conversationTurnContext, conversationCancellationToken) =>
{
Activity mentionActivity = MessageFactory.Text(this.localizer.GetString("NominationReminderNotificationText"));
await((BotFrameworkAdapter)this.adapter).ContinueConversationAsync(
this.microsoftAppCredentials.MicrosoftAppId,
conversationTurnContext.Activity.GetConversationReference(),
async(continueConversationTurnContext, continueConversationCancellationToken) =>
{
mentionActivity.ApplyConversationReference(conversationTurnContext.Activity.GetConversationReference());
await continueConversationTurnContext.SendActivityAsync(mentionActivity, continueConversationCancellationToken);
}, conversationCancellationToken);
},
default);
}
catch (Exception ex)
{
this.logger.LogError(ex, "Error while performing retry logic to send notification to channel.");
throw;
}
});
}
catch (Exception ex)
{
this.logger.LogError(ex, "Error while sending notification to channel from background service.");
}
}
