Forem: Garry Trinder

Join us for HackTogether: The Microsoft Teams Global Hack

Garry Trinder — Thu, 11 May 2023 14:40:00 +0000

Millions of people across the globe use Microsoft Teams at work and at school. It is one of the world’s most popular collaboration and communication platforms with more than 300 million monthly active users. But did you know that you can build apps that can run inside or extend Microsoft Teams features?

Join us for HackTogether: The Microsoft Teams Global Hack, our virtual hackathon to learn how to build powerful apps for Microsoft Teams. Join live events, connect with Microsoft experts and win awesome prizes!

The hackathon opens on June 1, 2023 with our live keynote. Register and start hacking on your project, alone or with a team. Submit your project before the event closes on June 15, 2023.

Not sure how to build apps for Microsoft Teams? Don’t worry, we have you covered! We will provide help and support every step of the way with live events and a chance to connect with Microsoft experts.

If you’re a beginner, a student, or experienced developer interested in learning a new skill or just want to showcase your existing skills, make sure that you don’t miss this opportunity!

Join live events 📺

We will host live events throughout the hackathon to inspire you with ideas and provide access to learning resources to help you on your app building journey.

Join Microsoft experts as they share the why, what, and how of building apps for Microsoft Teams.

Schedule of live events:

June 1st: Ready, Set, Hack: Empower the developer in you with Microsoft Teams app development!
June 5th: Introduction to Teams tabs and building them with SharePoint Framework: Maximize Microsoft 365 investments.
June 6th: Introduction to Teams bots: Integrating AI into your bot logic.
June 7th: Boost user engagement beyond Teams with message extensions and make your app intelligent using Microsoft Graph.
June 12th: Ask the experts: Meet our engineering team and ask your pressing questions!
June 15th: Wrap up and take action: Join our community for the next Big Thing!

Be sure to add these events to your calendar using our invite, so that you don’t miss out!

Connect with Microsoft experts 💬

If you need help or get stuck, ask a question in our Discussions forum and connect with Microsoft experts who will be on hand to help you.

Win awesome prizes! 🏆

Once the event closes, we will judge all entries and announce the winners.

Prizes will be awarded in the following categories:

🏆 Grand prize winner: The best of the best! This category rewards the solution that meets all judging criteria, wows judges, and has potential real-world value for the 300M Teams users.

Xbox 🎮
$300 digital gift card 💸

🥇 Best AI-powered solution. This category rewards the solution that integrates AI or machine learning in an innovative way. For example, a chatbot that automates common tasks in Teams or an app that uses AI to suggest relevant files for users.

$300 digital gift card 💸

🥇 Best productivity-focused solution. This category rewards the solution that facilitates productivity and collaboration within Teams. For example, extending an existing app to Teams or creating a custom solution that helps team members stay organized during meetings.

$300 digital gift card 💸

🥇 Community hack winner. This category rewards the solution chosen by our guest judges at European Collaboration Summit (ECS).

C64 retro computer 🖥️

How do I get started? 🚀

HackTogether: The Microsoft Teams Global Hack is a unique opportunity to challenge yourself, learn new skills, and showcase your talent.

This hackathon is run in partnership with Microsoft 365 & Power Platform Community and the European Collaboration Summit community. Learn more about Microsoft Teams development. Visit our Microsoft Teams Dev Center and follow us on (@Microsoft365Dev) / Twitter to stay on top of our news and announcements.

Happy coding!

Learn how to develop apps for Microsoft Teams using Teams Toolkit for Visual Studio Code video series

Garry Trinder — Thu, 27 Apr 2023 12:59:00 +0000

Are you a developer looking to start creating apps for Microsoft Teams?

We are delighted to share with you the Build and deploy apps for Microsoft Teams using Teams Toolkit for Visual Studio Code video playlist.

Teams Toolkit for Visual Studio Code is a tool for building apps for Microsoft Teams, fast.

It is the quickest way to create, build, debug, test, and deploy apps for Microsoft Teams.

This playlist teaches you basic concepts of building apps for Microsoft Teams using Teams Toolkit.

You will learn how to:

Get started
Build a bot
Build a tab
Use Teams JavaScript library
Deploy your app to Azure

Happy coding! 👋

Full playlist URL: https://www.youtube.com/playlist?list=PLR9nK3mnD-OUj_N95-MsO0kcuufOzRTTh

All videos in the playlist were recorded in the weekly Microsoft 365 Platform and Power Platform community call. Learn more: https://aka.ms/community/calls

🙋🤖 Place your order! - Build bots for Microsoft Teams to automate repetitive workflows using Teams Toolkit for VS Code

Garry Trinder — Tue, 06 Dec 2022 12:20:00 +0000

Imagine the scenario that your organisation wants to make it easier for employees to place orders at the company restaurant.

As your organisation is already a heavy user of Microsoft Teams, it makes sense to build an app and surface it where your employees spend most of their working day.

Placing an order at a restaurant is a simple repetitive task. Typically, the process goes like this:

Employee asks to make an order.
Restaurant responds with the menu.
Employee places their order based on the menu options.
Restaurant confirms and works on the order.

Developing a bot for Microsoft Teams, rather than a traditional web application, is a great way of implementing this type of workflow inside Microsoft Teams through a conversational interface.

In this tutorial, I'm going to walk you through the steps of how to use Teams Toolkit for Visual Studio Code to create a Microsoft Teams app that contains a bot that the employees can use to place orders with the restaurant.

If you want to see the finished version, checkout the sample in the gallery, or the final source code on the TeamsFx GitHub repository.

🎥 A recording from the weekly Microsoft 365 Platform Community call is available, Build your first Workflow bot for Microsoft Teams with Teams Toolkit for Visual Studio Code, which covers the steps discussed in this tutorial.

Teams Toolkit for Visual Studio Code
Prerequisites
Install Teams Toolkit for Visual Studio Code
Scaffold and run the project
Clean the project
Create the Adaptive Card templates
Create the order command
Create the order card action
Place your order
What next?
Learn more

🛠 Teams Toolkit for Visual Studio Code

Teams Toolkit for Visual Studio Code enables you to create, debug and deploy Microsoft Teams apps to a Microsoft 365 tenant fast using a no configuration approach.

In a recent release of Teams Toolkit for Visual Studio Code, a new scenario-based app capability has been released called Initiate sequential workflows.

This new capability makes it easy for developers to respond to actions invoked from Adaptive Cards, which is ideal for our restaurant order scenario.

Using this new capability, we will create a bot that uses the below workflow.

The employee sends a message containing the word order to the bot chat.
The bot returns an Adaptive Card containing a simple form.
The employee submits the form.
The bot captures the form data and replaces the form with a confirmation message.

🏁 Prerequisites

To follow this guide successfully you will need.

Microsoft 365 Tenant, which has been enabled for developing custom applications with. If you do not have a tenant, I highly recommend that you use a Microsoft 365 Developer Tenant, which you can obtain for free by joining the Microsoft 365 Developer Program. It is pre-configured for Microsoft Teams app development right out of the box.
Visual Studio Code, if you do not have it installed, download it for free!

