In this article, I would be showing you how to upload an attachment in a Confluence content using the "go-atlassian" library.

Step 1: Set up the project

1. Create a new directory for your project.

2. Open a terminal and navigate to the project directory.

3. Initialize a new Go module using the following command:

go mod init <module-name>

Step 2: Install the "go-atlassian" library

In the terminal, run the following command to install the "go-atlassian" library:

go get -v github.com/ctreminiom/go-atlassian

Step 3: Import the necessary packages

1. Create a new Go file (e.g., main.go) in your project directory.

2. Open the file and import the required packages:

package main

import (
	"github.com/ctreminiom/go-atlassian/confluence"
	"log"
	"os"
)

Step 4: Authenticate with Confluence

In the main function, create a new Confluence client and authenticate using your Atlassian URL, username, and API token:

func main() {

	atlassianHost := "https://<_jira_instance_>.atlassian.net"
	mailAddress := "<your_mail>"
	apiToken := "<your_api_token>"

	client, err := confluence.New(nil, atlassianHost )
	if err != nil {
		log.Fatal(err)
	}

	client.Auth.SetBasicAuth(mailAddress, apiToken)
}

Step 5: Upload an attachment to a Confluence page

• Define the necessary variables for the page ID, file path, and file name:

pageID := "76513281"
filePath := "confluence/mocks/mock.png"
fileName := "mock-00.png"

• Open the file using the provided file path:

absolutePath, err := filepath.Abs(filePath)
if err != nil {
	log.Fatal(err)
}

log.Println("Using the path", absolutePath)

reader, err := os.Open(absolutePath)
if err != nil {
	log.Fatal(err)
}

defer reader.Close()

• Upload the attachment using the Content.Attachment.Create()method and provide the page ID, file name, and file content:

attachmentsPage, response, err := client.Content.Attachment.Create(context.Background(), pageID, "current", fileName, reader)
if err != nil {

	if response != nil {
		if response.Code == http.StatusBadRequest {
			log.Println(response.Code)
		}
	}
	log.Println(response.Endpoint)
	log.Fatal(err)
}

log.Println("Endpoint:", response.Endpoint)
log.Println("Status Code:", response.Code)

for _, attachment := range attachmentsPage.Results {
	log.Println(attachment.ID, attachment.Title)
}

Step 6: Run the program

1. Save the main.go file.

2. In the terminal, navigate to your project directory.

3. Execute the following command to run the program:

go run main.go

This will upload the specified file as an attachment to the Confluence page with the provided page ID.

Get Current User

GET /rest/api/{2-3}/myself

Returns details for the current user.

package main

import (
	"context"
	_ "github.com/ctreminiom/go-atlassian/v2/jira/v3"
	"github.com/ctreminiom/go-atlassian/v2/jira/v2"
	"log"
	"os"
)

func main() {

	var (
		host  = os.Getenv("HOST")
		mail  = os.Getenv("MAIL")
		token = os.Getenv("TOKEN")
	)

	atlassian, err := v2.New(nil, host)
	if err != nil {
		return
	}

	atlassian.Auth.SetBasicAuth(mail, token)

	currentUser, response, err := atlassian.MySelf.Details(context.Background(), nil)
	if err != nil {
		log.Fatal(err)
	}

	log.Println("HTTP Endpoint Used", response.Endpoint)
	log.Println(currentUser.DisplayName, currentUser.Active, currentUser.AccountID)
}

In this article, I would be showing you how to create a Jira issue using the "go-atlassian" library.

Step 1: Set up the project

1. Create a new directory for your project.

2. Open a terminal and navigate to the project directory.

3. Initialize a new Go module using the following command:

go mod init <module-name>

Step 2: Install the "go-atlassian" library

In the terminal, run the following command to install the "go-atlassian" library:

go get -v github.com/ctreminiom/go-atlassian

Step 3: Import the necessary packages

1. Create a new Go file (e.g., main.go) in your project directory.

2. Open the file and import the required packages:

package main

import (
	"fmt"
	"log"
	"os"

	jira "github.com/ctreminiom/go-atlassian/jira/v2"
)

Step 4: Authenticate with Jira

In the main function, create a new Jira client and authenticate using your Jira URL, username, and API token:

func main() {

	jiraHost := "https://<_jira_instance_>.atlassian.net"
	mailAddress := "<your_mail>"
	apiToken := "<your_api_token>"

	client, err := jira.New(nil, jiraHost)
	if err != nil {
		log.Fatal(err)
	}

	client.Auth.SetBasicAuth(mailAddress, apiToken)
}

Step 5: Custom fields definition

OPTIONAL, you can define custom-fields values you want to set on the issue creation. This library supports the following custom-fields types:

var customFields = models.CustomFields{}
err = customFields.Groups("customfield_10052", []string{"jira-administrators", "jira-administrators-system"})
if err != nil {
	log.Fatal(err)
}

err = customFields.Number("customfield_10043", 1000.3232)
if err != nil {
	log.Fatal(err)
}

Step 6: Create an issue

Create a new issue using the Create method and set the custom fields:

payload := &models.IssueSchemeV2{
	Fields: &models.IssueFieldsSchemeV2{
		Summary:   "New summary test",
		Project:   &models.ProjectScheme{ID: "10000"},
		IssueType: &models.IssueTypeScheme{Name: "Story"},
	},
}

newIssue, _, err := client.Issue.Create(context.Background(), payload, &customFields)
if err != nil {
	log.Fatal(err)
}

Step 7: Run the program

1. Save the main.go file.

2. In the terminal, navigate to your project directory.

3. Execute the following command to run the program:

This will create a new issue in Jira with the specified custom field values. Please note that you may need to modify the code according to your specific Jira configuration and custom field types.

Overview

The go-atlassian jira module provides a set of functions and types for interacting with the Jira REST API. It is designed to make it easy for developers to build powerful integrations and automations that leverage the capabilities of the Jira platform.

The module is available in two versions: v2 and v3. These versions correspond to different versions of the Jira REST API, with v2 supporting Jira versions 6.4 to 7.2, and v3 supporting Jira versions 7.3 and later.

ADF Format

The Atlassian Document Format (ADF) is a JSON-based format used by Atlassian products, including Jira, to represent rich content such as text, tables, and lists. The jira module in go-atlassian provides support for working with ADF content in both the v3package.

In v3, the IssueService and related services like CommentService provide functions that allow you to interact with ADF content. For example, the CreateIssue function in v3 includes a parameter for Fields, which is a struct that includes fields for specifying various attributes of the new issue, including the issue summary, description, and any custom fields. The Fields struct includes a field for Description, which can be set to a struct representing ADF content.

To search issues using a JQL query, use the Issue.Search service function.

Get info

GET /rest/servicedeskapi/info

This method retrieves information about the Jira Service Management instance such as software version, builds, and related links.

The go-atlassian agile module provides a set of functions and types for interacting with the Jira Agile REST API. It is designed to allows developers to interact with and automate various aspects of agile project management within Jira, such as boards, sprints, and issues.

Here's a brief introduction to some key concepts in Jira Agile Rest API:

1. Boards: A board in Jira represents a visual representation of a project, typically in the form of a Kanban board or a Scrum board. It helps teams track and manage their work. The API provides endpoints to create, retrieve, update, and delete boards, as well as to manage the configuration and settings associated with them.

2. Sprints: Sprints are time-boxed iterations in agile development, typically used in Scrum methodology. They represent a fixed duration during which a team works on a set of prioritized issues. The API allows you to create, retrieve, update, and delete sprints, as well as manage the issues associated with them.

3. Issues: Issues in Jira represent tasks, bugs, user stories, or any other unit of work that needs to be tracked. The API provides endpoints to create, retrieve, update, and delete issues. You can also perform operations such as assigning issues to users, transitioning between workflow statuses, adding comments, and more.

4. Agile Boards API: This API allows you to manage the boards in Jira, including retrieving information about boards, creating new boards, updating board settings, and managing board filters.

5. Agile Sprints API: With the Agile Sprints API, you can interact with sprints, including creating new sprints, retrieving sprint details, updating sprint properties, and managing the issues associated with sprints.

6. Agile Issues API: This API allows you to perform operations on issues within the context of agile boards and sprints. You can retrieve issues assigned to a board or sprint, create new issues, update issue details, transition issues between workflow statuses, and more.

In this article, I would be showing you how to extract the boards associated with a Jira project using go-atlassian

Step 1: Create a new Go project

Create a new directory for your project and navigate to it in your terminal or command prompt. Initialize a new Go module using the following command:

go mod init your-module-name

