Merge pull request #289607 from palatter/palatter/update-bot-quickstart

Update Bot Chat Quickstart

Author: rmca14

articles/communication-services/quickstarts/chat/media/web-app-create-options.png

@@ -28,37 +28,42 @@ In this quickstart, you learn how to:
 
 - An Azure account and an active subscription. Create an [account for free](https://azure.microsoft.com/free/?WT.mc_id=A261C142F).
 - [Visual Studio 2019 or later](https://visualstudio.microsoft.com/vs/).
-- The latest version of .NET Core. In this quickstart, we use [.NET Core 3.1](https://dotnet.microsoft.com/download/dotnet-core/3.1). Be sure to install the version that corresponds with your instance of Visual Studio, 32-bit or 64-bit.
+- The latest version of .NET Core. (https://dotnet.microsoft.com/download/dotnet/).
 - Bot framework [SDK](https://github.com/microsoft/botframework-sdk/#readme)
 
 ## Create and deploy a bot in Azure
 
 To use Azure Communication Services chat as a channel in Azure Bot Service, first deploy a bot. To deploy a bot, you complete these steps:
 
-- Create an Azure Bot Service resource
-- Get the bot's app ID and password
-- Create a web app to hold the bot logic
-- Create a messaging endpoint for the bot
+- [Create an Azure Bot Service resource](#create-an-azure-bot-service-resource)
+- [Get the bot's app ID and password](#get-the-bots-app-id-and-app-password)
+- [Create a web app to hold the bot app](#create-a-web-app-to-hold-the-bot-app)
+- [Create a messaging endpoint for the bot](#create-a-messaging-endpoint-for-the-bot)
 
 ### Create an Azure Bot Service resource
 
-First, [use the Azure portal to create an Azure Bot Service resource](/azure/bot-service/abs-quickstart?tabs=userassigned).  Communication Services Chat channel supports single-tenant bots, managed identity bots, and multi-tenant bots. For the purposes of this quickstart we will use a *multi-tenant* bot. 
+First, [use the Azure portal to create an Azure Bot Service resource](/azure/bot-service/abs-quickstart?tabs=userassigned).  Communication Services Chat channel supports single-tenant bots, managed identity bots, and multitenant bots. 
 
-To set up a single-tenant or managed identity bot, review [Bot identity information](/azure/bot-service/bot-builder-authentication?tabs=userassigned%2Caadv2%2Ccsharp#bot-identity-information).
-
-For a managed identity bot, you might have to [update the bot service identity](/azure/bot-service/bot-builder-authentication?tabs=userassigned%2Caadv2%2Ccsharp#to-update-your-app-service).
+- For the purposes of this quickstart we will use a `multitenant` bot. 
+- To set up a `single-tenant` or `managed identity` bot, review [Bot identity information](/azure/bot-service/bot-builder-authentication?tabs=userassigned%2Caadv2%2Ccsharp#bot-identity-information).
+- For a `managed identity` bot, you might have to [update the bot service identity](/azure/bot-service/bot-builder-authentication?tabs=userassigned%2Caadv2%2Ccsharp#to-update-your-app-service).
 
 ### Get the bot's app ID and app password
 
 Next, [get the Microsoft app ID and password](/azure/bot-service/abs-quickstart?tabs=userassigned#to-get-your-app-or-tenant-id) that are assigned to your bot when it's deployed. You use these values for later configurations.
 
-### Create a web app to hold the bot logic
+### Create a bot app and publish it to a web app
 
-To create a web app for your bot, you can revise [Bot Builder samples](https://github.com/Microsoft/BotBuilder-Samples) for your scenario or use the [Bot Builder SDK](/composer/introduction) to create a web app. One of the simplest samples is [Echo Bot](https://github.com/microsoft/BotBuilder-Samples/tree/main/samples/csharp_dotnetcore/02.echo-bot).
+To create a bot you can do one of the following: 
 
-Azure Bot Service typically expects the Bot Application Web App Controller to expose an endpoint in the form `/api/messages`. The endpoint handles all messages that are sent to the bot.
+- Revise [Bot Builder samples](https://github.com/Microsoft/BotBuilder-Samples) for your scenario, create a web app, and then deploy your bot sample to it.
+- Use the [Bot Builder SDK](/composer/introduction) to create and publish a bot to a web app. 
+
+For this quickstart we will use the [Echo Bot](https://github.com/microsoft/BotBuilder-Samples/tree/main/samples/csharp_dotnetcore/02.echo-bot) sample from the Bot Builder samples.
 
-To create the bot app, either use the Azure CLI to [create an Azure App Service resource](/azure/bot-service/provision-app-service?tabs=singletenant%2Cexistingplan) or create the app in the Azure portal.
+#### Create a web app to hold the bot app
+
+To create the web app, either use the Azure CLI to [create an Azure App Service resource](/azure/bot-service/provision-app-service?tabs=singletenant%2Cexistingplan) or create the app in the Azure portal.
 
 To create a bot web app by using the Azure portal:
 
@@ -76,7 +81,9 @@ To create a bot web app by using the Azure portal:
 
    :::image type="content" source="./media/web-app-endpoint.png" alt-text="Screenshot that shows how to copy the web app endpoint URL.":::
 
-### Create a messaging endpoint for the bot
+#### Create a messaging endpoint for the bot
+
+Azure Bot Service typically expects the Bot Application Web App Controller to expose an endpoint in the form `/api/messages`. The endpoint handles all messages that are sent to the bot.
 
 Next, in the bot resource, create a web app messaging endpoint:
 
@@ -88,9 +95,9 @@ Next, in the bot resource, create a web app messaging endpoint:
 
 :::image type="content" source="./media/smaller-bot-configure-with-endpoint.png" alt-text="Screenshot that shows how to create a bot messaging endpoint by using the web app hostname." lightbox="./media/bot-configure-with-endpoint.png":::
 
-### Deploy the web app
+#### Deploy the web app
 
-The final step to create a bot is to deploy the web app. For this quickstart, use the Echo Bot sample. The Echo Bot functionality is limited to echoing the user input. Here's how you deploy it to your web app in Azure:
+The final step to create a bot is to deploy the web app. For this quickstart, use the [Echo Bot](https://github.com/microsoft/BotBuilder-Samples/tree/main/samples/csharp_dotnetcore/02.echo-bot) sample. The Echo Bot functionality is limited to echoing the user input. Here's how you deploy it to your web app in Azure:
 
 1. Use Git to clone this GitHub repository:
 
@@ -105,12 +112,14 @@ The final step to create a bot is to deploy the web app. For this quickstart, us
 
    ```json
       {
+        "MicrosoftAppType": "",
         "MicrosoftAppId": "<App-registration-ID>",
-        "MicrosoftAppPassword": "<App-password>"
+        "MicrosoftAppPassword": "<App-password>",
+          "MicrosoftAppTenantId": ""
       }
     ```
 
-   Next, use Visual Studio for C# bots to deploy the bot.
+   Next, use Visual Studio or VS Code for C# bots to deploy the bot.
 
    You also can use a Command Prompt window to [deploy an Azure bot](/azure/bot-service/provision-and-publish-a-bot?tabs=userassigned%2Ccsharp). 
 
@@ -162,142 +171,30 @@ When you have a Communication Services resource, you can set up a Communication
 
 Now that you have the bot's Communication Services ID, you can create a chat thread with the bot as a participant.
 
-### Create a new C# application
+### Follow the 'Add Chat to your app' quickstart
 
-1. Run the following command to create a C# application:
+Follow the steps in the [Add Chat to your app](/azure/communication-services/quickstarts/chat/get-started?pivots=programming-language-csharp) quickstart to create a chat app.
 
-   ```console
-   dotnet new console -o ChatQuickstart
-   ```
+1. Replace <Resource_Endpoint> with the Communication Services endpoint from the [Get a Communication Service Resource](#get-a-communication-services-resource) step.
+1. Replace <Access_Token> with the user access token from the [Get a Communication Service Resource](#get-a-communication-services-resource) step.
+1. Replace <Access_ID> with the bots ACS_ID from the [Enable the Communication Services Chat channel](#enable-the-communication-services-chat-channel) step.
 
-1. Change your directory to the new app folder and use the `dotnet build` command to compile your application:
+### Run the C# chat application locally
 
-   ```console
-   cd ChatQuickstart
-   dotnet build
-   ```
-
-### Install the package
-
-Install the Communication Services Chat SDK for .NET:
+To run the chat application locally, use the `dotnet run` command:
 
 ```powershell
-dotnet add package Azure.Communication.Chat
-```
-
-### Create a chat client
-
-To create a chat client, use your Communication Services endpoint and the user access token you generated earlier. Use the `CommunicationIdentityClient` class from the Identity SDK to create a user and issue a token to pass to your chat client. Access tokens can be generated in the portal using the following [instructions](/azure/communication-services/quickstarts/identity/access-tokens).
-
-Copy the following code and paste it in the *Program.cs* source file:
-
-```csharp
-using Azure;
-using Azure.Communication;
-using Azure.Communication.Chat;
-using System;
-
-namespace ChatQuickstart
-{
-    class Program
-    {
-        static async System.Threading.Tasks.Task Main(string[] args)
-        {
-            // Your unique Communication Services endpoint
-            Uri endpoint = new Uri("https://<RESOURCE_NAME>.communication.azure.com");
-
-            CommunicationTokenCredential communicationTokenCredential = new CommunicationTokenCredential(<Access_Token>);
-            ChatClient chatClient = new ChatClient(endpoint, communicationTokenCredential);
-        }
-    }
-}
-```
-
-### Start a chat thread with the bot
-
-Use the `createChatThread` method on `chatClient` to create a chat thread. Replace the ID with the bot's Communication Services ID.
-
-```csharp
-var chatParticipant = new ChatParticipant(identifier: new CommunicationUserIdentifier(id: "<BOT_ID>"))
-{
-    DisplayName = "BotDisplayName"
-};
-CreateChatThreadResult createChatThreadResult = await chatClient.CreateChatThreadAsync(topic: "Hello Bot!", participants: new[] { chatParticipant });
-ChatThreadClient chatThreadClient = chatClient.GetChatThreadClient(threadId: createChatThreadResult.ChatThread.Id);
-string threadId = chatThreadClient.Id;
-```
-
-### Get a chat thread client
-
-The `GetChatThreadClient` method returns a thread client for a thread that already exists:
-
-```csharp
-string threadId = "<THREAD_ID>";
-ChatThreadClient chatThreadClient = chatClient.GetChatThreadClient(threadId: threadId);
-```
-
-### Send a message to a chat thread
-
-To use `SendMessage` to send a message to a thread:
-
-```csharp
-SendChatMessageOptions sendChatMessageOptions = new SendChatMessageOptions()
-{
-    Content = "Hello World",
-    MessageType = ChatMessageType.Text
-};
-
-SendChatMessageResult sendChatMessageResult = await chatThreadClient.SendMessageAsync(sendChatMessageOptions);
-
-string messageId = sendChatMessageResult.Id;
-```
-
-### Receive chat messages from a chat thread
-
-You can get chat messages by polling the `GetMessages` method on the chat thread client at set intervals:
-
-```csharp
-AsyncPageable<ChatMessage> allMessages = chatThreadClient.GetMessagesAsync();
-await foreach (ChatMessage message in allMessages)
-{
-    Console.WriteLine($"{message.Id}:{message.Content.Message}");
-}
+dotnet run
 ```
 
-Check the list of messages for the bot's echo reply to "Hello World".
+You should receive a message from the bot in the console that says "Hello World".
 
-You can use JavaScript or the Azure mobile SDKs to subscribe to incoming message notifications:
-
-```javascript
-// Open notifications channel
-await chatClient.startRealtimeNotifications();
-// Subscribe to new notifications
-chatClient.on("chatMessageReceived", (e) => {
-  console.log("Notification chatMessageReceived!");
-  // Your code here
-});
-```
+Example output:
 
-### Clean up the chat thread
-
-When you're finished using the chat thread, delete the thread:
-
-```csharp
-chatClient.DeleteChatThread(threadId);
+```powershell
+1730405535010:Hello World
 ```
 
-### Deploy the C# chat application
-
-To deploy the chat application:
-
-1. In Visual Studio, open the chat project.
-
-1. Right-click the **ChatQuickstart** project and select **Publish**:
-
-   :::image type="content" source="./media/deploy-chat-application.png" alt-text="Screenshot that shows deploying the chat application to Azure from Visual Studio.":::
-
-1. Once you publish the solution, run it and check if Echobot echoes the user message on the command prompt. Now that you have the solution you can proceed to play with the various activities that are needed for the business scenarios that you need to solve for.
-
 ## More things you can do with a bot
 
 A bot can receive more than a plain-text message from a user in a Communications Services Chat channel. Some of the activities a bot can receive from a user include:
@@ -560,7 +457,3 @@ Verify that the bot's Microsoft app ID and password are saved correctly in the b
 ### Bot can't be added as a participant
 
 Verify that the bot's Communication Services ID is used correctly when a request is sent to add a bot to a chat thread.
-
-## Next steps
-
-Try the [chat bot demo app](https://github.com/Azure/communication-preview/tree/master/samples/AzureBotService-Sample-App) for a 1:1 chat between a chat user and a bot via the BotFramework WebChat UI component.