With the prerequisites done, let’s begin!

🛠 Install Teams Toolkit for Visual Studio Code

Our first step is to install Teams Toolkit into Visual Studio Code, you can do this several ways, however the easiest is way is to search for and install the extension using the Extensions panel from the Side Bar within Visual Studio Code.

Open Visual Studio Code.
Open the Extensions panel from the Side Bar.
Search for Teams Toolkit in the marketplace.
Select Teams Toolkit in the search results.
Click the Install button to install the extension.

Once the extension has been successfully installed, you will see a Microsoft Teams icon in the Side Bar.

👷 Scaffold and run the project

After installing the extension, let’s create our project.

Open the Teams Toolkit extension by clicking on the Microsoft Teams icon in the Side Bar
Click the Create a new Teams app button to start the project scaffolding wizard
Select Create a new Teams app in the first step
Select Initiate sequential workflows in the Capabilities step
Select TypeScript in the Programming Language step
Select a folder of your choice in the Workspace folder step, this is the location of where the project will be created.
Enter ContosoRestaurant in the application name step.

When you complete the last step, Teams Toolkit will create a project in a folder with the same name in the Workspace folder location you selected in the previous step.

After the project scaffolding is complete, Teams Toolkit will re-open Visual Studio Code in the project folder and open a Readme file for the project.

The scaffolded project contains some boilerplate code which provides some basic workflow functionality, containing a command and action.

You can run the bot to see how it works by opening the debug side panel, select your browser of choice in the dropdown, and start debugging by either clicking the green play icon or by pressing F5 on your keyboard.

If this is the first time you have used Teams Toolkit for Visual Studio Code, when you first launch your app using Debug, you will be prompted to sign into your Microsoft 365 tenant.

Click the Sign In button in the prompt, this will open your primary browser and navigate you to a Microsoft 365 login screen. Enter your account details to complete the authentication flow, once successful you can close the browser window and return to Visual Studio Code.

Teams Toolkit will setup all the required resources and services for your bot to run locally inside Microsoft Teams, and also provide debugging and hot reload functionality.

The first time you run your app, Teams Toolkit will perform an npm install to install all the required packages, so it might take a few moments depending on your network and machine resources.

This would be a good time to grab a ☕️

When complete, a browser window will be launched and you will be navigated to the web version of Microsoft Teams. You may be prompted for authentication again, if you are, just complete the steps using the same account as you signed in previously.

When Microsoft Teams loads, a dialog box will appear which enables you to side load your app. Click the Add button to add the app as a personal app, and open the bot chat.

Type helloWorld into the chat box and send your message, this will invoke the bot command which returns an Adaptive Card with a button.

Selecting the button will update the Adaptive Card with confirmation of that action.

👷 Clean the project

This is entirely optional, but to help follow along with the rest of this tutorial, I recommend that you remove the default code, so it doesn't get in the way and we can start from a clean slate.

Don't worry about what we are removing for now, I'll explain all this as we go through the steps.

If your debug session is still running, just close down the browser window or stop the debugging session in Visual Studio Code.

To remove the default code, you can use a script or do it manually.

To manually remove the code

Delete all files in the following folders
- bot\src\AdaptiveCards
- bot\src\cardActions
- bot\src\commands
Clear contents of bot\src\cardModels.ts
Update /bot/src/internal/initialize.ts
- Clear commands array 👉 commands: []
- Clear actions array 👉 actions: []
- Remove the unused imports
Update templates/appPackage/manifest.template.json
- Clear the commands array 👉 commands: []

To use the script to remove the code

Create a scripts folder in the root
Download the file and add it to the scripts folder
Open terminal prompt, change to root directory
Execute node scripts\ttk_workflowbot_clean.js

Now that we have a clean project, let's start building out our scenario.

🧑‍💻 Create the Adaptive Card templates

The first thing we will do is implement Adaptive Cards templates, these cards represent our user interface that employees will interact with.

Adaptive Cards are an open card exchange format enabling developers to exchange UI content in a common and consistent way.

Templating enables the separation of data from the layout in an Adaptive Card, by using data binding syntax ${data} we can add placeholders into our templates that can be populated data when we use the Adaptive Card SDK to render the card.

The first template will be sent back to the employee when they request to make an order with menu options.

Let's create a new file in the bot\src\AdaptiveCards folder called orderCommandResponse.json with the following contents.

{
    "type": "AdaptiveCard",
    "$schema": "http://adaptivecards.io/schemas/adaptive-card.json",
    "version": "1.4",
    "body": [
        {
            "type": "TextBlock",
            "text": "${FormInfo.title}",
            "size": "Large",
            "wrap": true,
            "weight": "Bolder"
        },
        {
            "type": "Input.ChoiceSet",
            "id": "EntreeSelectVal",
            "label": "${Order.questions[0].question}",
            "style": "filtered",
            "isRequired": true,
            "errorMessage": "This is a required input",
            "placeholder": "Please choose",
            "choices": [
                {
                    "$data": "${Order.questions[0].items}",
                    "title": "${choice}",
                    "value": "${value}"
                }
            ]
        },
        {
            "type": "Input.ChoiceSet",
            "id": "SideVal",
            "label": "${Order.questions[1].question}",
            "style": "filtered",
            "isRequired": true,
            "errorMessage": "This is a required input",
            "placeholder": "Please choose",
            "choices": [
                {
                    "$data": "${Order.questions[1].items}",
                    "title": "${choice}",
                    "value": "${value}"
                }
            ]
        },
        {
            "type": "Input.ChoiceSet",
            "id": "DrinkVal",
            "label": "${Order.questions[2].question}",
            "style": "filtered",
            "isRequired": true,
            "errorMessage": "This is a required input",
            "placeholder": "Please choose",
            "choices": [
                {
                    "$data": "${Order.questions[2].items}",
                    "title": "${choice}",
                    "value": "${value}"
                }
            ]
        }
    ],
    "actions": [
        {
            "type": "Action.Execute",
            "verb": "order",
            "title": "Place Order"
        }
    ]
}

When this card is rendered, it will display a mini form with three drop downs and an action button. When the action button is selected, the form data is sent to the bot along with a verb, which represents the action that was performed.

Note that the drop downs are given ID property values, when the form is submitted the data sent to bot as key/value pairs, e.g { "DrinkVal": "value" }.

The second template will be displayed to the employee when they have submitted their order to the restaurant.

Let's create a new file in the bot\src\AdaptiveCards folder called orderActionResponse.json with the following contents.