Step 2: Install the "go-atlassian" library

To use the "go-atlassian" library, you need to install it as a dependency in your project. Run the following command:

go get github.com/ctreminiom/go-atlassian

Step 3: Import the required packages

Create a new Go file, e.g., main.go, and import the necessary packages:

package main

import (
	"fmt"
	"log"

	jira "github.com/ctreminiom/go-atlassian/agile"
)

Step 4: Set up Jira Agile API client

Initialize the Jira Agile API client with your Jira base URL and API token:

func main() {
	jiraClient, err := jira.New(nil, "https://your-jira-instance.atlassian.net")
	if err != nil {
		log.Fatal(err)
	}

	// Set API token for authentication
	jiraClient.Auth.SetBasicAuth(mail, token)
}

Step 5: Extract the boards

In this step, you're going to use the Jira Agile API, more specifically, the Board service, Gets() method. This methods supports multiple query parameters, but in this example, we're going to use the ProjectKeyOrID param to filter the board linked to a Jira project.

The following example iterates the Board.Gets() method and appends the boards into a slice.

options := &models.GetBoardsOptions{
		ProjectKeyOrID: "KP",
	}

var boards []*models.BoardScheme
var startAt int

for {

	fmt.Println("Pagination #", startAt)

	page, response, err := instance.Board.Gets(context.Background(), options, startAt, 50)
	if err != nil {

		if response != nil {
			log.Fatal(response.Bytes.String())
		}
		log.Fatal(err)
	}

	boards = append(boards, page.Values...)

	if page.IsLast {
		break
	}

	startAt = +50
}

Use it to obtain JQL search auto-complete data and suggestions for use in programmatic construction of queries or custom query builders. It also provides operations to:

• convert one or more JQL queries with user identifiers (username or user key) to equivalent JQL queries with account IDs.

• convert readable details in one or more JQL queries to IDs where a user doesn't have permission to view the entity whose details are readable.

Parse JQL Query

POST /rest/api/{2-3}/jql/parse

Parses and validates JQL queries. The validation is performed in context of the current user.

package main

import (
	"context"
	"fmt"
	_ "github.com/ctreminiom/go-atlassian/v2/jira/v2"
	"github.com/ctreminiom/go-atlassian/v2/jira/v3"
	"log"
	"os"
)

func main() {

	var (
		host  = os.Getenv("HOST")
		mail  = os.Getenv("MAIL")
		token = os.Getenv("TOKEN")
	)

	jira, err := v3.New(nil, host)
	if err != nil {
		return
	}

	jira.Auth.SetBasicAuth(mail, token)
	jira.Auth.SetUserAgent("curl/7.54.0")

	queries, response, err := jira.JQL.Parse(context.Background(), "", []string{"project = KP"})
	if err != nil {
		if response != nil {
			log.Println("Response HTTP Response", response.Bytes.String())
		}
		log.Fatal(err)
	}

	for _, query := range queries.Queries {
		fmt.Println(query)
	}
}

Get all labels

GET /rest/api/{2-3}/label

Returns a paginated list of labels.

package main

import (
	"context"
	"github.com/ctreminiom/go-atlassian/v2/jira/v2"
	"log"
	"os"
)

func main() {

	/*
		----------- Set an environment variable in git bash -----------
		export HOST="https://ctreminiom.atlassian.net/"
		export MAIL="MAIL_ADDRESS"
		export TOKEN="TOKEN_API"

		Docs: https://stackoverflow.com/questions/34169721/set-an-environment-variable-in-git-bash
	*/

	var (
		host  = os.Getenv("HOST")
		mail  = os.Getenv("MAIL")
		token = os.Getenv("TOKEN")
	)

	atlassian, err := v2.New(nil, host)
	if err != nil {
		log.Fatal(err)
	}

	atlassian.Auth.SetBasicAuth(mail, token)

	labels, response, err := atlassian.Issue.Label.Gets(context.Background(), 0, 50)
	if err != nil {
		log.Fatal(err)
	}

	log.Println("HTTP Endpoint Used", response.Endpoint)

	for _, label := range labels.Values {
		log.Println(label)
	}
}

go-atlassian is a Go library that provides a simple and convenient way to interact with various Atlassian products' REST APIs. Atlassian is a leading provider of software and tools for software development, project management, and collaboration. Some of the products that go-atlassian supports include Jira, Confluence, Jira Service Management, and more.

The go-atlassian library is designed to simplify the process of building Go applications that interact with Atlassian products. It provides a set of functions and data structures that can be used to easily send HTTP requests to the Atlassian APIs, parse the responses, and work with the data returned.

🚀Features

• Easy-to-use functions and data structures that abstract away much of the complexity of working with the APIs.

• Comprehensive support for various Atlassian products' APIs.

• Support for common operations like creating, updating, and deleting entities in Atlassian products.

• Active development and maintenance by the community, with regular updates and bug fixes.

• Comprehensive documentation and examples to help developers get started with using the library.

📁 Installation

If you do not have Go installed yet, you can find installation instructions here. Please note that the package requires Go version 1.20 or later for module support.

To pull the most recent version of go-atlassian, use go get.

go get github.com/ctreminiom/go-atlassian/v2

📪 Packages

Then import the package into your project as you normally would. You can import the following packages:

🔨 Usage

Before using the go-atlassian package, you need to have an Atlassian API key. If you do not have a key yet, you can sign up here.

Create a client with your instance host and access token to start communicating with the Atlassian API's. In this example, we're going to instance a new Confluence Cloud client.

instance, err := confluence.New(nil, "INSTANCE_HOST")
if err != nil {
    log.Fatal(err)
}
instance.Auth.SetBasicAuth("YOUR_CLIENT_MAIL", "YOUR_APP_ACCESS_TOKEN")

If you need to use a preconfigured HTTP client, simply pass its address to the New function.

transport := http.Transport{
	Proxy: http.ProxyFromEnvironment,
	Dial: (&net.Dialer{
		// Modify the time to wait for a connection to establish
		Timeout:   1 * time.Second,
		KeepAlive: 30 * time.Second,
	}).Dial,
	TLSHandshakeTimeout: 10 * time.Second,
}
client := http.Client{
	Transport: &transport,
	Timeout:   4 * time.Second,
}
instance, err := confluence.New(&client, "INSTANCE_HOST")
if err != nil {
	log.Fatal(err)
}
instance.Auth.SetBasicAuth("YOUR_CLIENT_MAIL", "YOUR_APP_ACCESS_TOKEN")

☕Cookbooks

For detailed examples and usage of the go-atlassian library, please refer to our Cookbook. This section provides step-by-step guides and code samples for common tasks and scenarios.

🌍 Services

The library uses the services interfaces to provide a modular and flexible way to interact with Atlassian products' REST APIs. It defines a set of services interfaces that define the functionality of each API, and then provides implementations of those interfaces that can be used to interact with the APIs.

// BoardConnector represents the Jira boards.
// Use it to search, get, create, delete, and change boards.
type BoardConnector interface {
	Get(ctx context.Context, boardID int) (*model.BoardScheme, *model.ResponseScheme, error)
	Create(ctx context.Context, payload *model.BoardPayloadScheme) (*model.BoardScheme, *model.ResponseScheme, error)
	Filter(ctx context.Context, filterID, startAt, maxResults int) (*model.BoardPageScheme, *model.ResponseScheme, error)
	Backlog(ctx context.Context, boardID int, opts *model.IssueOptionScheme, startAt, maxResults int) (*model.BoardIssuePageScheme, *model.ResponseScheme, error)
	Configuration(ctx context.Context, boardID int) (*model.BoardConfigurationScheme, *model.ResponseScheme, error)
	Epics(ctx context.Context, boardID, startAt, maxResults int, done bool) (*model.BoardEpicPageScheme, *model.ResponseScheme, error)
	IssuesWithoutEpic(ctx context.Context, boardID int, opts *model.IssueOptionScheme, startAt, maxResults int) (
		*model.BoardIssuePageScheme, *model.ResponseScheme, error)
	IssuesByEpic(ctx context.Context, boardID, epicID int, opts *model.IssueOptionScheme, startAt, maxResults int) (
		*model.BoardIssuePageScheme, *model.ResponseScheme, error)
	Issues(ctx context.Context, boardID int, opts *model.IssueOptionScheme, startAt, maxResults int) (*model.BoardIssuePageScheme,
		*model.ResponseScheme, error)
	Move(ctx context.Context, boardID int, payload *model.BoardMovementPayloadScheme) (*model.ResponseScheme, error)
	Projects(ctx context.Context, boardID, startAt, maxResults int) (*model.BoardProjectPageScheme, *model.ResponseScheme, error)
	Sprints(ctx context.Context, boardID, startAt, maxResults int, states []string) (*model.BoardSprintPageScheme,
		*model.ResponseScheme, error)
	IssuesBySprint(ctx context.Context, boardID, sprintID int, opts *model.IssueOptionScheme, startAt, maxResults int) (
		*model.BoardIssuePageScheme, *model.ResponseScheme, error)
	Versions(ctx context.Context, boardID, startAt, maxResults int, released bool) (*model.BoardVersionPageScheme,
		*model.ResponseScheme, error)
	Delete(ctx context.Context, boardID int) (*model.ResponseScheme, error)
	Gets(ctx context.Context, opts *model.GetBoardsOptions, startAt, maxResults int) (*model.BoardPageScheme,
		*model.ResponseScheme, error)
}

