要約

This article describes how to integrate Jira Cloud with MS Teams, allowing users to post messages in private MS Teams channels. 

診断

Jira Cloud integration with MS Teams does not allow posting messages to private MS Teams channels.

原因

Because MS Teams "Bot" users can't be recognized as members of the private team channel, it is not possible to use standard integration workflow to send messages to private channels. 

ソリューション

To overcome this issue, we can create a custom workflow in MS Teams that iterates over the incoming webhook payload to create a custom message that is posted to a private channel. 

The steps to do that are described below: 

1. Create the Jira Automation Rule
   1. Add the trigger that will begin the Automation Rule execution
   2. Add the "Send Microsoft Teams message" block to the Automation Rule
      
      
      
      
2. Create MS Teams Workflow
   1. From the channel options  select Workflows and look for "Post to a channel when a webhook request is received" template: 
       
   2. Copy the webhook URL from MS Teams workflow and use it in Jira Automation Rule "Send Microsoft Teams message" block as a Webhook URL. 
3. In the automation rule configure Message titile and details, check "Include issue summary in message" box: 
   
4. Edit MS Teams Workflow. 
   1. The complete workflow will look as follows (we will go through the steps below): 
      
   2. The first step should be "When a Teams webhook request is received". 
      
      1. The "Who" field should be set to "Anyone".
      2. The HTTP POST URL is the URL used in Jira Automation Rule (point 2.b). 
         
   3. Initialize variables "bodyText", "Newline" and "Urlvar". 
      1. bodyText – This variable will be appended by all the text fields Jira will send in its packet.
      2. Newline – This is simply a <br> tag to break the text values into lines.
      3. Urlvar – This will store the url that points back to the ticket in Jira.
         
   4. Create an ‘Apply to each’ action that will cycle through the data packets.
      1. Use "attachments" output
         

      2. Next add Parse the JSON element: 
         
         Using the following schema:

         {
             "type": "object",
             "items": {
                 "type": "object",
                 "properties": {
                     "content": {
                         "type": "object",
                         "properties": {
                             "schema": {
                                 "type": "string"
                             },
                             "version": {
                                 "type": "string"
                             },
                             "type": {
                                 "type": "string"
                             },
                             "body": {
                                 "type": "array",
                                 "items": {
                                     "type": "object",
                                     "properties": {
                                         "type": {
                                             "type": "string"
                                         },
                                         "text": {
                                             "type": "string"
                                         },
                                         "style": {
                                             "type": "string"
                                         },
                                         "weight": {
                                             "type": "string"
                                         },
                                         "size": {
                                             "type": "string"
                                         },
                                         "wrap": {
                                             "type": "boolean"
                                         }
                                     },
                                     "required": [
                                         "type",
                                         "text",
                                         "style",
                                         "weight",
                                         "size",
                                         "wrap"
                                     ]
                                 }
                             },
                             "actions": {
                                 "type": "array",
                                 "items": {
                                     "type": "object",
                                     "properties": {
                                         "type": {
                                             "type": "string"
                                         },
                                         "title": {
                                             "type": "string"
                                         },
                                         "url": {
                                             "type": "string"
                                         }
                                     },
                                     "required": [
                                         "type",
                                         "title",
                                         "url"
                                     ]
                                 }
                             }
                         }
                     },
                     "contentType": {
                         "type": "string"
                     }
                 },
                 "required": [
                     "content",
                     "contentType"
                 ]
             }
         }

      3. Add a second Parse a JSON element: 
         
         Using Body as a content and following schema: 

         {
             "type": "object",
             "properties": {
                 "body": {
                     "type": "array",
                     "items": {
                         "type": "object",
                         "properties": {
                             "type": {
                                 "type": "string"
                             },
                             "text": {
                                 "type": "string"
                             },
                             "style": {
                                 "type": "string"
                             },
                             "weight": {
                                 "type": "string"
                             },
                             "size": {
                                 "type": "string"
                             },
                             "wrap": {
                                 "type": "boolean"
                             }
                         },
                         "required": [
                             "type",
                             "text",
                             "style",
                             "weight",
                             "size",
                             "wrap"
                         ]
                     }
                 }
             }
         }

      4. After adding a second JSON parser, we need to add "Apply to each" 
         
         The "body" from a previous action should be selected as output from previous steps
      5. WIthin this loop we will create a message by appending a variable "bodyText" with the "text" variable created previously in JSON parser action and "Newline" variable: 
         
         
         
         

      6. Next we will add another Parse JSON action, using "Body" as a content: 
         
         And following schema: 

         {
             "type": "object",
             "properties": {
                 "actions": {
                     "type": "array",
                     "items": {
                         "type": "object",
                         "properties": {
                             "type": {
                                 "type": "string"
                             },
                             "title": {
                                 "type": "string"
                             },
                             "url": {
                                 "type": "string"
                             }
                         },
                         "required": [
                             "type",
                             "title",
                             "url"
                         ]
                     }
                 }
             }
         }

      7. Add a new Apply to each element that will loop through "actions" and create link:
          
         
         
      8. Append the "bodyText" variable: 
         
      9. Append the "Urlvar" variable: 
         
   5. We have completed the main Apply to each loop. Now it is time to send the message to the private channel using "Post message in a chat or a channel: 
      
      Note that the message will be posted as User who is the owner the MS Teams workflow.