{
  "type": "AdaptiveCard",
  "$schema": "http://adaptivecards.io/schemas/adaptive-card.json",
  "version": "1.4",
  "body": [
    {
      "type": "TextBlock",
      "text": "${title}",
      "wrap": true,
      "style": "heading"
    },
    {
      "type": "Container",
      "items": [
        {
          "type": "FactSet",
          "facts": [
            {
              "title": "Entree",
              "value": "${actionData.EntreeSelectVal}"
            },
            {
              "title": "Side",
              "value": "${actionData.SideVal}"
            },
            {
              "title": "Drink",
              "value": "${actionData.DrinkVal}"
            }
          ]
        }
      ]
    }
  ],
  "actions": [
    {
      "type": "Action.Execute",
      "title": "Edit Order",
      "verb": "order-edit"
    }
  ]
}

When this card is rendered, it will display the selected options submitted in the first card and an action button.

Now that we have our templates in place, let's create the data models to define the correct data shape to use with our template when we render the card using the Adaptive Cards SDK.

Open the bot/src/cardModels.ts file.

Add the following interfaces which describes the data shape for the bot\src\AdaptiveCards\orderCommandResponse.json card.

export interface OrderData {
  FormInfo: FormInfo;
  Order: Order;
}

export interface FormInfo {
  title: string;
}

export interface Order {
  questions: Question[];
}

export interface Question {
  question: string;
  items: Item[];
}

export interface Item {
  choice: string;
  value: string;
}

Add the following interfaces which describes the data shape for the bot\src\AdaptiveCards\orderCommandResponse.json card.

export interface OrderResponseData {
  title: string;
  actionData: OrderActionData;
}

export interface OrderActionData {
  EntreeSelectVal: string;
  SideVal: string;
  DrinkVal: string;
}

The OrderActionData interface also provides the shape of the data which is returned to our bot when the first card is submitted.

Take a moment to look at the data binding syntax used in the templates and the shape of the data defined in the data models.

📝 Create the order command

To create a new command we need to perform three tasks

Create the command handler
Update the bot configuration
Update the app manifest

Create the command handler

With our user interface defined, let's create the order command which our employees will use to start the order process.

Let's create a new file in the bot\src\commands folder called orderCommandHandler.ts with the following contents.

export class OrderCommandHandler implements TeamsFxBotCommandHandler { }

The OrderCommandHandler class will represent the handler for when the order command is sent in the bot chat.

We will use the TeamsFxBotCommandHandler interface from the @microsoft/teamsfx library to implement the handler functionality.

Let's import the CommandMessage, TeamsFxBotCommandHandler and TriggerPatterns classes from the @microsoft/teamsfx library, the TurnContext class and Activity interface from botbuilder library, and implement the TeamsFxBotCommandHandler interface.

You can use the Quick Fix menu in Visual Studio Code to import packages and implement interfaces quickly

import { CommandMessage, TeamsFxBotCommandHandler, TriggerPatterns } from "@microsoft/teamsfx";
import { TurnContext, Activity } from "botbuilder";

export class OrderCommandHandler implements TeamsFxBotCommandHandler {

  triggerPatterns: TriggerPatterns;

  async handleCommandReceived(context: TurnContext, message: CommandMessage): Promise<string | void | Partial<Activity>> {
    throw new Error("Method not implemented.");
  }

}

Let's update the triggerPatterns property with the value order. This property defines the keyword that the bot will listen out for when it is sent messages.

triggerPatterns: TriggerPatterns = "order";

Next, let's add the logic to the handleCommandReceived method that will be executed when the handler is invoked.

First, add the async keyword to the method declaration as the method will return a Promise.