Each service interface includes a set of methods that correspond to the available endpoints in the corresponding API. For example, the IssueService interface includes methods like Create, Update, and Get that correspond to the POST, PUT, and GET endpoints in the Jira Issues API.

🎉 Implementation

Behind the scenes, the Create method on the IssueService interface is implemented by the issueService.Create function in the go-atlassian library. This function sends an HTTP request to the relevant endpoint in the Jira Issues API, using the credentials and configuration provided by the client, and then parses the response into a usable format.

Here's a little example about how to get the issue transitions using the Issue service.

ctx := context.Background()
issueKey := "KP-2"
expand := []string{"transitions"}
issue, response, err := atlassian.Issue.Get(ctx,issueKey, nil, expand)
if err != nil {
	log.Fatal(err)
}
log.Println(issue.Key)
for _, transition := range issue.Transitions {
	log.Println(transition.Name, transition.ID, transition.To.ID, transition.HasScreen)
}

The rest of the service functions work much the same way; they are concise and behave as you would expect. The documentation contains several examples on how to use each service function.

📪Call a RAW API Endpoint

If you need to interact with an Atlassian API endpoint that hasn't been implemented in the go-atlassian library yet, you can make a custom API request using the built-in Client.Call method to execute raw HTTP requests.

Please raise an issue in order to implement the endpoint

package main  
  
import (  
    "context"  
    "fmt" 
    "github.com/ctreminiom/go-atlassian/v2/jira/v3" 
    "log" 
    "net/http" 
    "os"
 )  
  
type IssueTypeMetadata struct {  
    IssueTypes []struct {  
       ID          string `json:"id"`  
  Name        string `json:"name"`  
  Description string `json:"description"`  
  } `json:"issueTypes"`  
}  
  
func main() {  
  
    var (  
       host  = os.Getenv("SITE")  
       mail  = os.Getenv("MAIL")  
       token = os.Getenv("TOKEN")  
    )  
  
    atlassian, err := v3.New(nil, host)  
    if err != nil {  
       log.Fatal(err)  
    }  
  
    atlassian.Auth.SetBasicAuth(mail, token)  
  
    // Define the RAW endpoint  
    apiEndpoint := "rest/api/3/issue/createmeta/KP/issuetypes"  
  
    request, err := atlassian.NewRequest(context.Background(), http.MethodGet, apiEndpoint, "", nil)  
    if err != nil {  
       log.Fatal(err)  
    }  
  
    customResponseStruct := new(IssueTypeMetadata)  
    response, err := atlassian.Call(request, &customResponseStruct)  
    if err != nil {  
       log.Fatal(err)  
    }  
  
    fmt.Println(response.Status)  
}

✍️ Contributions

If you would like to contribute to this project, please adhere to the following guidelines.

• Submit an issue describing the problem.

• Fork the repo and add your contribution.

• Follow the basic Go conventions found here.

• Create a pull request with a description of your changes.

Again, contributions are greatly appreciated!

💡 Inspiration

The project was created with the purpose to provide a unique point to provide an interface for interacting with Atlassian products.

This module is highly inspired by the Go library https://github.com/andygrunwald/go-jira but focused on Cloud solutions.

The library shares many similarities with go-jira, including its use of service interfaces to define the functionality of each API, its modular and flexible approach to working with Atlassian products' API's. However, go-atlassian also adds several new features and improvements that are not present in go-jira.

Despite these differences, go-atlassian remains heavily inspired by go-jira, and many of the core design principles and patterns used in go-jira can be found in go-atlassian as well.

📝 License

Copyright © 2023 Carlos Treminio. This project is MIT licensed.

🤝 Special Thanks

We would like to extend our sincere thanks to the following sponsors for their generous support:

• Atlassian for providing us Atlassian Admin/Jira/Confluence Standard licenses.

• JetBrains for providing us with free licenses of GoLand

• GitBook for providing us non-profit / open-source plan so hence I would like to express my thanks here.

The Jira audit logs are a set of records that document all the activities and changes made in Jira. These logs provide a detailed record of who did what, when, and where within Jira. Here are a few examples of the type of activities that are logged in the Jira audit logs:

The audit logs are useful for several reasons. For example, they can be used to track changes made to sensitive data, to identify who made specific changes to issues or projects, or to diagnose issues with Jira.

Get audit records

GET /rest/api/{2-3}/auditing/record

This method allows you to retrieve the audit records for specific activities that have occurred within Jira.

package main

import (
	"context"
	_ "github.com/ctreminiom/go-atlassian/v2/jira/v2"
	"github.com/ctreminiom/go-atlassian/v2/jira/v3"
	"github.com/ctreminiom/go-atlassian/pkg/infra/models"
	"log"
	"os"
	"time"
)

func main() {

	var (
		host  = os.Getenv("HOST")
		mail  = os.Getenv("MAIL")
		token = os.Getenv("TOKEN")
	)

	jira, err := v3.New(nil, host)
	if err != nil {
		return
	}

	jira.Auth.SetBasicAuth(mail, token)
	jira.Auth.SetUserAgent("curl/7.54.0")

	auditRecordOption := &models.AuditRecordGetOptions{

		//Filter the records by a word, in that case, the custom field history
		Filter: "",

		//Filter the records by the last month
		From: time.Now().AddDate(0, -1, 0),

		// Today
		To: time.Now(),
	}

	auditRecords, response, err := jira.Audit.Get(context.Background(), auditRecordOption, 0, 500)
	if err != nil {
		if response != nil {
			log.Println("Response HTTP Response", response.Bytes.String())
		}
		log.Fatal(err)
	}

	log.Println("Response HTTP Code", response.Code)
	log.Println("HTTP Endpoint Used", response.Endpoint)

	for _, record := range auditRecords.Records {

		log.Printf("Record ID: %v", record.ID)
		log.Printf("Record Category: %v", record.Category)
		log.Printf("Record Created: %v", record.Created)
		log.Printf("Record RemoteAddress: %v", record.RemoteAddress)
		log.Printf("Record Summary: %v", record.Summary)
		log.Printf("Record AuthorKey: %v", record.AuthorKey)
		log.Printf("\n")
	}
}

In this article, I would be showing you how to extract the Jira history information using a JQL query and saves it into a .csv file.

Step 1: Set up the project

1. Create a new directory for your project.

2. Open a terminal and navigate to the project directory.

3. Initialize a new Go module using the following command:

Step 2: Install the "go-atlassian" library

In the terminal, run the following command to install the "go-atlassian" library:

Step 3: Import the necessary packages

1. Create a new Go file (e.g., main.go) in your project directory.

2. Open the file and import the required packages:

Step 4: Authenticate with Jira

In the main function, create a new Jira client and authenticate using your Jira URL, username, and API token:

Step 5: Execute the JQL query

Add the following code inside the main function to execute the JQL query and retrieve the issues:

Step 6: Extract the issue history

Iterate over the retrieved issues and extract the changelog information.

Step 7: Save the issue history to a CSV file

Create a new CSV file and write the issue history data to it:

Step 8: Run the program

1. Save the main.go file.

2. In the terminal, navigate to your project directory

Jira application roles are a way of managing user permissions and access in Jira. Jira comes with a set of predefined roles that define common types of users, such as administrators, developers, and project managers.

Each Jira application role has a set of permissions associated with it, which determine what actions a user in that role is allowed to perform. For example, the "Admin" role has permission to manage Jira system settings and users, while the "Developer" role has permission to create and edit issues and view source code.

Get all application roles

GET /rest/api/{2-3}/applicationrole

This endpoint is used to retrieve a list of all application roles that are defined in a Jira instance. This endpoint can be used to get information about the roles that are available in Jira, and to help manage user access and permissions.

Get application role

