action.yaml

name: 'Sync github issues to jira'
inputs:
  JIRA_URL:
    description: Jira URL domain to be stored as a secret.
    required: true
  JIRA_USERNAME:
    description: Jira username to be stored as a secret. Provide with Jira API token.
    required: false
  JIRA_API_TOKEN:
    description: Jira API token to be stored as a secret. Provide with Jira username.
    required: false
  JIRA_AUTHORIZATION:
    description: Jira authorization to be stored as a secret. Mutually exclusive with JIRA_USERNAME and JIRA_API_TOKEN.
    required: false
  JIRA_COMPONENT:
    description: Jira component to be stored as a secret.
    required: true
  JIRA_PROJECT_KEY:
    description: Jira project key to be stored as a secret.
    required: true
  JIRA_EPIC_KEY:
    description: Jira epic key to be stored as a secret.
    required: true
  JIRA_ISSUE_TYPE:
    description: Jira issue type.
    required: false
    default: "Roadmap Item"
  GITHUB_TOKEN:
    description: 'GITHUB_TOKEN to be stored as a secret'
    required: false
  label:
    description: 'Label which will trigger a Jira import.'
    required: true
    default: 'jira'

runs:
  using: "composite"
  steps:
    #- name: Dump GitHub context
    #  run: echo '${{ toJSON(github) }}'
    #  shell: bash
    - name: restrict action to labelled issues and issue comments
      shell: bash
      run: |
        set -eu
        
        echo "NeedsJiraUpdate=false" >> $GITHUB_ENV

        if [ ${{ github.event_name }} != "issues" ] && [ ${{ github.event_name }} != "issue_comment" ]; then
          echo "This action only work on issue events. Please use on: issues or issue_comment to use this action."
          exit 1
        fi

        if [ ${{ github.event.issue.pull_request }} ]; then
          echo "This action only work on issues, not pull requests."
          exit 0
        fi

        # Issue creation with label will trigger 2 events and run twice: one create, one labelled.
        # let just focus on labelling then for creating issues Jira-side.
        if [ ${{ github.event_name }} == "issues" ] && [ ${{ github.event.action }} == "opened" ]; then
          echo "Ignoring creation of issues as a label will trigger a second event."
          exit 0
        fi

        # We only operate on labelled issues or issues that are just unlabeled with our desired label
        ## check if one label of labels is our jira label
        toconsider=${{ contains(github.event.issue.labels.*.name, inputs.label) }}
        ## second chance, this has just been unlabeled and needs to be deleted on Jira
        if [ ${{ github.event.action }} == "unlabeled" ] && [ ${{ github.event.label.name }} == ${{ inputs.label }} ]; then
          toconsider=true
        fi
        if [ "${toconsider}" == false ]; then
          echo "Our desired label '${{ inputs.label }}' is not found on the issue, skipping"
          exit 0
        fi

        # And finally, for the "labeled" event, we are only interested if the new added label is our desired one.
        if [ ${{ github.event.action }} == "labeled" ] && [ ${{ github.event.label.name }} != ${{ inputs.label }} ]; then
          echo "Not interested in this action, skipping"
          exit 0
        fi
        
        # Exit if the issue already has an OWS label. 
        # TODO: Support updates to Jira issues.
        labels=$(jq -r '.issue.labels[].name' "$GITHUB_EVENT_PATH")
        for lbl in $labels; do
          if [[ "$lbl" == OWS* ]]; then
            echo "Issue has a label bestarting with OWS, skipping"
            exit 0
          fi
        done

        # last one wins
        echo "NeedsJiraUpdate=true" >> $GITHUB_ENV

    - name: "Convert markdown to jira"
      if: ${{ env.NeedsJiraUpdate == 'true' }}
      id: convert_markdown
      shell: bash
      run: |
        set -eu
        
        # Install markdown to jira converter
        sudo apt update
        sudo apt install -y pandoc jq
        
        # Convert mardown to jira.
        TMPDIR=$(mktemp -d)
        trap 'rm -rf -- "$TMPDIR"' EXIT
        
        echo '${{ github.event.issue.body }}' > $TMPDIR/body.md
        sed -i 's/`//g' $TMPDIR/body.md
        
        pandoc -f markdown -t jira $TMPDIR/body.md -o $TMPDIR/description.txt
        description=$(cat $TMPDIR/description.txt)
        description_escaped=$(jq -Rs . <<< "$description")
        echo "description=${description_escaped}" >> $GITHUB_OUTPUT

    - name: "Create issue in jira"
      if: ${{ env.NeedsJiraUpdate == 'true' }}
      id: create_jira_issue
      shell: bash
      env:
        JIRA_USERNAME: '${{ inputs.JIRA_USERNAME }}'
        JIRA_API_TOKEN: '${{ inputs.JIRA_API_TOKEN }}'
        JIRA_AUTHORIZATION: '${{ inputs.JIRA_AUTHORIZATION }}'
      run: |
        set -eu
        
        if [[ -z "${JIRA_AUTHORIZATION}" ]]; then
          jira_auth=$(echo -n "${JIRA_USERNAME}:${JIRA_API_TOKEN}" | base64 | tr -d '\n')
        else
          jira_auth="${JIRA_AUTHORIZATION}"
        fi
        jira_auth_header="Authorization: Basic $jira_auth"
        
        echo "Creating issue ${{ github.event.issue.title }} and linking it as a dependency to ${{ inputs.DEPENDENT_ISSUE }}"
        create_body='{
          "fields": {
            "project": {
              "key": "${{ inputs.JIRA_PROJECT_KEY }}"
            },
            "summary": "${{ github.event.issue.title }}",
            "description": ${{ steps.convert_markdown.outputs.description }},
            "issuetype": {
              "name": "${{ inputs.JIRA_ISSUE_TYPE }}"
            },
            "components": [
              {
                "name": "${{ inputs.JIRA_COMPONENT }}"
              }
            ],
            "customfield_15140": "${{ inputs.JIRA_EPIC_KEY }}"
          }
        }'
        create_response=$(curl --silent -w "%{http_code}" -o /tmp/create_issue_response.json -H "$jira_auth_header" -X POST -H "Content-Type: application/json" --data "${create_body}" "${{ inputs.JIRA_URL }}/rest/api/2/issue/")
        
        http_status=$(tail -n1 <<< "$create_response")
        if [[ $http_status != 2* ]]; then
          echo "Creating issue failed with status $http_status"
          exit 1
        fi
        
        new_issue_key=$(jq -r '.key' /tmp/create_issue_response.json)
        echo "jira_issue_key=${new_issue_key}" >> $GITHUB_OUTPUT
        echo "created new issue in Jira: ${new_issue_key}"
        
        # Yes, that's indeed neccessary. Otherwise the link request will fail.
        echo "Waiting 10s to give the Jira API some to process the new issue before linking it subsequently"
        sleep 10

    - name: "Link issue to Github"
      if: ${{ env.NeedsJiraUpdate == 'true' }}
      id: link_to_github
      shell: bash
      env:
        JIRA_USERNAME: '${{ inputs.JIRA_USERNAME }}'
        JIRA_API_TOKEN: '${{ inputs.JIRA_API_TOKEN }}'
        JIRA_AUTHORIZATION: '${{ inputs.JIRA_AUTHORIZATION }}'
      run: |
        set -eu
        
        if [[ -z "${JIRA_AUTHORIZATION}" ]]; then
          jira_auth=$(echo -n "${JIRA_USERNAME}:${JIRA_API_TOKEN}" | base64 | tr -d '\n')
        else
          jira_auth="${JIRA_AUTHORIZATION}"
        fi
        jira_auth_header="Authorization: Basic $jira_auth"
        
        echo "Linking Jira issue to GitHub issue"
        gh_link_body='{
          "object": {
            "url": "${{ github.event.issue.html_url }}",
            "title": "GitHub Issue"
          },
          "globalId": "github:${{ github.event.issue.html_url }}",
          "relationship": "links to",
          "type": {
            "name": "GitHub Issue",
            "inward": "links to",
            "outward": "is linked to"
          }
        }'
        link_gh_response=$(curl --silent -w "%{http_code}" -o /tmp/link_gh_response.json -H "$jira_auth_header" -X POST -H "Content-Type: application/json" --data "${gh_link_body}" "${{ inputs.JIRA_URL }}/rest/api/2/issue/${{ steps.create_jira_issue.outputs.jira_issue_key }}/remotelink")
        
        http_status=$(tail -n1 <<< "$link_gh_response")
        if [[ $http_status != 2* ]]; then
          echo "Linking github issue failed with status $http_status"
          exit 1
        fi
        echo "Linked ${{ steps.create_jira_issue.outputs.jira_issue_key }} to GitHub issue ${{ github.event.issue.number }}"

