Skip to main content

Check out Port for yourself 

Examples

To view and test the integration's mapping against examples of the third-party API responses, use the jq playground in your data sources page. Find the integration in the list of data sources and click on it to open the playground.

Project​

Project blueprint (Click to expand)
{
  "identifier": "jiraProject",
  "title": "Jira Project",
  "icon": "Jira",
  "description": "A Jira project",
  "schema": {
    "properties": {
      "url": {
        "title": "Project URL",
        "type": "string",
        "format": "url",
        "description": "URL to the project in Jira"
      },
      "totalIssues": {
        "title": "Total Issues",
        "type": "number",
        "description": "The total number of issues in the project"
      }
    }
  },
  "mirrorProperties": {},
  "calculationProperties": {},
  "relations": {}
}
Integration configuration (Click to expand)

The project kind has a selector property, expand that specifies additional fields to be included in the response. It accepts a comma-separated string that allows you to include more fields in the response data that can be used in the mapping configuration. Possible values are description, lead, issueTypes, url, projectKeys, insight.

If not specified, it defaults to "insight".

createMissingRelatedEntities: true
deleteDependentEntities: true
resources:
  - kind: project
    selector:
      query: "true"
      expand: "description,lead,issueTypes,url,projectKeys,insight"
    port:
      entity:
        mappings:
          identifier: .key
          title: .name
          blueprint: '"jiraProject"'
          properties:
            url: (.self | split("/") | .[:3] | join("/")) + "/projects/" + .key
            totalIssues: .insight.totalIssueCount

User​

User blueprint (Click to expand)
{
 "identifier": "jiraUser",
 "title": "Jira User",
 "icon": "User",
 "description": "A Jira user account",
 "schema": {
   "properties": {
     "emailAddress": {
       "title": "Email",
       "type": "string",
       "format": "email", 
       "description": "User's email address"
     },
     "displayName": {
       "title": "Display Name",
       "type": "string",
       "description": "User's full name as displayed in Jira"
     },
     "active": {
       "title": "Active Status",
       "type": "boolean",
       "description": "Whether the user account is active"
     },
     "accountType": {
       "title": "Account Type",
       "type": "string",
       "description": "Type of Jira account (e.g., atlassian, customer)"
     }
   }
 },
 "mirrorProperties": {},
 "calculationProperties": {},
 "aggregationProperties": {},
 "relations": {}
}
Integration configuration (Click to expand)
- kind: user
  selector:
    query: "true"
  port:
    entity:
      mappings:
        identifier: .accountId
        title: .displayName
        blueprint: '"jiraUser"'
        properties:
          emailAddress: .emailAddress
          displayName: .displayName
          active: .active
          accountType: .accountType

Team​

Team blueprint
{
"identifier": "jiraTeam",
"title": "Jira Team",
"icon": "Users",
"description": "A team within the organization",
"schema": {
    "properties": {
    "organizationId": {
        "title": "Organization ID",
        "type": "string",
        "description": "Unique identifier for the parent organization"
    },
    "teamType": {
        "title": "Team Type",
        "type": "string",
        "description": "Type of team (e.g., MEMBER_INVITE, OPEN)",
        "enum": [
        "MEMBER_INVITE",
        "OPEN"
        ]
    },
    "description": {
        "title": "Description",
        "type": "string",
        "description": "Team description"
    }
    }
},
"relations": {
    "members": {
    "target": "jiraUser",
    "title": "Users",
    "description": "The Jira users belonging to this team",
    "required": false,
    "many": true
    }
},
"mirrorProperties": {},
"calculationProperties": {},
"aggregationProperties": {}
}
Integration configuration
- kind: team
  selector:
    query: "true"
    includeMembers: true
  port:
    entity:
      mappings:
        identifier: .teamId
        title: .displayName
        blueprint: '"jiraTeam"'
        properties:
          organizationId: .organizationId
          teamType: .teamType
          description: .description
        relations:
          members: if .__members != null then .__members | map(.accountId) else [] end

Issue​