GET /rest/api/{2-3}/applicationrole/{key}

This method allows you to retrieve information about a specific application role in Jira using the key name as reference.

Get resolutions

GET /rest/api/{2-3}/resolution

Returns a list of all issue resolution values, the method returns the following information:

Get resolution

GET /rest/api/{2-3}/resolution/{id}

Returns an issue resolution value

Create resolution

No implemented, yet, feel free to open a PR or issue

Set default resolution

No implemented, yet, feel free to open a PR or issue

Move resolutions

No implemented, yet, feel free to open a PR or issue

Search resolutions

No implemented, yet, feel free to open a PR or issue

Update resolution

No implemented, yet, feel free to open a PR or issue

Delete resolution

No implemented, yet, feel free to open a PR or issue

In this article, I would be showing you how to edit a Jira issue with the VERB operation using the "go-atlassian" library.

Step 1: Set up the project

1. Create a new directory for your project.

2. Open a terminal and navigate to the project directory.

3. Initialize a new Go module using the following command:

Step 2: Install the "go-atlassian" library

In the terminal, run the following command to install the "go-atlassian" library:

Step 3: Import the necessary packages

1. Create a new Go file (e.g., main.go) in your project directory.

2. Open the file and import the required packages:

Step 4: Authenticate with Jira

In the main function, create a new Jira client and authenticate using your Jira URL, username, and API token:

Step 5: Create Issue Payload

The fields of an issue may also be updated in more flexible ways using the SET, ADD and REMOVE operations. Not all fields support all operations, but as a general rule single value fields support SET, whereas multi-value fields support SET, ADD and REMOVE, where SET replaces the field contents while ADD and REMOVE add or remove one or more values from the the current list of values.

• Finally, call the Issue.Update() method and update the issue

Step 6: Run the program

1. Save the main.go file.

2. In the terminal, navigate to your project directory.

3. Execute the following command to run the program:

The go-atlassian sm module provides a set of functions and types for interacting with the Jira Service Management REST API. It provides a programmatic interface to interact with Jira Service Management, enabling developers to automate various aspects of service management.

Here are some key components and concepts related to the Jira Service Management REST API:

1. Request Types: Request types represent different types of service requests or issue types within Jira Service Management. Examples include "Incident," "Change Request," "Service Request," etc. Request types define the fields and workflows associated with each type of request.

2. Queues: Queues in Jira Service Management are used to organize and prioritize service requests. Requests are assigned to specific queues based on their attributes or criteria, such as request type, status, or assignee. Queues help teams manage and process incoming requests efficiently.

3. Approvers: Approvers are individuals or groups responsible for reviewing and approving certain actions or changes within Jira Service Management. For example, an approver might need to approve a change request before it can be implemented. The REST API allows you to retrieve and manage approvers associated with requests or specific workflows.

4. Customers: Customers in Jira Service Management represent the end-users or customers who raise service requests. These can be individuals or groups within an organization. The REST API enables you to create, update, and manage customer accounts, as well as retrieve information about customers and their associated requests.

5. Workflows: Workflows define the stages and transitions that a request goes through during its lifecycle in Jira Service Management. Workflows determine how requests move from one status to another, who can perform certain actions, and what actions are available at each stage. The REST API allows you to interact with workflows, including creating, updating, and transitioning requests between workflow states.

6. Service Level Agreements (SLAs): SLAs define the expected response and resolution times for different request types. They help teams prioritize and meet service-level targets. The REST API allows you to manage SLAs associated with requests, retrieve SLA information, and track SLA performance.

Search Fields In Trash

GET /rest/api/{2-3}/field/search/trashed

Search returns a paginated list of fields in the trash. The list may be restricted to fields whose field name or description partially match a string.

Only custom fields can be queried, type must be set to custom.

package main

import (
	"context"
	"github.com/ctreminiom/go-atlassian/v2/jira/v2"
	"github.com/ctreminiom/go-atlassian/pkg/infra/models"
	"log"
	"os"
)

func main() {

	var (
		host  = os.Getenv("HOST")
		mail  = os.Getenv("MAIL")
		token = os.Getenv("TOKEN")
	)

	atlassian, err := v2.New(nil, host)
	if err != nil {
		return
	}

	atlassian.Auth.SetBasicAuth(mail, token)

	options := &models.FieldSearchOptionsScheme{
		IDs: nil,
		//Query:   "Application Name",
		OrderBy: "name",
		Expand:  []string{"name", "-trashDate"},
	}

	fields, response, err := atlassian.Issue.Field.Trash.Search(context.Background(), options, 0, 50)
	if err != nil {
		log.Fatal(err)
	}

	log.Println("HTTP Endpoint Used", response.Endpoint)

	for _, field := range fields.Values {
		log.Println(field)
	}
}

Move Field To Trash

POST /rest/api/{2-3}/field/{id}/trash

Move moves a custom field to trash

package main

import (
	"context"
	"github.com/ctreminiom/go-atlassian/v2/jira/v2"
	"log"
	"os"
)

func main() {

	var (
		host  = os.Getenv("HOST")
		mail  = os.Getenv("MAIL")
		token = os.Getenv("TOKEN")
	)

	atlassian, err := v2.New(nil, host)
	if err != nil {
		return
	}

	atlassian.Auth.SetBasicAuth(mail, token)

	response, err := atlassian.Issue.Field.Trash.Move(context.Background(), "customfield_10020")
	if err != nil {
		log.Fatal(err)
	}

	log.Println("HTTP Endpoint Used", response.Endpoint)
}

Restore Field

POST /rest/api/{2-3}/field/{id}/restore

POST /rest/api/3/field/{id}/restoreRestore restores a custom field from trash

package main

import (
	"context"
	"github.com/ctreminiom/go-atlassian/v2/jira/v2"
	"log"
	"os"
)

func main() {

	var (
		host  = os.Getenv("HOST")
		mail  = os.Getenv("MAIL")
		token = os.Getenv("TOKEN")
	)

	atlassian, err := v2.New(nil, host)
	if err != nil {
		return
	}

	atlassian.Auth.SetBasicAuth(mail, token)

	response, err := atlassian.Issue.Field.Trash.Restore(context.Background(), "customfield_10020")
	if err != nil {
		log.Fatal(err)
	}

	log.Println("HTTP Endpoint Used", response.Endpoint)
}

Get Field Configuration Items

GET /rest/api/{2-3}/fieldconfiguration/{id}/fields

Returns a paginated list of all fields for a configuration.

package main

import (
	"context"
	"github.com/ctreminiom/go-atlassian/v2/jira/v2"
	"log"
	"os"
)

func main()  {

	var (
		host  = os.Getenv("HOST")
		mail  = os.Getenv("MAIL")
		token = os.Getenv("TOKEN")
	)

	atlassian, err := v2.New(nil, host)
	if err != nil {
		return
	}

	atlassian.Auth.SetBasicAuth(mail, token)

	fieldConfigurationID, startAt, maxResults := 10000, 0, 50
	items, response, err := atlassian.Issue.Field.Configuration.Item.Gets(context.Background(), fieldConfigurationID, startAt, maxResults)
	if err != nil {
		log.Fatal(err)
	}

	log.Println("HTTP Endpoint Used", response.Endpoint)

	for _, item := range items.Values {

		log.Println("----------------------")
		log.Println(item.ID)
		log.Println(item.Description)
		log.Println(item.IsRequired)
		log.Println(item.IsRequired)
		log.Println(item.Renderer)
		log.Println("----------------------")
	}
}

Update Field Configuration Items

PUT /rest/api/{2-3}/fieldconfiguration/{id}/fields

Updates fields in a field configuration. The properties of the field configuration fields provided override the existing values.

• The operation can set the renderer for text fields to the default text renderer (text-renderer) or wiki style renderer (wiki-renderer). However, the renderer cannot be updated for fields using the autocomplete renderer (autocomplete-renderer).

package main

import (
	"context"
	v2 "github.com/ctreminiom/go-atlassian/v2/jira/v2"
	"github.com/ctreminiom/go-atlassian/pkg/infra/models"
	"log"
	"os"
)

func main()  {

	var (
		host  = os.Getenv("HOST")
		mail  = os.Getenv("MAIL")
		token = os.Getenv("TOKEN")
	)

	atlassian, err := v2.New(nil, host)
	if err != nil {
		return
	}

	atlassian.Auth.SetBasicAuth(mail, token)

	payload := &models.UpdateFieldConfigurationItemPayloadScheme{
		FieldConfigurationItems: []*models.FieldConfigurationItemScheme{
			{
				ID:          "components",
				IsRequired:  true,
			},
		},
	}


	response, err := atlassian.Issue.Field.Configuration.Item.Update(context.Background(), 10000, payload)
	if err != nil {
		log.Fatal(err)
	}

	log.Println("HTTP Endpoint Used", response.Endpoint)
}