#    - name: "Link issue to Epic"
#      if: ${{ env.NeedsJiraUpdate == 'true' }}
#      id: link_to_epic
#      shell: bash
#      env:
#        JIRA_USERNAME: '${{ inputs.JIRA_USERNAME }}'
#        JIRA_API_TOKEN: '${{ inputs.JIRA_API_TOKEN }}'
#        JIRA_AUTHORIZATION: '${{ inputs.JIRA_AUTHORIZATION }}'
#      run: |
#        set -eu
#
#        if [[ -z "${JIRA_AUTHORIZATION}" ]]; then
#          jira_auth=$(echo -n "${JIRA_USERNAME}:${JIRA_API_TOKEN}" | base64 | tr -d '\n')
#        else
#          jira_auth="${JIRA_AUTHORIZATION}"
#        fi
#        jira_auth_header="Authorization: Basic $jira_auth"
#
#        echo "Linking Jira issue to epic"
#        epic_link_body='{
#          "type": {
#            "name": "Dependency",
#            "inward": "has dependency",
#            "outward": "depends on"
#          },
#          "inwardIssue": {
#            "key": "${{ inputs.JIRA_EPIC_KEY }}"
#          },
#          "outwardIssue": {
#            "key": "${{ steps.create_jira_issue.outputs.jira_issue_key }}"
#          }
#        }'
#        link_epic_response=$(curl --silent -w "%{http_code}" -o /tmp/link_epic_response.json -H "$jira_auth_header" -X POST -H "Content-Type: application/json" --data "${epic_link_body}" "${{ inputs.JIRA_URL }}/rest/api/2/issueLink")
#
#        http_status=$(tail -n1 <<< "$link_epic_response")
#        if [[ $http_status != 2* ]]; then
#          echo "Linking epic failed with status $http_status"
#          exit 1
#        fi
#        echo "Linked jira issue ${{ steps.create_jira_issue.outputs.jira_issue_key }} to jira epic ${{ inputs.JIRA_EPIC_KEY }}"

    - name: Adding label to GitHub issue
      if: ${{ env.NeedsJiraUpdate == 'true' }}
      shell: bash
      run: |
        issue_number=${{ github.event.issue.number }}
        owner=${{ github.repository_owner }}
        repo=${{ github.event.repository.name }}
        
        echo "Adding label ${{ steps.create_jira_issue.outputs.jira_issue_key }} to issue ${issue_number}"
        curl --silent -X POST \
          -H 'Authorization: Bearer ${{ inputs.GITHUB_TOKEN }}' \
          -H "Accept: application/vnd.github+json" \
          -d '{"labels":["${{ steps.create_jira_issue.outputs.jira_issue_key }}"]}' \
          "https://api.github.com/repos/${owner}/${repo}/issues/${issue_number}/labels"

    - name: Remove specific label from issue
      if: ${{ env.NeedsJiraUpdate == 'true' }}
      shell: bash
      run: |
        label_to_remove="${{ inputs.label }}"
        issue_number=${{ github.event.issue.number }}
        owner=${{ github.repository_owner }}
        repo=${{ github.event.repository.name }}
        
        echo "Removing label ${label_to_remove} from issue ${issue_number}"
        curl --silent -X DELETE \
          -H 'Authorization: Bearer ${{ inputs.GITHUB_TOKEN }}' \
          -H "Accept: application/vnd.github+json" \
          "https://api.github.com/repos/${owner}/${repo}/issues/${issue_number}/labels/${label_to_remove}"