async handleCommandReceived(context: TurnContext, message: CommandMessage): Promise<string | void | Partial<Activity>> {

Next we will create a new object that we will use populate the template in the shape of the OrderData model that we defined earlier. This object will represent the menu options that the employee can choose from in the form.

Import the OrderData interface using an import statement at the top of the file.

import { OrderData } from "../cardModels";

Create a new constant called orderData using the OrderData interface as its type, replacing the throw statement.

const orderData: OrderData = {
      "FormInfo": {
        "title": "Malt & Vine Order Form"
      },
      "Order": {
        "questions": [
          {
            "question": "Which entree would you like?",
            "items": [
              {
                "choice": "Steak",
                "value": "Steak"
              },
              {
                "choice": "Chicken",
                "value": "Chicken"
              },
              {
                "choice": "Tofu",
                "value": "Tofu"
              }
            ]
          },
          {
            "question": "Which side would you like?",
            "items": [
              {
                "choice": "Baked Potato",
                "value": "Baked Potato"
              },
              {
                "choice": "Rice",
                "value": "Baked Potato"
              },
              {
                "choice": "Vegetables",
                "value": "Baked Potato"
              },
              {
                "choice": "Noodles",
                "value": "Baked Potato"
              },
              {
                "choice": "No Side",
                "value": "Baked Potato"
              }
            ]
          },
          {
            "question": "Which drink would you like?",
            "items": [
              {
                "choice": "Water",
                "value": "Water"
              },
              {
                "choice": "Soft Drink",
                "value": "Soft Drink"
              },
              {
                "choice": "Coffee",
                "value": "Coffee"
              },
              {
                "choice": "Natural Juice",
                "value": "Natural Juice"
              },
              {
                "choice": "No Drink",
                "value": "No Drink"
              }
            ]
          }
        ]
      }
    }

Now we have our data, we need to populate our template with orderData to render a card that we can then send to the bot chat as our response. To do this we need to import our template and the Adaptive Cards SDK.

Import the template and SDK by adding import statements at the top of the file.

import orderCard from "../adaptiveCards/orderCommandResponse.json";
import { AdaptiveCards } from "@microsoft/adaptivecards-tools";

Add the following line after you initialise the orderData constant, where we will use the Adaptive Cards SDK to parse the template and passing the data object to it to render the card.

const cardJson = AdaptiveCards
  .declare<OrderData>(orderCard)
  .render(orderData);

We now have a card populated with data and ready to be sent, so let's do that.

Import the MessageFactory and CardFactory classes from the botbuilder library by updating the existing import statement.

import { TurnContext, Activity, MessageFactory, CardFactory } from "botbuilder";

Add the following line after you initialise the cardJson constant to send the populated Adaptive Card to the bot chat.

return MessageFactory.attachment(
  CardFactory.adaptiveCard(cardJson)
);

Update the bot configuration

After implementing the command handler, the next step is to update the bot configuration to tell our bot about our new handler.

Open the bot\src\internal\initialize.ts file which contains our bot configuration and import the OrderCommandHandler class at the top of the file.

import { OrderCommandHandler } from "../commands/orderCommandHandler";

Update the commands array, including a new instance of the OrderCommandHandler class in the array.

command: {
  enabled: true,
  commands: [new OrderCommandHandler()],
},

Update the app manifest

The final step is to add our order command to the list of suggestions that the bot can recommend to employees who use it.

Open the templates\manifest.template.json app manifest file, which describes how our app integrates into Microsoft Teams.

Update the commands array, including a new command object in the array.

"commands": [
  {
    "title": "order",
    "description": "Place an order"
  }
]

⚡️ Create the order card action

With our user interface and command handler defined, we now need to create an action handler which will be triggered when the employee submits the order.

To create a new action handler we need to perform two tasks

Create the action handler
Update the bot configuration

Create the action handler

Let's create a new file in the bot\src\cardActions folder called orderActionHandler.ts with the following contents.

export class OrderActionHandler implements TeamsFxAdaptiveCardActionHandler { }

The OrderActionHandler class will represent the handler for when an Adaptive Card action that uses the Action.Execute type passing the order verb.

We will use the TeamsFxAdaptiveCardActionHandler interface from the @microsoft/teamsfx library to implement the handler functionality.

Let's import the AdaptiveCardResponse enum and TeamsFxAdaptiveCardActionHandler class from the @microsoft/teamsfx library, the TurnContext class and InvokeResponse interface from botbuilder library, and implement the TeamsFxAdaptiveCardActionHandler interface.

import { AdaptiveCardResponse, TeamsFxAdaptiveCardActionHandler } from "@microsoft/teamsfx";
import { TurnContext, InvokeResponse } from "botbuilder";

export class OrderActionHandler implements TeamsFxAdaptiveCardActionHandler {

  triggerVerb: string;

  adaptiveCardResponse?: AdaptiveCardResponse;

  handleActionInvoked(context: TurnContext, actionData: any): Promise<InvokeResponse<any>> {
    throw new Error("Method not implemented.");
  }

}

Let's update the triggerVerb property with the value order. This property defines the verb that the bot will listen out for when it is sent data as a result of an Action.Execute action invoked from an Adaptive Card.

triggerVerb: string = "order";

Next, let's add the logic to the handleActionInvoked method that will be executed when the handler is invoked.

Add the async keyword to the method declaration as the method will return a Promise.

async handleActionInvoked(context: TurnContext, actionData: any): Promise<InvokeResponse<any>> {

You may have noticed that handleActionInvoked method returns an actionData parameter, this will contain the data submitted from our Adaptive Card.

As we have already defined the model for this data, let's replace any with our own type.

Import the OrderActionData interface using an import statement at the top of the file.

import { OrderActionData } from "../cardModels";

Update actionData parameter type.

async handleActionInvoked(context: TurnContext, actionData: OrderActionData): Promise<InvokeResponse<any>> {

Next we will create a new object that we will use populate the template in the shape of the OrderResponseData model that we defined earlier. This object will represent the menu options selected by the employee and includes a title to display in the confirmation.

Import the OrderResponseData interface using an import statement at the top of the file.

import { OrderResponseData } from "../cardModels";

Create a new constant called orderResponseData using the OrderResponseData interface as its type, replacing the throw statement.

const orderResponseData: OrderResponseData = {
  title: "✅ [ACK] Order Placed",
  actionData
};

Now we have our data, we need to populate our template with orderResponseData to render a card that we can then replace the submitted Adaptive Card with. To do this we need to import our template and the Adaptive Cards SDK.

Import the template and SDK by adding import statements at the top of the file.

import orderActionResponseCard from "../adaptiveCards/orderActionResponse.json";
import { AdaptiveCards } from "@microsoft/adaptivecards-tools";

Add the following line after you initialise the orderResponseData constant, where we will use the Adaptive Cards SDK to parse the template and passing the data object to it to render the card.

const cardJson = AdaptiveCards
  .declare<OrderResponseData>(orderActionResponseCard)
  .render(orderResponseData);

We now have a card populated with data and ready to be sent, so let's do that.

Import the InvokeResponseFactory class from the @microsoft/teamsfx library by updating the existing import statement.

import { AdaptiveCardResponse, InvokeResponseFactory, TeamsFxAdaptiveCardActionHandler } from "@microsoft/teamsfx";

Add the following line after you initialise the cardJson constant to send the populated Adaptive Card to the bot chat, replacing the existing Adaptive Card.

return InvokeResponseFactory.adaptiveCard(cardJson);

Update the bot configuration

After implementing the action handler, the next step is to update the bot configuration to tell our bot about our new handler.

Open the bot\src\internal\initialize.ts file which contains our bot configuration and import the OrderActionHandler class at the top of the file.

import { OrderCommandHandler } from "../commands/orderCommandHandler";

Update the actions array, including a new instance of the OrderActionHandler class in the array.

cardAction: {
  enabled: true,
  actions: [new OrderActionHandler()]
},

🙋 Place your order

Now it's time to run our bot and test it out.

You can do this easily, either by opening the Debug panel and selecting the green play button or by pressing F5 on your keyboard.

Follow the steps to side load your application, when the bot chat is visible, submit order in the chat to start the workflow.

🎉 Congratulations! You've just created your first bot that implements a simple workflow to automate a repetitive task enabling an employee to place an order with the company restaurant.

⏭ What next?

Want to make more updates? Here are a few things you can try.

Edit order, implement the Edit Order button that is displayed when the order is confirmed.
Expand the menu, add more options to the order form.
Update the app icons, currently the app uses stock icons, update the icons in the templates/appPackage/resources directory with new, more relevant icons.
Restrict supported Teams scopes, by default the bot can be installed into a personal, chat or channel context, to restrict where the bot can be used, update the scopes array in the app manifest.

📚 Learn more

👋 Happy coding!

Banner image generated using DALL·E 2 text to image API, a robot placing an order at a restaurant

Build a stock update notification bot for Microsoft Teams using C# and Teams Toolkit for Visual Studio

Garry Trinder — Tue, 08 Nov 2022 13:31:00 +0000

Microsoft Teams Toolkit for Visual Studio enables you to create, debug and deploy Microsoft Teams apps to a Microsoft 365 tenant fast using a no configuration approach.

In this tutorial, I will guide you through the steps to create a Stock Update Notification bot for Teams Toolkit and C#.

If you want to see the finished version, checkout the sample code in the TeamsFX Samples GitHub repository.

Prerequisites
Install Teams Toolkit for Visual Studio
Scaffold the project
Update the adaptive card
Update the bot logic
Start ngrok
Prepare dependencies
Test your bot
What next?
Learn more!

🏁 Prerequisites

To follow this guide successfully you will need.

Microsoft 365 Tenant, which has been enabled for developing custom applications with. If you do not have a tenant, I highly recommend that you use a Microsoft 365 Developer Tenant, which you can obtain for free by joining the Microsoft 365 Developer Program. It is pre-configured for Microsoft Teams app development right out of the box.
Visual Studio 2022 17.3+, you can use either of the Community, Professional or Enterprise editions. If you do not have Visual Studio installed, try out the Community edition for free!
ngrok, is a globally distributed reverse proxy which you can use to promote web services running on your local machine to an internet available address, in short, it puts localhost on the internet. This is required for Microsoft Teams to talk to the code running locally on your machine. If you do not have ngrok you can download for free.

With the prerequisites done, let’s begin!

🛠 Install Teams Toolkit for Visual Studio

Our first step is to install Teams Toolkit into Visual Studio.

Open the Visual Studio Installer.
Click the Modify button to configure your installation.
On the Workloads tab, select the ASP.NET and web development workload.
In the Installation details pane on the right, scroll down the list and check the option called Microsoft Teams development tools.
Click the Modify button to install Teams Toolkit.

Once the installation is complete, you can close the Visual Studio installer.

👷 Scaffold the project

After installing Teams Toolkit into Visual Studio, it is now time to create our project.

Open Visual Studio 2022
From the start-up screen, select Create a new project.
On the Create a new project screen, expand the All platforms dropdown, and select Microsoft Teams, this will display a single template called Microsoft Teams App, click Next to confirm the template choice.
On the Configure your new project screen, enter StocksUpdateNotificationBot in the Project name field, then click Create to confirm.
In the Create a new Teams application dialog, expand the Trigger type dropdown, and select Timer Trigger (Azure Function), then click Create to confirm.

Teams Toolkit will now generate a new project for you and open it for you.

ℹ️ Update the adaptive card

We will use an Adaptive Card to represent our stock price update, so let’s update the default adaptive card design to fit our needs.

Open the NotificationDefault.json file in the Resources directory and replace the contents with the following JSON.

{
  "$schema": "http://adaptivecards.io/schemas/adaptive-card.json",
  "type": "AdaptiveCard",
  "version": "1.4",
  "body": [
    {
      "type": "Container",
      "items": [
        {
          "type": "TextBlock",
          "text": "${name}",
          "size": "Medium",
          "wrap": true
        },
        {
          "type": "TextBlock",
          "text": "${symbol}",
          "isSubtle": true,
          "spacing": "None",
          "wrap": true
        },
        {
          "type": "TextBlock",
          "text": "{{DATE(${timestamp},SHORT)}} {{TIME(${timestamp})}}",
          "wrap": true
        }
      ]
    },
    {
      "type": "Container",
      "spacing": "None",
      "items": [
        {
          "type": "ColumnSet",
          "columns": [
            {
              "type": "Column",
              "width": "stretch",
              "items": [
                {
                  "type": "TextBlock",
                  "text": "${formatNumber(price,2)}",
                  "size": "ExtraLarge",
                  "wrap": true
                },
                {
                  "type": "TextBlock",
                  "text": "${if(change >= 0, '▲', '▼')} ${formatNumber(change,2)} USD (${formatNumber(changePercent, 2)}%)",
                  "spacing": "None",
                  "wrap": true
                }
              ]
            },
            {
              "type": "Column",
              "width": "auto",
              "items": [
                {
                  "type": "FactSet",
                  "facts": [
                    {
                      "title": "Open",
                      "value": "${formatNumber(open,2)}"
                    },
                    {
                      "title": "High",
                      "value": "${formatNumber(high,2)}"
                    },
                    {
                      "title": "Low",
                      "value": "${formatNumber(low,2)}"
                    }
                  ]
                }
              ]
            }
          ]
        }
      ]
    }
  ]
}

We are using Adaptive Cards Template Language here to provide separation between our data and layout. Using binding expressions i.e., ${name}, we can add placeholders to our layout in locations where we want our data to be rendered.

Let’s create a class to represent the data object to use with the template. Open the NotificationDefaultModel.ts file in the Models directory and replace the contents with the following.

namespace StocksUpdateNotificationBot.Models{
    public class GlobalQuote
    {
        public string Symbol { get; set; }
        public double Open { get; set; }
        public double High { get; set; }
        public double Low { get; set; }
        public double Price { get; set; }
        public double Volume { get; set; }
        public string LatestTradingDay { get; set; }
        public double PreviousClose { get; set; }
        public double Change { get; set; }
        public double ChangePercent { get; set; }
        public string Name { get; set; }
        public string Timestamp { get; set; }
    }
}

When we combine our template and data using the Adaptive Cards SDK, the notification will look something like this.

🤖 Update the bot logic

Open the NotifyTimerTrigger.cs file, this file contains the core logic of our bot that will be executed on a schedule.

For now, let’s remove the contents of Run method and remove unused using statements, you can remove the statements by using the keyboard shortcut, Ctrl + R followed by Ctrl + G.

As our bot will call out to an external API, we will need an HTTP client to execute the requests, so let’s also create a new read-only property in the NotifyTimerTrigger class and create a new HTTP client.

private readonly HttpClient _client = new();

Your file should look like the below block of code.

using Microsoft.Azure.WebJobs;
using Microsoft.Extensions.Logging;
using Microsoft.TeamsFx.Conversation;

using ExecutionContext = Microsoft.Azure.WebJobs.ExecutionContext;

namespace StocksUpdateNotificationBot
{
    public sealed class NotifyTimerTrigger
    {
        private readonly ConversationBot _conversation;
        private readonly ILogger<NotifyTimerTrigger> _log;
        private readonly HttpClient _client = new();

        public NotifyTimerTrigger(ConversationBot conversation, ILogger<NotifyTimerTrigger> log)
        {
            _conversation = conversation;
            _log = log;
        }

        [FunctionName("NotifyTimerTrigger")]
        public async Task Run([TimerTrigger("*/30 * * * * *")]TimerInfo myTimer, ExecutionContext context, CancellationToken cancellationToken)
        {

        }
    }
}

Let’s add in the logic for our bot.

First let’s add a try/catch block to the Run method.

try {
    // bot logic goes here
} catch (HttpRequestException e) {
    _log.LogError(e.Message);
}

When the bot is executed, our bot will need to obtain the latest stock price, to do this we will send a HTTP request to the Alpha Vantage API.

Replace the // bot logic goes here comment inside the try block, with the following code.

// Get quote data from Alpha Vantage API
var response = await _client.GetStringAsync($"https://www.alphavantage.co/query?function=GLOBAL_QUOTE&symbol=MSFT&apikey=demo", cancellationToken);

Next, we need to deserialize and transform the response into the correct shape to use with our Adaptive Card model.

Add the following using statements to the top of the file.

using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using StocksUpdateNotificationBot.Models;

Add the following code into the try block.

// Deserialize JSON response
JObject jObj = (JObject)JsonConvert.DeserializeObject(response);

// Transform Global Quote object
var globalQuote = new GlobalQuote
{
    Symbol = jObj["Global Quote"]["01. symbol"].ToString(),
    Open = double.Parse(jObj["Global Quote"]["02. open"].ToString()),
    High = double.Parse(jObj["Global Quote"]["03. high"].ToString()),
    Low = double.Parse(jObj["Global Quote"]["04. low"].ToString()),
    Price = double.Parse(jObj["Global Quote"]["05. price"].ToString()),
    Volume = double.Parse(jObj["Global Quote"]["06. volume"].ToString()),
    LatestTradingDay = jObj["Global Quote"]["07. latest trading day"].ToString(),
    PreviousClose = double.Parse(jObj["Global Quote"]["08. previous close"].ToString()),
    Change = double.Parse(jObj["Global Quote"]["09. change"].ToString()),
    ChangePercent = double.Parse(jObj["Global Quote"]["10. change percent"].ToString().Replace("%", string.Empty)),
    Name = "Microsoft Corporation",
    Timestamp = $"{DateTime.Now.ToUniversalTime().ToString("o").Split(".")[0]}Z"
};

Now that we have all the data and it has been transformed into the correct shape, we need to obtain our Adaptive Card template.

Add the following code into the try block.

// Read adaptive card template
var adaptiveCardFilePath = Path.Combine(context.FunctionAppDirectory, "Resources", "NotificationDefault.json");
var cardTemplate = await File.ReadAllTextAsync(adaptiveCardFilePath, cancellationToken);

Finally, we want to iterate over all the locations where the bot has been installed in Microsoft Teams, render our Adaptive Card by combining the data and template, and send the card output into those locations.

Add the following code into the try block.

// Get bot installation
var installations = await _conversation.Notification.GetInstallationsAsync(cancellationToken);

foreach (var installation in installations)
{
    // Build and send adaptive card
    var cardContent = new AdaptiveCardTemplate(cardTemplate).Expand(globalQuote);
    await installation.SendAdaptiveCard(JsonConvert.DeserializeObject(cardContent), cancellationToken);
}

That’s the code complete, so let’s move onto getting our project ready to run our bot locally.

📡 Start ngrok

We need to ensure that ngrok is running so that Microsoft Teams can communicate with the code running on our local machines.

Open a terminal prompt at the location where you installed the ngrok executable and start the ngrok service forwarding port 5130 using the following command.

.\ngrok http 5130

When ngrok is running, a dashboard will be displayed in your terminal prompt with the internet accessible ngrok address that is forwarding network traffic to your localhost hostname, which will be in the format of ..ngrok.io.

🧑‍🍳 Prepare dependencies

In Visual Studio, right click the StocksUpdateNotificationBot project in the Solution Explorer pane, expand the Teams Toolkit menu and select the first option in the menu, Prepare Teams Apps Dependencies.

A Visual Studio account dialog box will be shown, add your Microsoft 365 Tenant account and follow the authentication steps. Once your account has been authenticated, click Continue to start the process.

The Prepare Teams Apps Dependencies process ensures that the required resources have been provisioned in your target Microsoft 365 Tenant, that services that are needed are running on your machine, such as ngrok, and updating the app manifest file.

🧪 Test your bot

Now it is time to see our bot in action!

To do this, simply press F5 on your keyboard.

The first time you run your bot, you will need to allow the Azure Functions executable to send network requests through the Windows Defender firewall, to enable this, click Allow access in the prompt.

Teams Toolkit will open a browser window for you and start to open Microsoft Teams, you may be asked to sign into you Microsoft 365 Tenant at this point, if you are, complete the process. When you are authenticated, you will be presented with Microsoft Teams dialog which enables you to side load our app into your Microsoft 365 tenant.

Click the Add button to install the bot as a personal app and you will be taken to the chat tab of your personal app.

Wait a few seconds for your bot to be executed, and you will see a message arrive from our bot with the latest stock price rendered as an Adaptive Card.

Congratulations, you have just created your first notification bot using Teams Toolkit for Visual Studio! 🎉

⏭ What next?

Want to make some updates? Here are a few things you can try.

Use a different symbol, currently the stock price for MSFT is returned, pass a different symbol into the API call, and update the company name in the GlobalQuote object.
Change the timer frequency, currently the timer trigger is executed every 30 seconds, change this by updating the CRON expression passed into the Run method in NotificationTimerTrigger.cs file.
Update the app manifest, currently the app manifest contains mostly default values, use the Open Manifest File menu item in the Teams Toolkit menu to open the app manifest template and makes changes to it.
Update the app icons, currently the app uses stock icons, update the icons in the Templates/appPackage/resources directory with new more relevant icons.
Disable the bot chat compose box and @ mentions, by default the bot chat compose box and the ability to @ mention the bot is enabled. To disable this, edit the app manifest and update the isNotificationOnly property to true.
Restrict supported Teams scopes, by default the bot can be installed into a personal, chat or channel context, to restrict where the bot can be used, update the scopes array in the app manifest.

📚 Learn more!

👋 Happy coding!

Banner image generated using DALL·E 2 text to image API, A friendly robot stood on the wall street trading floor

Start your journey to becoming a Microsoft 365 developer

Garry Trinder — Mon, 12 Sep 2022 16:10:57 +0000

There has never been a better time to start your journey to becoming a Microsoft 365 Developer.

In the past few years, Microsoft 365 has become the place for organizations to communicate and collaborate, with more than 270 million monthly active users on Microsoft Teams.

By becoming a Microsoft 365 Developer, you can extend, integrate LOB applications and access Microsoft 365 data through Microsoft Graph, tailoring your experience to your organization’s needs.

Whether you are a new or experienced developer, this post will help you get started on this journey, providing you with guidance on where to find the content you need.

🧑‍💻 Join the Microsoft 365 Developer Program

The easiest way to start your developer journey with Microsoft 365 is to join the Microsoft 365 Developer Program.

Joining the program is free and by becoming a member, you get a free Microsoft 365 Developer Tenant, a free-instant sandbox that comes with sample user licenses, sample content packs for Microsoft Teams, email and calendar and is pre-configured for development, so you can get started quickly.

The tenant will renew every 90 days, so if you keep using it, it will be yours forever.

 ☁️ Learn the fundamentals of Microsoft Cloud

As a Microsoft 365 Developer, you will use all three clouds of the Microsoft Cloud – Microsoft 365, Microsoft Azure, and Microsoft Power Platform – to extend and integrate with Microsoft 365 services.

While you don’t need to have a deep understanding of Microsoft Azure and Microsoft Power Platform, it is highly recommended that you gain a basic knowledge of how they integrate with Microsoft 365 and the services that they offer which you can utilize in your apps and integrations.

Checkout the below learning paths on Microsoft Learn that will give you a basic understanding of the three clouds.

📚 Study the learning paths

While you don’t need to learn a specific language to build apps for and integrate with Microsoft 365, it is recommended that you have a knowledge of JavaScript/TypeScript and/or Microsoft .NET.

The following learning paths are recommended:

Once you have your developer tenant and a have a grasp of the basics of the Microsoft Cloud, the next place to go is to check out the free learning paths on Microsoft Learn, which are focused on the skills needed to become a Microsoft 365 Developer.

Microsoft 365 Developer Path

First take the fundamentals module to understand the basics of extending Microsoft 365, then dive into the basics of Microsoft Graph, extending Viva Connections and how to develop apps using the Microsoft Graph Toolkit components.

Beginner Paths

Build on the foundational knowledge you have gained in the previous and start introducing more advanced topics, here is where you will learn how to extend and build apps on Microsoft Teams, extend Viva Connections and SharePoint Online, extend Office clients with Office add-ins, as well as accessing Microsoft 365 data via the Microsoft Graph.

Intermediate Paths

🎓 Get certified!

Everyone loves to be rewarded, if you take and pass an official Microsoft exam you will be rewarded with an industry recognized professional certification, which will help validate your learning and demonstrate your knowledge of Microsoft 365.

Microsoft 365 Certified: Developer Associate

🏘 Join our community

Microsoft 365 has one of the best communities in tech. With the Microsoft 365 Platform community you can benefit from an abundance of content and tools built by and shared by the community to help you be more productive, attend and participate in community calls to keep up with the latest practices and learn from community shared samples.

Learn from others how to build apps on Microsoft 365. Don’t reinvent the wheel. Focus on what truly matters for your organization.

📣 Keep up to date

Keep up to date with the latest announcements and best practices across official Microsoft and community channels.

Read

Watch

Engage

👷 What will you build today?

There is an abundance of content just waiting to help you get started on your Microsoft 365 Developer journey and what’s great, is that it is totally free.

Sign up for your Microsoft 365 Developer tenant and get building on Microsoft 365 today!

CLI for Microsoft 365 v3.4

Garry Trinder — Mon, 04 Jan 2021 09:29:40 +0000

We’ve just published a new version of the CLI for Microsoft 365 with new commands for working with and managing Microsoft 365 tenants and SharePoint Framework projects on any platform.

Manage Microsoft 365 and SharePoint Framework projects on any platform

CLI for Microsoft 365 is a cross-platform CLI that allows you to manage various configuration settings of Microsoft 365 and SharePoint Framework projects no matter which operating system or shell you use.

While building solutions for Microsoft 365 expands beyond the Windows operating system, managing many of the platform settings is possible only through PowerShell on Windows. As more and more users work on non-Windows machines, it’s inconvenient for them to have to use a Windows virtual machine to configure their tenants. With the CLI for Microsoft 365, you can configure your tenant no matter which operating system you use. Additionally, using CLI for Microsoft 365, you can manage your SharePoint Framework projects.

New version of CLI for Microsoft 365 – v3.4

Following our monthly release cadence, we’ve released a new version of the CLI for Microsoft 365 with some new capabilities. Here are a few of the most noteworthy additions.

Changes

We’ve continued improving CLI building upon the changes we’ve introduced in the previous version.

Improved support for login with certificate authentication

The CLI supports a number of different authentication methods supporting user and app-only authentication scenarios. In automation scenarios it is quite common for certificate authentication to be used as a preference to using usernames and passwords. With that in mind, we have made a number of improvements to the way that we handle certificate authentication by extending the m365 login command.

Previously, we only supported passing certificates as a file path to the m365 login command using the --certificateFile option. In the latest release we now support passing the contents of a certificate as a Base64 encoded string. This helps simplify scenarios where it is inconvenient to store certificates on disk such as in a CI/CD pipeline.

To pass a certificate as a Base64 encoded string, execute:

m365 login --authType certificate --certificateBase64Encoded MIII2QIBAzCCCJ8GCSqGSIb3DQEHAaCCCJAEg...eX1N5AgIIAA== --thumbprint D0C9B442DE249F55D10CDA1A2418952DC7D407A3

Previously, we asked for you to provide the certificate thumbprint along with the location of the certificate file, as in the example above. This is no longer required. We will now automatically calculate the thumbprint from the certificate passed in.

To have the certificate thumbprint automatically calculated for you, execute:

m365 login --authType certificate --certificateBase64Encoded MIII2QIBAzCCCJ8GCSqGSIb3DQEHAaCCCJAEg...eX1N5AgIIAA==

Previously, we asked for you to provide a password when using .pfx certificates, in the latest release, we have made the --password option optional. As it is possible to generate .pfx certificates with empty passwords, this is not mandatory and can be inconvenient when using certificates to authenticate against Microsoft 365 development environments.

We always recommend that certificates used in production scenarios use a strong password

To use a .pfx certificate that uses an empty password, execute:

m365 login --authType certificate --certificateFile /Users/user/dev/localhost.pfx

Simplified usage of custom Azure Active Directory identities

In the past, if you wanted to use your own Azure AD identity, we asked you to set the value of two environment variables, CLIMICROSOFT365_AADAPPID & CLIMICROSOFT365_TENANT to instruct the CLI to use your own Azure AD identity to authenticate with your Microsoft 365 tenant.

To simplify this process, we have introduced two new options to the m365 login command, appId and tenant, to instruct the CLI to use your own identity.

m365 login --appId 31359c7f-bd7e-475c-86db-fdb8c937548c --tenant 31359c7f-bd7e-475c-86db-fdb8c937548a

Run CLI for Microsoft 365 in Docker Container

We recently announced that we are now publishing pre-configured Docker images to Docker Hub to make it easier for you to use the CLI. We will be releasing new beta and stable versions as part of our regular release cadence, so you will be able to use new Docker images immediately after our release to npm.

To run the latest version of the CLI in a Docker container, execute:

docker run --rm -it m365pnp/cli-microsoft365:latest

The Docker images are pre-configured with

node@14
bash
PowerShell 7
Command auto-completion
Azure DevOps agent support

Checkout our guide for more details on how to use these images, including how to get the latest beta releases, update existing images, execute scripts stored on your local machine inside the running container and how to use your own Azure AD identity for connecting to Microsoft 365 from the running container.

Improved performance

We have made a couple of changes to the internal workings of the CLI to help improve performance of commands executed at the command line. These include improved lazy loading of dependencies so that we only load them when needed, and we removed the started telemetry event. This event was primarily used to track when immersive mode was invoked and as you may remember we removed the immersive mode in v3, so this was no longer serving a purpose but was invoked if you executed m365 to display the CLI interactive help.

New Commands

Set the default content type for a SharePoint Online list

By default, SharePoint includes many content types. Every piece of content in SharePoint is created from a content type. You can use the pre-defined content types, such as Blank Document or Announcement, without any change, or you can create custom content types. We’ve introduced a command that enables you to set the default content type on a list.

To set a content type with ID 0x0120 as default in the list with ID 0cd891ef-afce-4e55-b836-fce03286cccf located in site https://contoso.sharepoint.com/sites/project-x, execute:

m365 spo list contenttype default set --webUrl https://contoso.sharepoint.com/sites/project-x --listId 0cd891ef-afce-4e55-b836-fce03286cccf --contentTypeId 0x0120

Get details about Microsoft Teams Direct Routing calls made within a given time period

Direct Routing allows you to make and receive calls whilst using an existing telephone provider through the Microsoft Teams interface. In this version, we’ve introduced a command to help your report on the usage of this method of calling.

To get details about Direct Routing calls made and received between 2020-10-31 and today, execute:

m365 teams report directroutingcalls --fromDateTime 2020-10-31

Get details about Microsoft Teams PSTN calls made within a given time period

Public Switched Telephone Network (PSTN) calling can be configured to make and receive calls whilst using an existing telephone provider through the Microsoft Teams interface. In this release, we’ve introduced a command to help your report on the usage of this method of calling.

To get details about PSTN calls made and received between 2020-10-31 and today, execute:

m365 teams report pstncalls --fromDateTime 2020-10-31

Search Yammer messages, users, topics and groups

Staying connected is more important than ever, Yammer is a social networking tool to openly connect and engage with employees across your organization. We have introduced a command to enable you to execute search queries across your Yammer network.

To returns search results for the query community, execute:

m365 yammer search --queryText "community"

To return a list of groups that match community, execute:

m365 yammer search --queryText "community" --show "groups"

To return a list of topics that match community, execute:

m365 yammer search --queryText "community" --show "topics"

To return a list of the first 50 users who match the search query nuborocks.onmicrosoft.com, execute:

m365 yammer search --queryText "nuborocks.onmicrosoft.com" --show "users" --limit 50

New script samples

CLI for Microsoft 365 is a great tool both for quick adjustments to the configuration of your Microsoft 365 tenant as well as automating more complex tasks. Because CLI for Microsoft 365 is cross-platform you can use it on any OS and in any shell. To help you get started using the CLI for Microsoft 365 for automation scenarios, we started gathering some sample scripts.

If you have any scripts that you use frequently, please share them with us so that we can learn more about the common automation scenarios.

Contributors

This release wouldn’t be possible without the help of (in alphabetical order):

Thank you all for the time you chose to spend on the CLI for Microsoft 365 and your help to advance it!

Work in progress

Here are some things that we’re currently working on.

More commands, what else

Microsoft 365 is evolving and new capabilities are being released every day. With CLI for Microsoft 365, we aim to help you manage your tenant on any platform in a consistent way, no matter which part of Microsoft 365 you interact with. While we keep adding new commands to CLI for Microsoft 365 each release, we still barely scratched the surface with what’s possible in Microsoft 365. In the upcoming versions of the CLI for Microsoft, you can expect us to add more commands across the different workloads in Microsoft 365.

Friendlier commands

While there are now over 350 commands available to use in CLI for Microsoft 365 to help you manage your Microsoft 365 tenant, a lot of commands expect you to provide object ids to perform actions. We understand that this is not as intuitive as being able to provide a the name of an object and the command work out what the required object ids for you based on the object name given. We are actively creating new issues to address this, updating our commands to be more user friendly and provide a better user experience. We’ll start to implement new name options on our Microsoft Teams commands and will start to appear in the next release.

Another thing that we’re working on in the context of simplification is allowing you to easily register applications in Azure AD. Creating Azure AD applications is a prerequisite in developing on Microsoft 365. We believe, that being able to do it with just one command would significantly improve the development process.

Quicker and easier developer onboarding

CLI for Microsoft 365 is a community project and it relies upon contributions from developers around the world to help add new commands and enhance existing commands in every release. As part of our ongoing improvements to the project, we want to make the onboarding process of new developers to the project as quick and easy as possible. We will be looking to release a Remote Development container, that will provide a one click approach for developers to configure a development environment with all dependencies and tools required to contribute to the project.

The release will also support use of GitHub Codespaces, enabling developers to spin up dedicated development environments in the cloud and contribute to the project using nothing but a web browser.

Script examples

In every release of the CLI for Microsoft 365, we introduce new commands for managing Microsoft 365. With over 350 commands across the different Microsoft 365 services, the CLI for Microsoft 365 has become a powerful tool, not just for managing your tenant but also for automating your daily work.

We’d love to show you how you can use the CLI for Microsoft 365 to build automation scripts in PowerShell Core and Bash.

If you have any scripts using SPO or PnP PowerShell that you use frequently, please share them with us so that we can learn more about the common automation scenarios.
ensure commands

Currently, CLI for Microsoft 365 has dedicated commands for retrieving, creating and updating resources. If you were to create a script that ensures a specific configuration, for each resource you’d need to see if it exists, create it if it doesn’t or update it if it does.

We’re thinking about simplifying this scenario by introducing commands with a new verb named ensure. For example, to ensure that a particular site collection exists, instead of executing a combination of spo site list/spo site get, spo site add and spo site set, you’d execute spo site ensure with the necessary parameters which would automatically verify if the particular site exists and matches your configuration. If the site doesn’t exist, it would create it. If it does, the command would check if the properties you specified match the retrieved site and update them if necessary.

We’ll start to implement this idea on the spo site commands. We’d love to hear from you if it’s something that you’d find helpful and what other objects we should take into account.

Try it today

Get the latest release of the CLI for Microsoft 365 from npm by executing in the command line:

npm i -g @pnp/cli-microsoft365

Alternatively, you can get the latest release from Docker by executing in the command line:

docker run --rm -it m365pnp/cli-microsoft365:latest

If you need more help getting started or want more details about the commands, the architecture or the project, go to aka.ms/cli-m365.

If you see any room for improvement, please, don’t hesitate to reach out to us either on GitHub or twitter.

Forem: Garry Trinder

Join us for HackTogether: The Microsoft Teams Global Hack

Join live events 📺

Connect with Microsoft experts 💬

Win awesome prizes! 🏆

How do I get started? 🚀

Learn how to develop apps for Microsoft Teams using Teams Toolkit for Visual Studio Code video series

🙋🤖 Place your order! - Build bots for Microsoft Teams to automate repetitive workflows using Teams Toolkit for VS Code

Table of Contents

🛠 Teams Toolkit for Visual Studio Code

🏁 Prerequisites

🛠 Install Teams Toolkit for Visual Studio Code

👷 Scaffold and run the project

👷 Clean the project

🧑‍💻 Create the Adaptive Card templates

📝 Create the order command

Create the command handler

Update the bot configuration

Update the app manifest

⚡️ Create the order card action

Create the action handler

Update the bot configuration

🙋 Place your order

⏭ What next?

📚 Learn more

Build a stock update notification bot for Microsoft Teams using C# and Teams Toolkit for Visual Studio

Table of Contents

🏁 Prerequisites

🛠 Install Teams Toolkit for Visual Studio

👷 Scaffold the project

ℹ️ Update the adaptive card

🤖 Update the bot logic

📡 Start ngrok

🧑‍🍳 Prepare dependencies

🧪 Test your bot

⏭ What next?

📚 Learn more!

Start your journey to becoming a Microsoft 365 developer

🧑‍💻 Join the Microsoft 365 Developer Program

☁️ Learn the fundamentals of Microsoft Cloud

📚 Study the learning paths

🎓 Get certified!

🏘 Join our community

📣 Keep up to date

Read

Watch

Engage

👷 What will you build today?

CLI for Microsoft 365 v3.4

Manage Microsoft 365 and SharePoint Framework projects on any platform

New version of CLI for Microsoft 365 – v3.4

Changes

Improved support for login with certificate authentication

Simplified usage of custom Azure Active Directory identities

Run CLI for Microsoft 365 in Docker Container

Improved performance

New Commands

Set the default content type for a SharePoint Online list

Get details about Microsoft Teams Direct Routing calls made within a given time period

Get details about Microsoft Teams PSTN calls made within a given time period

Search Yammer messages, users, topics and groups

New script samples

Contributors

Work in progress

More commands, what else

Friendlier commands

Quicker and easier developer onboarding

Script examples

Try it today

 ☁️ Learn the fundamentals of Microsoft Cloud