Get my permissions

GET /rest/api/{2-3}/mypermissions

Returns a list of permissions indicating which permissions the user has. Details of the user's permissions can be obtained in a global, project, or issue context.

package main

import (
	"context"
	_ "github.com/ctreminiom/go-atlassian/v2/jira/v3"
	"github.com/ctreminiom/go-atlassian/v2/jira/v2"
	"log"
	"os"
)

func main() {

	var (
		host  = os.Getenv("HOST")
		mail  = os.Getenv("MAIL")
		token = os.Getenv("TOKEN")
	)

	atlassian, err := v2.New(nil, host)
	if err != nil {
		log.Fatal(err)
	}

	atlassian.Auth.SetBasicAuth(mail, token)

	permissions, response, err := atlassian.Permission.Gets(context.Background())
	if err != nil {
		log.Fatal(err)
	}

	log.Println("HTTP Endpoint Used", response.Endpoint)

	for _, permission := range permissions {
		log.Println(permission)
	}
}

Check permissions

POST /rest/api/{2-3}/permissions/check

• for a list of global permissions, the global permissions are granted to a user.

• for a list of project permissions and lists of projects and issues, for each project permission a list of the projects and issues a user can access or manipulate.

If no account ID is provided, the operation returns details for the logged-in user.

package main

import (
	"context"
	_ "github.com/ctreminiom/go-atlassian/v2/jira/v3"
	"github.com/ctreminiom/go-atlassian/v2/jira/v2"
	"github.com/ctreminiom/go-atlassian/pkg/infra/models"
	"log"
	"os"
)

func main() {

	/*
		----------- Set an environment variable in git bash -----------
		export HOST="https://ctreminiom.atlassian.net/"
		export MAIL="MAIL_ADDRESS"
		export TOKEN="TOKEN_API"

		Docs: https://stackoverflow.com/questions/34169721/set-an-environment-variable-in-git-bash
	*/

	var (
		host  = os.Getenv("HOST")
		mail  = os.Getenv("MAIL")
		token = os.Getenv("TOKEN")
	)

	atlassian, err := v2.New(nil, host)
	if err != nil {
		log.Fatal(err)
	}

	atlassian.Auth.SetBasicAuth(mail, token)

	payload := &models.PermissionCheckPayload{
		GlobalPermissions: []string{"ADMINISTER"},
		AccountID:         "", //
		ProjectPermissions: []*models.BulkProjectPermissionsScheme{
			{
				Issues:      nil,
				Projects:    []int{10000},
				Permissions: []string{"EDIT_ISSUES"},
			},
		},
	}

	grants, response, err := atlassian.Permission.Check(context.Background(), payload)
	if err != nil {
		log.Fatal(err)
	}

	log.Println("HTTP Endpoint Used", response.Endpoint)

	for _, permission := range grants.ProjectPermissions {
		log.Println(permission.Permission, permission.Issues)
	}
}

Get permitted projects

POST /rest/api/{2-3}/permissions/project

Returns all the projects where the user is granted a list of project permissions.

This operation can be accessed anonymously.

Add actors to project role

POST /rest/api/{2-3}/project/{projectIdOrKey}/role/{id}

Adds actors to a project role for the project.

package main

import (
	"context"
	_ "github.com/ctreminiom/go-atlassian/v2/jira/v3"
	"github.com/ctreminiom/go-atlassian/v2/jira/v2"
	"log"
	"os"
)

func main() {

	/*
		----------- Set an environment variable in git bash -----------
		export HOST="https://ctreminiom.atlassian.net/"
		export MAIL="MAIL_ADDRESS"
		export TOKEN="TOKEN_API"

		Docs: https://stackoverflow.com/questions/34169721/set-an-environment-variable-in-git-bash
	*/

	var (
		host  = os.Getenv("HOST")
		mail  = os.Getenv("MAIL")
		token = os.Getenv("TOKEN")
	)

	atlassian, err := v2.New(nil, host)
	if err != nil {
		log.Fatal(err)
	}

	atlassian.Auth.SetBasicAuth(mail, token)

	var (
		projectKeyOrID = "KP"
		projectRoleID  = 10005
		accountIDs     = []string{"5b86be50b8e3cb5895860d6d"}
		groupsNames    = []string{"scrum-masters"}
	)

	role, response, err := atlassian.Project.Role.Actor.Add(context.Background(),
		projectKeyOrID, projectRoleID, accountIDs, groupsNames)

	if err != nil {
		if response != nil {
			log.Println("Response HTTP Response", response.Bytes.String())
		}
		log.Fatal(err)
	}

	log.Println("Response HTTP Code", response.Code)
	log.Println("HTTP Endpoint Used", response.Endpoint)

	for _, actor := range role.Actors {
		log.Println(actor)
	}
}

Delete actors from project role

DELETE /rest/api/{2-3}/project/{projectIdOrKey}/role/{id}

Deletes actors from a project role for the project.

package main

import (
	"context"
	_ "github.com/ctreminiom/go-atlassian/v2/jira/v3"
	"github.com/ctreminiom/go-atlassian/v2/jira/v2"
	"log"
	"os"
)

func main() {

	/*
		----------- Set an environment variable in git bash -----------
		export HOST="https://ctreminiom.atlassian.net/"
		export MAIL="MAIL_ADDRESS"
		export TOKEN="TOKEN_API"

		Docs: https://stackoverflow.com/questions/34169721/set-an-environment-variable-in-git-bash
	*/

	var (
		host  = os.Getenv("HOST")
		mail  = os.Getenv("MAIL")
		token = os.Getenv("TOKEN")
	)

	atlassian, err := v2.New(nil, host)
	if err != nil {
		log.Fatal(err)
	}

	atlassian.Auth.SetBasicAuth(mail, token)

	var (
		projectKeyOrID = "KP"
		projectRoleID  = 10005
		accountID      = "5b86be50b8e3cb5895860d6d"
		groupName      = "scrum-masters"
	)

	response, err := atlassian.Project.Role.Actor.Delete(context.Background(),
		projectKeyOrID,
		projectRoleID,
		accountID,
		groupName,
	)

	if err != nil {
		if response != nil {
			log.Println("Response HTTP Response", response.Bytes.String())
		}
		log.Fatal(err)
	}

	log.Println("Response HTTP Code", response.Code)
	log.Println("HTTP Endpoint Used", response.Endpoint)
}

Get project features

GET /rest/api/{2-3}/project/{projectIdOrKey}/features

Returns the list of features for a project.

package main

import (
	"context"
	_ "github.com/ctreminiom/go-atlassian/v2/jira/v3"
	v2 "github.com/ctreminiom/go-atlassian/v2/jira/v2"
	"log"
	"os"
)

func main()  {

	/*
		----------- Set an environment variable in git bash -----------
		export HOST="https://ctreminiom.atlassian.net/"
		export MAIL="MAIL_ADDRESS"
		export TOKEN="TOKEN_API"

		Docs: https://stackoverflow.com/questions/34169721/set-an-environment-variable-in-git-bash
	*/

	var (
		host  = os.Getenv("HOST")
		mail  = os.Getenv("MAIL")
		token = os.Getenv("TOKEN")
	)

	atlassian, err := v2.New(nil, host)
	if err != nil {
		log.Fatal(err)
	}

	atlassian.Auth.SetBasicAuth(mail, token)

	features, response, err := atlassian.Project.Feature.Gets(context.Background(), "KP")
	if err != nil {
		log.Fatal(err)
	}
	log.Println("HTTP Endpoint Used", response.Endpoint)

	for _, feature := range features.Features {
		log.Printf("%#v", feature)
	}
}

Set project feature state

PUT /rest/api/{2-3}/project/{projectIdOrKey}/features/{featureKey}

Sets the state of a project feature.

package main

import (
	"context"
	_ "github.com/ctreminiom/go-atlassian/v2/jira/v3"
	v2 "github.com/ctreminiom/go-atlassian/v2/jira/v2"
	"log"
	"os"
)