Issue blueprint (Click to expand)
{
  "identifier": "jiraIssue",
  "title": "Jira Issue",
  "icon": "Jira",
  "schema": {
    "properties": {
      "url": {
        "title": "Issue URL",
        "type": "string",
        "format": "url",
        "description": "URL to the issue in Jira"
      },
      "status": {
        "title": "Status",
        "type": "string",
        "description": "The status of the issue"
      },
      "issueType": {
        "title": "Type",
        "type": "string",
        "description": "The type of the issue"
      },
      "components": {
        "title": "Components",
        "type": "array",
        "description": "The components related to this issue"
      },
      "creator": {
        "title": "Creator",
        "type": "string",
        "description": "The user that created to the issue",
        "format": "user"
      },
      "priority": {
        "title": "Priority",
        "type": "string",
        "description": "The priority of the issue"
      },
      "labels": {
        "items": {
          "type": "string"
        },
        "title": "Labels",
        "type": "array"
      },
      "created": {
        "title": "Created At",
        "type": "string",
        "description": "The created datetime of the issue",
        "format": "date-time"
      },
      "updated": {
        "title": "Updated At",
        "type": "string",
        "description": "The updated datetime of the issue",
        "format": "date-time"
      },
      "resolutionDate": {
        "title": "Resolved At",
        "type": "string",
        "description": "The datetime the issue changed to a resolved state",
        "format": "date-time"
      }
    }
  },
  "calculationProperties": {
    "handlingDuration": {
      "title": "Handling Duration (Days)",
      "icon": "Clock",
      "description": "The amount of time in days from issue creation to issue resolution",
      "calculation": "if (.properties.resolutionDate != null and .properties.created != null) then ((.properties.resolutionDate[0:19] + \"Z\" | fromdateiso8601) - (.properties.created[0:19] + \"Z\" | fromdateiso8601)) / 86400 else null end",
      "type": "number"
    }
  },
  "mirrorProperties": {},
  "aggregationProperties": {},
  "relations": {
    "project": {
      "target": "jiraProject",
      "title": "Project",
      "description": "The Jira project that contains this issue",
      "required": false,
      "many": false
    },
    "parentIssue": {
      "target": "jiraIssue",
      "title": "Parent Issue",
      "required": false,
      "many": false
    },
    "subtasks": {
      "target": "jiraIssue",
      "title": "Subtasks",
      "required": false,
      "many": true
    },
    "assignee": {
      "target": "jiraUser",
      "title": "Assignee",
      "required": false,
      "many": false
    },
    "reporter": {
      "target": "jiraUser",
      "title": "Reporter",
      "required": false,
      "many": false
    }
  }
}
Integration configuration (Click to expand)
- kind: issue
  selector:
    query: "true"
    jql: "(statusCategory != Done) OR (created >= -1w) OR (updated >= -1w)"
  port:
    entity:
      mappings:
        identifier: .key
        title: .fields.summary
        blueprint: '"jiraIssue"'
        properties:
          url: (.self | split("/") | .[:3] | join("/")) + "/browse/" + .key
          status: .fields.status.name
          issueType: .fields.issuetype.name
          components: .fields.components
          creator: .fields.creator.emailAddress
          priority: .fields.priority.name
          labels: .fields.labels
          created: .fields.created
          updated: .fields.updated
          resolutionDate: .fields.resolutiondate
        relations:
          project: .fields.project.key
          parentIssue: .fields.parent.key
          subtasks: .fields.subtasks | map(.key)
          assignee: .fields.assignee.accountId
          reporter: .fields.reporter.accountId

Slack notifications​

Using Port's automation capabilities, you can set up real-time Slack notifications when issues are created or updated in Jira.

Automation for new bug reports (click to expand)
{
  "identifier": "jira_new_bug_notification",
  "title": "Notify Slack on New Jira Bug",
  "icon": "Slack",
  "description": "Sends a Slack notification when a new bug is created in Jira",
  "trigger": {
    "type": "automation",
    "event": {
      "type": "ENTITY_CREATED",
      "blueprintIdentifier": "jiraIssue"
    },
    "condition": {
      "type": "JQ",
      "expressions": [
        ".diff.after.properties.issueType == \"Bug\""
      ],
      "combinator": "and"
    }
  },
  "invocationMethod": {
    "type": "WEBHOOK",
    "url": "YOUR_SLACK_WEBHOOK_URL",
    "agent": false,
    "synchronized": true,
    "method": "POST",
    "headers": {
      "Content-Type": "application/json"
    },
    "body": {
      "text": "🐛 New Bug Reported\n\n*Issue:* {{ .event.diff.after.title }}\n*Project:* {{ .event.diff.after.relations.project }}\n*Status:* {{ .event.diff.after.properties.status }}\n*Priority:* {{ .event.diff.after.properties.priority }}\n\n<{{ .event.diff.after.properties.url }}|View in Jira> | <https://app.getport.io/jiraIssueEntity?identifier={{ .event.context.entityIdentifier }}|View in Port>"
    }
  },
  "publish": true
}
Automation for high-priority tasks (click to expand)
{
  "identifier": "jira_high_priority_task",
  "title": "Notify Slack on High-Priority Jira Task",
  "icon": "Slack",
  "description": "Sends a Slack notification when a high-priority task is created or updated in Jira",
  "trigger": {
    "type": "automation",
    "event": {
      "type": "ENTITY_UPDATED",
      "blueprintIdentifier": "jiraIssue"
    },
    "condition": {
      "type": "JQ",
      "expressions": [
        ".diff.after.properties.priority == \"Highest\" or .diff.after.properties.priority == \"High\"",
        ".diff.before.properties.priority != \"Highest\" and .diff.before.properties.priority != \"High\""
      ],
      "combinator": "and"
    }
  },
  "invocationMethod": {
    "type": "WEBHOOK",
    "url": "YOUR_SLACK_WEBHOOK_URL",
    "agent": false,
    "synchronized": true,
    "method": "POST",
    "headers": {
      "Content-Type": "application/json"
    },
    "body": {
      "text": "⚠️ High-Priority Issue Alert\n\n*Issue:* {{ .event.diff.after.title }}\n*Type:* {{ .event.diff.after.properties.issueType }}\n*Priority:* {{ .event.diff.after.properties.priority }}\n*Status:* {{ .event.diff.after.properties.status }}\n\n<{{ .event.diff.after.properties.url }}|View in Jira> | <https://app.getport.io/jiraIssueEntity?identifier={{ .event.context.entityIdentifier }}|View in Port>"
    }
  },
  "publish": true
}
Slack webhook URL

Replace YOUR_SLACK_WEBHOOK_URL with your actual Slack incoming webhook URL. For information on creating Slack webhooks, see the Slack API documentation.

These automations allow your team to receive immediate notifications in Slack when bugs are reported or issues are updated with high priority, making your project management workflow more efficient.