/// <summary> /// Get the state api endpoint from settings. /// </summary> /// <param name="key">The key.</param> /// <returns>The state api endpoint from settings.</returns> private static string GetSettingsStateApiUrl(string key = "BotStateEndpoint") { var url = SettingsUtils.GetAppSettings(key); if (!string.IsNullOrEmpty(url)) { MicrosoftAppCredentials.TrustServiceUrl(url, DateTime.MaxValue); } return(url); }
static void Main(string[] args) { var appId = "<Microsoft App ID>"; var appPassword = "******"; //Emulator var fromId = "default - user"; var recipientId = "95i2nkda1dd4"; var serviceUrl = "http://*****:*****@dTuM__gWAS0"; //var serviceUrl = "https://webchat.botframework.com/"; //var conversationId = "fd8a04848c4744ddbbcce046f6086967"; MicrosoftAppCredentials.TrustServiceUrl(serviceUrl); var connector = new ConnectorClient(new Uri(serviceUrl), appId, appPassword); var botAccount = new ChannelAccount(id: recipientId); var userAccount = new ChannelAccount(id: fromId); IMessageActivity message = Activity.CreateMessageActivity(); message.Conversation = new ConversationAccount(id: conversationId); message.From = botAccount; message.Recipient = userAccount; message.Locale = "ja-jp"; message.Text = $@"Chatbotからのお知らせです。 本日のおすすめは、季節のフルーツとれたてのあまーいいちごです。"; var cardImage = new CardImage { Url = "https://chatbot201707.azurewebsites.net/img/strawberry.jpg" }; var heroCard = new HeroCard { Title = "季節のフルーツ", Images = new List <CardImage> { cardImage } }; message.Attachments.Add(heroCard.ToAttachment()); connector.Conversations.SendToConversation((Activity)message); }
/// <summary> /// Method ends the existing scrum if running and then sends the start scrum card. /// </summary> /// <param name="scrumConfiguration">Scrum configuration details obtained from storage.</param> /// <returns>A task that ends the existing scrum and sends the start scrum card .</returns> public async Task ScrumStartActivityAsync(ScrumConfiguration scrumConfiguration) { try { string serviceUrl = scrumConfiguration.ServiceUrl; MicrosoftAppCredentials.TrustServiceUrl(serviceUrl); var conversationReference = new ConversationReference() { ChannelId = TeamsBotFrameworkChannelId, Bot = new ChannelAccount() { Id = $"28:{this.microsoftAppCredentials.MicrosoftAppId}" }, ServiceUrl = serviceUrl, Conversation = new ConversationAccount() { ConversationType = Constants.ChannelConversationType, IsGroup = true, Id = scrumConfiguration.ChannelId, TenantId = this.options.Value.TenantId }, }; this.logger.LogInformation($"Sending start scrum card to channelId: {scrumConfiguration.ChannelId}"); await RetryPolicy.ExecuteAsync(async() => { try { await((BotFrameworkAdapter)this.adapter).ContinueConversationAsync( this.microsoftAppCredentials.MicrosoftAppId, conversationReference, async(conversationTurnContext, conversationCancellationToken) => { bool isValidScrum = await this.EndExistingScrumAsync(conversationTurnContext, scrumConfiguration, conversationCancellationToken); if (!isValidScrum) { this.logger.LogInformation("Error while ending the existing scrum."); await conversationTurnContext.SendActivityAsync(this.localizer.GetString(this.localizer.GetString("ErrorMessage"))); } await this.SendScrumStartCardAsync(conversationTurnContext, scrumConfiguration, conversationCancellationToken); }, CancellationToken.None); } catch (Exception ex) { this.logger.LogError(ex, "Error while performing retry logic to send scrum start card."); throw; } }); } catch (Exception ex) { this.logger.LogError(ex, "Error while sending start scrum to channel from background service."); } }
public static async Task NotifyUser(this IDialogContext context, string messageText) { if (!string.IsNullOrEmpty(messageText)) { string serviceUrl = context.PrivateConversationData.Get <string>("ServiceUrl"); var connector = new ConnectorClient(new Uri(serviceUrl)); var reply = context.MakeMessage(); reply.Text = messageText; MicrosoftAppCredentials.TrustServiceUrl(serviceUrl); await connector.Conversations.ReplyToActivityAsync((Activity)reply); } }
// TODO: Pending review // Forward message to Slack private async Task <bool> SendSlackMessageAsync(User recipient, object messageContent) { if (recipient == null || messageContent == null) { return(false); } var isSuccess = false; try { var toId = recipient.Id; var toName = recipient.Name; var fromId = recipient.BotId; var fromName = recipient.BotName; var serviceUrl = recipient.ServiceUrl; var userAccount = new ChannelAccount(toId, toName); var botAccount = new ChannelAccount(fromId, fromName); var message = Activity.CreateMessageActivity(); message.From = botAccount; message.Recipient = userAccount; message.ChannelData = messageContent; MicrosoftAppCredentials.TrustServiceUrl(serviceUrl); var account = new MicrosoftAppCredentials(_appId, _password); var client = new ConnectorClient(new Uri(serviceUrl), account); // Reuse existing conversation if recipient is a channel string conversationId; if (recipient.IsGroupChannel) { conversationId = recipient.SlackConversationId; } else { var conversation = client.Conversations.CreateDirectConversation(botAccount, userAccount); conversationId = conversation.Id; } message.Conversation = new ConversationAccount(id: conversationId); var response = await client.Conversations.SendToConversationAsync((Activity)message); _logger.LogInformation($"Response id: {response.Id}"); isSuccess = true; } catch (Exception ex) { _logger.LogError(ex.Message); } return(isSuccess); }
protected void Application_Start() { GlobalConfiguration.Configure(WebApiConfig.Register); var builder = new ContainerBuilder(); builder.RegisterModule(new LessonPlanModule()); builder.RegisterModule(new BasicDialogModule()); builder .RegisterType <AzureTableLogger>() .Keyed <ILogger>(FiberModule.Key_DoNotSerialize) .AsSelf() .As <ILogger>() .SingleInstance(); builder.RegisterApiControllers(Assembly.GetExecutingAssembly()); builder.RegisterModule(new AzureModule(Assembly.GetExecutingAssembly())); var store = new TableBotDataStore(ConfigurationManager.AppSettings["StorageConnectionString"]); var cache = new CachingBotDataStore(store, CachingBotDataStoreConsistencyPolicy .ETagBasedConsistency); MicrosoftAppCredentials.TrustServiceUrl("directline.botframework.com"); builder.RegisterType <AzureActivityLogger>().As <IActivityLogger>().InstancePerDependency(); Conversation.UpdateContainer( coversation => { coversation.Register(c => store) .Keyed <IBotDataStore <BotData> >(AzureModule.Key_DataStore) .AsSelf() .SingleInstance(); coversation.Register(c => cache) .As <IBotDataStore <BotData> >() .AsSelf() .InstancePerLifetimeScope(); }); var config = GlobalConfiguration.Configuration; var container = builder.Build(); config.DependencyResolver = new AutofacWebApiDependencyResolver(container); Environment.SetEnvironmentVariable("GOOGLE_APPLICATION_CREDENTIALS", Server.MapPath("translation.json")); }
static ConnectorClient GetConnectorClient(string serviceUrl, string botClientId, string botSecret) { MicrosoftAppCredentials appCredentials = new MicrosoftAppCredentials(botClientId, botSecret); MicrosoftAppCredentials.TrustServiceUrl(serviceUrl); Uri uri = new Uri(serviceUrl); ConnectorClient connectorClient = new ConnectorClient(uri, appCredentials); return(connectorClient); }
/// <summary> /// Method to update team goal, personal goal and note details in storage when team goal is ended. /// </summary> /// <param name="teamGoalDetail">Holds team goal detail entity data sent from background service.</param> /// <returns>A task that represents team goal, personal goal and personal goal note details data is saved or updated.</returns> public async Task UpdateGoalDetailsAsync(TeamGoalDetail teamGoalDetail) { teamGoalDetail = teamGoalDetail ?? throw new ArgumentNullException(nameof(teamGoalDetail)); try { var teamId = teamGoalDetail.TeamId; string serviceUrl = teamGoalDetail.ServiceUrl; MicrosoftAppCredentials.TrustServiceUrl(serviceUrl); var conversationReference = new ConversationReference() { ChannelId = Constants.TeamsBotFrameworkChannelId, Bot = new ChannelAccount() { Id = $"28:{this.microsoftAppCredentials.MicrosoftAppId}" }, ServiceUrl = serviceUrl, Conversation = new ConversationAccount() { ConversationType = Constants.ChannelConversationType, IsGroup = true, Id = teamId, TenantId = this.options.Value.TenantId }, }; await this.retryPolicy.ExecuteAsync(async() => { try { await((BotFrameworkAdapter)this.adapter).ContinueConversationAsync( this.microsoftAppCredentials.MicrosoftAppId, conversationReference, async(turnContext, cancellationToken) => { await this.UpdateGoalEntitiesAsync(turnContext, teamGoalDetail, cancellationToken); }, CancellationToken.None); } catch (Exception ex) { this.logger.LogError(ex, $"Error while performing retry logic to send goal reminder card for : {teamGoalDetail.TeamGoalId}."); throw; } }); } #pragma warning disable CA1031 // Catching general exceptions to log exception details in telemetry client. catch (Exception ex) #pragma warning restore CA1031 // Catching general exceptions to log exception details in telemetry client. { this.logger.LogError(ex, $"Error while updating personal goal, team goal and personal goal note detail from background service for : {teamGoalDetail.TeamGoalId} at {nameof(this.UpdateGoalDetailsAsync)}"); } }
private static async Task NotifyUser(string serviceUrl, string cardToSend, ChannelAccount user, string tenantId) { var me = new ChannelAccount() { Id = CloudConfigurationManager.GetSetting("MicrosoftAppId"), Name = "MeetupBot" }; MicrosoftAppCredentials.TrustServiceUrl(serviceUrl); // Create 1:1 with user using (var connectorClient = new ConnectorClient(new Uri(serviceUrl))) { // ensure conversation exists var response = connectorClient.Conversations.CreateOrGetDirectConversation(me, user, tenantId); // construct the activity we want to post var activity = new Activity() { Type = ActivityTypes.Message, Conversation = new ConversationAccount() { Id = response.Id, }, Attachments = new List <Attachment>() { new Attachment() { ContentType = "application/vnd.microsoft.card.adaptive", Content = JsonConvert.DeserializeObject(cardToSend), } } }; var isTesting = Boolean.Parse(CloudConfigurationManager.GetSetting("Testing")); if (!isTesting) { // shoot the activity over // added try catch because if user has set "Block conversations with bots" try { await connectorClient.Conversations.SendToConversationAsync(activity, response.Id); } catch (UnauthorizedAccessException uae) { System.Diagnostics.Trace.TraceError($"Failed to notify user due to error {uae.ToString()}"); } } } }
/// <summary> /// Get a team's roster. /// </summary> /// <param name="serviceUrl">The service URL.</param> /// <param name="teamId">Team id, e.g. "19:[email protected]".</param> /// <param name="tenantId">Tenant id for the team and user.</param> /// <returns>Roster of the team with the passed in id.</returns> private async Task <IEnumerable <UserDataEntity> > GetTeamRosterRecipientDataEntityListAsync( string serviceUrl, string teamId, string tenantId) { // Set the service URL in the trusted list to ensure the SDK includes the token in the request. MicrosoftAppCredentials.TrustServiceUrl(serviceUrl); var conversationReference = new ConversationReference { ServiceUrl = serviceUrl, Conversation = new ConversationAccount { Id = teamId, }, }; IEnumerable <UserDataEntity> userDataEntitiesResult = null; await this.botAdapter.ContinueConversationAsync( this.microsoftAppId, conversationReference, async (turnContext, cancellationToken) => { var members = await this.GetMembersAsync(turnContext, cancellationToken); userDataEntitiesResult = members.Select(member => { var userDataEntity = new UserDataEntity { UserId = member.Id, Name = member.Name, // Set the conversation ID to null because it is not known at this time and // may not have been created yet. ConversationId = null, ServiceUrl = serviceUrl, Email = member.Email, Upn = member.UserPrincipalName, AadId = member.AadObjectId, TenantId = tenantId, }; return(userDataEntity); }); }, CancellationToken.None); return(userDataEntitiesResult); }
private static async Task <TeamsChannelAccount[]> GetTeamMembers(string serviceUrl, string teamId, string tenantId) { MicrosoftAppCredentials.TrustServiceUrl(serviceUrl); using (var connector = new ConnectorClient(new Uri(serviceUrl))) { // Pull the roster of specified team and then remove everyone who has opted out explicitly #pragma warning disable CS0618 // Type or member is obsolete var members = await connector.Conversations.GetTeamsConversationMembersAsync(teamId, tenantId); #pragma warning restore CS0618 // Type or member is obsolete return(members); } }
public async Task <string> SendToChannel(IActivity activity) { MicrosoftAppCredentials.TrustServiceUrl(ServiceUrl, DateTime.MaxValue); var connector = new ConnectorClient(new Uri(ServiceUrl)); activity.ChannelId = ChannelId; activity.From = new ChannelAccount(id: BotId, name: BotName); activity.Conversation = new ConversationAccount(id: ConversationId); await connector.Conversations.SendToConversationAsync((Activity)activity); return(ConversationId); }
public async Task <IActionResult> Post([FromBody] Activity activity) { try { if (activity.Type == ActivityTypes.Message) { MicrosoftAppCredentials.TrustServiceUrl(activity.ServiceUrl); var appCredentials = new MicrosoftAppCredentials(this.configuration); var connector = new ConnectorClient(new Uri(activity.ServiceUrl), appCredentials); var arguments = new ArguementsHandler(activity.Text); if (arguments.CanAction()) { var command = arguments.GetCommand(); var userHandler = new UserIntractionHandler(connector, activity); switch (command) { case CommandHandler.Commands.Download: await new CommandHandler(this.download, this.videoConverter).DownloadCommand(arguments, userHandler); break; default: var message = $"Usage: bot download [Optional Commands] [Youtube URL] {Environment.NewLine}"; message += $"Where [Commands] is one of: {Environment.NewLine}"; message += $"--start HH:MM:SS {Environment.NewLine}"; message += $"--end HH:MM:SS {Environment.NewLine}"; await userHandler.SendHeroCard("Bot Help", message); break; } } // return our reply to the user // var reply = activity.CreateReply("HelloWorld"); // await connector.Conversations.ReplyToActivityAsync(reply); } else { // HandleSystemMessage(activity); } return(this.Ok()); } catch (Exception ex) { Console.WriteLine($"{ex.Message} "); throw; } }
/// <summary> /// Sends notification to the user. /// </summary> /// <param name="user">The user to which notification need to send</param> /// <param name="card">The notification card that to be send</param> /// <returns>A <see cref="Tasks.Task"/> representing the asynchronous operation.</returns> public async Tasks.Task SendNotificationToUserAsync(Conversation user, Attachment card) { if (user == null || string.IsNullOrEmpty(user.ConversationId) || string.IsNullOrEmpty(Convert.ToString(user.UserId, CultureInfo.InvariantCulture)) || string.IsNullOrEmpty(user.ServiceUrl) || card == null) { return; } try { MicrosoftAppCredentials.TrustServiceUrl(user.ServiceUrl); var conversationReference = new ConversationReference() { Bot = new ChannelAccount() { Id = $"28:{this.microsoftAppCredentials.MicrosoftAppId}" }, ChannelId = TeamsBotChannelId, Conversation = new ConversationAccount() { Id = user.ConversationId }, ServiceUrl = user.ServiceUrl, }; var botFrameworkAdapter = this.botFrameworkHttpAdapter as BotFrameworkAdapter; ResourceResponse resourceResponse = null; await this.retryPolicy.ExecuteAsync(async() => { await botFrameworkAdapter.ContinueConversationAsync( this.microsoftAppCredentials.MicrosoftAppId, conversationReference, async(turnContext, cancellationToken) => { resourceResponse = await turnContext.SendActivityAsync(MessageFactory.Attachment(card), cancellationToken); }, CancellationToken.None); }); } #pragma warning disable CA1031 // Caching general exception to log exception and user Id catch (Exception ex) #pragma warning restore CA1031 // Caching general exception to log exception and user Id { this.logger.LogError(ex, $"Unable to send notification to user {user.UserId}"); } }
// This will send an adhoc message to the user public static async Task Resume( string toId, string toName, string fromId, string fromName, string conversationId, string message, string serviceUrl = "https://smba.trafficmanager.net/apis/", string channelId = "skype") { if (!MicrosoftAppCredentials.IsTrustedServiceUrl(serviceUrl)) { MicrosoftAppCredentials.TrustServiceUrl(serviceUrl); } try { var userAccount = new ChannelAccount(toId, toName); var botAccount = new ChannelAccount(fromId, fromName); var connector = new ConnectorClient(new Uri(serviceUrl)); var activity = Activity.CreateMessageActivity(); // var activity = Activity.CreateConversationUpdateActivity(); if (!string.IsNullOrEmpty(conversationId) && !string.IsNullOrEmpty(channelId)) { activity.ChannelId = channelId; } else { conversationId = (await connector.Conversations.CreateDirectConversationAsync(botAccount, userAccount)).Id; } activity.From = botAccount; activity.Recipient = userAccount; activity.Conversation = new ConversationAccount(id: conversationId); activity.Text = message; activity.Locale = "en-Us"; //activity.ReplyToId = "Reply told"; await connector.Conversations.SendToConversationAsync((Activity)activity); //await connector.Conversations.SendToConversationAsync((Activity)activity2); } catch (Exception exp) { Debug.WriteLine(exp); } }
/// <summary> /// Send a preview of a draft notification. /// </summary> /// <param name="draftNotificationEntity">Draft notification entity.</param> /// <param name="teamDataEntity">The team data entity.</param> /// <param name="teamsChannelId">The Teams channel id.</param> /// <returns>It returns HttpStatusCode.OK, if this method triggers the bot service to send the adaptive card successfully. /// It returns HttpStatusCode.TooManyRequests, if the bot service throttled the request to send the adaptive card.</returns> public async Task <HttpStatusCode> SendPreview(NotificationDataEntity draftNotificationEntity, TeamDataEntity teamDataEntity, string teamsChannelId) { if (draftNotificationEntity == null) { throw new ArgumentException("Null draft notification entity."); } if (teamDataEntity == null) { throw new ArgumentException("Null team data entity."); } if (string.IsNullOrWhiteSpace(teamsChannelId)) { throw new ArgumentException("Null channel id."); } // Create bot conversation reference. var conversationReference = this.PrepareConversationReferenceAsync(teamDataEntity, teamsChannelId); // Ensure the bot service URL is trusted. if (!MicrosoftAppCredentials.IsTrustedServiceUrl(conversationReference.ServiceUrl)) { MicrosoftAppCredentials.TrustServiceUrl(conversationReference.ServiceUrl); } // Trigger bot to send the adaptive card. try { await this.diConnectBotAdapter.ContinueConversationAsync( this.botAppId, conversationReference, async (turnContext, cancellationToken) => await this.SendAdaptiveCardAsync(turnContext, draftNotificationEntity), CancellationToken.None); return(HttpStatusCode.OK); } catch (ErrorResponseException e) { var errorResponse = (ErrorResponse)e.Body; if (errorResponse != null && errorResponse.Error.Code.Equals(DraftNotificationPreviewService.ThrottledErrorResponse, StringComparison.OrdinalIgnoreCase)) { return(HttpStatusCode.TooManyRequests); } throw; } }
public async Task <bool> SignOutUserAsync(string userId, string connectionName, CancellationToken cancellationToken = default(CancellationToken)) { if (connectionName == null) { throw new ValidationException(ValidationRules.CannotBeNull, "connectionName"); } if (userId == null) { throw new ValidationException(ValidationRules.CannotBeNull, "userId"); } // Construct URL var _baseUrl = BaseUri.AbsoluteUri; var _url = new System.Uri(new System.Uri(_baseUrl + (_baseUrl.EndsWith("/") ? "" : "/")), "api/usertoken/SignOut?&userId={userId}&connectionName={connectionName}").ToString(); _url = _url.Replace("{connectionName}", System.Uri.EscapeDataString(connectionName)); _url = _url.Replace("{userId}", System.Uri.EscapeDataString(userId)); MicrosoftAppCredentials.TrustServiceUrl(_url); // Create HTTP transport objects var _httpRequest = new HttpRequestMessage(); HttpResponseMessage _httpResponse = null; _httpRequest.Method = new HttpMethod("GET"); _httpRequest.RequestUri = new System.Uri(_url); // Set Credentials if (Credentials != null) { cancellationToken.ThrowIfCancellationRequested(); await Credentials.ProcessHttpRequestAsync(_httpRequest, cancellationToken).ConfigureAwait(false); } cancellationToken.ThrowIfCancellationRequested(); _httpResponse = await HttpClient.SendAsync(_httpRequest, cancellationToken).ConfigureAwait(false); HttpStatusCode _statusCode = _httpResponse.StatusCode; cancellationToken.ThrowIfCancellationRequested(); if (_statusCode == HttpStatusCode.OK) { return(true); } else { // TODO: some error situation should be logged return(false); } }
public static async Task <bool> AuthenticateBotRequest(HttpRequestMessage req, Activity activity, CancellationToken token) { var credProvider = new SettingsCredentialProvider(); var authenticator = new BotAuthenticator(credProvider, JwtConfig.ToBotFromChannelOpenIdMetadataUrl, disableEmulatorTokens: false); var authenticated = await authenticator.TryAuthenticateAsync(req, new[] { activity }, token); if (authenticated) { MicrosoftAppCredentials.TrustServiceUrl(activity.ServiceUrl); } return(authenticated); }
/// <summary> /// Send a reply to a specific message that was previously sent. /// </summary> /// <param name="text">The text to send.</param> /// <param name="serviceUrl">ServiceUrl for the tenant.</param> /// <param name="conversationId">The conversation ID of the previously sent message.</param> /// <param name="activityId">The activity ID of the previously sent message.</param> /// <param name="botSettings">Bot configuration settings.</param> /// <returns>Async task.</returns> public static async Task <ResourceResponse> ReplyToChannelMessageAsync(string text, string serviceUrl, string conversationId, string activityId, BotSettings botSettings) { var message = Activity.CreateMessageActivity(); message.Text = text; MicrosoftAppCredentials.TrustServiceUrl(serviceUrl, DateTime.MaxValue); using (var connectorClient = new ConnectorClient(new Uri(serviceUrl), botSettings.Id, botSettings.Password)) { var resourceResponse = await connectorClient.Conversations.ReplyToActivityAsync(conversationId, activityId, (Activity)message); // Returns resource response containing message ID return(resourceResponse); } }
private async Task SendToConversation( string text, IList <Attachment> attachments, ConversationData conversationData, CancellationToken cancellationToken) { MicrosoftAppCredentials.TrustServiceUrl(conversationData.ServiceUrl); using (var client = new ConnectorClient( new Uri(conversationData.ServiceUrl), new MicrosoftAppCredentials(_appSettings.MicrosoftAppId, _appSettings.MicrosoftAppPassword))) { var conversationParameters = new ConversationParameters { Bot = new ChannelAccount(_appSettings.MicrosoftAppId), ChannelData = new TeamsChannelData { Tenant = new TenantInfo { Id = conversationData.TenantId } }, Members = new List <ChannelAccount> { new ChannelAccount(conversationData.AccountId) } }; var conversation = await client.Conversations.CreateConversationAsync(conversationParameters, cancellationToken); var activity = MessageFactory.Text(text); activity.Conversation = new ConversationAccount { Id = conversation.Id }; activity.ChannelData = new TeamsChannelData { Notification = new NotificationInfo { Alert = true } }; if (attachments != null && attachments.Count > 0) { activity.Attachments = attachments; } await client.Conversations.SendToConversationAsync(activity, cancellationToken); } }
static async Task Main(string[] args) { //The Bot Service Url needs to be dynamically stored and fetched from the Team. //This Url is present in every payload which Teams sends to the Bot after the Bot is added to the Team. //Recommendation is to store the serviceUrl from the bot payload and later re-use it to send proactive messages. string serviceUrl = "https://smba.trafficmanager.net/emea/"; //From the Bot Channel Registration string botClientID = "<client-id>"; string botClientSecret = "<client-secret>"; //Teams channel id in which to create the post. string teamsChannelId = "19:[email protected]"; MicrosoftAppCredentials.TrustServiceUrl(serviceUrl); var connectorClient = new ConnectorClient(new Uri(serviceUrl), new MicrosoftAppCredentials(botClientID, botClientSecret)); string adaptiveCardJsonFilePath = @"AdaptiveCard.json"; string json = File.ReadAllText(adaptiveCardJsonFilePath); AdaptiveCardParseResult result = AdaptiveCard.FromJson(json); // Get card from result AdaptiveCard adaptiveCard = result.Card; var cardAttachment = new Attachment { Content = adaptiveCard, ContentType = AdaptiveCard.ContentType, }; var messageActivity = MessageFactory.Attachment(cardAttachment); //Send the activity to Teams. var conversationParameters = new ConversationParameters { IsGroup = true, ChannelData = new TeamsChannelData { Channel = new ChannelInfo(teamsChannelId), }, Activity = (Activity)messageActivity }; await connectorClient.Conversations.CreateConversationAsync(conversationParameters); }
public async Task SendMessageToChannel(string title, BotSubscription subscription) { var subscriptionFacade = new SubscriptionFacade(); var channelData = new TeamsChannelData { Channel = new ChannelInfo(subscription.ChannelId), Team = new TeamInfo(subscription.TeamId), Tenant = new TenantInfo(subscription.TenantId) }; var newMessageText = await Build(); var newMessage = new Activity { Type = ActivityTypes.Message, Text = newMessageText.FixNewLines(), }; var conversationParams = new ConversationParameters( isGroup: true, bot: null, members: null, topicName: title, activity: (Activity)newMessage, channelData: channelData); var connector = new ConnectorClient(new Uri(subscription.ServiceUrl), Environment.GetEnvironmentVariable("MicrosoftAppId"), Environment.GetEnvironmentVariable("MicrosoftAppPassword")); MicrosoftAppCredentials.TrustServiceUrl(subscription.ServiceUrl, DateTime.MaxValue); if (subscription.LastActivity == null) { var result = await connector.Conversations.CreateConversationAsync(conversationParams); subscription.LastActivity = new LastActivity { ConversationId = result.Id, ActitityId = result.ActivityId }; } else { var result = await connector.Conversations.UpdateActivityAsync(subscription.LastActivity.ConversationId, subscription.LastActivity.ActitityId, newMessage); subscription.LastActivity.ActitityId = result.Id; } await subscriptionFacade.UpdateBotSubscription(subscription); }
public async Task <IActionResult> PostAsync() { var form = await Request.ReadFormAsync(); if (form != null) { // Ugly formatted response comes back from Vodafone - likely to be different format for other GSM providers // BAL=Yourbalanceis#2.98.Tocheckanyremainingallowancespleasecall1345,forfree.Thankyou OK VIDEX GSM string balanceText = form["Body"]; if (balanceText != null) { Regex regex = new Regex(@"([^#]\d*[.]+\d{0,2})"); var regexAmount = regex.Match(balanceText); if (regexAmount.Success) { decimal amount = Convert.ToDecimal(regexAmount.Value); string responseText = $"Your current balance is £{amount}"; Activity videxResponse = new Activity() { Type = "message", InputHint = "acceptingInput", Text = responseText }; if (!_conversationReferences.IsEmpty) { foreach (var conversationReference in _conversationReferences.Values) { await((BotAdapter)_adapter).ContinueConversationAsync( _appId, conversationReference, (ITurnContext turnContext, CancellationToken cancellationToken) => { MicrosoftAppCredentials.TrustServiceUrl(conversationReference.ServiceUrl); return(turnContext.SendActivityAsync(videxResponse)); }, default); } } } } } var mr = new MessagingResponse(); Response.ContentType = "text/xml"; Response.StatusCode = StatusCodes.Status200OK; return(TwiML(mr)); }
/// <summary> /// Registers dependencies with the <paramref name="builder"/>. /// </summary> /// <param name="builder"> The container builder.</param> protected override void Load(ContainerBuilder builder) { builder.RegisterType <ConnectorStore>() .AsSelf() .InstancePerLifetimeScope(); // if application settings indicate that bot should use the table storage, // TableBotDataStore will be registered as underlying storage // otherwise bot connector state service will be used. if (ShouldUseTableStorage()) { builder.Register(c => MakeTableBotDataStore()) .Keyed <IBotDataStore <BotData> >(Key_DataStore) .AsSelf() .SingleInstance(); } else { builder.Register(c => new ConnectorStore(c.Resolve <IStateClient>())) .Keyed <IBotDataStore <BotData> >(Key_DataStore) .AsSelf() .InstancePerLifetimeScope(); } // register the data store with caching data store // and set the consistency policy to be "Last write wins". builder.Register(c => new CachingBotDataStore(c.ResolveKeyed <IBotDataStore <BotData> >(Key_DataStore), CachingBotDataStoreConsistencyPolicy.LastWriteWins)) .As <IBotDataStore <BotData> >() .AsSelf() .InstancePerLifetimeScope(); // register the appropriate StateClient based on the state api url. builder.Register(c => { var activity = c.Resolve <IActivity>(); if (activity.ChannelId == "emulator") { // for emulator we should use serviceUri of the emulator for storage return(new StateClient(new Uri(activity.ServiceUrl))); } MicrosoftAppCredentials.TrustServiceUrl(BotService.stateApi.Value, DateTime.MaxValue); return(new StateClient(new Uri(BotService.stateApi.Value))); }) .As <IStateClient>() .InstancePerLifetimeScope(); }
private static async Task AnswerAsync(Activity activity, CancellationToken ct) { try { var client = new ConnectorClient(new Uri(activity.ServiceUrl), new MicrosoftAppCredentials("26a47099-ba81-49e1-a425-23b4152cd5fe", @"BOD554=%enkzmpmQRWB88[#")); var answer = activity.CreateReply(activity.Text, activity.Locale); MicrosoftAppCredentials.TrustServiceUrl(activity.ServiceUrl); await client.Conversations.ReplyToActivityAsync(answer, ct); } catch (Exception e) { Trace.TraceError(e.ToString()); throw; } }
public async Task <string> SendToChannel(IActivity activity) { MicrosoftAppCredentials.TrustServiceUrl(ServiceUrl, DateTime.MaxValue); var connector = new ConnectorClient(new Uri(ServiceUrl)); var channelData = new TeamsChannelData(channel: new ChannelInfo(TeamsChannelId)); var conversationParameters = new ConversationParameters( isGroup: true, bot: new ChannelAccount(id: BotId, name: BotName), channelData: channelData, topicName: "New question", activity: (Activity)activity ); return((await connector.Conversations.CreateConversationAsync(conversationParameters)).Id); }
/// <summary> /// This method creates a bot connector client per service URL. /// </summary> /// <param name="serviceUrl">Service URL.</param> /// <returns>It returns a bot connector client.</returns> public CustomConnectorClient Create(string serviceUrl) { if (!this.serviceUrlToConnectorClientMap.ContainsKey(serviceUrl)) { MicrosoftAppCredentials.TrustServiceUrl(serviceUrl); var connectorClient = new CustomConnectorClient( new Uri(serviceUrl), this.configurationSettings.MicrosoftAppId, this.configurationSettings.MicrosoftAppPassword); this.serviceUrlToConnectorClientMap.TryAdd(serviceUrl, connectorClient); } return(this.serviceUrlToConnectorClientMap[serviceUrl]); }
public async Task PostContentEventAsync() { using (var readStream = new StreamReader(Request.Body, Encoding.UTF8)) { var body = await readStream.ReadToEndAsync(); if (!Authenticate(Request, body)) { return; } var wbhookData = JsonConvert.DeserializeObject <Models.Webhook.WebhookData>(body); foreach (var change in wbhookData.body.changes) { if ([email protected] == "ContentEvent" && change?.originatorMetadata?.role == "ASSIGNED_AGENT") { if ([email protected] != null) { var humanActivity = MessageFactory.Text([email protected]); ConversationRecord conversationRec; if (_conversationMap.ConversationRecords.TryGetValue(change.conversationId, out conversationRec)) { if (!conversationRec.IsClosed) { MicrosoftAppCredentials.TrustServiceUrl(conversationRec.ConversationReference.ServiceUrl); await((BotFrameworkHttpAdapter)_adapter).ContinueConversationAsync( _creds.MsAppId, conversationRec.ConversationReference, (ITurnContext turnContext, CancellationToken cancellationToken) => turnContext.SendActivityAsync(humanActivity, cancellationToken), default(CancellationToken)); } } else { // The bot has no record of this conversation, this should not happen throw new Exception("Cannot find conversation"); } } } } } Response.StatusCode = (int)HttpStatusCode.OK; }
/// <summary> /// This method is used to send notifications to all channels of a group activity. /// </summary> /// <param name="request">notification request object.</param> /// <returns>Task.</returns> private async Task SendNotificationsAsync(NotificationRequest request) { if (request != null) { string serviceUrl = request.ServiceUrl; MicrosoftAppCredentials.TrustServiceUrl(serviceUrl); foreach (GroupNotification channel in request.GroupNotificationChannels) { string teamsChannelId = channel.RowKey; var conversationReference = new ConversationReference() { ChannelId = Constants.Channel, Bot = new ChannelAccount() { Id = this.microsoftAppCredentials.MicrosoftAppId }, ServiceUrl = serviceUrl, Conversation = new ConversationAccount() { ConversationType = Constants.ChannelConversationType, IsGroup = true, Id = teamsChannelId, TenantId = this.tenantId }, }; this.logger.LogInformation($"sending notification to channelId- {teamsChannelId}"); var card = NotificationCard.GetNotificationCardAttachment(request, channel.ChannelName); try { await retryPolicy.ExecuteAsync(async() => { await((BotFrameworkAdapter)this.adapter).ContinueConversationAsync( this.microsoftAppCredentials.MicrosoftAppId, conversationReference, async(conversationTurnContext, conversationCancellationToken) => { await conversationTurnContext.SendActivityAsync(MessageFactory.Attachment(card)); }, CancellationToken.None); }); } catch (Exception ex) { this.logger.LogError(ex, "Error while sending notification to channel from background service."); } } } }
private static async Task AnswerAsync(Activity activity, CancellationToken ct) { try { var client = new ConnectorClient(new Uri(activity.ServiceUrl), new MicrosoftAppCredentials("appid", @"apppassword")); var answer = activity.CreateReply(activity.Text, activity.Locale); MicrosoftAppCredentials.TrustServiceUrl(activity.ServiceUrl); await client.Conversations.ReplyToActivityAsync(answer, ct); } catch (Exception e) { //Trace.TraceError(e.ToString()); throw; } }