func main()  {

	/*
		----------- Set an environment variable in git bash -----------
		export HOST="https://ctreminiom.atlassian.net/"
		export MAIL="MAIL_ADDRESS"
		export TOKEN="TOKEN_API"

		Docs: https://stackoverflow.com/questions/34169721/set-an-environment-variable-in-git-bash
	*/

	var (
		host  = os.Getenv("HOST")
		mail  = os.Getenv("MAIL")
		token = os.Getenv("TOKEN")
	)

	atlassian, err := v2.New(nil, host)
	if err != nil {
		log.Fatal(err)
	}

	atlassian.Auth.SetBasicAuth(mail, token)

	projectKeyOrID := "KP"
	featureKey := "jsw.classic.deployments"
	state := "DISABLED"

	features, response, err := atlassian.Project.Feature.Set(context.Background(), projectKeyOrID, featureKey, state)
	if err != nil {
		log.Fatal(err)
	}
	log.Println("HTTP Endpoint Used", response.Endpoint)

	for _, feature := range features.Features {
		log.Printf("%#v", feature)
	}
}

Search articles

GET /rest/servicedeskapi/knowledgebase/article

Returns articles that match the given query string across all service desks.

package main

import (
	"context"
	"github.com/ctreminiom/go-atlassian/jira/sm"
	"log"
	"os"
)

func main() {

	var (
		host  = os.Getenv("HOST")
		mail  = os.Getenv("MAIL")
		token = os.Getenv("TOKEN")
	)

	atlassian, err := sm.New(nil, host)
	if err != nil {
		return
	}

	atlassian.Auth.SetBasicAuth(mail, token)
	atlassian.Auth.SetUserAgent("curl/7.54.0")

	var (
		query = "login"
		start = 0
		limit = 50
	)

	articles, response, err := atlassian.Knowledgebase.Search(
		context.Background(),
		query,
		false,
		start, limit,
	)

	if err != nil {
		if response != nil {
			log.Println("Response HTTP Response", response.Bytes.String())
			log.Println("HTTP Endpoint Used", response.Endpoint)
		}
		log.Fatal(err)
	}

	log.Println("Response HTTP Code", response.Code)
	log.Println("HTTP Endpoint Used", response.Endpoint)

	for _, article := range articles.Values {
		log.Println(article)
	}

}

Get articles

GET /rest/servicedeskapi/servicedesk/{serviceDeskId}/knowledgebase/article

Returns articles that match the given query and belong to the knowledge base linked to the service desk.

package main

import (
	"context"
	"github.com/ctreminiom/go-atlassian/jira/sm"
	"log"
	"os"
)

func main() {

	var (
		host  = os.Getenv("HOST")
		mail  = os.Getenv("MAIL")
		token = os.Getenv("TOKEN")
	)

	atlassian, err := sm.New(nil, host)
	if err != nil {
		return
	}

	atlassian.Auth.SetBasicAuth(mail, token)
	atlassian.Auth.SetUserAgent("curl/7.54.0")

	var (
		serviceDeskID = 1
		query         = "login"
		start         = 0
		limit         = 50
	)

	articles, response, err := atlassian.Knowledgebase.Gets(
		context.Background(),
		serviceDeskID,
		query,
		false,
		start, limit,
	)

	if err != nil {
		if response != nil {
			log.Println("Response HTTP Response", response.Bytes.String())
			log.Println("HTTP Endpoint Used", response.Endpoint)
		}
		log.Fatal(err)
	}

	log.Println("Response HTTP Code", response.Code)
	log.Println("HTTP Endpoint Used", response.Endpoint)

	for _, article := range articles.Values {
		log.Println(article)
	}
}

Get Jira instance info

GET /rest/api/{2-3}/serverInfo

Returns information about the Jira instance.

package main

import (
	"context"
	_ "github.com/ctreminiom/go-atlassian/v2/jira/v3"
	"github.com/ctreminiom/go-atlassian/v2/jira/v2"
	"log"
	"os"
)

func main() {

	/*
		----------- Set an environment variable in git bash -----------
		export HOST="https://ctreminiom.atlassian.net/"
		export MAIL="MAIL_ADDRESS"
		export TOKEN="TOKEN_API"

		Docs: https://stackoverflow.com/questions/34169721/set-an-environment-variable-in-git-bash
	*/

	var (
		host  = os.Getenv("HOST")
		mail  = os.Getenv("MAIL")
		token = os.Getenv("TOKEN")
	)

	atlassian, err := v2.New(nil, host)
	if err != nil {
		log.Fatal(err)
	}

	atlassian.Auth.SetBasicAuth(mail, token)

	info, response, err := atlassian.Server.Info(context.Background())
	if err != nil {
		log.Fatal(err)
	}

	log.Println("Response HTTP Code", response.Code)
	log.Println("HTTP Endpoint Used", response.Endpoint)
	log.Println(info)
}

In this article, I would be showing you how to extract user last-activity information from the Atlassian Admin API's using go-atlassian

Step 1: Create a new Go project

Create a new directory for your project and navigate to it in your terminal or command prompt. Initialize a new Go module using the following command:

go mod init your-module-name

Step 2: Install the "go-atlassian" library

To use the "go-atlassian" library, you need to install it as a dependency in your project. Run the following command:

go get github.com/ctreminiom/go-atlassian

Step 3: Import the required packages

Create a new Go file, e.g., main.go, and import the necessary packages:

package main

import (
	"fmt"
	"log"

	"github.com/ctreminiom/go-atlassian/admin"
)

Step 4: Set up Cloud Admin client

Initialize the Atlassian Admin client with your API token:

func main() {
	//https://support.atlassian.com/organization-administration/docs/manage-an-organization-with-the-admin-apis/
	var apiKey = os.Getenv("ATLASSIAN_ADMIN_TOKEN")

	cloudAdmin, err := admin.New(nil)
	if err != nil {
		log.Fatal(err)
	}

	cloudAdmin.Auth.SetBearerToken(apiKey)
	cloudAdmin.Auth.SetUserAgent("curl/7.54.0")
}

Step 5: Extract the organization ID

It's required to extract the ID of the organization you're using, the organization ID can be extract on the admin URL, as the image below:

Step 6: Extract the organization users

In this step, we're going to extract the organization users and store them into an array variable, please use the following code block to extract them.

// Extract the organization users
var (
	organizationID = "9a1jj823-jac8-123d-jj01-63315k059cb2"
	cursor         string
	users          []*models.AdminOrganizationUserScheme
)

for {

	page, response, err := cloudAdmin.Organization.Users(context.Background(), organizationID, cursor)
	if err != nil {
		if response != nil {
			log.Println("Response HTTP Response", response.Bytes.String())
		}
		log.Fatal(err)
	}

	users = append(users, page.Data...)

	if len(page.Links.Next) == 0 {
		break
	}

	//extract the next cursor pagination
	nextAsURL, err := url.Parse(page.Links.Next)
	if err != nil {
		log.Fatal(err)
	}

	cursor = nextAsURL.Query().Get("cursor")
}

for _, user := range users {
	log.Println("Name:", user.Name, " -- ID:", user.AccountID)
}

Step 7: Extract the last-login date

With the organization users extracted, we need to iterate each user and extract the last-login information, you can use the following code to do that:

for _, user := range users {

	lastLogin, response, err := cloudAdmin.Organization.Directory.Activity(context.Background(), organizationID, user.AccountID)
	if err != nil {
		if response != nil {
			log.Println("Response HTTP Response", response.Bytes.String())
		}
		log.Fatal(err)
	}

	// The products are iterated because an Atlassian user may contain multiple products
	// If you're looking to a specific product, you can modify the loop logic and extract
	// the last-login for Jira or Confluence
	for _, product := range lastLogin.Data.ProductAccess {

		fmt.Println(lastLogin.Data.AddedToOrg, product)
	}
}

Overview

Teams in Advanced Roadmaps are different from the teams found in the rest of Jira Software Cloud. In Advanced Roadmaps, they act as a label applied to issues that designates which team will eventually pick up the work on your timeline. By adding the Team field to your Jira issues, you can save this value back to your Jira issues, which makes sprint planning easier.

Since Advanced Roadmaps is a planning tool, the Team field is a way to use features like capacity management without assigning issues to individuals, which happens in sprint grooming or planning sessions.

You can also use Advanced Roadmaps' view settings to focus on work assigned to a specific team. For example, you can choose to color issues based on the team to which they’re assigned, group issues by team on your timeline, or hide teams from your view.

Get Teams

POST /rest/teams/1.0/teams/find

Gets returns the Teams information from the Jira Advanced Roadmaps application.

• Teams in Advanced Roadmaps are different from the teams found in the rest of Jira Software Cloud. In Advanced Roadmaps, they act as a label applied to issues that designates which team will eventually pick up the work on your timeline.

• By adding the Team field to your Jira issues, you can save this value back to your Jira issues, which makes sprint planning easier

Create Team

POST /rest/teams/1.0/teams/create

Create create creates a team on the Advanced Roadmaps.

Validate project key

GET /rest/api/{2-3}/projectvalidate/key

Validates a project key by confirming the key is a valid string and not in use.

package main

import (
	"context"
	_ "github.com/ctreminiom/go-atlassian/v2/jira/v3"
	"github.com/ctreminiom/go-atlassian/v2/jira/v2"
	"log"
	"os"
)

func main()  {

	/*
		----------- Set an environment variable in git bash -----------
		export HOST="https://ctreminiom.atlassian.net/"
		export MAIL="MAIL_ADDRESS"
		export TOKEN="TOKEN_API"

		Docs: https://stackoverflow.com/questions/34169721/set-an-environment-variable-in-git-bash
	*/

	var (
		host  = os.Getenv("HOST")
		mail  = os.Getenv("MAIL")
		token = os.Getenv("TOKEN")
	)

	atlassian, err := v2.New(nil, host)
	if err != nil {
		log.Fatal(err)
	}

	atlassian.Auth.SetBasicAuth(mail, token)

	message, response, err := atlassian.Project.Valid.Validate(context.Background(), "KP")
	if err != nil {
		log.Fatal(err)
	}
	log.Println("Response HTTP Code", response.Code)
	log.Println("HTTP Endpoint Used", response.Endpoint)
	log.Println(message)
}

Get valid project key

GET /rest/api/{2-3}/projectvalidate/validProjectKey

Validates a project key and, if the key is invalid or in use, generates a valid random string for the project key.

package main

import (
	"context"
	_ "github.com/ctreminiom/go-atlassian/v2/jira/v3"
	"github.com/ctreminiom/go-atlassian/v2/jira/v2"
	"log"
	"os"
)

func main()  {

	/*
		----------- Set an environment variable in git bash -----------
		export HOST="https://ctreminiom.atlassian.net/"
		export MAIL="MAIL_ADDRESS"
		export TOKEN="TOKEN_API"

		Docs: https://stackoverflow.com/questions/34169721/set-an-environment-variable-in-git-bash
	*/

	var (
		host  = os.Getenv("HOST")
		mail  = os.Getenv("MAIL")
		token = os.Getenv("TOKEN")
	)

	atlassian, err := v2.New(nil, host)
	if err != nil {
		log.Fatal(err)
	}

	atlassian.Auth.SetBasicAuth(mail, token)

	message, response, err := atlassian.Project.Valid.Key(context.Background(), "KP")
	if err != nil {
		log.Fatal(err)
	}
	log.Println("Response HTTP Code", response.Code)
	log.Println("HTTP Endpoint Used", response.Endpoint)
	log.Println(message)
}

Get valid project name

GET /rest/api/{2-3}/projectvalidate/validProjectName

Checks that a project name isn't in use. If the name isn't in use, the passed string is returned. If the name is in use, this operation attempts to generate a valid project name based on the one supplied, usually by adding a sequence number. If a valid project name cannot be generated, a 404 response is returned.

package main

import (
	"context"
	_ "github.com/ctreminiom/go-atlassian/v2/jira/v3"
	"github.com/ctreminiom/go-atlassian/v2/jira/v2"
	"log"
	"os"
)

func main()  {

	/*
		----------- Set an environment variable in git bash -----------
		export HOST="https://ctreminiom.atlassian.net/"
		export MAIL="MAIL_ADDRESS"
		export TOKEN="TOKEN_API"

		Docs: https://stackoverflow.com/questions/34169721/set-an-environment-variable-in-git-bash
	*/

	var (
		host  = os.Getenv("HOST")
		mail  = os.Getenv("MAIL")
		token = os.Getenv("TOKEN")
	)

	atlassian, err := v2.New(nil, host)
	if err != nil {
		log.Fatal(err)
	}

	atlassian.Auth.SetBasicAuth(mail, token)

	message, response, err := atlassian.Project.Valid.Name(context.Background(), "KP")
	if err != nil {
		log.Fatal(err)
	}
	log.Println("Response HTTP Code", response.Code)
	log.Println("HTTP Endpoint Used", response.Endpoint)
	log.Println(message)
}

Archive issues by issue ID/Key

PUT /rest/api/{2-3}/issue/archive

Preserve archives the given issues based on their issue IDs or keys.

package main

import (
	"context"
	"fmt"
	"github.com/ctreminiom/go-atlassian/v2/jira/v2"
	"log"
	"os"
)

func main() {

	var (
		host  = os.Getenv("HOST")
		mail  = os.Getenv("MAIL")
		token = os.Getenv("TOKEN")
	)

	fmt.Println(host)

	atlassian, err := v2.New(nil, host)
	if err != nil {
		log.Fatal(err)
	}

	atlassian.Auth.SetBasicAuth(mail, token)

	archivalResult, response, err := atlassian.Archive.Preserve(context.Background(), []string{"KP-2"})
	if err != nil {
		if response != nil {
			log.Println("Response HTTP Code", response.Code)
			log.Println("HTTP Endpoint Used", response.Endpoint)
		}
		log.Fatal(err)
	}

	fmt.Println(archivalResult.NumberOfIssuesUpdated)
}

Archive issues by JQL

POST /rest/api/{2-3}/issue/archive

PreserveByJQL archives issues than match the provided JQL query.

package main

import (
	"context"
	"fmt"
	"github.com/ctreminiom/go-atlassian/v2/jira/v2"
	"log"
	"os"
)

func main() {

	var (
		host  = os.Getenv("HOST")
		mail  = os.Getenv("MAIL")
		token = os.Getenv("TOKEN")
	)

	fmt.Println(host)

	atlassian, err := v2.New(nil, host)
	if err != nil {
		log.Fatal(err)
	}

	atlassian.Auth.SetBasicAuth(mail, token)

	taskID, response, err := atlassian.Archive.PreserveByJQL(context.Background(), "project = WORK")
	if err != nil {
		if response != nil {
			log.Println("Response HTTP Code", response.Code)
			log.Println("HTTP Endpoint Used", response.Endpoint)
		}
		log.Fatal(err)
	}

	fmt.Println(taskID)
}

Restore issues by issue ID/Key

PUT /rest/api/{2-3}/issue/unarchive

Restore brings back the given archived issues using their issue IDs or keys.

package main

import (
	"context"
	"fmt"
	"github.com/ctreminiom/go-atlassian/v2/jira/v2"
	"log"
	"os"
)

func main() {

	/*
		----------- Set an environment variable in git bash -----------
		export HOST="https://ctreminiom.atlassian.net/"
		export MAIL="MAIL_ADDRESS"
		export TOKEN=""

		Docs: https://stackoverflow.com/questions/34169721/set-an-environment-variable-in-git-bash
	*/

	var (
		host  = os.Getenv("HOST")
		mail  = os.Getenv("MAIL")
		token = os.Getenv("TOKEN")
	)

	fmt.Println(host)

	atlassian, err := v2.New(nil, host)
	if err != nil {
		log.Fatal(err)
	}

	atlassian.Auth.SetBasicAuth(mail, token)

	archivalResult, response, err := atlassian.Archive.Restore(context.Background(), []string{"KP-2"})
	if err != nil {
		if response != nil {
			log.Println("Response HTTP Code", response.Code)
			log.Println("HTTP Endpoint Used", response.Endpoint)
		}
		log.Fatal(err)
	}

	fmt.Println(archivalResult.NumberOfIssuesUpdated)
}

Export archived issues

PUT /rest/api/{2-3}/issues/archive/export

Export generates an export of archived issues based on the provided payload.

package main

import (
	"context"
	"fmt"
	"github.com/ctreminiom/go-atlassian/v2/jira/v2"
	"github.com/ctreminiom/go-atlassian/v2/pkg/infra/models"
	"log"
	"os"
)

func main() {

	/*
		----------- Set an environment variable in git bash -----------
		export HOST="https://ctreminiom.atlassian.net/"
		export MAIL="MAIL_ADDRESS"
		export TOKEN=""

		Docs: https://stackoverflow.com/questions/34169721/set-an-environment-variable-in-git-bash
	*/

	var (
		host  = os.Getenv("HOST")
		mail  = os.Getenv("MAIL")
		token = os.Getenv("TOKEN")
	)

	atlassian, err := v2.New(nil, host)
	if err != nil {
		log.Fatal(err)
	}

	atlassian.Auth.SetBasicAuth(mail, token)

	exportConfigPayload := &models.IssueArchivalExportPayloadScheme{
		/*

			ArchivedBy: []string{
				"uuid-sample",
				"uuid-sample",
			},
		*/
		ArchivedDateRange: &models.DateRangeFilterRequestScheme{
			DateAfter:  "2023-01-01",
			DateBefore: "2023-01-12",
		},
		//IssueTypes: []string{"Bug", "Story"},
		Projects: []string{"WORK"},
		//Reporters:  []string{"uuid-sample"},
	}

	taskID, response, err := atlassian.Archive.Export(context.Background(), exportConfigPayload)
	if err != nil {
		if response != nil {
			log.Println("Response HTTP Code", response.Code)
			log.Println("HTTP Endpoint Used", response.Endpoint)
		}
		log.Fatal(err)
	}

	fmt.Println(response.Endpoint)
	fmt.Println(taskID)
}

Get votes

GET /rest/api/{2-3}/issue/{issueIdOrKey}/votes

Returns details about the votes on an issue.

package main

import (
	"context"
	"github.com/ctreminiom/go-atlassian/v2/jira/v2"
	"log"
	"os"
)

func main() {

	/*
		----------- Set an environment variable in git bash -----------
		export HOST="https://ctreminiom.atlassian.net/"
		export MAIL="MAIL_ADDRESS"
		export TOKEN="TOKEN_API"

		Docs: https://stackoverflow.com/questions/34169721/set-an-environment-variable-in-git-bash
	*/

	var (
		host  = os.Getenv("HOST")
		mail  = os.Getenv("MAIL")
		token = os.Getenv("TOKEN")
	)

	atlassian, err := v2.New(nil, host)
	if err != nil {
		log.Fatal(err)
	}

	atlassian.Auth.SetBasicAuth(mail, token)

	votes, response, err := atlassian.Issue.Votes.Gets(context.Background(), "KP-2")
	if err != nil {
		log.Fatal(err)
	}

	log.Println("HTTP Endpoint Used", response.Endpoint)

	for _, voter := range votes.Voters {
		log.Println(voter.DisplayName, voter.Self)
	}
}

Add vote

POST /rest/api/{2-3}/issue/{issueIdOrKey}/votes

Adds the user's vote to an issue. This is the equivalent of the user clicking Vote on an issue in Jira.

package main

import (
	"context"
	"github.com/ctreminiom/go-atlassian/v2/jira/v2"
	"log"
	"os"
)

func main() {

	/*
		----------- Set an environment variable in git bash -----------
		export HOST="https://ctreminiom.atlassian.net/"
		export MAIL="MAIL_ADDRESS"
		export TOKEN="TOKEN_API"

		Docs: https://stackoverflow.com/questions/34169721/set-an-environment-variable-in-git-bash
	*/

	var (
		host  = os.Getenv("HOST")
		mail  = os.Getenv("MAIL")
		token = os.Getenv("TOKEN")
	)

	atlassian, err := v2.New(nil, host)
	if err != nil {
		log.Fatal(err)
	}

	atlassian.Auth.SetBasicAuth(mail, token)

	response, err := atlassian.Issue.Votes.Add(context.Background(), "KP-2")
	if err != nil {
		log.Fatal(err)
	}

	log.Println("HTTP Endpoint Used", response.Endpoint)
}

Delete vote

DELETE /rest/api/{2-3}/issue/{issueIdOrKey}/votes

Deletes a user's vote from an issue. This is the equivalent of the user clicking Unvote on an issue in Jira.

package main

import (
	"context"
	"github.com/ctreminiom/go-atlassian/v2/jira/v2"
	"log"
	"os"
)

func main() {

	/*
		----------- Set an environment variable in git bash -----------
		export HOST="https://ctreminiom.atlassian.net/"
		export MAIL="MAIL_ADDRESS"
		export TOKEN="TOKEN_API"

		Docs: https://stackoverflow.com/questions/34169721/set-an-environment-variable-in-git-bash
	*/

	var (
		host  = os.Getenv("HOST")
		mail  = os.Getenv("MAIL")
		token = os.Getenv("TOKEN")
	)

	atlassian, err := v2.New(nil, host)
	if err != nil {
		log.Fatal(err)
	}

	atlassian.Auth.SetBasicAuth(mail, token)

	response, err := atlassian.Issue.Votes.Delete(context.Background(), "KP-2")
	if err != nil {
		log.Fatal(err)
	}

	log.Println("HTTP Endpoint Used", response.Endpoint)
}

Search for issues using JQL (GET)

GET /rest/api/{2-3}/search

Searches for issues using . If the JQL query expression is too large to be encoded as a query parameter, use the version of this resource.

Search for issues using JQL (POST)

POST /rest/api/{2-3}/search

Searches for issues using . There is a version of this resource that can be used for smaller JQL query expressions.

Check issues against JQL

POST /rest/api/{2-3}/jql/match

Checks whether one or more issues would be returned by one or more JQL queries.

Find users assignable to projects

GET /rest/api/{2-3}/user/assignable/multiProjectSearch

Returns a list of users who can be assigned issues in one or more projects. The list may be restricted to users whose attributes match a string.

Find users

GET /rest/api/{2-3}/user/search

Returns a list of users that match the search string and property.

Find users with permissions

GET /rest/api/{2-3}/user/viewissue/search

Returns a list of users who fulfill these criteria:

• their user attributes match a search string.

• they have a set of permissions for a project or issue.

Get Epic

GET /rest/agile/1.0/epic/{epicIdOrKey}

Returns the epic for a given epic ID. This epic will only be returned if the user has permission to view it.

Get Issues for epic

GET /rest/agile/1.0/epic/{epicIdOrKey}/issue

Returns all issues that belong to the epic, for the given epic ID. This only includes issues that the user has permission to view. Issues returned from this resource include Agile fields, like sprint, closedSprints, flagged, and epic. By default, the returned issues are ordered by rank.

Move issues to Epic

POST /rest/agile/1.0/epic/{epicIdOrKey}/issue

Move moves issues to an epic, for a given epic id. Issues can be only in a single epic at the same time. That means that already assigned issues to an epic, will not be assigned to the previous epic anymore. The user needs to have the edit issue permission for all issue they want to move and to the epic. The maximum number of issues that can be moved in one operation is 50.

System Administrators can configure an announcement banner to display pertinent information on all Jira pages. The banner can be used to relate important information (e.g. scheduled server maintenance, approaching project deadlines, etc.) to all users. Further, the banner visibility level can be configured to display to all users or just logged-in users.

Get announcement banner configuration

GET /rest/api/{2/3}/announcementBanner

Get returns the current announcement banner configuration.

Update announcement banner configuration

PUT /rest/api/{2-3}/announcementBanner

Update updates the announcement banner configuration.

In Jira, a backlog is a prioritized list of work items that need to be completed. It serves as a repository for all the tasks, user stories, bugs, and other work items that are yet to be worked on or are in the planning stage. Backlogs are typically associated with agile project management methodologies such as Scrum and Kanban.

Backlogs are visualized as lists of items that can be sorted, filtered, and prioritized. Teams can easily move items between different backlogs, update their status, estimate effort, and collaborate on the work items. Backlogs provide a centralized view of all the work in progress and assist in effective planning, tracking, and delivery of projects.

Move issues to backlog

POST /rest/agile/1.0/backlog/issue

Move moves issues to the backlog.

• This operation is equivalent to remove future and active sprints from a given set of issues.

• At most 50 issues may be moved at once.

Move issues to a board backlog

POST /rest/agile/1.0/backlog/{boardId}/issue

• This operation is equivalent to remove future and active sprints from a given set of issues if the board has sprints.

• If the board does not have sprints this will put the issues back into the backlog from the board.

• At most 50 issues may be moved at once.

This resource represents issue link types. Use it to get, create, update, and delete link issue types as well as get lists of all link issue types.

Get issue link types

GET /rest/api/{2-3}/issueLinkType

Returns a list of all issue link types, the method returns the following information:

package main

import (
	"context"
	"github.com/ctreminiom/go-atlassian/v2/jira/v2"
	"log"
	"os"
)

func main() {

	var (
		host  = os.Getenv("HOST")
		mail  = os.Getenv("MAIL")
		token = os.Getenv("TOKEN")
	)

	atlassian, err := v2.New(nil, host)
	if err != nil {
		log.Fatal(err)
	}

	atlassian.Auth.SetBasicAuth(mail, token)

	types, response, err := atlassian.Issue.Link.Type.Gets(context.Background())
	if err != nil {
		log.Fatal(err)
	}

	log.Println("HTTP Endpoint Used", response.Endpoint)

	for _, value := range types.IssueLinkTypes {
		log.Println(value)
	}

}