Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
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)
settings, response, err := atlassian.Issue.Attachment.Settings(context.Background())
if err != nil {
log.Fatal(err)
return
}
log.Println("HTTP Endpoint Used", response.Endpoint)
log.Println("settings", settings.Enabled, settings.UploadLimit)
}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)
}
}This resource represents issue resolution values. Use it to obtain a list of all issue resolution values and the details of individual resolution values.
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)
resolutions, response, err := atlassian.Issue.Resolution.Gets(context.Background())
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
for pos, resolution := range resolutions {
log.Println(pos, resolution)
}
}This resource represents various ways to search for issues. Use it to search for issues with a JQL query and find issues to populate an issue picker.
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)
var (
jql = "order by created DESC"
fields = []string{"status"}
expand = []string{"changelog", "renderedFields", "names", "schema", "transitions", "operations", "editmeta"}
)
issues, response, err := atlassian.Issue.Search.Get(context.Background(), jql, fields, expand, 0, 50, "")
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
log.Println(issues.Total)
for _, issue := range issues.Issues {
for _, history := range issue.Changelog.Histories {
for _, item := range history.Items {
log.Println(issue.Key, item.Field, history.Author.DisplayName)
}
}
}
for _, issue := range issues.Issues {
for _, transition := range issue.Transitions {
log.Println(issue.Key, transition.Name, transition.ID)
}
}
}This resource represents issue type schemes in classic projects
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)
issueTypeSchemes, response, err := atlassian.Issue.Type.Scheme.Gets(context.Background(), nil, 0, 50)
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
for _, issueTypeScheme := range issueTypeSchemes.Values {
log.Println(issueTypeScheme)
}
}This resource represents issue type screen schemes.
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)
screenSchemes, response, err := atlassian.Issue.Type.ScreenScheme.Gets(context.Background(), []int{10001, 10002}, 0, 50)
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
log.Println(screenSchemes)
for _, screenScheme := range screenSchemes.Values {
log.Println(screenScheme)
}
}This resource represents users watching an issue. Use it to get details of users watching an issue as well as start and stop a user watching 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)
watchers, response, err := atlassian.Issue.Watchers.Gets(context.Background(), "KP-2")
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
log.Println(watchers.IsWatching, watchers.WatchCount)
for _, watcher := range watchers.Watchers {
log.Println(watcher.Self, watcher.AccountID)
}
}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)
var (
ctx = context.Background()
key = "KP-1"
maxResult = 50
after = 0
expand = []string{""}
)
worklogs, response, err := atlassian.Issue.Worklog.Issue(ctx, key, 0, maxResult, after, expand)
if err != nil {
log.Fatal(err)
}
log.Println(response.Endpoint, response.Code)
for _, worklog := range worklogs.Worklogs {
log.Println(worklog.ID)
}
}package main
import (
"context"
"fmt"
v2 "github.com/ctreminiom/go-atlassian/v2/jira/v2"
_ "github.com/ctreminiom/go-atlassian/v2/jira/v3"
"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)
properties, response, err := atlassian.Issue.Property.Gets(context.Background(), "KP-3")
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
for _, key := range properties.Keys {
fmt.Println(key.Self, key.Key)
}
}
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)
}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)
screenSchemes, response, err := atlassian.Screen.Scheme.Gets(context.Background(), nil, 0, 50)
if err != nil {
log.Fatal(err)
}
log.Println("Response HTTP Code", response.Code)
log.Println("HTTP Endpoint Used", response.Endpoint)
for _, screenScheme := range screenSchemes.Values {
log.Println(screenScheme)
}
}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 (
email = "[email protected]"
displayName = "Example Customer 1"
)
newCustomer, response, err := atlassian.Customer.Create(context.Background(), email, displayName)
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)
log.Println("The new customer has been created!!")
log.Println("-------------------------")
log.Println(newCustomer.Name)
log.Println(newCustomer.DisplayName)
log.Println(newCustomer.AccountID)
log.Println(newCustomer.EmailAddress)
log.Println(newCustomer.Links)
log.Println(newCustomer)
log.Println("-------------------------")
}ppackage 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 (
email = "[email protected]"
displayName = "Example Customer 1"
)
newCustomer, response, err := atlassian.Customer.Create(context.Background(), email, displayName)
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)
log.Println("The new customer has been created!!")
log.Println("-------------------------")
log.Println(newCustomer.Name)
log.Println(newCustomer.DisplayName)
log.Println(newCustomer.AccountID)
log.Println(newCustomer.EmailAddress)
log.Println(newCustomer.Links)
log.Println(newCustomer)
log.Println("-------------------------")
}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)
}
}
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)
}
}
package models
// InfoScheme represents the information about a system.
type InfoScheme struct {
Version string `json:"version,omitempty"` // The version of the system.
PlatformVersion string `json:"platformVersion,omitempty"` // The platform version of the system.
BuildDate *InfoBuildDataScheme `json:"buildDate,omitempty"` // The build date of the system.
BuildChangeSet string `json:"buildChangeSet,omitempty"` // The build change set of the system.
IsLicensedForUse bool `json:"isLicensedForUse,omitempty"` // Indicates if the system is licensed for use.
Links *InfoLinkScheme `json:"_links,omitempty"` // Links related to the system.
}
// InfoBuildDataScheme represents the build date of a system.
type InfoBuildDataScheme struct {
ISO8601 DateTimeScheme `json:"iso8601,omitempty"` // The ISO 8601 format of the build date.
Jira string `json:"jira,omitempty"` // The Jira format of the build date.
Friendly string `json:"friendly,omitempty"` // The friendly format of the build date.
EpochMillis int64 `json:"epochMillis,omitempty"` // The epoch milliseconds of the build date.
}
// InfoLinkScheme represents a link related to a system.
type InfoLinkScheme struct {
Self string `json:"self,omitempty"` // The URL of the system itself.
}
go mod init <module-name>go get -v github.com/ctreminiom/go-atlassianpackage main
import (
"fmt"
"log"
"os"
jira "github.com/ctreminiom/go-atlassian/jira/v2"
)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)
}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)
}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)
}issue, response, err := client.Issue.Get(context.Background(), "KP-23", nil, []string{"transitions"})
if err != nil {
log.Fatal(err)
}
options, err := models.ParseMultiSelectCustomField(response.Bytes, "customfield_10046")
if err != nil {
log.Fatal(err)
}
for _, option := range options {
fmt.Println(option.ID, option.Value)
}_, response, err := client.Issue.Get(context.Background(), "KP-23", nil, []string{"transitions"})
if err != nil {
log.Fatal(err)
}
option, err := models.ParseSelectCustomField(response.Bytes, "customfield_10047")
if err != nil {
log.Fatal(err)
}
fmt.Println(option.ID, option.Value)issue, response, err := client.Issue.Get(context.Background(), "KP-23", nil, []string{"transitions"})
if err != nil {
log.Fatal(err)
}
cascading, err := models.ParseCascadingSelectCustomField(response.Bytes, "customfield_10045")
if err != nil {
log.Fatal(err)
}
fmt.Println(cascading.Value, cascading.Child.Value)_, response, err := client.Issue.Get(context.Background(), "KP-24", nil, []string{"transitions"})
if err != nil {
log.Fatal(err)
}
datePicker, err := models.ParseDatePickerCustomField(response.Bytes, "customfield_10040")
if err != nil {
log.Fatal(err)
}
fmt.Println(datePicker.String())_, response, err := client.Issue.Get(context.Background(), "KP-24", nil, []string{"transitions"})
if err != nil {
log.Fatal(err)
}
datePicker, err := models.ParseDateTimeCustomField(response.Bytes, "customfield_10041")
if err != nil {
log.Fatal(err)
}
fmt.Println(datePicker.String())issue, response, err := client.Issue.Get(context.Background(), "KP-23", nil, []string{"transitions"})
if err != nil {
log.Fatal(err)
}
users, err := models.ParseMultiUserPickerCustomField(response.Bytes, "customfield_10055")
if err != nil {
log.Fatal(err)
}
for _, user := range users {
fmt.Println(user.EmailAddress, user.AccountID)
}issue, response, err := client.Issue.Get(context.Background(), "KP-23", nil, []string{"transitions"})
if err != nil {
log.Fatal(err)
}
groups, err := models.ParseMultiGroupPickerCustomField(response.Bytes, "customfield_10052")
if err != nil {
log.Fatal(err)
}
for _, group := range groups {
fmt.Println(group.Name)
}issue, response, err := client.Issue.Get(context.Background(), "KP-23", nil, []string{"transitions"})
if err != nil {
log.Fatal(err)
}
number, err := models.ParseFloatCustomField(response.Bytes, "customfield_10043")
if err != nil {
log.Fatal(err)
}
fmt.Println(number)issue, response, err := client.Issue.Get(context.Background(), "KP-23", nil, []string{"transitions"})
if err != nil {
log.Fatal(err)
}
sprints, err := models.ParseSprintCustomField(response.Bytes, "customfield_10020")
if err != nil {
log.Fatal(err)
}
for _, sprint := range sprints {
fmt.Println(sprint.ID)
}issue, response, err := client.Issue.Get(context.Background(), "KP-23", nil, []string{"transitions"})
if err != nil {
log.Fatal(err)
}
labels, err := models.ParseLabelCustomField(response.Bytes, "customfield_10042")
if err != nil {
log.Fatal(err)
}
for _, label := range labels {
fmt.Println(label)
}issue, response, err := client.Issue.Get(context.Background(), "KP-23", nil, []string{"transitions"})
if err != nil {
log.Fatal(err)
}
versions, err := models.ParseMultiVersionCustomField(response.Bytes, "customfield_10067")
if err != nil {
log.Fatal(err)
}
for _, version := range versions {
fmt.Println(version.ID, version.Name, version.Description)
}_, response, err := client.Issue.Get(context.Background(), "KP-24", nil, []string{"transitions"})
if err != nil {
log.Fatal(err)
}
user, err := models.ParseUserPickerCustomField(response.Bytes, "customfield_10051")
if err != nil {
log.Fatal(err)
}
fmt.Println(user.EmailAddress)
fmt.Println(user.DisplayName)
fmt.Println(user.AccountID)
fmt.Println(user.AccountType)issue, response, err := client.Issue.Get(context.Background(), "KP-23", nil, []string{"transitions"})
if err != nil {
log.Fatal(err)
}
assets, err := models.ParseAssetCustomField(response.Bytes, "customfield_10068")
if err != nil {
log.Fatal(err)
}
for _, asset := range assets {
fmt.Println(asset.Id, asset.WorkspaceId, asset.ObjectId)
}_, response, err := client.Issue.Get(context.Background(), "KP-24", nil, []string{"transitions"})
if err != nil {
log.Fatal(err)
}
textField, err := models.ParseStringCustomField(response.Bytes, "customfield_10049")
if err != nil {
log.Fatal(err)
}
fmt.Println(textField)_, response, err := client.Issue.Search.Post(context.Background(), "project = KP", []string{"customfield_10046"}, nil, 0, 50, "")
if err != nil {
log.Fatal(err)
}
multiSelectOptions, err := models.ParseMultiSelectCustomFields(response.Bytes, "customfield_10046")
if err != nil {
log.Fatal(err)
}
for issue, options := range multiSelectOptions {
for _, option := range options {
fmt.Println(issue, option.ID, option.Value)
}
}_, response, err := client.Issue.Search.Post(context.Background(), "project = KP", []string{"customfield_10047"}, nil, 0, 50, "")
if err != nil {
log.Fatal(err)
}
customfields, err := models.ParseSelectCustomFields(response.Bytes, "customfield_10047")
if err != nil {
log.Fatal(err)
}
for issue, option := range customfields {
fmt.Println(issue, option.ID, option.Value)
}_, response, err := client.Issue.Search.Post(context.Background(), "project = KP", []string{"customfield_10045"}, nil, 0, 50, "")
if err != nil {
log.Fatal(err)
}
customfields, err := models.ParseCascadingCustomFields(response.Bytes, "customfield_10045")
if err != nil {
log.Fatal(err)
}
for issue, value := range customfields {
fmt.Println(issue, value.Value, value.Child.Value)
}_, response, err := client.Issue.Search.Post(context.Background(), "project = KP", []string{"customfield_10055"}, nil, 0, 50, "")
if err != nil {
log.Fatal(err)
}
customfields, err := models.ParseMultiUserPickerCustomFields(response.Bytes, "customfield_10055")
if err != nil {
log.Fatal(err)
}
for issue, users := range customfields {
for _, user := range users {
fmt.Println(issue, user.AccountID, user.DisplayName)
}
}_, response, err := client.Issue.Search.Post(context.Background(), "project = KP", []string{"customfield_10040"}, nil, 0, 50, "")
if err != nil {
log.Fatal(err)
}
customfields, err := models.ParseDatePickerCustomFields(response.Bytes, "customfield_10040")
if err != nil {
log.Fatal(err)
}
for issue, datepicker := range customfields {
fmt.Println(issue, datepicker.String())
}_, response, err := client.Issue.Search.Post(context.Background(), "project = KP", []string{"customfield_10041"}, nil, 0, 50, "")
if err != nil {
log.Fatal(err)
}
customfields, err := models.ParseDateTimeCustomFields(response.Bytes, "customfield_10041")
if err != nil {
log.Fatal(err)
}
for issue, datetime := range customfields {
fmt.Println(issue, datetime.String())
}_, response, err := client.Issue.Search.Post(context.Background(), "project = KP", []string{"customfield_10052"}, nil, 0, 50, "")
if err != nil {
log.Fatal(err)
}
customfields, err := models.ParseMultiGroupPickerCustomFields(response.Bytes, "customfield_10052")
if err != nil {
log.Fatal(err)
}
for issue, groups := range customfields {
for _, group := range groups {
fmt.Println(issue, group.Name, group.GroupID)
}
}_, response, err := client.Issue.Search.Post(context.Background(), "project = KP", []string{"customfield_10043"}, nil, 0, 50, "")
if err != nil {
log.Fatal(err)
}
customfields, err := models.ParseFloatCustomFields(response.Bytes, "customfield_10043")
if err != nil {
log.Fatal(err)
}
for issue, number := range customfields {
fmt.Println(issue, number)
}_, response, err := client.Issue.Search.Post(context.Background(), "project = KP", []string{"customfield_10049"}, nil, 0, 50, "")
if err != nil {
log.Fatal(err)
}
customfields, err := models.ParseStringCustomFields(response.Bytes, "customfield_10049")
if err != nil {
log.Fatal(err)
}
for issue, textField := range customfields {
fmt.Println(issue, textField)
}_, response, err := client.Issue.Search.Post(context.Background(), "project = KP", []string{"customfield_10051"}, nil, 0, 50, "")
if err != nil {
log.Fatal(err)
}
customfields, err := models.ParseUserPickerCustomFields(response.Bytes, "customfield_10051")
if err != nil {
log.Fatal(err)
}
for issue, user := range customfields {
fmt.Println(issue, user.AccountID)
}_, response, err := client.Issue.Search.Post(context.Background(), "project = KP", []string{"customfield_10020"}, nil, 0, 50, "")
if err != nil {
log.Fatal(err)
}
customfields, err := models.ParseSprintCustomFields(response.Bytes, "customfield_10020")
if err != nil {
log.Fatal(err)
}
for issue, sprints := range customfields {
for _, sprint := range sprints {
fmt.Println(issue, sprint.Name, sprint.ID, sprint.BoardID, sprint.State)
}
}_, response, err := client.Issue.Search.Post(context.Background(), "project = KP", []string{"customfield_10042"}, nil, 0, 50, "")
if err != nil {
log.Fatal(err)
}
customfields, err := models.ParseLabelCustomFields(response.Bytes, "customfield_10042")
if err != nil {
log.Fatal(err)
}
for issue, labels := range customfields {
fmt.Println(issue, labels)
}_, response, err := client.Issue.Search.Post(context.Background(), "project = KP", []string{"customfield_10067"}, nil, 0, 50, "")
if err != nil {
log.Fatal(err)
}
customfields, err := models.ParseMultiVersionCustomFields(response.Bytes, "customfield_10067")
if err != nil {
log.Fatal(err)
}
for issue, versions := range customfields {
for _, version := range versions {
fmt.Println(issue, version.Name, version.ID)
}
}_, response, err := client.Issue.Search.Post(context.Background(), "project = KP", []string{"customfield_10072"}, nil, 0, 50, "")
if err != nil {
log.Fatal(err)
}
customfields, err := models.ParseAssetCustomFields(response.Bytes, "customfield_10072")
if err != nil {
log.Fatal(err)
}
for issue, assets := range customfields {
for _, asset := range assets {
fmt.Println(issue, asset.Id, asset.WorkspaceId, asset.ObjectId)
}
}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")
}
}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)
group, response, err := atlassian.Group.Create(context.Background(), "jira-users-22")
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
log.Println("Group created", group.Name)
}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)
response, err := atlassian.Group.Delete(context.Background(), "jira-users-2")
if err != nil {
log.Fatal(err)
return
}
log.Println("HTTP Endpoint Used", response.Endpoint)
}
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() {
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.GroupBulkOptionsScheme{
GroupIDs: nil,
GroupNames: nil,
}
groups, response, err := atlassian.Group.Bulk(context.Background(), &options, 0, 50)
if err != nil {
return
}
log.Println("HTTP Endpoint Used", response.Endpoint)
log.Println(groups.IsLast)
for index, group := range groups.Values {
log.Printf("#%v, Group: %v", index, group.Name)
}
}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)
members, response, err := atlassian.Group.Members(context.Background(), "jira-users", false, 0, 100)
if err != nil {
log.Fatal(err)
return
}
log.Println("HTTP Endpoint Used", response.Endpoint)
log.Println(members.IsLast)
for index, member := range members.Values {
log.Printf("#%v - Group %v - Member Mail %v - Member AccountID %v", index, "jira-users", member.EmailAddress, member.AccountID)
}
}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)
_, response, err := atlassian.Group.Add(context.Background(), "groupName", "accountID")
if err != nil {
return
}
log.Println("HTTP Endpoint Used", response.Endpoint)
}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)
response, err := atlassian.Group.Remove(context.Background(), "groupName", "accountID")
if err != nil {
return
}
log.Println("HTTP Endpoint Used", response.Endpoint)
}package main
import (
"context"
"github.com/ctreminiom/go-atlassian/v2/jira/v2"
_ "github.com/ctreminiom/go-atlassian/v2/jira/v3"
"github.com/davecgh/go-spew/spew"
"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)
metadata, response, err := atlassian.Issue.Attachment.Metadata(context.Background(), "10016")
if err != nil {
log.Fatal(err)
}
log.Println("Response HTTP Code", response.Code)
log.Println("HTTP Endpoint Used", response.Endpoint)
spew.Dump(metadata)
}package main
import (
"context"
"github.com/ctreminiom/go-atlassian/v2/jira/v2"
_ "github.com/ctreminiom/go-atlassian/v2/jira/v3"
"github.com/davecgh/go-spew/spew"
"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)
humanMetadata, response, err := atlassian.Issue.Attachment.Human(context.Background(), "10016")
if err != nil {
log.Fatal(err)
return
}
log.Println("HTTP Endpoint Used", response.Endpoint)
spew.Dump(humanMetadata)
}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)
response, err := atlassian.Issue.Attachment.Delete(context.Background(), "attachmentID")
if err != nil {
log.Fatal(err)
return
}
log.Println("HTTP Endpoint Used", response.Endpoint)
}package main
import (
"context"
"github.com/ctreminiom/go-atlassian/v2/jira/v2"
_ "github.com/ctreminiom/go-atlassian/v2/jira/v3"
"log"
"os"
"path/filepath"
)
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)
absolutePath, err := filepath.Abs("jira/mocks/image.png")
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()
var (
issueKeyOrID = "KP-2"
fileName = "image-mock-00.png"
)
attachments, response, err := atlassian.Issue.Attachment.Add(context.Background(), issueKeyOrID, fileName, reader)
if err != nil {
log.Fatal(err)
return
}
log.Println("Response HTTP Code", response.Code)
log.Println("HTTP Endpoint Used", response.Endpoint)
log.Printf("We've found %v attachments", len(attachments))
for _, attachment := range attachments {
log.Println(attachment.ID, attachment.Filename)
}
}package main
import (
"context"
"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")
)
atlassian, err := v2.New(nil, host)
if err != nil {
return
}
atlassian.Auth.SetBasicAuth(mail, token)
attachmentMetadata, response, err := atlassian.Issue.Attachment.Metadata(context.Background(), "10016")
if err != nil {
log.Fatal(err)
}
response, err = atlassian.Issue.Attachment.Download(context.Background(), "10016", false)
if err != nil {
log.Fatal(err)
}
log.Println("Response HTTP Code", response.Code)
log.Println("HTTP Endpoint Used", response.Endpoint)
if err := os.WriteFile(attachmentMetadata.Filename, response.Bytes.Bytes(), 0666); err != nil {
log.Fatal(err)
}
}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)
fields, response, err := atlassian.Issue.Field.Gets(context.Background())
if err != nil {
log.Fatal(err)
return
}
log.Println("HTTP Endpoint Used", response.Endpoint)
for _, field := range fields {
log.Println(field)
}
}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)
fieldNewCreate := models.CustomFieldScheme{
Name: "Alliance 2",
Description: "this is the alliance description field",
FieldType: "cascadingselect",
SearcherKey: "cascadingselectsearcher",
}
field, response, err := atlassian.Issue.Field.Create(context.Background(), &fieldNewCreate)
if err != nil {
return
}
log.Println("HTTP Endpoint Used", response.Endpoint)
log.Println("field", field)
}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{
Types: []string{"custom"},
OrderBy: "lastUsed",
Expand: []string{"screensCount", "lastUsed"},
}
fields, response, err := atlassian.Issue.Field.Search(context.Background(), &options, 0, 50)
if err != nil {
log.Fatal(err)
return
}
log.Println("HTTP Endpoint Used", response.Endpoint)
log.Println(fields.IsLast, fields.Total, fields.MaxResults, fields.StartAt)
for _, field := range fields.Values {
log.Println(field.ID, field.Description)
}
}package main
import (
"context"
"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")
)
atlassian, err := v2.New(nil, host)
if err != nil {
return
}
atlassian.Auth.SetBasicAuth(mail, token)
task, response, err := atlassian.Issue.Field.Delete(context.Background(), "customfield_103034")
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
log.Println(task.Status, task.ID, task.Finished)
}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("----------------------")
}
}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)
}package main
import (
"context"
"fmt"
v2 "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)
fieldSchemes, response, err := atlassian.Issue.Field.Configuration.Scheme.Gets(context.Background(), nil, 0, 50)
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
for _, scheme := range fieldSchemes.Values {
fmt.Println("-------------------")
fmt.Println("ID ", scheme.ID)
fmt.Println("Name ", scheme.Name)
fmt.Println("Description ", scheme.Description)
}
}package main
import (
"context"
"fmt"
v2 "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)
schemeCreated, response, err := atlassian.Issue.Field.Configuration.Scheme.Create(context.Background(), "test", "")
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
fmt.Println("ID ", schemeCreated.ID)
fmt.Println("Name ", schemeCreated.Name)
fmt.Println("Description ", schemeCreated.Description)
}package main
import (
"context"
"fmt"
v2 "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)
items, response, err := atlassian.Issue.Field.Configuration.Scheme.Mapping(context.Background(), []int{10000}, 0, 50)
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
for _, item := range items.Values {
fmt.Println(item)
}
}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")
)
atlassian, err := v2.New(nil, host)
if err != nil {
return
}
atlassian.Auth.SetBasicAuth(mail, token)
items, response, err := atlassian.Issue.Field.Configuration.Scheme.Project(context.Background(), []int{10003}, 0, 50)
if err != nil {
log.Println(response.Bytes.String())
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
for _, item := range items.Values {
fmt.Println(item.ProjectIds)
fmt.Println(item.FieldConfigurationScheme)
}
}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)
payload := &models.FieldConfigurationSchemeAssignPayload{
FieldConfigurationSchemeID: "10000",
ProjectID: "10003",
}
response, err := atlassian.Issue.Field.Configuration.Scheme.Assign(context.Background(), payload)
if err != nil {
log.Println(response.Bytes.String())
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
}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.Configuration.Scheme.Update(context.Background(),10002, "test updated", "")
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
}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.Configuration.Scheme.Delete(context.Background(),10002)
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
}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)
payload := &models.FieldConfigurationToIssueTypeMappingPayloadScheme{
Mappings: []*models.FieldConfigurationToIssueTypeMappingScheme{
{
IssueTypeID: "10002",
FieldConfigurationID: "10003",
},
},
}
response, err := atlassian.Issue.Field.Configuration.Scheme.Link(context.Background(),10003, payload)
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
}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.Configuration.Scheme.Unlink(context.Background(),10003, []string{"10002"})
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
}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)
var fieldID = "customfield_10038"
options := models.FieldContextOptionsScheme{
IsAnyIssueType: false,
IsGlobalContext: false,
ContextID: nil,
}
contexts, response, err := atlassian.Issue.Field.Context.Gets(context.Background(), fieldID, &options, 0, 50)
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
log.Println(contexts)
for _, fieldContext := range contexts.Values {
log.Println(fieldContext)
}
}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)
var fieldID = "customfield_10038"
payload := models.FieldContextPayloadScheme{
IssueTypeIDs: []int{10004},
ProjectIDs: []int{10002},
Name: "Bug fields context $3 aaw",
Description: "A context used to define the custom field options for bugs.",
}
contextCreated, response, err := atlassian.Issue.Field.Context.Create(context.Background(), fieldID, &payload)
if err != nil {
log.Fatal(err)
return
}
log.Println("HTTP Endpoint Used", response.Endpoint)
log.Println(contextCreated)
}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)
var fieldID = "customfield_10038"
defaultValues, response, err := atlassian.Issue.Field.Context.GetDefaultValues(context.Background(), fieldID, nil, 0, 50)
if err != nil {
return
}
log.Println("HTTP Endpoint Used", response.Endpoint)
for _, value := range defaultValues.Values {
/*
For singleOption customField type, use value.OptionID
For multipleOption customField type, use value.OptionIDs
For cascadingOption customField type, use value.OptionID and value.CascadingOptionID
*/
log.Println(value)
}
}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)
var fieldID = "customfield_10038"
var payload = &models.FieldContextDefaultPayloadScheme{
DefaultValues: []*models.CustomFieldDefaultValueScheme{
{
ContextID: "10138",
OptionID: "10022",
Type: "option.single",
},
},
}
response, err := atlassian.Issue.Field.Context.SetDefaultValue(context.Background(), fieldID, payload)
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
}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)
var (
customFieldID = "customfield_10038"
contextID = 10140
newName = "New Context Name"
newDescription = "New Context Description"
)
response, err := atlassian.Issue.Field.Context.Update(context.Background(), customFieldID, contextID, newName, newDescription)
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
}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)
var (
customFieldID = "customfield_10038"
contextID = 10140
)
response, err := atlassian.Issue.Field.Context.Delete(context.Background(), customFieldID, contextID)
if err != nil {
log.Fatal(err)
return
}
log.Println("HTTP Endpoint Used", response.Endpoint)
}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)
var (
customFieldID = "customfield_10038"
contextID = 10180
issueTypesIDs = []string{"10007", "10002"}
)
response, err := atlassian.Issue.Field.Context.AddIssueTypes(context.Background(), customFieldID, contextID, issueTypesIDs)
if err != nil {
log.Fatal(err)
return
}
log.Println("HTTP Endpoint Used", response.Endpoint)
}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)
var (
customFieldID = "customfield_10038"
contextID = 10180
issueTypesIDs = []string{"10007", "10002"}
)
response, err := atlassian.Issue.Field.Context.RemoveIssueTypes(context.Background(), customFieldID, contextID, issueTypesIDs)
if err != nil {
return
}
log.Println("HTTP Endpoint Used", response.Endpoint)
}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)
var (
customFieldID = "customfield_10038"
contextID = 10179
projectIDs = []string{"10003"}
)
response, err := atlassian.Issue.Field.Context.Link(context.Background(), customFieldID, contextID, projectIDs)
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
}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)
var (
customFieldID = "customfield_10038"
contextID = 10179
projectIDs = []string{"10003"}
)
response, err := atlassian.Issue.Field.Context.UnLink(context.Background(), customFieldID, contextID, projectIDs)
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
}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)
var fieldID = "customfield_10038"
mapping, response, err := atlassian.Issue.Field.Context.ProjectsContext(context.Background(), fieldID, nil, 0, 50)
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
log.Println(mapping.Total)
}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)
var (
fieldID = "customfield_10038"
contextID = 10180
)
fieldOptions, response, err := atlassian.Issue.Field.Context.Option.Gets(context.Background(), fieldID, contextID, nil, 0, 50)
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
for _, option := range fieldOptions.Values {
log.Println(option)
}
}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)
var (
fieldID = "customfield_10038"
contextID = 10180
payload = &models.FieldContextOptionListScheme{
Options: []*models.CustomFieldContextOptionScheme{
// Single/Multiple Choice example
{
Value: "Option 3",
Disabled: false,
},
{
Value: "Option 4",
Disabled: false,
},
///////////////////////////////////////////
/*
// Cascading Choice example
{
OptionID: "1027",
Value: "Argentina",
Disabled: false,
},
{
OptionID: "1027",
Value: "Uruguay",
Disabled: false,
},
*/
}}
)
fieldOptions, response, err := atlassian.Issue.Field.Context.Option.Create(context.Background(), fieldID, contextID, payload)
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
for _, option := range fieldOptions.Options {
log.Println(option)
}
}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)
var (
fieldID = "customfield_10038"
contextID = 10180
payload = &models.FieldContextOptionListScheme{
Options: []*models.CustomFieldContextOptionScheme{
// Single/Multiple Choice example
{
ID: "10064",
Value: "Option 3 - Updated",
Disabled: false,
},
{
ID: "10065",
Value: "Option 4 - Updated",
Disabled: true,
},
///////////////////////////////////////////
/*
// Cascading Choice example
{
OptionID: "1027",
Value: "Argentina",
Disabled: false,
},
{
OptionID: "1027",
Value: "Uruguay",
Disabled: false,
},
*/
}}
)
fieldOptions, response, err := atlassian.Issue.Field.Context.Option.Update(context.Background(), fieldID, contextID, payload)
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
for _, option := range fieldOptions.Options {
log.Println(option)
}
}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)
var (
fieldID = "customfield_10038"
contextID, optionID = 10180, 10064
)
response, err := atlassian.Issue.Field.Context.Option.Delete(context.Background(), fieldID, contextID, optionID)
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
}package main
import (
"context"
"github.com/ctreminiom/go-atlassian/v2/jira/v2"
"github.com/ctreminiom/go-atlassian/pkg/infra/models"
"log"
"os"
"sort"
)
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)
var (
fieldID = "customfield_10038"
contextID = 10180
)
log.Println("Getting the field context options")
options, response, err := atlassian.Issue.Field.Context.Option.Gets(context.Background(), fieldID, contextID, nil, 0, 50)
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
var (
optionsAsMap = make(map[string]string)
optionsAsList []string
)
for _, option := range options.Values {
optionsAsList = append(optionsAsList, option.Value)
optionsAsMap[option.Value] = option.ID
}
log.Println("Sorting the fields")
sort.Strings(optionsAsList)
log.Println("Creating the new option ID's payload to order")
var optionsIDsAsList []string
for _, option := range optionsAsList {
optionsIDsAsList = append(optionsIDsAsList, optionsAsMap[option])
}
var payload = &models.OrderFieldOptionPayloadScheme{
Position: "First",
CustomFieldOptionIds: optionsIDsAsList,
}
log.Println("Ordering the options")
response, err = atlassian.Issue.Field.Context.Option.Order(context.Background(), fieldID, contextID, payload)
if err != nil {
if response != nil {
log.Println("HTTP Endpoint Used", response.Endpoint)
log.Fatal(err)
}
return
}
log.Println("HTTP Endpoint Used", response.Endpoint)
}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)
}
}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)
}
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)
}package main
import (
"context"
"fmt"
v2 "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")
)
instance, err := v2.New(nil, host)
if err != nil {
log.Fatal(err)
}
instance.Auth.SetBasicAuth(mail, token)
instance.Auth.SetUserAgent("curl/7.54.0")
remoteLinks, response, err := instance.Issue.Link.Remote.Gets(context.Background(), "KP-23", "")
if err != nil {
if response != nil {
log.Println(response.Bytes.String())
}
log.Fatal(err)
}
for _, remoteLink := range remoteLinks {
fmt.Println(remoteLink.ID)
}
}package main
import (
"context"
"fmt"
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")
)
instance, err := v2.New(nil, host)
if err != nil {
log.Fatal(err)
}
instance.Auth.SetBasicAuth(mail, token)
instance.Auth.SetUserAgent("curl/7.54.0")
payload := &models.RemoteLinkScheme{
Application: &models.RemoteLinkApplicationScheme{
Name: "My Acme Tracker",
Type: "com.acme.tracker",
},
GlobalID: "system=http://www.mycompany.com/support&id=1",
ID: 0,
Object: &models.RemoteLinkObjectScheme{
Icon: &models.RemoteLinkObjectLinkScheme{
Title: "Support Ticket",
URL16X16: "http://www.mycompany.com/support/ticket.png",
},
Status: &models.RemoteLinkObjectStatusScheme{
Icon: &models.RemoteLinkObjectLinkScheme{
Link: "http://www.mycompany.com/support?id=1&details=closed",
Title: "Case Closed",
URL16X16: "http://www.mycompany.com/support/resolved.png",
},
Resolved: true,
},
Summary: "Customer support issue",
Title: "TSTSUP-111",
URL: "http://www.mycompany.com/support?id=1",
},
Relationship: "causes",
}
remoteLink, response, err := instance.Issue.Link.Remote.Create(context.Background(), "KP-23", payload)
if err != nil {
if response != nil {
log.Println(response.Bytes.String())
}
log.Fatal(err)
}
fmt.Print(remoteLink.Self, remoteLink.ID)
}package main
import (
"context"
v2 "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")
)
instance, err := v2.New(nil, host)
if err != nil {
log.Fatal(err)
}
instance.Auth.SetBasicAuth(mail, token)
instance.Auth.SetUserAgent("curl/7.54.0")
response, err := instance.Issue.Link.Remote.DeleteById(context.Background(), "KP-23", "10001")
if err != nil {
if response != nil {
log.Println(response.Bytes.String())
}
log.Fatal(err)
}
}package main
import (
"context"
"fmt"
v2 "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")
)
instance, err := v2.New(nil, host)
if err != nil {
log.Fatal(err)
}
instance.Auth.SetBasicAuth(mail, token)
instance.Auth.SetUserAgent("curl/7.54.0")
remoteLink, response, err := instance.Issue.Link.Remote.Get(context.Background(), "KP-23", "10002")
if err != nil {
if response != nil {
log.Println(response.Bytes.String())
}
log.Fatal(err)
}
fmt.Println(remoteLink.ID, remoteLink.GlobalID)
}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")
)
instance, err := v2.New(nil, host)
if err != nil {
log.Fatal(err)
}
instance.Auth.SetBasicAuth(mail, token)
instance.Auth.SetUserAgent("curl/7.54.0")
payload := &models.RemoteLinkScheme{
Application: &models.RemoteLinkApplicationScheme{
Name: "My Acme Tracker",
Type: "com.acme.tracker",
},
GlobalID: "system=http://www.mycompany.com/support&id=1",
Object: &models.RemoteLinkObjectScheme{
Icon: &models.RemoteLinkObjectLinkScheme{
Title: "Support Ticket",
URL16X16: "http://www.mycompany.com/support/ticket.png",
},
Status: &models.RemoteLinkObjectStatusScheme{
Icon: &models.RemoteLinkObjectLinkScheme{
Link: "http://www.mycompany.com/support?id=1&details=closed",
Title: "Case Closed",
URL16X16: "http://www.mycompany.com/support/resolved.png",
},
Resolved: true,
},
Summary: "Customer support issue",
Title: "TSTSUP-111",
URL: "http://www.mycompany.com/support?id=1",
},
Relationship: "causes",
}
response, err := instance.Issue.Link.Remote.Update(context.Background(), "KP-23", "10001", payload)
if err != nil {
if response != nil {
log.Println(response.Bytes.String())
}
log.Fatal(err)
}
}package main
import (
"context"
v2 "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")
)
instance, err := v2.New(nil, host)
if err != nil {
log.Fatal(err)
}
instance.Auth.SetBasicAuth(mail, token)
instance.Auth.SetUserAgent("curl/7.54.0")
response, err := instance.Issue.Link.Remote.DeleteByGlobalId(context.Background(), "KP-23", "system=http://www.mycompany.com/support&id=1")
if err != nil {
if response != nil {
log.Println(response.Bytes.String())
}
log.Fatal(err)
}
}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)
payload := models.LinkTypeScheme{
Inward: "Clone/Duplicated by",
Name: "Clone/Duplicate",
Outward: "Clone/Duplicates",
}
issueLinkType, response, err := atlassian.Issue.Link.Type.Create(context.Background(), &payload)
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
log.Println(issueLinkType)
}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)
issueLinkType, response, err := atlassian.Issue.Link.Type.Get(context.Background(), "10000")
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
log.Println(issueLinkType)
}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)
payload := models.LinkTypeScheme{
Inward: "Clone/Duplicated by - Updated",
Name: "Clone/Duplicate - Updated",
Outward: "Clone/Duplicates - Updated",
}
issueLinkType, response, err := atlassian.Issue.Link.Type.Update(context.Background(), "10008", &payload)
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
log.Println(issueLinkType)
}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.Link.Type.Delete(context.Background(), "10008")
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
}package main
import (
"context"
"fmt"
"github.com/ctreminiom/go-atlassian/v2/jira/v2"
"log"
)
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)
issueTypeMappings, response, err := atlassian.Issue.Metadata.FetchIssueMappings(context.Background(), "KP", 0, 50)
if err != nil {
log.Println(response.Bytes.String())
log.Fatal(err)
}
fmt.Println(response.Endpoint)
for _, issueType := range issueTypeMappings.Get("issueTypes").Array() {
/*
{
"description": "An error in the code",
"iconUrl": "https://your-domain.atlassian.net/images/icons/issuetypes/bug.png",
"id": "1",
"name": "Bug",
"self": "https://your-domain.atlassian.net/rest/api/3/issueType/1",
"subtask": false
}
*/
fmt.Println(issueType.Get("description").String())
fmt.Println(issueType.Get("iconUrl").String())
fmt.Println(issueType.Get("id").String())
fmt.Println(issueType.Get("name").String())
fmt.Println(issueType.Get("self").String())
fmt.Println(issueType.Get("subtask").Bool())
fmt.Println("------------")
}
}package main
import (
"context"
"fmt"
"github.com/ctreminiom/go-atlassian/v2/jira/v2"
"log"
)
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)
fieldsMappings, response, err := atlassian.Issue.Metadata.FetchFieldMappings(context.Background(), "KP", "10001", 0, 50)
if err != nil {
log.Println(response.Bytes.String())
log.Fatal(err)
}
fmt.Println(response.Endpoint)
for _, fieldSchema := range fieldsMappings.Get("fields").Array() {
fmt.Println("fieldId", fieldSchema.Get("fieldId"))
fmt.Println("required", fieldSchema.Get("required"))
fmt.Println("name", fieldSchema.Get("name"))
fmt.Println("key", fieldSchema.Get("key"))
fmt.Println("autoCompleteUrl", fieldSchema.Get("autoCompleteUrl"))
fmt.Println("hasDefaultValue", fieldSchema.Get("hasDefaultValue"))
fmt.Println("operations", fieldSchema.Get("operations").String())
fmt.Println("schema.type", fieldSchema.Get("schema.type"))
fmt.Println("schema.system", fieldSchema.Get("schema.system"))
fmt.Println("schema.items", fieldSchema.Get("schema.items"))
fmt.Println("------------")
}
}package main
import (
"context"
"fmt"
v2 "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)
metadata, response, err := atlassian.Issue.Metadata.Get(context.Background(), "KP-1", false, false)
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
fields, response, err := atlassian.Issue.Field.Gets(context.Background())
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
for _, field := range fields {
path := fmt.Sprintf("fields.%v.required", field.ID)
value := metadata.Get(path)
if value.Exists() {
fmt.Println("Field Name:", field.Name, "Required?:", value.String())
}
}
}package main
import (
"context"
"fmt"
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 {
log.Fatal(err)
}
atlassian.Auth.SetBasicAuth(mail, token)
options := &models.IssueMetadataCreateOptions{
ProjectIDs: nil,
ProjectKeys: []string{"KP"},
IssueTypeIDs: nil,
IssueTypeNames: nil,
Expand: "",
}
metadata, response, err := atlassian.Issue.Metadata.Create(context.Background(), options)
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
fmt.Println(metadata)
}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)
var resolutionID = "10000"
resolution, response, err := atlassian.Issue.Resolution.Get(context.Background(), resolutionID)
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
log.Println(resolution)
}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)
var (
jql = "order by created DESC"
fields = []string{"status"}
expand = []string{"changelog", "renderedFields", "names", "schema", "transitions", "operations", "editmeta"}
)
issues, response, err := atlassian.Issue.Search.Post(context.Background(), jql, fields, expand, 0, 50, "")
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
log.Println(issues.Total)
}package main
import (
"context"
"fmt"
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 {
log.Fatal(err)
}
atlassian.Auth.SetBasicAuth(mail, token)
payload := &models.IssueSearchCheckPayloadScheme{
IssueIds: []int{10036},
JQLs: []string{"issuekey = KP-23"},
}
matches, response, err := atlassian.Issue.Search.Checks(context.Background(), payload)
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
for _, match := range matches.Matches {
fmt.Println(match)
}
}
package main
import (
"context"
"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.IssueTypeSchemePayloadScheme{
DefaultIssueTypeID: "10001",
IssueTypeIds: []string{"10001", "10002", "10005"},
Name: "Kanban Issue Type Scheme 1",
Description: "A collection of issue types suited to use in a kanban style project.",
}
issueTypeSchemeID, response, err := atlassian.Issue.Type.Scheme.Create(context.Background(), &payload)
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
log.Println("issueTypeSchemeID", issueTypeSchemeID)
}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)
items, response, err := atlassian.Issue.Type.Scheme.Items(context.Background(), nil, 0, 50)
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
for _, item := range items.Values {
log.Println(item)
}
}
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)
issueTypesSchemes, response, err := atlassian.Issue.Type.Scheme.Projects(context.Background(), []int{10000}, 0, 50)
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
for _, issueTypeScheme := range issueTypesSchemes.Values {
log.Println(issueTypeScheme.IssueTypeScheme.Name, issueTypeScheme.ProjectIds)
}
}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.Type.Scheme.Assign(context.Background(), "schemeID", "projectID")
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
}package main
import (
"context"
"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.IssueTypeSchemePayloadScheme{
Name: "Kanban Issue Type Scheme - UPDATED",
Description: "A collection of issue types suited to use in a kanban style project.- UPDATED",
}
response, err := atlassian.Issue.Type.Scheme.Update(context.Background(), 1000, &payload)
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
}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.Type.Scheme.Delete(context.Background(), 1001)
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
}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.Type.Scheme.Append(context.Background(), 10182, []int{10003, 10000})
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
}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.Type.Scheme.Remove(context.Background(), 10182, 10003)
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
}package main
import (
"context"
"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.IssueTypeScreenSchemePayloadScheme{
Name: "FX 2 Issue Type Screen Scheme",
IssueTypeMappings: []*models.IssueTypeScreenSchemeMappingPayloadScheme{
{
IssueTypeID: "default",
ScreenSchemeID: "10000",
},
{
IssueTypeID: "10004", // Bug
ScreenSchemeID: "10002",
},
},
}
issueTypeScreenSchemeID, response, err := atlassian.Issue.Type.ScreenScheme.Create(context.Background(), &payload)
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
log.Println(issueTypeScreenSchemeID)
}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)
mapping, response, err := atlassian.Issue.Type.ScreenScheme.Mapping(context.Background(), nil, 0, 50)
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
for _, item := range mapping.Values {
log.Println(item)
}
}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)
var (
issueTypeScreenSchemeID = "10002"
projectID = "10002"
)
response, err := atlassian.Issue.Type.ScreenScheme.Assign(context.Background(), issueTypeScreenSchemeID, projectID)
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
}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)
var (
issueTypeScreenSchemeID = "10002"
name = "FX Issue Type Screen Scheme - UPDATED"
description = ""
)
response, err := atlassian.Issue.Type.ScreenScheme.Update(context.Background(), issueTypeScreenSchemeID, name, description)
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
}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)
var (
issueTypeScreenSchemeID = "10004"
)
response, err := atlassian.Issue.Type.ScreenScheme.Delete(context.Background(), issueTypeScreenSchemeID)
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
}package main
import (
"context"
"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)
var payload = &models.IssueTypeScreenSchemePayloadScheme{
IssueTypeMappings: []*models.IssueTypeScreenSchemeMappingPayloadScheme{
{
IssueTypeID: "10000", // Epic Issue Type
ScreenSchemeID: "10002",
},
{
IssueTypeID: "10002", // Task Issue Type
ScreenSchemeID: "10002",
},
},
}
var issueTypeScreenSchemeID = "10005"
response, err := atlassian.Issue.Type.ScreenScheme.Append(context.Background(), issueTypeScreenSchemeID, payload)
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
}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)
var (
issueTypeScreenSchemeID = "10005"
screenSchemeID = "10002"
)
response, err := atlassian.Issue.Type.ScreenScheme.UpdateDefault(context.Background(), issueTypeScreenSchemeID, screenSchemeID)
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
}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)
var (
issueTypeScreenSchemeID = "10005"
issueTypesIDs = []string{"10002", "10000"}
)
response, err := atlassian.Issue.Type.ScreenScheme.Remove(context.Background(), issueTypeScreenSchemeID, issueTypesIDs)
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
}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.Watchers.Add(context.Background(), "KP-2")
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
}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.Watchers.Delete(context.Background(), "KP-2", "5b86be50b8e3cb5895860d6d")
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
}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 {
log.Fatal(err)
}
atlassian.Auth.SetBasicAuth(mail, token)
// V3 payload
/*
// Comment worklog
commentBody := models.CommentNodeScheme{}
commentBody.Version = 1
commentBody.Type = "doc"
//Create the Tables Headers
tableHeaders := &v3.CommentNodeScheme{
Type: "tableRow",
Content: []*v3.CommentNodeScheme{
{
Type: "tableHeader",
Content: []*v3.CommentNodeScheme{
{
Type: "paragraph",
Content: []*v3.CommentNodeScheme{
{
Type: "text",
Text: "Header 1",
Marks: []*v3.MarkScheme{
{
Type: "strong",
},
},
},
},
},
},
},
{
Type: "tableHeader",
Content: []*v3.CommentNodeScheme{
{
Type: "paragraph",
Content: []*v3.CommentNodeScheme{
{
Type: "text",
Text: "Header 2",
Marks: []*v3.MarkScheme{
{
Type: "strong",
},
},
},
},
},
},
},
{
Type: "tableHeader",
Content: []*v3.CommentNodeScheme{
{
Type: "paragraph",
Content: []*v3.CommentNodeScheme{
{
Type: "text",
Text: "Header 3",
Marks: []*v3.MarkScheme{
{
Type: "strong",
},
},
},
},
},
},
},
},
}
row1 := &v3.CommentNodeScheme{
Type: "tableRow",
Content: []*v3.CommentNodeScheme{
{
Type: "tableCell",
Content: []*v3.CommentNodeScheme{
{
Type: "paragraph",
Content: []*v3.CommentNodeScheme{
{Type: "text", Text: "Row 00"},
},
},
},
},
{
Type: "tableCell",
Content: []*v3.CommentNodeScheme{
{
Type: "paragraph",
Content: []*v3.CommentNodeScheme{
{Type: "text", Text: "Row 01"},
},
},
},
},
{
Type: "tableCell",
Content: []*v3.CommentNodeScheme{
{
Type: "paragraph",
Content: []*v3.CommentNodeScheme{
{Type: "text", Text: "Row 02"},
},
},
},
},
},
}
row2 := &v3.CommentNodeScheme{
Type: "tableRow",
Content: []*v3.CommentNodeScheme{
{
Type: "tableCell",
Content: []*v3.CommentNodeScheme{
{
Type: "paragraph",
Content: []*v3.CommentNodeScheme{
{Type: "text", Text: "Row 10"},
},
},
},
},
{
Type: "tableCell",
Content: []*v3.CommentNodeScheme{
{
Type: "paragraph",
Content: []*v3.CommentNodeScheme{
{Type: "text", Text: "Row 11"},
},
},
},
},
{
Type: "tableCell",
Content: []*v3.CommentNodeScheme{
{
Type: "paragraph",
Content: []*v3.CommentNodeScheme{
{Type: "text", Text: "Row 12"},
},
},
},
},
},
}
commentBody.AppendNode(&v3.CommentNodeScheme{
Type: "table",
Attrs: map[string]interface{}{"isNumberColumnEnabled": false, "layout": "default"},
Content: []*v3.CommentNodeScheme{tableHeaders, row1, row2},
})
var options = &v3.WorklogOptionsScheme{
Notify: true,
AdjustEstimate: "auto",
ReduceBy: "3h",
//OverrideEditableFlag: true,
Expand: []string{"expand", "properties"},
Payload: &v3.WorklogPayloadScheme{
Comment: &commentBody,
Visibility: &jira.IssueWorklogVisibilityScheme{
Type: "group",
Value: "jira-users",
},
Started: "2021-07-16T07:01:10.774+0000",
TimeSpentSeconds: 12000,
},
}
*/
options := &models.WorklogOptionsScheme{
Notify: false,
AdjustEstimate: "",
NewEstimate: "",
ReduceBy: "",
OverrideEditableFlag: false,
Expand: nil,
}
payload := &models.WorklogPayloadSchemeV2{
Comment: &models.CommentPayloadSchemeV2{
Visibility: nil,
Body: "test",
},
Visibility: nil,
Started: "2021-07-16T07:01:10.774+0000",
TimeSpentSeconds: 12000,
}
worklog, response, err := atlassian.Issue.Worklog.Add(context.Background(), "KP-1", payload, options)
if err != nil {
log.Println(response.Endpoint, response.Code)
log.Fatal(err)
}
log.Println(response.Endpoint, response.Code)
log.Println(worklog.ID, worklog.IssueID)
}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)
var (
ctx = context.Background()
key = "KP-1"
worklogID = "10000"
expand = []string{"all"}
)
worklog, response, err := atlassian.Issue.Worklog.Get(ctx, key, worklogID, expand)
if err != nil {
log.Fatal(err)
}
log.Println(response.Endpoint, response.Code)
log.Println(worklog.ID, worklog.Self)
}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 {
log.Fatal(err)
}
atlassian.Auth.SetBasicAuth(mail, token)
/*
// Comment worklog
commentBody := v3.CommentNodeScheme{}
commentBody.Version = 1
commentBody.Type = "doc"
//Create the Tables Headers
tableHeaders := &v3.CommentNodeScheme{
Type: "tableRow",
Content: []*v3.CommentNodeScheme{
{
Type: "tableHeader",
Content: []*v3.CommentNodeScheme{
{
Type: "paragraph",
Content: []*v3.CommentNodeScheme{
{
Type: "text",
Text: "Header 1",
Marks: []*v3.MarkScheme{
{
Type: "strong",
},
},
},
},
},
},
},
{
Type: "tableHeader",
Content: []*v3.CommentNodeScheme{
{
Type: "paragraph",
Content: []*v3.CommentNodeScheme{
{
Type: "text",
Text: "Header 2",
Marks: []*v3.MarkScheme{
{
Type: "strong",
},
},
},
},
},
},
},
{
Type: "tableHeader",
Content: []*v3.CommentNodeScheme{
{
Type: "paragraph",
Content: []*v3.CommentNodeScheme{
{
Type: "text",
Text: "Header 3",
Marks: []*v3.MarkScheme{
{
Type: "strong",
},
},
},
},
},
},
},
},
}
row1 := &v3.CommentNodeScheme{
Type: "tableRow",
Content: []*v3.CommentNodeScheme{
{
Type: "tableCell",
Content: []*v3.CommentNodeScheme{
{
Type: "paragraph",
Content: []*v3.CommentNodeScheme{
{Type: "text", Text: "Row 00"},
},
},
},
},
{
Type: "tableCell",
Content: []*v3.CommentNodeScheme{
{
Type: "paragraph",
Content: []*v3.CommentNodeScheme{
{Type: "text", Text: "Row 01"},
},
},
},
},
{
Type: "tableCell",
Content: []*v3.CommentNodeScheme{
{
Type: "paragraph",
Content: []*v3.CommentNodeScheme{
{Type: "text", Text: "Row 02"},
},
},
},
},
},
}
row2 := &v3.CommentNodeScheme{
Type: "tableRow",
Content: []*v3.CommentNodeScheme{
{
Type: "tableCell",
Content: []*v3.CommentNodeScheme{
{
Type: "paragraph",
Content: []*v3.CommentNodeScheme{
{Type: "text", Text: "Row 10"},
},
},
},
},
{
Type: "tableCell",
Content: []*v3.CommentNodeScheme{
{
Type: "paragraph",
Content: []*v3.CommentNodeScheme{
{Type: "text", Text: "Row 11"},
},
},
},
},
{
Type: "tableCell",
Content: []*v3.CommentNodeScheme{
{
Type: "paragraph",
Content: []*v3.CommentNodeScheme{
{Type: "text", Text: "Row 12"},
},
},
},
},
},
}
commentBody.AppendNode(&v3.CommentNodeScheme{
Type: "table",
Attrs: map[string]interface{}{"isNumberColumnEnabled": false, "layout": "default"},
Content: []*v3.CommentNodeScheme{tableHeaders, row1, row2},
})
var options = &v3.WorklogOptionsScheme{
Notify: true,
AdjustEstimate: "auto",
ReduceBy: "3h",
//OverrideEditableFlag: true,
Expand: []string{"expand", "properties"},
Payload: &v3.WorklogPayloadScheme{
Comment: &commentBody,
Visibility: &jira.IssueWorklogVisibilityScheme{
Type: "group",
Value: "jira-users",
},
Started: "2021-07-16T07:01:10.774+0000",
TimeSpentSeconds: 12000,
},
}
*/
options := &models.WorklogOptionsScheme{
Notify: true,
AdjustEstimate: "auto",
ReduceBy: "3h",
OverrideEditableFlag: false,
Expand: nil,
}
payload := &models.WorklogPayloadSchemeV2{
Comment: &models.CommentPayloadSchemeV2{
Visibility: nil,
Body: "test",
},
Visibility: nil,
Started: "2021-07-16T07:01:10.774+0000",
TimeSpentSeconds: 12000,
}
worklog, response, err := atlassian.Issue.Worklog.Update(context.Background(), "KP-1", "10000", payload, options)
if err != nil {
log.Println(response.Endpoint, response.Code)
log.Fatal(err)
}
log.Println(response.Endpoint, response.Code)
log.Println(worklog.ID, worklog.IssueID)
}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)
response, err := atlassian.Issue.Worklog.Delete(context.Background(), "KP-1", "10000", nil)
if err != nil {
log.Println(response.Endpoint, response.Code)
log.Fatal(err)
}
log.Println(response.Endpoint, response.Code)
}
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)
result, response, err := atlassian.Issue.Worklog.Deleted(context.Background(), 0)
if err != nil {
log.Println(response.Endpoint, response.Code)
log.Fatal(err)
}
log.Println(response.Endpoint, response.Code)
log.Println(result)
}
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)
var (
worklogsIDs = []int{10000}
expand = []string{"all"}
)
worklogs, response, err := atlassian.Issue.Worklog.Gets(context.Background(), worklogsIDs, expand)
if err != nil {
log.Fatal(err)
}
log.Println(response.Endpoint, response.Code)
for _, worklog := range worklogs {
log.Println(worklog)
}
}
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)
result, response, err := atlassian.Issue.Worklog.Updated(context.Background(), 0, nil)
if err != nil {
log.Println(response.Endpoint, response.Code)
log.Fatal(err)
}
log.Println(response.Endpoint, response.Code)
log.Println(result)
}package main
import (
"context"
"fmt"
v2 "github.com/ctreminiom/go-atlassian/v2/jira/v2"
_ "github.com/ctreminiom/go-atlassian/v2/jira/v3"
"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)
property, response, err := atlassian.Issue.Property.Get(context.Background(), "KP-3", "property-key")
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
switch value := property.Value.(type) {
case string:
fmt.Println(value)
case int:
fmt.Println(value)
case map[string]interface{}:
for key, mapValue := range value {
fmt.Println(key, mapValue)
}
default:
fmt.Printf("I don't know about type %T!\n", value)
}
}package main
import (
"context"
v2 "github.com/ctreminiom/go-atlassian/v2/jira/v2"
_ "github.com/ctreminiom/go-atlassian/v2/jira/v3"
"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 := `{
"number": 5,
"string": "string-value"
}`
response, err := atlassian.Issue.Property.Set(context.Background(), "KP-3", "property-key", &payload)
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
}package main
import (
"context"
v2 "github.com/ctreminiom/go-atlassian/v2/jira/v2"
_ "github.com/ctreminiom/go-atlassian/v2/jira/v3"
"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.Property.Delete(context.Background(), "KP-3", "property-key")
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
}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)
}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)
}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)
}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.ScreenSchemePayloadScheme{
Screens: &models.ScreenTypesScheme{
Default: 10000,
View: 10000,
Edit: 10000,
},
Name: "FX | Epic Screen Scheme",
Description: "sample description",
}
newScreenScheme, response, err := atlassian.Screen.Scheme.Create(context.Background(), payload)
if err != nil {
log.Fatal(err)
}
log.Println("Response HTTP Code", response.Code)
log.Println("HTTP Endpoint Used", response.Endpoint)
log.Printf("The new screen scheme has been created with the ID %v", newScreenScheme.ID)
}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.ScreenSchemePayloadScheme{
Screens: &models.ScreenTypesScheme{
Default: 10001,
View: 10000,
Edit: 10000,
},
Name: "FX | Epic Screen Scheme - UPDATED",
Description: "sample description - UPDATED",
}
response, err := atlassian.Screen.Scheme.Update(context.Background(), "10005", payload)
if err != nil {
log.Fatal(err)
}
log.Println("Response HTTP Code", response.Code)
log.Println("HTTP Endpoint Used", response.Endpoint)
}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)
response, err := atlassian.Screen.Scheme.Delete(context.Background(), "10005")
if err != nil {
log.Fatal(err)
}
log.Println("Response HTTP Code", response.Code)
log.Println("HTTP Endpoint Used", response.Endpoint)
}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)
}
}package main
import (
"context"
"fmt"
"github.com/ctreminiom/go-atlassian/v2/jira/v2"
"github.com/ctreminiom/go-atlassian/pkg/infra/models"
"github.com/google/uuid"
"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)
newFilterBody := models.FilterPayloadScheme{
Name: fmt.Sprintf("Filter #%v", uuid.New().String()),
Description: "Filter's description",
JQL: "issuetype = Bug",
Favorite: false,
SharePermissions: []*models.SharePermissionScheme{
{
Type: "project",
Project: &models.ProjectScheme{
ID: "10000",
},
Role: nil,
Group: nil,
},
{
Type: "group",
Group: &models.GroupScheme{Name: "jira-administrators"},
},
},
}
filter, response, err := atlassian.Filter.Create(context.Background(), &newFilterBody)
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
log.Printf("The filter has been created: %v - %v", filter.ID, filter.Name)
}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)
filters, response, err := atlassian.Filter.Favorite(context.Background())
if err != nil {
return
}
log.Println("HTTP Endpoint Used", response.Endpoint)
log.Println("favorite filters", len(filters))
for _, filter := range filters {
log.Println(filter)
}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)
myFilters, response, err := atlassian.Filter.My(context.Background(), false, []string{"sharedUsers", "subscriptions"})
if err != nil {
log.Fatal(err)
}
log.Println("Response HTTP Code", response.Code)
log.Println("HTTP Endpoint Used", response.Endpoint)
log.Println("my filters", len(myFilters))
for _, filter := range myFilters {
log.Println(filter.ID)
for _, shareUser := range filter.ShareUsers.Items {
log.Println(shareUser.Name, shareUser.DisplayName)
}
for _, subscription := range filter.Subscriptions.Items {
log.Println(subscription.ID)
}
}
}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() {
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.FilterSearchOptionScheme{
Name: "",
AccountID: "",
Group: "",
ProjectID: 0,
IDs: nil,
OrderBy: "description",
Expand: nil,
}
filters, response, err := atlassian.Filter.Search(context.Background(), &options, 0, 10)
if err != nil {
if response != nil {
log.Println("HTTP Endpoint Used", response.Endpoint)
}
return
}
log.Println("HTTP Endpoint Used", response.Endpoint)
log.Println("Filters found", len(filters.Values))
}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)
filter, response, err := atlassian.Filter.Get(context.Background(), 1, nil)
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
log.Println("Get Filter result", filter.Name, filter.Name)
}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() {
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.FilterPayloadScheme{
JQL: "issuetype = Story",
}
filter, response, err := atlassian.Filter.Update(context.Background(), 1, &payload)
if err != nil {
return
}
log.Println("HTTP Endpoint Used", response.Endpoint)
log.Println("new JQL filter value", filter.Jql)
}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)
response, err := atlassian.Filter.Delete(context.Background(), 1)
if err != nil {
return
}
log.Println("HTTP Endpoint Used", response.Endpoint)
}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)
response, err := atlassian.Filter.Change(context.Background(), 1, "asda03333")
if err != nil {
return
}
log.Println("HTTP Endpoint Used", response.Endpoint)
}
// The CustomFields struct is used on the Create(s), Edit methods
var customFields = jira.CustomFields{}
//Groups Picker customfield
err = customFields.Groups("customfield_10052", []string{"jira-administrators", "jira-administrators-system"})
if err != nil {
log.Fatal(err)
}
//Number customfield
err = customFields.Number("customfield_10043", 1000.3232)
if err != nil {
log.Fatal(err)
}
//User picker customfield
err = customFields.User("customfield_10044", "92c50fd7-4336-4761-abbc-bdd31ecbc380")
if err != nil {
log.Fatal(err)
}
//Users picker customfield
err = customFields.Users("customfield_10045", []string{"727b5300-78dc-4b92-961b-082676dea3f2", "697c6d52-993d-4ae3-84b2-1842bdb5b7c0"})
if err != nil {
log.Fatal(err)
}
//Group picker customfield
err = customFields.Group("customfield_10046", "scrum-masters")
if err != nil {
log.Fatal(err)
}
//URL customfield
err = customFields.URL("customfield_10047", "https://docs.go-atlassian.io/jira-software-cloud/issues")
if err != nil {
log.Fatal(err)
}
//Text customfield
err = customFields.Text("customfield_10048", "sample text")
if err != nil {
log.Fatal(err)
}
//Date customfield
err = customFields.Date("customfield_10049", time.Now().AddDate(0, -1, 0))
if err != nil {
log.Fatal(err)
}
//DateTime customfield
err = customFields.DateTime("customfield_10050", time.Now())
if err != nil {
log.Fatal(err)
}
//Select customfield
err = customFields.Select("customfield_10051", "Option 1")
if err != nil {
log.Fatal(err)
}
//MultiSelect customfield
err = customFields.MultiSelect("customfield_10052", []string{"Option 1", "Option 2", "Option 3"})
if err != nil {
log.Fatal(err)
}
//RadioButton customfield
err = customFields.RadioButton("customfield_10053", "Option 1")
if err != nil {
log.Fatal(err)
}
//CheckBox customfield
err = customFields.CheckBox("customfield_10054", []string{"Option 1", "Option 2"})
if err != nil {
log.Fatal(err)
}
//Cascading customfield
err = customFields.Cascading("customfield_10056", "America", "Costa Rica")
if err != nil {
log.Fatal(err)
}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 {
log.Fatal(err)
}
atlassian.Auth.SetBasicAuth(mail, token)
var payload = models.IssueSchemeV2{
Fields: &models.IssueFieldsSchemeV2{
Summary: "New summary test",
Project: &models.ProjectScheme{ID: "10000"},
IssueType: &models.IssueTypeScheme{Name: "Story"},
},
}
//CustomFields
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)
}
newIssue, response, err := atlassian.Issue.Create(context.Background(), &payload, &customFields)
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
log.Printf("The new issue %v has been created with the ID %v", newIssue.Key, newIssue.ID)
}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)
//CustomFields
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)
}
var issue1 = models.IssueBulkSchemeV2{
Payload: &models.IssueSchemeV2{
Fields: &models.IssueFieldsSchemeV2{
Summary: "New summary test",
Project: &models.ProjectScheme{ID: "10000"},
IssueType: &models.IssueTypeScheme{Name: "Story"},
},
},
CustomFields: &customFields,
}
var issue2 = models.IssueBulkSchemeV2{
Payload: &models.IssueSchemeV2{
Fields: &models.IssueFieldsSchemeV2{
Summary: "New summary test",
Project: &models.ProjectScheme{ID: "10000"},
IssueType: &models.IssueTypeScheme{Name: "Story"},
},
},
CustomFields: &customFields,
}
var issue3 = models.IssueBulkSchemeV2{
Payload: &models.IssueSchemeV2{
Fields: &models.IssueFieldsSchemeV2{
Summary: "New summary test",
Project: &models.ProjectScheme{ID: "10000"},
IssueType: &models.IssueTypeScheme{Name: "Story"},
},
},
CustomFields: &customFields,
}
var payload []*models.IssueBulkSchemeV2
payload = append(payload, &issue1, &issue2, &issue3)
newIssues, response, err := atlassian.Issue.Creates(context.Background(), payload)
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
for _, issue := range newIssues.Issues {
log.Printf(issue.Key)
}
for _, apiError := range newIssues.Errors {
log.Println(apiError.Status, apiError.Status)
}
}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)
issue, response, err := atlassian.Issue.Get(context.Background(), "KP-2", nil, []string{"transitions"})
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
log.Println(issue.Key)
log.Println(issue.Fields.Reporter.AccountID)
for _, transition := range issue.Transitions {
log.Println(transition.Name, transition.ID, transition.To.ID, transition.HasScreen)
}
// Check if the issue contains sub-tasks
if issue.Fields.Subtasks != nil {
for _, subTask := range issue.Fields.Subtasks {
log.Println("Sub-Task: ", subTask.Key, subTask.Fields.Summary)
}
}
}var payload = jira.IssueScheme{
Fields: &jira.IssueFieldsScheme{
Summary: "New summary test test",
},
}//Issue Update Operations
var operations = &jira.UpdateOperations{}
err = operations.AddArrayOperation("custom_field_id", map[string]string{
"value": "verb",
"value": "verb",
"value": "verb",
"value": "verb",
})
if err != nil {
log.Fatal(err)
}
// If the need to add multi-array customfields, you can the following method:
// In this particular example, we're going to the manipulate the fixVersions field.
err = operations.AddMultiRawOperation("fixVersions", []map[string]interface{}{
{
"remove": map[string]interface{}{
"name": "Version 00",
},
},
{
"remove": map[string]interface{}{
"name": "Version 101",
},
},
{
"add": map[string]interface{}{
"name": "Version 301",
},
},
})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)
var payload = models.IssueSchemeV2{
Fields: &models.IssueFieldsSchemeV2{
// Summary: "New summary test",
},
}
//CustomFields
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", 9000)
if err != nil {
log.Fatal(err)
}
//Issue Update Operations
var operations = &models.UpdateOperations{}
err = operations.AddArrayOperation("labels", map[string]string{
"triaged": "remove",
"triaged-2": "remove",
"triaged-1": "remove",
"blocker": "remove",
})
if err != nil {
log.Fatal(err)
}
err = operations.AddStringOperation("summary", "set", "new summary using operation")
if err != nil {
log.Fatal(err)
}
response, err := atlassian.Issue.Update(context.Background(), "KP-2", false, &payload, &customFields, operations)
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
}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.Delete(context.Background(), "KP-6", false)
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
}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.Assign(context.Background(), "KP-2", "bedc0e56-c9d1-4f5d-b380-cbced9125849")
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
}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)
var userRecipients []*models.IssueNotifyUserScheme
userRecipients = append(userRecipients, &models.IssueNotifyUserScheme{AccountID: "87dde939-73be-465f-83c5-2217fb9dd9de"})
userRecipients = append(userRecipients, &models.IssueNotifyUserScheme{AccountID: "8abc0d5f-5eb9-48af-bd8d-b83451828a40"})
var groupsRecipients []*models.IssueNotifyGroupScheme
groupsRecipients = append(groupsRecipients, &models.IssueNotifyGroupScheme{Name: "jira-users"})
groupsRecipients = append(groupsRecipients, &models.IssueNotifyGroupScheme{Name: "scrum-masters"})
opts := &models.IssueNotifyOptionsScheme{
// The HTML body of the email notification for the issue.
HTMLBody: "The <strong>latest</strong> test results for this ticket are now available.",
// The subject of the email notification for the issue.
// If this is not specified, then the subject is set to the issue key and summary.
Subject: "SUBJECT EMAIL EXAMPLE",
// The plain text body of the email notification for the issue.
// TextBody: "lorem",
// The recipients of the email notification for the issue.
To: &models.IssueNotifyToScheme{
Reporter: true,
Assignee: true,
Watchers: true,
Voters: true,
Users: userRecipients,
Groups: groupsRecipients,
},
// Restricts the notifications to users with the specified permissions.
Restrict: nil,
}
response, err := atlassian.Issue.Notify(context.Background(), "KP-2", opts)
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
}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)
transitions, response, err := atlassian.Issue.Transitions(context.Background(), "KP-2")
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
for _, transition := range transitions.Transitions {
log.Println(transition.ID, transition.Name)
}
}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)
var payload = &models.IssueSchemeV2{
Fields: &models.IssueFieldsSchemeV2{
Summary: "New summary test test",
Resolution: &models.ResolutionScheme{
Name: "Done",
},
},
}
//CustomFields
var customFields = &models.CustomFields{}
err = customFields.Groups("customfield_10052", []string{"jira-administrators", "jira-administrators-system"})
if err != nil {
log.Fatal(err)
}
//Issue Update Operations
var operations = &models.UpdateOperations{}
err = operations.AddArrayOperation("labels", map[string]string{
"triaged": "add",
"triaged-2": "add",
"triaged-1": "add",
"blocker": "add",
})
if err != nil {
log.Fatal(err)
}
options := &models.IssueMoveOptionsV2{
Fields: payload,
Operations: operations,
CustomFields: customFields,
}
response, err := atlassian.Issue.Move(context.Background(), "KP-7", "41", options)
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
}commentBody := jira.CommentNodeScheme{}
commentBody.Version = 1
commentBody.Type = "doc"
//Append Header
commentBody.AppendNode(&jira.CommentNodeScheme{
Type: "heading",
Attrs: map[string]interface{}{"level": 1},
Content: []*jira.CommentNodeScheme{
{
Type: "text",
Text: "Header 1",
},
},
})var (
jql = "order by created DESC"
fields = []string{"status"}
expand = []string{"changelog", "renderedFields", "names", "schema", "transitions", "operations", "editmeta"}
)
issues, response, err := atlassian.Issue.Search.Post(context.Background(), jql, fields, expand, 0, 50, "")
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
log.Println(issues.Total)package main
import (
"context"
"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")
)
atlassianV2, err := v2.New(nil, host)
if err != nil {
return
}
atlassianV2.Auth.SetBasicAuth(mail, token)
richTextComments, response, err := atlassianV2.Issue.Comment.Gets(context.Background(), "KP-2", "", nil, 0, 50)
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
for _, comment := range richTextComments.Comments {
log.Println(comment.ID, comment.Created, comment.Body)
}
atlassianV3, err := v3.New(nil, host)
if err != nil {
return
}
atlassianV3.Auth.SetBasicAuth(mail, token)
adfComments, response, err := atlassianV3.Issue.Comment.Gets(context.Background(), "KP-2", "", nil, 0, 50)
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
for _, adfComment := range adfComments.Comments {
log.Println(adfComment.Body.Type)
}
}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)
comment, response, err := atlassian.Issue.Comment.Get(context.Background(), "KP-2", "10011")
if err != nil {
log.Fatal(err)
}
log.Println(response.Endpoint)
log.Println(comment.ID, comment.Created)
}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.Comment.Delete(context.Background(), "KP-2", "10011")
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
}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)
atlassian.Auth.SetUserAgent("curl/7.54.0")
payload := &models.CommentPayloadSchemeV2{
Body: "test",
}
newComment, response, err := atlassian.Issue.Comment.Add(context.Background(), "KP-2", payload, nil)
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
log.Println(newComment.ID)
} commentBody := jira.CommentNodeScheme{}
commentBody.Version = 1
commentBody.Type = "doc"
//Append Header
commentBody.AppendNode(&jira.CommentNodeScheme{
Type: "heading",
Attrs: map[string]interface{}{"level": 1},
Content: []*jira.CommentNodeScheme{
{
Type: "text",
Text: "Header 1",
},
},
})
//Append Lorem text
commentBody.AppendNode(&jira.CommentNodeScheme{
Type: "paragraph",
Content: []*jira.CommentNodeScheme{
{
Type: "text",
Text: "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore " +
"et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip " +
"ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore " +
"eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui " +
"officia deserunt mollit anim id est laborum",
},
},
})
//Append Nested Panel Data
commentBody.AppendNode(&jira.CommentNodeScheme{
Type: "panel",
Attrs: map[string]interface{}{"panelType":"note"},
Content: []*jira.CommentNodeScheme{
{
Type: "paragraph",
Content: []*jira.CommentNodeScheme{
{
Type: "text",
Text: "Excepteur ",
Marks: []*jira.MarkScheme{
{Type: "textColor", Attrs: map[string]interface{}{"color":"#6554c0"}},
},
},
{
Type: "text",
Text: "sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum",
},
},
},
},
})
//Append Heading Title
commentBody.AppendNode(&jira.CommentNodeScheme{
Type: "heading",
Attrs: map[string]interface{}{"level": 2},
Content: []*jira.CommentNodeScheme{
{
Type: "text",
Text: "Links",
},
},
})
//Append bulletList
commentBody.AppendNode(&jira.CommentNodeScheme{
Type: "bulletList",
Content: []*jira.CommentNodeScheme{
{
Type: "listItem",
Content: []*jira.CommentNodeScheme{
{
Type: "paragraph",
Content: []*jira.CommentNodeScheme{
{
Type: "text",
Text: "Google.com",
Marks: []*jira.MarkScheme{
{
Type: "link",
Attrs: map[string]interface{}{"href": "https://www.google.com/"},
},
},
},
},
},
},
},
{
Type: "listItem",
Content: []*jira.CommentNodeScheme{
{
Type: "paragraph",
Content: []*jira.CommentNodeScheme{
{
Type: "text",
Text: "Facebook.com",
Marks: []*jira.MarkScheme{
{
Type: "link",
Attrs: map[string]interface{}{"href": "https://www.facebook.com/"},
},
},
},
},
},
},
},
},
}) commentBody := jira.CommentNodeScheme{}
commentBody.Version = 1
commentBody.Type = "doc"
//Create the Tables Headers
tableHeaders := &jira.CommentNodeScheme{
Type: "tableRow",
Content: []*jira.CommentNodeScheme{
{
Type: "tableHeader",
Content: []*jira.CommentNodeScheme{
{
Type: "paragraph",
Content: []*jira.CommentNodeScheme{
{
Type: "text",
Text: "Header 1",
Marks: []*jira.MarkScheme{
{
Type: "strong",
},
},
},
},
},
},
},
{
Type: "tableHeader",
Content: []*jira.CommentNodeScheme{
{
Type: "paragraph",
Content: []*jira.CommentNodeScheme{
{
Type: "text",
Text: "Header 2",
Marks: []*jira.MarkScheme{
{
Type: "strong",
},
},
},
},
},
},
},
{
Type: "tableHeader",
Content: []*jira.CommentNodeScheme{
{
Type: "paragraph",
Content: []*jira.CommentNodeScheme{
{
Type: "text",
Text: "Header 3",
Marks: []*jira.MarkScheme{
{
Type: "strong",
},
},
},
},
},
},
},
},
}
row1 := &jira.CommentNodeScheme{
Type: "tableRow",
Content: []*jira.CommentNodeScheme{
{
Type: "tableCell",
Content: []*jira.CommentNodeScheme{
{
Type: "paragraph",
Content: []*jira.CommentNodeScheme{
{Type: "text", Text: "Row 00"},
},
},
},
},
{
Type: "tableCell",
Content: []*jira.CommentNodeScheme{
{
Type: "paragraph",
Content: []*jira.CommentNodeScheme{
{Type: "text", Text: "Row 01"},
},
},
},
},
{
Type: "tableCell",
Content: []*jira.CommentNodeScheme{
{
Type: "paragraph",
Content: []*jira.CommentNodeScheme{
{Type: "text", Text: "Row 02"},
},
},
},
},
},
}
row2 := &jira.CommentNodeScheme{
Type: "tableRow",
Content: []*jira.CommentNodeScheme{
{
Type: "tableCell",
Content: []*jira.CommentNodeScheme{
{
Type: "paragraph",
Content: []*jira.CommentNodeScheme{
{Type: "text", Text: "Row 10"},
},
},
},
},
{
Type: "tableCell",
Content: []*jira.CommentNodeScheme{
{
Type: "paragraph",
Content: []*jira.CommentNodeScheme{
{Type: "text", Text: "Row 11"},
},
},
},
},
{
Type: "tableCell",
Content: []*jira.CommentNodeScheme{
{
Type: "paragraph",
Content: []*jira.CommentNodeScheme{
{Type: "text", Text: "Row 12"},
},
},
},
},
},
}
commentBody.AppendNode(&jira.CommentNodeScheme{
Type: "table",
Attrs: map[string]interface{}{"isNumberColumnEnabled": false, "layout": "default"},
Content: []*jira.CommentNodeScheme{tableHeaders, row1, row2},
})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 {
log.Fatal(err)
}
atlassian.Auth.SetBasicAuth(mail, token)
// Payload for the package v3 ---> ADF Format sample
/*
payloadADF := &models.LinkPayloadSchemeV3{
Comment: &models.CommentPayloadScheme{
Body: &models.CommentNodeScheme{
Version: 1,
Type: "doc",
Content: []*models.CommentNodeScheme{
{
Type: "paragraph",
Content: []*models.CommentNodeScheme{
{
Type: "text",
Text: "Carlos Test",
},
{
Type: "emoji",
Attrs: map[string]interface{}{
"shortName": ":grin",
"id": "1f601",
"text": "😁",
},
},
{
Type: "text",
Text: " ",
},
},
},
},
},
},
InwardIssue: &models.LinkedIssueScheme{
Key: "KP-1",
},
OutwardIssue: &models.LinkedIssueScheme{
Key: "KP-2",
},
Type: &models.LinkTypeScheme{
Name: "Duplicate",
},
}
*/
payload := &models.LinkPayloadSchemeV2{
Comment: &models.CommentPayloadSchemeV2{
Body: "test",
},
InwardIssue: &models.LinkedIssueScheme{
Key: "KP-1",
},
OutwardIssue: &models.LinkedIssueScheme{
Key: "KP-2",
},
Type: &models.LinkTypeScheme{
Name: "Duplicate",
},
}
response, err := atlassian.Issue.Link.Create(context.Background(), payload)
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
}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)
issueLinks, response, err := atlassian.Issue.Link.Gets(context.Background(), "KP-1")
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
for _, link := range issueLinks.Fields.IssueLinks {
log.Println(link)
}
}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)
issueLink, response, err := atlassian.Issue.Link.Get(context.Background(), "10002")
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
log.Println(issueLink.ID)
log.Println("----------------")
log.Println(issueLink.Type.Name)
log.Println(issueLink.Type.ID)
log.Println(issueLink.Type.Self)
log.Println(issueLink.Type.Inward)
log.Println(issueLink.Type.Outward)
log.Println("----------------")
log.Println(issueLink.InwardIssue)
log.Println(issueLink.OutwardIssue)
}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)
response, err := atlassian.Issue.Link.Delete(context.Background(), "10002")
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
}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)
priorities, response, err := atlassian.Issue.Priority.Gets(context.Background())
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
for pos, priority := range priorities {
log.Println(pos, priority)
}
}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)
var priorityID = "1"
priority, response, err := atlassian.Issue.Priority.Get(context.Background(), priorityID)
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
log.Println(priority)
}
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)
types, response, err := atlassian.Issue.Type.Gets(context.Background())
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
for _, value := range types {
log.Println(value.ID, value.Name, value.Subtask, value.Scope)
}
}package main
import (
"context"
"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)
issueTypePayload := models.IssueTypePayloadScheme{
Name: "Risk",
Description: "this is the issue type description",
Type: "standard",
}
issueType, response, err := atlassian.Issue.Type.Create(context.Background(), &issueTypePayload)
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
log.Println(issueType.Name)
}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)
issueType, response, err := atlassian.Issue.Type.Get(context.Background(), "10000")
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
log.Println(issueType.Name)
}package main
import (
"context"
"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)
issueTypePayload := models.IssueTypePayloadScheme{
Name: "Risk UPDATED",
Description: "this is the issue type description, UPDATED",
}
issueType, response, err := atlassian.Issue.Type.Update(context.Background(), "id", &issueTypePayload)
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
log.Println(issueType.Name)
}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.Type.Delete(context.Background(), "id")
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
}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)
issueTypes, response, err := atlassian.Issue.Type.Alternatives(context.Background(), "")
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
for _, issueType := range issueTypes {
log.Println(issueType)
}
}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 (
accountIDs = []string{"qm:7ee1b8dc-1ce3-467b-94cd-9bb2dcf083e2:3f06c44b-36e8-4394-9ff3-d679f854477c"}
)
response, err := atlassian.Customer.Add(context.Background(), 1, accountIDs)
if err != nil {
if response != nil {
log.Println("Response HTTP Response", string(response.Bytes.String()))
}
log.Fatal(err)
}
log.Println("Response HTTP Code", response.Code)
log.Println("HTTP Endpoint Used", response.Endpoint)
}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")
atlassian.Auth.SetExperimentalFlag()
var (
serviceDeskID = 1
query = ""
start = 0
limit = 50
)
customers, response, err := atlassian.Customer.Gets(context.Background(), serviceDeskID, query, start, limit)
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 _, customer := range customers.Values {
log.Println(customer)
}
}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")
atlassian.Auth.SetExperimentalFlag()
var (
accountIDs = []string{"qm:7ee1b8dc-1ce3-467b-94cd-9bb2dcf083e2:3f06c44b-36e8-4394-9ff3-d679f854477c"}
)
response, err := atlassian.Customer.Remove(context.Background(), 1, accountIDs)
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)
}package models
// CustomerPageScheme represents a page of customers in a system.
type CustomerPageScheme struct {
Expands []interface{} `json:"_expands,omitempty"` // Additional data related to the customers.
Size int `json:"size,omitempty"` // The number of customers on the page.
Start int `json:"start,omitempty"` // The index of the first customer on the page.
Limit int `json:"limit,omitempty"` // The maximum number of customers that can be on the page.
IsLastPage bool `json:"isLastPage,omitempty"` // Indicates if this is the last page of customers.
Links *CustomerPageLinksScheme `json:"_links,omitempty"` // Links related to the page of customers.
Values []*CustomerScheme `json:"values,omitempty"` // The customers on the page.
}
// CustomerPageLinksScheme represents links related to a page of customers.
type CustomerPageLinksScheme struct {
Base string `json:"base,omitempty"` // The base URL for the links.
Context string `json:"context,omitempty"` // The context for the links.
Next string `json:"next,omitempty"` // The URL for the next page of customers.
Prev string `json:"prev,omitempty"` // The URL for the previous page of customers.
}
// CustomerScheme represents a customer in a system.
type CustomerScheme struct {
AccountID string `json:"accountId,omitempty"` // The account ID of the customer.
Name string `json:"name,omitempty"` // The name of the customer.
Key string `json:"key,omitempty"` // The key of the customer.
EmailAddress string `json:"emailAddress,omitempty"` // The email address of the customer.
DisplayName string `json:"displayName,omitempty"` // The display name of the customer.
Active bool `json:"active,omitempty"` // Indicates if the customer is active.
TimeZone string `json:"timeZone,omitempty"` // The time zone of the customer.
Links *CustomerLinkScheme `json:"_links,omitempty"` // Links related to the customer.
}
// CustomerLinkScheme represents links related to a customer.
type CustomerLinkScheme struct {
JiraREST string `json:"jiraRest"` // The Jira REST API link for the customer.
AvatarURLs *AvatarURLScheme `json:"avatarUrls"` // The URLs for the customer's avatars.
Self string `json:"self"` // The URL for the customer itself.
}
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)
}
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)
}
}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)
}
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)
}
}
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)
}
}go mod init <module-name>go get -v github.com/ctreminiom/go-atlassianpackage main
import (
"fmt"
"log"
"os"
jira "github.com/ctreminiom/go-atlassian/jira/v2"
)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)
}var payload = models.IssueSchemeV2{
Fields: &models.IssueFieldsSchemeV2{
Summary: "New summary test",
Priority: &models.PriorityScheme{Name: "Minor"},
},
}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", 9000)
if err != nil {
log.Fatal(err)
}_, err = atlassian.Issue.Update(context.Background(), "KP-2", false, &payload, &customFields, nil)
if err != nil {
log.Fatal(err)
}go run main.gogo get github.com/ctreminiom/go-atlassianpackage main
import (
"fmt"
"log"
jira "github.com/ctreminiom/go-atlassian/agile"
)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)
}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
}package main
import (
"context"
_ "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")
applicationRoles, response, err := jira.Role.Gets(context.Background())
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 _, role := range applicationRoles {
log.Println(role.Key, role.Name)
}
}package main
import (
"context"
_ "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")
role, response, err := jira.Role.Get(context.Background(), "jira-core")
if err != nil {
if response != nil {
log.Println("Response HTTP Response", response.Bytes.String())
log.Println("Status HTTP Response", response.Status)
}
log.Fatal(err)
}
log.Println("Response HTTP Code", response.Code)
log.Println("HTTP Endpoint Used", response.Endpoint)
log.Printf("Application Role Name: %v", role.Name)
log.Printf("Application Role Key: %v", role.Key)
log.Printf("Application Role User Count: %v", role.UserCount)
}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)
task, response, err := atlassian.Task.Get(context.Background(), "1000")
if err != nil {
log.Fatal(err)
}
log.Println("Response HTTP Code", response.Code)
log.Println("HTTP Endpoint Used", response.Endpoint)
log.Println(task)
}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)
response, err := atlassian.Task.Cancel(context.Background(), "1000")
if err != nil {
log.Fatal(err)
}
log.Println("Response HTTP Code", response.Code)
log.Println("HTTP Endpoint Used", response.Endpoint)
}go mod init <module-name>go get -v github.com/ctreminiom/go-atlassianpackage main
import (
"github.com/ctreminiom/go-atlassian/confluence"
"log"
"os"
)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)
}pageID := "76513281"
filePath := "confluence/mocks/mock.png"
fileName := "mock-00.png"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()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)
}go run main.gopackage 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)
}
}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)
}
}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)
}
}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)
}go mod init <module-name>go get -v github.com/ctreminiom/go-atlassianpackage main
import (
"fmt"
"github.com/ctreminiom/go-atlassian/jira/sm"
"github.com/ctreminiom/go-atlassian/pkg/infra/models"
)func main() {
jiraHost := "https://<_jira_instance_>.atlassian.net"
mailAddress := "<your_mail>"
apiToken := "<your_api_token>"
client, err := sm.New(nil, jiraHost)
if err != nil {
log.Fatal(err)
}
client.Auth.SetBasicAuth(mailAddress, apiToken)
}payload := &models.CreateCustomerRequestPayloadScheme{
Channel: "",
Form: nil,
IsAdfRequest: false,
RaiseOnBehalfOf: "",
RequestFieldValues: nil,
RequestParticipants: nil,
RequestTypeID: "10",
ServiceDeskID: "1",
}
if err := payload.AddCustomField("summary", "Summary Sample"); err != nil {
log.Fatal(err)
}
if err := payload.DateCustomField("duedate", time.Now()); err != nil {
log.Fatal(err)
}
if err := payload.Components([]string{"Intranet"}); err != nil {
log.Fatal(err)
}
if err := payload.AddCustomField("labels", []string{"label-00", "label-01"}); err != nil {
log.Fatal(err)
}
ticket, response, err := atlassian.Request.Create(context.Background(), payload, form)
if err != nil {
log.Fatal(err)
}go run main.gogo mod init your-module-namego get github.com/ctreminiom/go-atlassianpackage main
import (
"fmt"
"log"
"github.com/ctreminiom/go-atlassian/admin"
)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")
}// 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)
}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)
}
}package main
import (
"context"
_ "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")
banner, response, err := jira.Banner.Get(context.Background())
if err != nil {
if response != nil {
log.Println("Response HTTP Response", response.Bytes.String())
log.Println("Status HTTP Response", response.Status)
}
log.Fatal(err)
}
log.Println("Response HTTP Code", response.Code)
log.Println("HTTP Endpoint Used", response.Endpoint)
log.Println(banner.Message)
log.Println(banner.IsDismissible)
log.Println(banner.HashId)
log.Println(banner.IsEnabled)
log.Println(banner.Visibility)
}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"
)
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")
payload := &models.AnnouncementBannerPayloadScheme{
IsDismissible: true,
IsEnabled: true,
Message: "This is a public, enabled, non-dismissible banner, set using the API",
Visibility: "public",
}
response, err := jira.Banner.Update(context.Background(), payload)
if err != nil {
if response != nil {
log.Println("Response HTTP Response", response.Bytes.String())
log.Println("Status HTTP Response", response.Status)
}
log.Fatal(err)
}
log.Println("Response HTTP Code", response.Code)
log.Println("HTTP Endpoint Used", response.Endpoint)
}
package main
import (
"context"
"fmt"
v2 "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)
atlassian.Auth.SetUserAgent("curl/7.54.0")
teams, response, err := atlassian.Team.Gets(context.Background(), 1000)
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 _, team := range teams.Teams {
fmt.Println(team.Title, team.Id, team.ExternalId, team.Shareable)
}
for _, person := range teams.Persons {
fmt.Println(person.PersonId, person.JiraUser)
}
}package main
import (
"context"
v2 "github.com/ctreminiom/go-atlassian/v2/jira/v2"
"github.com/ctreminiom/go-atlassian/pkg/infra/models"
"github.com/davecgh/go-spew/spew"
"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)
atlassian.Auth.SetUserAgent("curl/7.54.0")
payload := &models.JiraTeamCreatePayloadScheme{
Title: "Team Voldemort",
Shareable: true,
Resources: nil,
}
team, response, err := atlassian.Team.Create(context.Background(), payload)
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)
spew.Dump(team)
}package main
import (
"context"
"github.com/ctreminiom/go-atlassian/jira/agile"
"log"
"os"
)
func main() {
var (
host = os.Getenv("HOST")
mail = os.Getenv("MAIL")
token = os.Getenv("TOKEN")
)
agile, err := agile.New(nil, host)
if err != nil {
return
}
agile.Auth.SetBasicAuth(mail, token)
agile.Auth.SetUserAgent("curl/7.54.0")
response, err := agile.Backlog.Move(context.Background(), []string{"KP-23"})
if err != nil {
if response != nil {
log.Println("Response HTTP Response", response.Bytes.String())
log.Println("Status HTTP Response", response.Status)
}
log.Fatal(err)
}
log.Println("Response HTTP Code", response.Code)
log.Println("HTTP Endpoint Used", response.Endpoint)
return
}package main
import (
"context"
"github.com/ctreminiom/go-atlassian/jira/agile"
"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")
)
agile, err := agile.New(nil, host)
if err != nil {
return
}
agile.Auth.SetBasicAuth(mail, token)
agile.Auth.SetUserAgent("curl/7.54.0")
payload := &models.BoardBacklogPayloadScheme{
Issues: []string{"KP-23"},
RankBeforeIssue: "",
RankAfterIssue: "",
RankCustomFieldId: 0,
}
response, err := agile.Backlog.MoveTo(context.Background(), 5, payload)
if err != nil {
if response != nil {
log.Println("Response HTTP Response", response.Bytes.String())
log.Println("Status HTTP Response", response.Status)
}
log.Fatal(err)
}
log.Println("Response HTTP Code", response.Code)
log.Println("HTTP Endpoint Used", response.Endpoint)
return
}This resource represents votes cast by users on an issue. Use it to get details of votes on an issue as well as cast and withdrawal votes.
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)
}
}
go mod init <module-name>go get -v github.com/ctreminiom/go-atlassianpackage main
import (
"encoding/csv"
"fmt"
"log"
"os"
jira "github.com/ctreminiom/go-atlassian/jira/v2"
)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)
}jql := "order by created DESC"
var startAt int
var issues []*models.IssueSchemeV2
for {
log.Printf("Executing the pagination #%v", startAt)
issuePage, _, err := client.Issue.Search.Post(
context.Background(),
jql,
nil,
[]string{"changelog"},
startAt,
50,
"")
if err != nil {
log.Fatal(err)
}
issues = append(issues, issuePage.Issues...)
if len(issuePage.Issues) == 0 {
break
}
startAt += 50
}var changelogs [][]string
for _, issue := range issues {
for _, history := range issue.Changelog.Histories {
for _, item := range history.Items {
var from string
if item.From == "" {
from = item.FromString
} else {
from = item.From
}
var to string
if item.To == "" {
to = item.ToString
} else {
to = item.To
}
changelogs = append(changelogs, []string{
issue.Key,
issue.Fields.Project.Name,
issue.Fields.Summary,
item.Field,
from,
to,
history.Created,
history.Author.EmailAddress,
})
}
}
}file, err := os.Create("issue_history.csv")
if err != nil {
log.Fatal(err)
}
defer file.Close()
writer := csv.NewWriter(file)
defer writer.Flush()
// Write header
if err := writer.Write([]string{"Issue Key", "Project Name", "Issue Summary", "Issue Field", "From", "To", "When", "Who?"}); err != nil {
log.Fatal(err)
}
// Write the information
if err := writer.WriteAll(changelogs); err != nil {
log.Fatal(err)
}
log.Println("Issue history saved to issue_history.csv")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)
}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)
}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)
scheme, response, err := atlassian.Project.Permission.Get(context.Background(), "KP", []string{"all"})
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
log.Println(scheme)
}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"
permissionSchemeID = 10000
)
scheme, response, err := atlassian.Project.Permission.Assign(context.Background(), projectKeyOrID, permissionSchemeID)
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
log.Println(scheme)
}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)
levels, response, err := atlassian.Project.Permission.SecurityLevels(context.Background(), "KP")
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
for _, level := range levels.Levels {
log.Println(level)
}
}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)
}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)
}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)
}
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 (
screenID = 10000
tabID = 10003
)
fields, response, err := atlassian.Screen.Tab.Field.Gets(context.Background(), screenID, tabID)
if err != nil {
log.Fatal(err)
}
log.Println("Response HTTP Code", response.Code)
log.Println("HTTP Endpoint Used", response.Endpoint)
for _, field := range fields {
log.Println(field)
}
}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 (
screenID = 10000
tabID = 10003
fieldID = "customfield_10030"
)
tab, response, err := atlassian.Screen.Tab.Field.Add(context.Background(), screenID, tabID, fieldID)
if err != nil {
log.Fatal(err)
}
log.Println("Response HTTP Code", response.Code)
log.Println("HTTP Endpoint Used", response.Endpoint)
log.Println(tab)
}
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 (
screenID = 10000
tabID = 10003
fieldID = "customfield_10030"
)
response, err := atlassian.Screen.Tab.Field.Remove(context.Background(), screenID, tabID, fieldID)
if err != nil {
log.Fatal(err)
}
log.Println("Response HTTP Code", response.Code)
log.Println("HTTP Endpoint Used", response.Endpoint)
}package main
import (
"context"
"github.com/ctreminiom/go-atlassian/jira/agile"
"log"
"os"
)
func main() {
var (
host = os.Getenv("HOST")
mail = os.Getenv("MAIL")
token = os.Getenv("TOKEN")
)
atlassian, err := agile.New(nil, host)
if err != nil {
return
}
atlassian.Auth.SetBasicAuth(mail, token)
atlassian.Auth.SetUserAgent("curl/7.54.0")
epic, response, err := atlassian.Epic.Get(context.Background(), "KP-16")
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)
log.Println(epic)
}package main
import (
"context"
"github.com/ctreminiom/go-atlassian/jira/agile"
"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 := agile.New(nil, host)
if err != nil {
return
}
atlassian.Auth.SetBasicAuth(mail, token)
atlassian.Auth.SetUserAgent("curl/7.54.0")
var (
options = &models.IssueOptionScheme{
JQL: "project = KP",
ValidateQuery: true,
Fields: []string{"status", "issuetype", "summary"},
Expand: []string{"changelog"},
}
epicKey = "KP-16"
startAt = 0
maxResult = 50
)
issues, response, err := atlassian.Epic.Issues(context.Background(), epicKey, options, startAt, maxResult)
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 _, issue := range issues.Issues {
log.Println(issue.Key)
}
}package main
import (
"context"
"github.com/ctreminiom/go-atlassian/jira/agile"
"log"
"os"
)
func main() {
var (
host = os.Getenv("HOST")
mail = os.Getenv("MAIL")
token = os.Getenv("TOKEN")
)
atlassian, err := agile.New(nil, host)
if err != nil {
return
}
atlassian.Auth.SetBasicAuth(mail, token)
atlassian.Auth.SetUserAgent("curl/7.54.0")
response, err := atlassian.Epic.Move(context.Background(), "KP-16", []string{"DUMMY-1"})
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)
}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 (
accountID = ""
projectKeys = []string{"KP"}
startAt = 0
maxResults = 50
)
users, response, err := atlassian.User.Search.Projects(context.Background(), accountID, projectKeys, startAt, maxResults)
if err != nil {
log.Fatal(err)
}
log.Println("Response HTTP Code", response.Code)
log.Println("HTTP Endpoint Used", response.Endpoint)
for _, user := range users {
log.Println(user)
}
}package main
import (
"context"
"fmt"
v3 "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")
)
instance, err := v3.New(nil, host)
if err != nil {
log.Fatal(err)
}
instance.Auth.SetBasicAuth(mail, token)
instance.Auth.SetUserAgent("curl/7.54.0")
mapping, response, err := instance.Workflow.Scheme.IssueType.Get(context.Background(), 10002, "10007", false)
if err != nil {
if response != nil {
log.Println(response.Bytes.String())
log.Println(response.Code)
}
log.Fatal(err)
}
fmt.Println(mapping)
}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 (
accountID = ""
query = ""
startAt = 0
maxResults = 50
)
users, response, err := atlassian.User.Search.Do(context.Background(), accountID, query, startAt, maxResults)
if err != nil {
log.Fatal(err)
}
log.Println("Response HTTP Code", response.Code)
log.Println("HTTP Endpoint Used", response.Endpoint)
for _, user := range users {
log.Println(user)
}
}package main
import (
"context"
"fmt"
_ "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"
)
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")
options := &models.UserPermissionCheckParamsScheme{
Query: "",
AccountID: "5b86be50b8e3cb5895860d6d",
IssueKey: "",
ProjectKey: "KP",
}
users, response, err := jira.User.Search.Check(context.Background(), "EDIT_ISSUE", options, 0, 50)
if err != nil {
if response != nil {
log.Println("Response HTTP Response", response.Bytes.String())
}
log.Fatal(err)
}
for _, user := range users {
fmt.Println(user)
}
}package main
import (
"context"
"fmt"
v3 "github.com/ctreminiom/go-atlassian/v2/jira/v3"
"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")
)
instance, err := v3.New(nil, host)
if err != nil {
log.Fatal(err)
}
instance.Auth.SetBasicAuth(mail, token)
instance.Auth.SetUserAgent("curl/7.54.0")
payload := &models.IssueTypeWorkflowPayloadScheme{
IssueType: "10000",
UpdateDraftIfNeeded: false,
Workflow: "DESK: Jira Service Management default workflow",
}
workflowScheme, response, err := instance.Workflow.Scheme.IssueType.Set(context.Background(), 10007, "10007", payload)
if err != nil {
if response != nil {
log.Println(response.Bytes.String())
log.Println(response.Code)
}
log.Fatal(err)
}
fmt.Println(workflowScheme)
}package main
import (
"context"
"fmt"
v3 "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")
)
instance, err := v3.New(nil, host)
if err != nil {
log.Fatal(err)
}
instance.Auth.SetBasicAuth(mail, token)
instance.Auth.SetUserAgent("curl/7.54.0")
mapping, response, err := instance.Workflow.Scheme.IssueType.Delete(context.Background(), 10002, "10000", false)
if err != nil {
if response != nil {
log.Println(response.Bytes.String())
log.Println(response.Code)
}
log.Fatal(err)
}
fmt.Println(mapping)
}package main
import (
"context"
"fmt"
v3 "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")
)
instance, err := v3.New(nil, host)
if err != nil {
log.Fatal(err)
}
instance.Auth.SetBasicAuth(mail, token)
instance.Auth.SetUserAgent("curl/7.54.0")
mapping, response, err := instance.Workflow.Scheme.IssueType.Mapping(context.Background(), 10007, "", false)
if err != nil {
if response != nil {
log.Println(response.Bytes.String())
log.Println(response.Code)
}
log.Fatal(err)
}
log.Println(response.Endpoint)
for _, element := range mapping {
fmt.Println(element.Workflow, element.Workflow)
}
}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 permissionSchemeID = 10002
grants, response, err := atlassian.Permission.Scheme.Grant.Gets(context.Background(), permissionSchemeID, []string{"all"})
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
for _, grant := range grants.Permissions {
log.Println(grant)
}
}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)
projectTypes, response, err := atlassian.Project.Type.Gets(context.Background())
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)
log.Println("Response Buffer", response.Bytes.String())
for _, projectType := range projectTypes {
log.Println(projectType)
}
}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)
properties, response, err := atlassian.Project.Property.Gets(context.Background(), "KP")
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
for _, key := range properties.Keys {
log.Printf("Key: %v -- Self: %v", key.Key, key.Self)
}
}package main
import (
"context"
"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")
)
atlassian, err := v2.New(nil, host)
if err != nil {
return
}
atlassian.Auth.SetBasicAuth(mail, token)
fieldConfigurations, response, err := atlassian.Issue.Field.Configuration.Gets(
context.Background(),
nil,
false,
0,
50,
)
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
for _, configuration := range fieldConfigurations.Values {
log.Println(configuration)
}
}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")
)
atlassian, err := v2.New(nil, host)
if err != nil {
return
}
atlassian.Auth.SetBasicAuth(mail, token)
newFieldConfiguration, response, err := atlassian.Issue.Field.Configuration.Create(
context.Background(),
"Story DUMMY Field Configuration",
"description sample")
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
fmt.Println(newFieldConfiguration.ID)
fmt.Println(newFieldConfiguration.Name)
fmt.Println(newFieldConfiguration.Description)
fmt.Println(newFieldConfiguration.IsDefault)
}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.Configuration.Update(context.Background(), 10002, "name updated", "")
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
}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.Configuration.Delete(context.Background(), 10002)
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
}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)
var permissionSchemeID = 10001
grant := &models.PermissionGrantPayloadScheme{
Holder: &models.PermissionGrantHolderScheme{
Parameter: "jira-administrators-system",
Type: "group",
},
Permission: "EDIT_ISSUES",
}
permissionGrant, response, err := atlassian.Permission.Scheme.Grant.Create(context.Background(), permissionSchemeID, grant)
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
log.Println(permissionGrant)
}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 (
permissionSchemeID = 10002
permissionGrantID = 10517
)
grant, response, err := atlassian.Permission.Scheme.Grant.Get(context.Background(), permissionSchemeID, permissionGrantID, []string{"all"})
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
log.Println(grant)
}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 (
permissionSchemeID = 10002
permissionGrantID = 10517
)
response, err := atlassian.Permission.Scheme.Grant.Delete(context.Background(), permissionSchemeID, permissionGrantID)
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
}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)
projectTypes, response, err := atlassian.Project.Type.Licensed(context.Background())
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 _, projectType := range projectTypes {
log.Println(projectType.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)
projectType, response, err := atlassian.Project.Type.Get(context.Background(), "software")
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)
log.Println(projectType)
}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)
projectType, response, err := atlassian.Project.Type.Accessible(context.Background(), "software")
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)
log.Println(projectType)
}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)
property, response, err := atlassian.Project.Property.Get(context.Background(), "KP", "jswSelectedBoardType")
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
log.Printf("Key: %v -- Value: %v", property.Key, property.Value)
}
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)
payload := `{
"number": 5,
"string": "string-value"
}`
response, err := atlassian.Project.Property.Set(context.Background(), "KP", "property-key", &payload)
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
}
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)
response, err := atlassian.Project.Property.Delete(context.Background(), "KP", "property-key")
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
}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 (
screenID = 10000
projectKey = "KP"
)
tabs, response, err := atlassian.Screen.Tab.Gets(context.Background(), screenID, projectKey)
if err != nil {
log.Fatal(err)
}
log.Println("Response HTTP Code", response.Code)
log.Println("HTTP Endpoint Used", response.Endpoint)
for _, tab := range tabs {
log.Println(tab.ID, tab.Name)
}
}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 (
screenID = 10000
tabName = "Development"
)
newTab, response, err := atlassian.Screen.Tab.Create(context.Background(), screenID, tabName)
if err != nil {
log.Fatal(err)
}
log.Println("Response HTTP Code", response.Code)
log.Println("HTTP Endpoint Used", response.Endpoint)
log.Printf("The new tab has been created: %v", newTab.ID)
}
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 (
screenID = 10000
tabID = 10019
tabNameUpdated = "Time tracking"
)
tabUpdated, response, err := atlassian.Screen.Tab.Update(context.Background(), screenID, tabID, tabNameUpdated)
if err != nil {
log.Fatal(err)
}
log.Println("Response HTTP Code", response.Code)
log.Println("HTTP Endpoint Used", response.Endpoint)
log.Printf("The tab has been updated: %v", tabUpdated.ID)
}
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 (
screenID = 10000
tabID = 10019
)
response, err := atlassian.Screen.Tab.Delete(context.Background(), screenID, tabID)
if err != nil {
log.Fatal(err)
}
log.Println("Response HTTP Code", response.Code)
log.Println("HTTP Endpoint Used", response.Endpoint)
}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 (
screenID = 10000
tabID = 1
tabPosition = 0
)
response, err := atlassian.Screen.Tab.Move(context.Background(), screenID, tabID, tabPosition)
if err != nil {
log.Fatal(err)
}
log.Println("Response HTTP Code", response.Code)
log.Println("HTTP Endpoint Used", response.Endpoint)
}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)
roles, response, err := atlassian.Project.Role.Gets(context.Background(), "KP")
if err != nil {
log.Fatal(err)
}
log.Println("Response HTTP Code", response.Code)
log.Println("HTTP Endpoint Used", response.Endpoint)
for key, value := range *roles {
log.Println(key, value)
}
}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)
role, response, err := atlassian.Project.Role.Get(context.Background(), "KP", 10005)
if err != nil {
log.Fatal(err)
}
log.Println("Response HTTP Code", response.Code)
log.Println("HTTP Endpoint Used", response.Endpoint)
log.Println(role.ID)
log.Println(role.Name)
log.Println(role.Description)
log.Println(role.Self)
}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)
rolesDetails, response, err := atlassian.Project.Role.Details(context.Background(), "KP")
if err != nil {
log.Fatal(err)
}
log.Println("Response HTTP Code", response.Code)
log.Println("HTTP Endpoint Used", response.Endpoint)
for _, role := range rolesDetails {
log.Println(role.Name)
log.Println(role.ID)
log.Println(role.Admin)
log.Println(role.TranslatedName)
}
}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)
roles, response, err := atlassian.Project.Role.Global(context.Background())
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
for _, role := range roles {
log.Println(role)
}
}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)
var payload = &models.ProjectRolePayloadScheme{
Name: "Developers",
Description: "A project role that represents developers in a project",
}
newRole, response, err := atlassian.Project.Role.Create(context.Background(), payload)
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
log.Println(newRole)
}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)
categories, response, err := atlassian.Project.Category.Gets(context.Background())
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 _, category := range categories {
log.Println("----------------")
log.Println(category.Self)
log.Println(category.ID)
log.Println(category.Name)
log.Println(category.Description)
log.Println("----------------")
}
}package main
import (
"context"
"fmt"
_ "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"
"math/rand"
"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 payload = &models.ProjectCategoryPayloadScheme{
Name: fmt.Sprintf("Category #%v", rand.Intn(100)),
Description: "description sample",
}
newCategory, response, err := atlassian.Project.Category.Create(context.Background(), payload)
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)
log.Printf("The new category %v has been created with the ID %v", newCategory.Name, newCategory.ID)
}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)
category, response, err := atlassian.Project.Category.Get(context.Background(), 10002)
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)
log.Println(category)
}package main
import (
"context"
"fmt"
_ "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"
"math/rand"
"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 (
projectCategoryID = 10000
payload = &models.ProjectCategoryPayloadScheme{
Name: fmt.Sprintf("Category #%v - updated", rand.Intn(100)),
}
)
categoryUpdated, response, err := atlassian.Project.Category.Update(context.Background(), projectCategoryID, payload)
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)
log.Printf("The project category %v has been updated", categoryUpdated.ID)
}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)
response, err := atlassian.Project.Category.Delete(context.Background(), 10002)
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)
log.Println("HTTP Endpoint Bytes", response.Bytes.String())
}go get github.com/ctreminiom/go-atlassian/v2instance, err := confluence.New(nil, "INSTANCE_HOST")
if err != nil {
log.Fatal(err)
}
instance.Auth.SetBasicAuth("YOUR_CLIENT_MAIL", "YOUR_APP_ACCESS_TOKEN")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")// 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)
}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)
}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)
}go mod init your-module-nameThis resource represents project components. Uses to get, create, update, and delete project components. Also get components for project and get a count of issues by component.
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.ComponentPayloadScheme{
IsAssigneeTypeValid: false,
Name: "Component 2",
Description: "This is a Jira component",
Project: "KP",
AssigneeType: "PROJECT_LEAD",
LeadAccountID: "5b86be50b8e3cb5895860d6d",
}
newComponent, response, err := atlassian.Project.Component.Create(context.Background(), payload)
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
log.Printf("The new component has been created with the ID %v", newComponent.ID)
}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 (
accountID = "5b86be50b8e3cb5895860d6d"
expands = []string{"groups", "applicationRoles"}
)
user, response, err := atlassian.User.Get(context.Background(), accountID, expands)
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
log.Println(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)
scope, response, err := atlassian.Filter.Share.Scope(context.Background())
if err != nil {
if response != nil {
log.Println("Response HTTP Response", response.Bytes.String())
}
return
}
log.Println("Response HTTP Code", response.Code)
log.Println("HTTP Endpoint Used", response.Endpoint)
log.Println("Scope", scope)
}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)
component, response, err := atlassian.Project.Component.Get(context.Background(), "10006")
if err != nil {
log.Fatal(err)
}
log.Println(component)
log.Println(response.Endpoint)
}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.ComponentPayloadScheme{
IsAssigneeTypeValid: false,
Name: "Component 1 - UPDATED",
Description: "This is a Jira component - UPDATED",
}
componentUpdated, response, err := atlassian.Project.Component.Update(context.Background(), "10006", payload)
if err != nil {
log.Fatal(err)
}
log.Println(response.Endpoint)
log.Println(componentUpdated)
}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)
response, err := atlassian.Project.Component.Delete(context.Background(), "10006")
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
}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)
count, response, err := atlassian.Project.Component.Count(context.Background(), "10005")
if err != nil {
log.Fatal(err)
}
log.Println(count)
log.Println(response.Endpoint)
}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 projectKey = "KP"
components, response, err := atlassian.Project.Component.Gets(context.Background(), projectKey)
if err != nil {
log.Fatal(err)
}
log.Println(response.Endpoint)
for _, component := range components {
log.Println(component)
}
}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.UserPayloadScheme{
EmailAddress: "[email protected]",
DisplayName: "Example DisplayName",
Notification: false,
}
newUser, response, err := atlassian.User.Create(context.Background(), payload)
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
log.Println("The new user has been created", newUser.AccountID)
}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)
response, err := atlassian.User.Delete(context.Background(), "607b98df2ad11c0072664322")
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
}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 (
accountIDs = []string{"5b86be50b8e3cb5895860d6d"}
startAt = 0
maxResults = 50
)
users, response, err := atlassian.User.Find(context.Background(), accountIDs, startAt, maxResults)
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
for _, user := range users.Values {
log.Println(user.DisplayName)
}
}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 accountID = "5b86be50b8e3cb5895860d6d"
groups, response, err := atlassian.User.Groups(context.Background(), accountID)
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
for _, group := range groups {
log.Println(group)
}
}
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 (
startAt = 0
maxResults = 50
)
users, response, err := atlassian.User.Gets(context.Background(), startAt, maxResults)
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
for _, user := range users {
log.Println(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)
permissions, response, err := atlassian.Filter.Share.Gets(context.Background(), 1)
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
for index, permission := range permissions {
log.Println(index, permission.Type, permission.Type)
}
}package main
import (
"context"
_ "github.com/ctreminiom/go-atlassian/jira/v3"
"github.com/ctreminiom/go-atlassian/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)
/*
We can add different share permissions, for example:
---- Project ID only
payload := jira.PermissionFilterBodyScheme{
Type: "project",
ProjectID: "10000",
}
---- Project ID and role ID
payload := jira.PermissionFilterBodyScheme{
Type: "project",
ProjectID: "10000",
ProjectRoleID: "222222",
}
==== Group Name
payload := jira.PermissionFilterBodyScheme{
Type: "group",
GroupName: "jira-users",
}
*/
payload := models.PermissionFilterPayloadScheme{
Type: "project",
ProjectID: "10000",
}
permissions, response, err := atlassian.Filter.Share.Add(context.Background(), 1001, &payload)
if err != nil {
return
}
log.Println("HTTP Endpoint Used", response.Endpoint)
for index, permission := range permissions {
log.Println(index, permission.ID, permission.Type)
}
}package main
import (
"context"
_ "github.com/ctreminiom/go-atlassian/jira/v3"
"github.com/ctreminiom/go-atlassian/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)
permission, response, err := atlassian.Filter.Share.Get(context.Background(), 10001, 100012)
if err != nil {
log.Fatal(err)
return
}
log.Println("HTTP Endpoint Used", response.Endpoint)
log.Println(permission)
}package main
import (
"context"
_ "github.com/ctreminiom/go-atlassian/jira/v3"
"github.com/ctreminiom/go-atlassian/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.Filter.Share.Delete(context.Background(), 11111, 11111)
if err != nil {
log.Fatal(err)
return
}
log.Println("HTTP Endpoint Used", response.Endpoint)
}package main
import (
"context"
_ "github.com/ctreminiom/go-atlassian/jira/v3"
"github.com/ctreminiom/go-atlassian/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.Filter.Share.SetScope(context.Background(), "GLOBAL")
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
}go get github.com/ctreminiom/go-atlassianpackage main
import (
"fmt"
"log"
jira "github.com/ctreminiom/go-atlassian/jira/v2"
)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)
}var statusesNamesAsSlice = []string{
"Open", "In Progress", "QA",
"Waiting for approval", "Escalated",
"Closed", "Resolved",
}
var statusesAsMap = make(map[string]*models.WorkflowStatusDetailScheme)
for _, statusName := range statusesNamesAsSlice {
options := &models.WorkflowStatusSearchParams{
SearchString: statusName,
}
page, response, err := instance.Workflow.Status.Search(context.Background(), options, 0, 1)
if err != nil {
if response != nil {
log.Println(response.Bytes.String())
log.Println(response.Code)
}
log.Fatal(err)
}
var wasFound bool
for _, status := range page.Values {
if status.Name == statusName {
statusesAsMap[status.Name] = status
wasFound = true
break
}
}
if !wasFound {
// If the workflow is not found, it's required to create a new global status
statusPayload := &models.WorkflowStatusPayloadScheme{
Statuses: []*models.WorkflowStatusNodeScheme{
{
Name: statusName,
StatusCategory: "IN_PROGRESS",
},
},
Scope: &models.WorkflowStatusScopeScheme{
Type: "GLOBAL",
},
}
statuses, response, err := instance.Workflow.Status.Create(context.Background(), statusPayload)
if err != nil {
if response != nil {
log.Println(response.Bytes.String())
log.Println(response.Code)
}
log.Fatal(err)
}
for _, status := range statuses {
if status.Name == statusName {
statusesAsMap[status.Name] = status
break
}
}
}
}
for name, data := range statusesAsMap {
fmt.Println(name, data.ID)
}var workflowStatuses []*models.WorkflowTransitionScreenScheme
for _, status := range statusesAsMap {
workflowStatuses = append(workflowStatuses, &models.WorkflowTransitionScreenScheme{
ID: status.ID,
Properties: nil,
})
}var workflowTransitions []*models.WorkflowTransitionPayloadScheme
// -----
// The initial transition is required, it creates the relationship between the creation trigger with the
// first status
// -----
workflowTransitions = append(workflowTransitions, &models.WorkflowTransitionPayloadScheme{
Name: "Create",
To: "1",
Type: "initial",
})
// -----
// Create the Escalated and Waiting for approval statuses because the relationship is all-to-all
workflowTransitions = append(workflowTransitions, &models.WorkflowTransitionPayloadScheme{
Name: "Escalated",
To: statusesAsMap["Escalated"].ID,
Type: "global",
})
workflowTransitions = append(workflowTransitions, &models.WorkflowTransitionPayloadScheme{
Name: "Waiting for approval",
To: statusesAsMap["Waiting for approval"].ID,
Type: "global",
})
// -----
// ----
// Create the directed transitions, it's required to use the from and to statuses
// Open -----------------------> In Progress
workflowTransitions = append(workflowTransitions, &models.WorkflowTransitionPayloadScheme{
Name: "In Progress",
From: []string{statusesAsMap["Open"].ID},
To: statusesAsMap["In Progress"].ID,
Type: "directed",
})
// In Progress -----------------------> QA
workflowTransitions = append(workflowTransitions, &models.WorkflowTransitionPayloadScheme{
Name: "QA",
From: []string{statusesAsMap["In Progress"].ID},
To: statusesAsMap["QA"].ID,
Type: "directed",
})
// QA -----------------------> In Progress
workflowTransitions = append(workflowTransitions, &models.WorkflowTransitionPayloadScheme{
Name: "QA",
From: []string{statusesAsMap["QA"].ID},
To: statusesAsMap["In Progress"].ID,
Type: "directed",
})
// QA -----------------------> Closed
workflowTransitions = append(workflowTransitions, &models.WorkflowTransitionPayloadScheme{
Name: "Closed",
From: []string{statusesAsMap["QA"].ID},
To: statusesAsMap["Closed"].ID,
Type: "directed",
})
// QA -----------------------> Resolved
workflowTransitions = append(workflowTransitions, &models.WorkflowTransitionPayloadScheme{
Name: "Resolved",
From: []string{statusesAsMap["QA"].ID},
To: statusesAsMap["Resolved"].ID,
Type: "directed",
})workflowPayload := &models.WorkflowPayloadScheme{
Name: "Workflow Name - Sample",
Description: "Workflow Name - Description",
Statuses: workflowStatuses,
Transitions: workflowTransitions,
}
newWorkflow, response, err := instance.Workflow.Create(context.Background(), workflowPayload)
if err != nil {
if response != nil {
log.Println(response.Bytes.String())
log.Println(response.Code)
}
log.Fatal(err)
}
log.Println(newWorkflow.Name)
log.Println(newWorkflow.EntityID)
go mod init your-module-namego get github.com/ctreminiom/go-atlassianpackage main
import (
"fmt"
"log"
jira "github.com/ctreminiom/go-atlassian/jira/v2"
)func main() {
client, err := jira.New(nil, "https://your-jira-instance.atlassian.net")
if err != nil {
log.Fatal(err)
}
// Set API token for authentication
client.Auth.SetBasicAuth(mail, token)
}var projectKey = "KP"
// --------------------------------------------------
// Extract the project ID using the Project.Get() method
// --------------------------------------------------
project, response, err := client.Project.Get(context.Background(), projectKey, nil)
if err != nil {
if response != nil {
log.Println("Response HTTP Response", response.Bytes.String())
log.Println("Status HTTP Response", response.Status)
}
log.Fatal(err)
}
// --------------------------------------------------
// Transform the project id string to integer
// --------------------------------------------------
projectIDAsInt, err := strconv.Atoi(project.ID)
if err != nil {
log.Fatal(err)
}
// --------------------------------------------------
// Extract the issue type screen scheme linked to the project selected
// --------------------------------------------------
projectMapping, response, err := client.Issue.Type.ScreenScheme.Projects(context.Background(), []int{projectIDAsInt}, 0, 50)
if err != nil {
if response != nil {
log.Println("Response HTTP Response", response.Bytes.String())
log.Println("Status HTTP Response", response.Status)
}
log.Fatal(err)
}
// --------------------------------------------------
// Iterates the struts and extract the issue type screen scheme id
// --------------------------------------------------
var issueTypeScreenSchemeID string
for _, scheme := range projectMapping.Values {
for _, projectID := range scheme.ProjectIds {
if project.ID == projectID {
issueTypeScreenSchemeID = projectID
}
}
}// --------------------------------------------------
// Transform the project id string to integer
// --------------------------------------------------
issueTypeScreenSchemeIDAsInt, err := strconv.Atoi(issueTypeScreenSchemeID)
if err != nil {
log.Fatal(err)
}
// --------------------------------------------------
// Extract the screen schemes linked to the issue type screen schemes
// --------------------------------------------------
schemeMapping, response, err := client.Issue.Type.ScreenScheme.Mapping(
context.Background(),
[]int{issueTypeScreenSchemeIDAsInt},
0,
50)
if err != nil {
if response != nil {
log.Println("Response HTTP Response", response.Bytes.String())
log.Println("Status HTTP Response", response.Status)
}
log.Fatal(err)
}
// --------------------------------------------------
// Iterates the struts and extract the screen schemes ID as integers
// --------------------------------------------------
var screenSchemesIDs []int
for _, scheme := range schemeMapping.Values {
screenSchemeIDAsInt, err := strconv.Atoi(scheme.ScreenSchemeID)
if err != nil {
log.Fatal(err)
}
screenSchemesIDs = append(screenSchemesIDs, screenSchemeIDAsInt)
}// --------------------------------------------------
// Extract the screens from the screen schemes IDs
// --------------------------------------------------
options := &models.ScreenSchemeParamsScheme{IDs: screenSchemesIDs}
screenSchemes, response, err := client.Screen.Scheme.Gets(context.Background(), options, 0, 50)
if err != nil {
if response != nil {
log.Println("Response HTTP Response", response.Bytes.String())
log.Println("Status HTTP Response", response.Status)
}
log.Fatal(err)
}
// --------------------------------------------------
// Iterates the struts and screen IDs
// --------------------------------------------------
var screenIDs []int
for _, screenScheme := range screenSchemes.Values {
if screenScheme.Screens != nil {
screenIDs = append(screenIDs, screenScheme.Screens.Default)
screenIDs = append(screenIDs, screenScheme.Screens.Create)
screenIDs = append(screenIDs, screenScheme.Screens.Edit)
screenIDs = append(screenIDs, screenScheme.Screens.View)
}
}
// --------------------------------------------------
// Remove the duplicated values from the screenIDs slice
// I used the function "removeDuplicateInt" from the Stackoverflow question
// https://stackoverflow.com/questions/66643946/how-to-remove-duplicates-strings-or-int-from-slice-in-go
// --------------------------------------------------
screenIDsWithOutDuplicated := removeDuplicateInt(screenIDs)var customFieldsIDs = []string{
"customfield_10068",
"customfield_10020",
"duedate",
"timetracking",
"customfield_10069",
"customfield_10070",
"customfield_10071",
}
// --------------------------------------------------
// Process each screen and do the following validations/logic
// 1. Extract the screen default tab
// 2. Using the default screen tab, extract the customfields stored on it
// 3. Check if the customfield is already added on the screen tab
// 4. If so, skip it
// 5. If not, append the customfield on the screen tab
// --------------------------------------------------
for _, screenID := range screenIDsWithOutDuplicated {
// --------------------------------------------------
// If you want to process the default screen, you can comment this if statement
// --------------------------------------------------
if screenID == 0 {
continue
}
tabs, response, err := client.Screen.Tab.Gets(context.Background(), screenID, projectKey)
if err != nil {
if response != nil {
log.Println("Response HTTP Response", response.Bytes.String())
log.Println("Status HTTP Response", response.Status)
}
log.Fatal(err)
}
defaultTab := tabs[0].ID
fields, response, err := client.Screen.Tab.Field.Gets(context.Background(), screenID, defaultTab)
if err != nil {
if response != nil {
log.Println("Response HTTP Response", response.Bytes.String())
log.Println("Status HTTP Response", response.Status)
}
log.Fatal(err)
}
// --------------------------------------------------
// Iterate the fields slice and stores the fields already added on the screen tab
// --------------------------------------------------
var fieldsAlreadyAdded []string
for _, field := range fields {
fieldsAlreadyAdded = append(fieldsAlreadyAdded, field.ID)
}
// --------------------------------------------------
// Check if the customfield requested is already added on the screen tab
// --------------------------------------------------
var fieldsAvailableToAdd []string
for _, customFieldID := range customFieldsIDs {
var isTaken bool
for _, fieldsAdded := range fieldsAlreadyAdded {
if customFieldID == fieldsAdded {
isTaken = true
break
}
}
if !isTaken {
fieldsAvailableToAdd = append(fieldsAvailableToAdd, customFieldID)
}
}
// --------------------------------------------------
// For each customfield filtered, add the field on the screen tab
// --------------------------------------------------
for _, fieldID := range fieldsAvailableToAdd {
_, response, err = client.Screen.Tab.Field.Add(context.Background(), screenID, defaultTab, fieldID)
if err != nil {
if response != nil {
log.Println("Response HTTP Response", response.Bytes.String())
log.Println("Status HTTP Response", response.Status)
}
log.Fatal(err)
}
log.Println("The field", fieldID, "has been added on the screen ", screenID)
}
This resource represents the screens used to record issue details
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 (
fieldID = "customfield_10014"
startAt = 0
maxResult = 50
)
screens, response, err := atlassian.Screen.Fields(context.Background(), fieldID, startAt, maxResult)
if err != nil {
log.Fatal(err)
}
log.Println("Response HTTP Code", response.Code)
log.Println("HTTP Endpoint Used", response.Endpoint)
for _, screen := range screens.Values {
log.Println(screen.ID, screen.Name, screen.Description)
}
}package main
import (
"context"
"fmt"
v3 "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")
)
instance, err := v3.New(nil, host)
if err != nil {
log.Fatal(err)
}
instance.Auth.SetBasicAuth(mail, token)
instance.Auth.SetUserAgent("curl/7.54.0")
workflowSchemes, response, err := instance.Workflow.Scheme.Gets(context.Background(), 0, 50)
if err != nil {
if response != nil {
log.Println(response.Bytes.String())
log.Println(response.Code)
}
log.Fatal(err)
}
for _, workflowScheme := range workflowSchemes.Values {
fmt.Println(workflowScheme.Name)
fmt.Println(workflowScheme.Description)
fmt.Println(workflowScheme.ID)
fmt.Println(workflowScheme.Self)
fmt.Println(workflowScheme.DefaultWorkflow)
}
fmt.Println(workflowSchemes.IsLast)
}
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 (
screenIDs = []int{10000}
startAt = 0
maxResults = 0
)
screens, response, err := atlassian.Screen.Gets(context.Background(), screenIDs, startAt, maxResults)
if err != nil {
log.Fatal(err)
}
log.Println("Response HTTP Code", response.Code)
log.Println("HTTP Endpoint Used", response.Endpoint)
for _, screen := range screens.Values {
log.Println(screen.ID, screen.Name, screen.Description)
}
}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)
newScreen, response, err := atlassian.Screen.Create(context.Background(), "FX Screen", "sample description")
if err != nil {
log.Fatal(err)
}
log.Println("Response HTTP Code", response.Code)
log.Println("HTTP Endpoint Used", response.Endpoint)
log.Printf("The new screen has been created with the ID %v", newScreen.ID)
}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)
response, err := atlassian.Screen.AddToDefault(context.Background(), "customfield_xxxx")
if err != nil {
log.Fatal(err)
}
log.Println("Response HTTP Code", response.Code)
log.Println("HTTP Endpoint Used", response.Endpoint)
}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)
screenUpdated, response, err := atlassian.Screen.Update(context.Background(), 10015, "AX Screen", "")
if err != nil {
log.Fatal(err)
}
log.Println("Response HTTP Code", response.Code)
log.Println("HTTP Endpoint Used", response.Endpoint)
log.Println(screenUpdated)
}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)
response, err := atlassian.Screen.Delete(context.Background(), 10015)
if err != nil {
log.Fatal(err)
}
log.Println("Response HTTP Code", response.Code)
log.Println("HTTP Endpoint Used", response.Endpoint)
}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)
fields, response, err := atlassian.Screen.Available(context.Background(), 10000)
if err != nil {
log.Fatal(err)
}
log.Println("Response HTTP Code", response.Code)
log.Println("HTTP Endpoint Used", response.Endpoint)
for _, field := range fields {
log.Println(field.ID, field.Name)
}
}package main
import (
"context"
"fmt"
v3 "github.com/ctreminiom/go-atlassian/v2/jira/v3"
"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")
)
instance, err := v3.New(nil, host)
if err != nil {
log.Fatal(err)
}
instance.Auth.SetBasicAuth(mail, token)
instance.Auth.SetUserAgent("curl/7.54.0")
payload := &models.WorkflowSchemePayloadScheme{
DefaultWorkflow: "jira",
Name: "Example workflow scheme",
Description: "The description of the example workflow scheme.",
IssueTypeMappings: map[string]interface{}{
"10002": "PV: Project Management Workflow",
"10005": "Software Simplified Workflow for Project K2",
},
}
newWorkflowScheme, response, err := instance.Workflow.Scheme.Create(context.Background(), payload)
if err != nil {
if response != nil {
log.Println(response.Bytes.String())
log.Println(response.Code)
}
log.Fatal(err)
}
fmt.Println(newWorkflowScheme.Name)
fmt.Println(newWorkflowScheme.Description)
fmt.Println(newWorkflowScheme.ID)
fmt.Println(newWorkflowScheme.Self)
fmt.Println(newWorkflowScheme.DefaultWorkflow)
}package main
import (
"context"
"fmt"
v3 "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")
)
instance, err := v3.New(nil, host)
if err != nil {
log.Fatal(err)
}
instance.Auth.SetBasicAuth(mail, token)
instance.Auth.SetUserAgent("curl/7.54.0")
workflowScheme, response, err := instance.Workflow.Scheme.Get(context.Background(), 10007, false)
if err != nil {
if response != nil {
log.Println(response.Bytes.String())
log.Println(response.Code)
}
log.Fatal(err)
}
fmt.Println(workflowScheme.Name)
fmt.Println(workflowScheme.Description)
fmt.Println(workflowScheme.ID)
fmt.Println(workflowScheme.Self)
fmt.Println(workflowScheme.DefaultWorkflow)
}
package main
import (
"context"
"fmt"
v3 "github.com/ctreminiom/go-atlassian/v2/jira/v3"
"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")
)
instance, err := v3.New(nil, host)
if err != nil {
log.Fatal(err)
}
instance.Auth.SetBasicAuth(mail, token)
instance.Auth.SetUserAgent("curl/7.54.0")
payload := &models.WorkflowSchemePayloadScheme{
Name: "Example workflow scheme - UPDATED",
Description: "The description of the example workflow scheme.",
IssueTypeMappings: map[string]interface{}{
"10002": "PV: Project Management Workflow",
"10005": "Software Simplified Workflow for Project K2",
},
UpdateDraftIfNeeded: true,
}
workflowSchemeUpdated, response, err := instance.Workflow.Scheme.Update(context.Background(), 10003, payload)
if err != nil {
if response != nil {
log.Println(response.Bytes.String())
log.Println(response.Code)
}
log.Fatal(err)
}
fmt.Println(workflowSchemeUpdated.Name)
fmt.Println(workflowSchemeUpdated.Description)
fmt.Println(workflowSchemeUpdated.ID)
fmt.Println(workflowSchemeUpdated.Self)
fmt.Println(workflowSchemeUpdated.DefaultWorkflow)
}package main
import (
"context"
v3 "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")
)
instance, err := v3.New(nil, host)
if err != nil {
log.Fatal(err)
}
instance.Auth.SetBasicAuth(mail, token)
instance.Auth.SetUserAgent("curl/7.54.0")
response, err := instance.Workflow.Scheme.Delete(context.Background(), 10003)
if err != nil {
if response != nil {
log.Println(response.Bytes.String())
log.Println(response.Code)
}
log.Fatal(err)
}
}package main
import (
"context"
"fmt"
v3 "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")
)
instance, err := v3.New(nil, host)
if err != nil {
log.Fatal(err)
}
instance.Auth.SetBasicAuth(mail, token)
instance.Auth.SetUserAgent("curl/7.54.0")
schemesByProject, response, err := instance.Workflow.Scheme.Associations(context.Background(), []int{10001})
if err != nil {
if response != nil {
log.Println(response.Bytes.String())
log.Println(response.Code)
}
log.Fatal(err)
}
for _, mapping := range schemesByProject.Values {
fmt.Println(mapping.WorkflowScheme.Name, mapping.WorkflowScheme.ID)
fmt.Println(mapping.ProjectIds)
}
}package main
import (
"context"
v3 "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")
)
instance, err := v3.New(nil, host)
if err != nil {
log.Fatal(err)
}
instance.Auth.SetBasicAuth(mail, token)
instance.Auth.SetUserAgent("curl/7.54.0")
response, err := instance.Workflow.Scheme.Assign(context.Background(), "10001", "10001")
if err != nil {
if response != nil {
log.Println(response.Bytes.String())
log.Println(response.Code)
}
log.Fatal(err)
}
}package main
import (
"context"
"fmt"
_ "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"
)
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")
options := &models.NotificationSchemeSearchOptions{
NotificationSchemeIDs: []string{"10000"},
ProjectIDs: nil,
OnlyDefault: false,
Expand: nil,
}
notificationSchemes, response, err := jira.NotificationScheme.Search(context.Background(), options, 0, 50)
if err != nil {
if response != nil {
log.Println("Response HTTP Response", response.Bytes.String())
}
log.Fatal(err)
}
for _, notificationScheme := range notificationSchemes.Values {
fmt.Println(notificationScheme)
}
}
package main
import (
"context"
"fmt"
_ "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"
)
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")
payload := &models.NotificationSchemePayloadScheme{
Description: "Notification Scheme #2",
Name: "Notification Scheme Description sample",
Events: []*models.NotificationSchemePayloadEventScheme{
{
Event: &models.NotificationSchemeEventTypeScheme{
ID: "1",
},
Notifications: []*models.NotificationSchemeEventNotificationScheme{
{
NotificationType: "Group",
Parameter: "jira-administrators",
},
},
},
},
}
notificationScheme, response, err := jira.NotificationScheme.Create(context.Background(), payload)
if err != nil {
if response != nil {
log.Println("Response HTTP Response", response.Bytes.String())
}
log.Fatal(err)
}
fmt.Println(notificationScheme.Id)
}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")
mapping, response, err := jira.NotificationScheme.Projects(context.Background(), nil, nil, 0, 50)
if err != nil {
if response != nil {
log.Println("Response HTTP Response", response.Bytes.String())
}
log.Fatal(err)
}
for _, element := range mapping.Values {
fmt.Println(element.NotificationSchemeId, element.ProjectId)
}
}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"
)
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")
payload := &models.NotificationSchemePayloadScheme{
Description: "description update sample",
Name: "new notification scheme name",
}
response, err := jira.NotificationScheme.Update(context.Background(), "10002", payload)
if err != nil {
if response != nil {
log.Println("Response HTTP Response", response.Bytes.String())
}
log.Fatal(err)
}
}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")
notificationScheme, response, err := jira.NotificationScheme.Get(context.Background(), "10000", []string{"all"})
if err != nil {
if response != nil {
log.Println("Response HTTP Response", response.Bytes.String())
}
log.Fatal(err)
}
fmt.Println(notificationScheme.Self)
fmt.Println(notificationScheme.Name)
fmt.Println(notificationScheme.ID)
fmt.Println(notificationScheme.Description)
fmt.Println(notificationScheme.Scope)
fmt.Println(notificationScheme.NotificationSchemeEvents)
}package main
import (
"context"
_ "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")
response, err := jira.NotificationScheme.Delete(context.Background(), "10002")
if err != nil {
if response != nil {
log.Println("Response HTTP Response", response.Bytes.String())
}
log.Fatal(err)
}
}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"
)
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")
payload := &models.NotificationSchemeEventsPayloadScheme{
NotificationSchemeEvents: []*models.NotificationSchemePayloadEventScheme{
{
Event: &models.NotificationSchemeEventTypeScheme{
ID: "1",
},
Notifications: []*models.NotificationSchemeEventNotificationScheme{
{
NotificationType: "Group",
Parameter: "jira-administrators",
},
},
},
},
}
response, err := jira.NotificationScheme.Append(context.Background(), "10002", payload)
if err != nil {
if response != nil {
log.Println("Response HTTP Response", response.Bytes.String())
}
log.Fatal(err)
}
}package main
import (
"context"
_ "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")
response, err := jira.NotificationScheme.Remove(context.Background(), "10002", "10000")
if err != nil {
if response != nil {
log.Println("Response HTTP Response", response.Bytes.String())
}
log.Fatal(err)
}
}package main
import (
"context"
"fmt"
_ "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)
versions, response, err := atlassian.Project.Version.Gets(context.Background(), "KP")
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 _, version := range versions {
fmt.Println(version)
}
}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.VersionPayloadScheme{
Archived: false,
ReleaseDate: "2021-03-06",
Name: "Version Sandbox",
Description: "Version Sandbox description",
ProjectID: 10000,
Released: false,
StartDate: "2021-03-02",
}
newVersion, response, err := atlassian.Project.Version.Create(context.Background(), payload)
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)
log.Printf("The new version has been created with the ID %v", newVersion.ID)
}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)
version, response, err := atlassian.Project.Version.Get(context.Background(), "10002", []string{"issuesstatus", "operations"})
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)
log.Println(version)
}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.VersionPayloadScheme{
Archived: false,
Name: "Version Sandbox - UPDATED",
Description: "Version Sandbox description - UPDATED",
ProjectID: 10000,
Released: true,
}
versionUpdated, response, err := atlassian.Project.Version.Update(context.Background(), "10002", payload)
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)
log.Println(versionUpdated)
}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)
response, err := atlassian.Project.Version.Merge(context.Background(), "10001", "10000")
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)
}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)
count, response, err := atlassian.Project.Version.RelatedIssueCounts(context.Background(), "10002")
if err != nil {
log.Fatal(err)
}
log.Println(response.Endpoint)
log.Println(count)
}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)
count, response, err := atlassian.Project.Version.UnresolvedIssueCount(context.Background(), "10000")
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)
log.Println(count)
}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)
permissionSchemes, response, err := atlassian.Permission.Scheme.Gets(context.Background())
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
for _, permissionScheme := range permissionSchemes.PermissionSchemes {
log.Println(permissionScheme.ID, permissionScheme.Name)
}
}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 (
permissionSchemeID = 10001
expand = []string{"field", "group", "permissions", "projectRole", "user"}
)
permissionScheme, response, err := atlassian.Permission.Scheme.Get(context.Background(), permissionSchemeID, expand)
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
log.Println(permissionScheme)
}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.PermissionSchemeScheme{
Name: "EF Permission Scheme",
Description: "EF Permission Scheme description",
Permissions: []*models.PermissionGrantScheme{
{
Permission: "ADMINISTER_PROJECTS",
Holder: &models.PermissionGrantHolderScheme{
Parameter: "jira-administrators-system",
Type: "group",
},
},
{
Permission: "CLOSE_ISSUES",
Holder: &models.PermissionGrantHolderScheme{
Type: "assignee",
},
},
},
}
permissionScheme, response, err := atlassian.Permission.Scheme.Create(context.Background(), payload)
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
log.Println(permissionScheme)
}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 permissionSchemeID = 10004
response, err := atlassian.Permission.Scheme.Delete(context.Background(), permissionSchemeID)
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
}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.PermissionSchemeScheme{
Name: "EF Permission Scheme - UPDATED",
Description: "EF Permission Scheme description - UPDATED",
Permissions: []*models.PermissionGrantScheme{
{
Permission: "CLOSE_ISSUES",
Holder: &models.PermissionGrantHolderScheme{
Parameter: "jira-administrators-system",
Type: "group",
},
},
},
}
permissionScheme, response, err := atlassian.Permission.Scheme.Update(context.Background(), 10004, payload)
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
log.Println(permissionScheme.Name)
log.Println(permissionScheme.ID)
log.Println(permissionScheme.Description)
log.Println(permissionScheme.Self)
for _, permissionGrant := range permissionScheme.Permissions {
log.Println(permissionGrant.ID, permissionGrant.Permission)
}
}package main
import (
"context"
"fmt"
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)
options := &models.WorkflowStatusSearchParams{
ProjectID: "10000",
StatusCategory: "IN_PROGRESS",
Expand: []string{"usages"},
}
var projectStatuses []*models.WorkflowStatusDetailScheme
var startAt int
for {
page, response, err := atlassian.Workflow.Status.Search(context.Background(), options, startAt, 50)
if err != nil {
log.Println(response.Code)
log.Println(response.Endpoint)
log.Fatal(err)
}
projectStatuses = append(projectStatuses, page.Values...)
if page.IsLast {
break
}
startAt = startAt + 50
}
for _, status := range projectStatuses {
fmt.Println(status.Name, status.ID, status.StatusCategory)
fmt.Println("--------------------------------")
fmt.Println("Status Name:", status.Name)
fmt.Println("Status ID:", status.ID)
fmt.Println("Status Category:", status.StatusCategory)
for index, project := range status.Usages {
fmt.Println("--- Project Usage #", index)
fmt.Println("---- Project ID:", project.Project.ID)
fmt.Println("---- Project IssueTypes:", project.IssueTypes)
}
fmt.Println("--------------------------------")
}
}package main
import (
"context"
"fmt"
v2 "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)
statuses, response, err := atlassian.Workflow.Status.Gets(context.Background(), []string{"401", "400", "10008"}, []string{"usages"})
if err != nil {
log.Println(response.Code)
log.Println(response.Endpoint)
log.Fatal(err)
}
for _, status := range statuses {
fmt.Println(status.Name, status.ID, status.StatusCategory)
fmt.Println("--------------------------------")
fmt.Println("Status Name:", status.Name)
fmt.Println("Status ID:", status.ID)
fmt.Println("Status Category:", status.StatusCategory)
for index, project := range status.Usages {
fmt.Println("--- Project Usage #", index)
fmt.Println("---- Project ID:", project.Project.ID)
fmt.Println("---- Project IssueTypes:", project.IssueTypes)
}
fmt.Println("--------------------------------")
}
}package main
import (
"context"
"fmt"
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.WorkflowStatusPayloadScheme{
Statuses: []*models.WorkflowStatusNodeScheme{
{
Name: "UAT TEST",
StatusCategory: "IN_PROGRESS",
Description: "status description",
},
{
Name: "Stage TEST",
StatusCategory: "IN_PROGRESS",
Description: "status description",
},
},
Scope: &models.WorkflowStatusScopeScheme{
Type: "GLOBAL",
},
}
statuses, response, err := atlassian.Workflow.Status.Create(context.Background(), payload)
if err != nil {
log.Println(response.Code)
log.Println(response.Endpoint)
log.Println(response.Bytes.String())
log.Fatal(err)
}
for _, status := range statuses {
fmt.Println(status.Name, status.ID, status.StatusCategory)
fmt.Println("--------------------------------")
fmt.Println("Status Name:", status.Name)
fmt.Println("Status ID:", status.ID)
fmt.Println("Status Category:", status.StatusCategory)
fmt.Println("--------------------------------")
}
}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.WorkflowStatusPayloadScheme{
Statuses: []*models.WorkflowStatusNodeScheme{
{
ID: "10013",
Name: "UAT Finished",
StatusCategory: "DONE",
Description: "status description",
},
{
ID: "10014",
Name: "Stage Finished",
StatusCategory: "DONE",
Description: "status description",
},
},
}
response, err := atlassian.Workflow.Status.Update(context.Background(), payload)
if err != nil {
log.Println(response.Code)
log.Println(response.Endpoint)
log.Println(response.Bytes.String())
log.Fatal(err)
}
}package main
import (
"context"
v2 "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.Workflow.Status.Delete(context.Background(), []string{"10013", "10014"})
if err != nil {
log.Println(response.Code)
log.Println(response.Endpoint)
log.Println(response.Bytes.String())
log.Fatal(err)
}
}package main
import (
"context"
"fmt"
v3 "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")
)
instance, err := v3.New(nil, host)
if err != nil {
log.Fatal(err)
}
instance.Auth.SetBasicAuth(mail, token)
instance.Auth.SetUserAgent("curl/7.54.0")
activeStatuses, response, err := instance.Workflow.Status.Bulk(context.Background())
if err != nil {
if response != nil {
log.Println(response.Bytes.String())
log.Println(response.Code)
}
log.Fatal(err)
}
for _, status := range activeStatuses {
fmt.Println(status.Name, status.ID)
}
}package main
import (
"context"
"fmt"
v3 "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")
)
instance, err := v3.New(nil, host)
if err != nil {
log.Fatal(err)
}
instance.Auth.SetBasicAuth(mail, token)
instance.Auth.SetUserAgent("curl/7.54.0")
status, response, err := instance.Workflow.Status.Get(context.Background(), "Open")
if err != nil {
if response != nil {
log.Println(response.Bytes.String())
log.Println(response.Code)
}
log.Fatal(err)
}
fmt.Println(status.Name, status.ID)
}
package main
import (
"context"
"github.com/ctreminiom/go-atlassian/jira/agile"
"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 := agile.New(nil, host)
if err != nil {
return
}
atlassian.Auth.SetBasicAuth(mail, token)
atlassian.Auth.SetUserAgent("curl/7.54.0")
payload := &models.SprintPayloadScheme{
Name: "Sprint XX",
StartDate: "2015-04-11T15:22:00.000+10:00",
EndDate: "2015-04-20T01:22:00.000+10:00",
OriginBoardID: 4,
Goal: "Sprint XX goal",
}
sprint, response, err := atlassian.Sprint.Create(context.Background(), payload)
if err != nil {
if response != nil {
log.Println("Response HTTP Response", response.Bytes.String())
}
log.Fatal(err)
}
log.Println("Response HTTP Code", response.Bytes.String())
log.Println("HTTP Endpoint Used", response.Endpoint)
log.Println(sprint)
}package main
import (
"context"
"github.com/ctreminiom/go-atlassian/jira/agile"
"log"
"os"
)
func main() {
var (
host = os.Getenv("HOST")
mail = os.Getenv("MAIL")
token = os.Getenv("TOKEN")
)
atlassian, err := agile.New(nil, host)
if err != nil {
return
}
atlassian.Auth.SetBasicAuth(mail, token)
atlassian.Auth.SetUserAgent("curl/7.54.0")
sprint, response, err := atlassian.Sprint.Get(context.Background(), 3)
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)
log.Println(sprint)
}package main
import (
"context"
"github.com/ctreminiom/go-atlassian/jira/agile"
"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 := agile.New(nil, host)
if err != nil {
return
}
atlassian.Auth.SetBasicAuth(mail, token)
atlassian.Auth.SetUserAgent("curl/7.54.0")
payload := &models.SprintPayloadScheme{
Name: "Sprint XX-Updated",
Goal: "Sprint XX goal-Updated",
State: "Active",
StartDate: "2020-04-11T15:22:00.000+10:00",
EndDate: "2021-04-20T01:22:00.000+10:00",
}
sprint, response, err := atlassian.Sprint.Update(context.Background(), 2, payload)
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)
log.Println(sprint.Name, sprint.Goal)
}package main
import (
"context"
"github.com/ctreminiom/go-atlassian/jira/agile"
"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 := agile.New(nil, host)
if err != nil {
return
}
atlassian.Auth.SetBasicAuth(mail, token)
atlassian.Auth.SetUserAgent("curl/7.54.0")
payload := &models.SprintPayloadScheme{
Name: "Sprint XX-Patched",
}
sprint, response, err := atlassian.Sprint.Path(context.Background(), 2, payload)
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)
log.Println(sprint.Name, sprint.Goal)
}package main
import (
"context"
"github.com/ctreminiom/go-atlassian/jira/agile"
"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 := agile.New(nil, host)
if err != nil {
return
}
atlassian.Auth.SetBasicAuth(mail, token)
atlassian.Auth.SetUserAgent("curl/7.54.0")
options := &models.IssueOptionScheme{
JQL: "",
Fields: nil,
Expand: nil,
ValidateQuery: false,
}
issues, response, err := atlassian.Sprint.Issues(context.Background(), 2, options, 0, 50)
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)
log.Println(issues.Total)
log.Println(issues.Expand)
log.Println(issues.MaxResults)
log.Println(issues.StartAt)
for _, issue := range issues.Issues {
log.Println(issue.Key, issue.ID)
}
}package main
import (
"context"
"github.com/ctreminiom/go-atlassian/jira/agile"
"log"
"os"
)
func main() {
var (
host = os.Getenv("HOST")
mail = os.Getenv("MAIL")
token = os.Getenv("TOKEN")
)
atlassian, err := agile.New(nil, host)
if err != nil {
return
}
atlassian.Auth.SetBasicAuth(mail, token)
atlassian.Auth.SetUserAgent("curl/7.54.0")
response, err := atlassian.Sprint.Start(context.Background(), 3)
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)
}package main
import (
"context"
"github.com/ctreminiom/go-atlassian/jira/agile"
"log"
"os"
)
func main() {
var (
host = os.Getenv("HOST")
mail = os.Getenv("MAIL")
token = os.Getenv("TOKEN")
)
atlassian, err := agile.New(nil, host)
if err != nil {
return
}
atlassian.Auth.SetBasicAuth(mail, token)
atlassian.Auth.SetUserAgent("curl/7.54.0")
response, err := atlassian.Sprint.Start(context.Background(), 3)
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)
}package main
import (
"context"
"github.com/ctreminiom/go-atlassian/jira/agile"
"log"
"os"
)
func main() {
var (
host = os.Getenv("HOST")
mail = os.Getenv("MAIL")
token = os.Getenv("TOKEN")
)
atlassian, err := agile.New(nil, host)
if err != nil {
return
}
atlassian.Auth.SetBasicAuth(mail, token)
atlassian.Auth.SetUserAgent("curl/7.54.0")
response, err := atlassian.Sprint.Delete(context.Background(), 3)
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)
}package main
import (
"context"
"github.com/ctreminiom/go-atlassian/jira/agile"
"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 := agile.New(nil, host)
if err != nil {
return
}
atlassian.Auth.SetBasicAuth(mail, token)
atlassian.Auth.SetUserAgent("curl/7.54.0")
options := &models.SprintMovePayloadScheme{
Issues: nil,
RankBeforeIssue: "",
RankAfterIssue: "",
RankCustomFieldId: 0,
}
response, err := atlassian.Sprint.Move(context.Background(), 3, options)
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)
}package main
import (
"context"
_ "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")
)
jiraCloud, err := v3.New(nil, host)
if err != nil {
return
}
jiraCloud.Auth.SetBasicAuth(mail, token)
jiraCloud.Auth.SetUserAgent("curl/7.54.0")
dashboards, response, err := jiraCloud.Dashboard.Gets(context.Background(), 0, 50, "")
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
for _, dashboard := range dashboards.Dashboards {
log.Println(dashboard.ID, dashboard.Name)
}
}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"
)
func main() {
var (
host = os.Getenv("HOST")
mail = os.Getenv("MAIL")
token = os.Getenv("TOKEN")
)
jiraCloud, err := v3.New(nil, host)
if err != nil {
return
}
jiraCloud.Auth.SetBasicAuth(mail, token)
jiraCloud.Auth.SetUserAgent("curl/7.54.0")
var payload = &models.DashboardPayloadScheme{
Name: "Team Tracking 4",
Description: "description sample",
SharePermissions: []*models.SharePermissionScheme{
{
Type: "project",
Project: &models.ProjectScheme{
ID: "10000",
},
Role: nil,
Group: nil,
},
{
Type: "group",
Group: &models.GroupScheme{Name: "jira-administrators"},
},
},
}
dashboard, response, err := jiraCloud.Dashboard.Create(context.Background(), payload)
if err != nil {
log.Fatal(err)
}
log.Println("Response HTTP Code", response.Code)
log.Println("HTTP Endpoint Used", response.Endpoint)
log.Printf("Dashboard Name: %v", dashboard.Name)
log.Printf("Dashboard ID: %v", dashboard.ID)
log.Printf("Dashboard View: %v", dashboard.View)
}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"
)
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")
searchOptions := models.DashboardSearchOptionsScheme{
DashboardName: "Bug",
GroupPermissionName: "administrators",
OrderBy: "description",
Expand: []string{"description", "favourite", "sharePermissions"},
}
dashboards, response, err := jira.Dashboard.Search(context.Background(), &searchOptions, 0, 50)
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
for _, dashboard := range dashboards.Values {
log.Printf("Dashboard Name: %v", dashboard.Name)
log.Printf("Dashboard ID: %v", dashboard.ID)
log.Printf("Dashboard View: %v", dashboard.View)
if dashboard.SharePermissions != nil {
for _, permission := range dashboard.SharePermissions {
log.Println(permission)
}
}
}
}package main
import (
"context"
_ "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")
dashboard, response, err := jira.Dashboard.Get(context.Background(), "10001")
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
log.Printf("Dashboard Name: %v", dashboard.Name)
log.Printf("Dashboard ID: %v", dashboard.ID)
log.Printf("Dashboard View: %v", dashboard.View)
}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"
)
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")
var payload = &models.DashboardPayloadScheme{
Name: "Team Tracking #1111",
Description: "",
SharePermissions: []*models.SharePermissionScheme{
{
Type: "project",
Project: &models.ProjectScheme{
ID: "10000",
},
Role: nil,
Group: nil,
},
{
Type: "group",
Group: &models.GroupScheme{Name: "jira-administrators"},
},
},
}
dashboard, response, err := jira.Dashboard.Update(context.Background(), "10001", payload)
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
log.Printf("Dashboard Name: %v", dashboard.Name)
log.Printf("Dashboard ID: %v", dashboard.ID)
log.Printf("Dashboard View: %v", dashboard.View)
}package main
import (
"context"
_ "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")
)
jiraCloud, err := v3.New(nil, host)
if err != nil {
return
}
jiraCloud.Auth.SetBasicAuth(mail, token)
jiraCloud.Auth.SetUserAgent("curl/7.54.0")
response, err := jiraCloud.Dashboard.Delete(context.Background(), "10003")
if err != nil {
log.Fatal(err)
}
log.Println("Response HTTP Code", response.Code)
log.Println("HTTP Endpoint Used", response.Endpoint)
}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"
)
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")
var payload = &models.DashboardPayloadScheme{
Name: "Team Tracking #2 copy",
Description: "Description sample",
SharePermissions: []*models.SharePermissionScheme{
{
Type: "project",
Project: &models.ProjectScheme{
ID: "10000",
},
Role: nil,
Group: nil,
},
{
Type: "group",
Group: &models.GroupScheme{Name: "jira-administrators"},
},
},
}
dashboard, response, err := jira.Dashboard.Copy(context.Background(), "10001", payload)
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)
log.Printf("Dashboard Name: %v", dashboard.Name)
log.Printf("Dashboard ID: %v", dashboard.ID)
log.Printf("Dashboard View: %v", dashboard.View)
}
const (
BusinessContentManagement = "com.atlassian.jira-core-project-templates:jira-core-simplified-content-management"
BusinessDocumentApproval = "com.atlassian.jira-core-project-templates:jira-core-simplified-document-approval"
BusinessLeadTracking = "com.atlassian.jira-core-project-templates:jira-core-simplified-lead-tracking"
BusinessProcessControl = "com.atlassian.jira-core-project-templates:jira-core-simplified-process-control"
BusinessProcurement = "com.atlassian.jira-core-project-templates:jira-core-simplified-procurement"
BusinessProjectManagement = "com.atlassian.jira-core-project-templates:jira-core-simplified-project-management"
BusinessRecruitment = "com.atlassian.jira-core-project-templates:jira-core-simplified-recruitment"
BusinessTaskTracking = "com.atlassian.jira-core-project-templates:jira-core-simplified-task-tracking"
ITSMServiceDesk = "com.atlassian.servicedesk:simplified-it-service-desk"
ITSMInternalServiceDesk = "com.atlassian.servicedesk:simplified-internal-service-desk"
ITSMExternalServiceDesk = "com.atlassian.servicedesk:simplified-external-service-desk"
SoftwareTeamManagedKanban = "com.pyxis.greenhopper.jira:gh-simplified-agility-kanban"
SoftwareTeamManagedScrum = "com.pyxis.greenhopper.jira:gh-simplified-agility-scrum"
SoftwareCompanyManagedKanban = "com.pyxis.greenhopper.jira:gh-simplified-kanban-classic"
SoftwareCompanyManagedScrum = "com.pyxis.greenhopper.jira:gh-simplified-scrum-classic"
)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.ProjectPayloadScheme{
NotificationScheme: 10021,
Description: "Example Project description",
LeadAccountID: "5b86be50b8e3cb5895860d6d",
URL: "https://atlassian.com",
ProjectTemplateKey: "com.pyxis.greenhopper.jira:gh-simplified-agility-kanban",
AvatarID: 10200,
IssueSecurityScheme: 10001,
Name: "Project DUMMY #3",
PermissionScheme: 10011,
AssigneeType: "PROJECT_LEAD",
ProjectTypeKey: "software",
Key: "DUMMY3",
CategoryID: 10120,
}
newProject, response, err := atlassian.Project.Create(context.Background(), payload)
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
log.Println("-------------------")
log.Println(newProject.ID)
log.Println(newProject.Self)
log.Println(newProject.Key)
log.Println("-------------------")
}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)
options := &models.ProjectSearchOptionsScheme{
OrderBy: "issueCount",
Action: "browse",
Expand: []string{"insight", "lead", "issueTypes", "projectKeys", "description"},
}
var (
startAt = 0
maxResults = 50
)
projects, response, err := atlassian.Project.Search(context.Background(), options, startAt, maxResults)
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
for _, project := range projects.Values {
log.Println(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)
project, response, err := atlassian.Project.Get(context.Background(), "KP", []string{"issueTypes"})
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
log.Println(project)
for _, issueType := range project.IssueTypes {
log.Println(issueType.Name)
}
}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.ProjectUpdateScheme{
Description: "Example Project description",
}
projectUpdated, response, err := atlassian.Project.Update(context.Background(), "KP", payload)
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
log.Println(projectUpdated)
}
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")
)
jiraCloud, err := v2.New(nil, host)
if err != nil {
return
}
jiraCloud.Auth.SetBasicAuth(mail, token)
jiraCloud.Auth.SetUserAgent("curl/7.54.0")
response, err := jiraCloud.Project.Delete(context.Background(), "DUM", true)
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
}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)
response, err := atlassian.Project.Archive(context.Background(), "PK")
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
}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")
)
jiraCloud, err := v2.New(nil, host)
if err != nil {
return
}
jiraCloud.Auth.SetBasicAuth(mail, token)
jiraCloud.Auth.SetUserAgent("curl/7.54.0")
task, response, err := jiraCloud.Project.DeleteAsynchronously(context.Background(), "DUM")
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
log.Println(task.ID)
log.Println(task)
}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")
)
jiraCloud, err := v2.New(nil, host)
if err != nil {
return
}
jiraCloud.Auth.SetBasicAuth(mail, token)
jiraCloud.Auth.SetUserAgent("curl/7.54.0")
projectRestored, response, err := jiraCloud.Project.Restore(context.Background(), "DUM")
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
log.Println(projectRestored)
}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)
statuses, response, err := atlassian.Project.Statuses(context.Background(), "KP")
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
for _, status := range statuses {
log.Println(status)
}
}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)
notificationScheme, response, err := atlassian.Project.NotificationScheme(context.Background(), "KP", []string{"all"})
if err != nil {
log.Fatal(err)
}
log.Println("HTTP Endpoint Used", response.Endpoint)
log.Println(notificationScheme)
log.Println(notificationScheme.Name, notificationScheme.ID)
for _, event := range notificationScheme.NotificationSchemeEvents {
log.Println(event.Event.ID, event.Event.Name)
for index, notification := range event.Notifications {
log.Println(index, event.Event.Name, notification.ID, notification.NotificationType, notification.Parameter)
}
}
}A board displays issues from one or more projects, giving you a flexible way of viewing, managing, and reporting on work in progress.
package main
import (
"context"
"github.com/ctreminiom/go-atlassian/jira/agile"
"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 := agile.New(nil, host)
if err != nil {
return
}
atlassian.Auth.SetBasicAuth(mail, token)
atlassian.Auth.SetUserAgent("curl/7.54.0")
var (
options = &models.IssueOptionScheme{
JQL: "project = KP",
ValidateQuery: true,
Fields: []string{"status", "issuetype", "summary"},
Expand: []string{"changelog"},
}
boardID = 4
startAt = 0
maxResult = 50
)
issues, response, err := atlassian.Board.Backlog(context.Background(), boardID, startAt, maxResult, options)
if err != nil {
if response != nil {
log.Println("Response HTTP Response", string(response.Bytes.Bytes()))
}
log.Fatal(err)
}
log.Println("Response HTTP Code", response.Code)
log.Println("HTTP Endpoint Used", response.Endpoint)
for _, issue := range issues.Issues {
log.Println(issue.Key)
}
}package main
import (
"context"
"github.com/ctreminiom/go-atlassian/jira/agile"
"log"
"os"
)
func main() {
var (
host = os.Getenv("HOST")
mail = os.Getenv("MAIL")
token = os.Getenv("TOKEN")
)
atlassian, err := agile.New(nil, host)
if err != nil {
return
}
atlassian.Auth.SetBasicAuth(mail, token)
atlassian.Auth.SetUserAgent("curl/7.54.0")
boardConfig, response, err := atlassian.Board.Configuration(context.Background(), 4)
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)
log.Println(boardConfig)
}package main
import (
"context"
"github.com/ctreminiom/go-atlassian/jira/agile"
"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 := agile.New(nil, host)
if err != nil {
return
}
atlassian.Auth.SetBasicAuth(mail, token)
atlassian.Auth.SetUserAgent("curl/7.54.0")
newBoard := &models.BoardPayloadScheme{
Name: "DUMMY Board Name",
Type: "scrum", //scrum or kanban
FilterID: 10016,
// Omit the Location if you want to the board to yourself (location)
Location: &models.BoardPayloadLocationScheme{
ProjectKeyOrID: "KP",
Type: "project",
},
}
board, response, err := atlassian.Board.Create(context.Background(), newBoard)
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)
log.Println(board)
}
package main
import (
"context"
"github.com/ctreminiom/go-atlassian/jira/agile"
"log"
"os"
)
func main() {
var (
host = os.Getenv("HOST")
mail = os.Getenv("MAIL")
token = os.Getenv("TOKEN")
)
atlassian, err := agile.New(nil, host)
if err != nil {
return
}
atlassian.Auth.SetBasicAuth(mail, token)
atlassian.Auth.SetUserAgent("curl/7.54.0")
epicsPage, response, err := atlassian.Board.Epics(context.Background(), 4, 0, 50, false)
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 _, epic := range epicsPage.Values {
log.Println(epic)
}
}
package main
import (
"context"
"github.com/ctreminiom/go-atlassian/jira/agile"
"log"
"os"
)
func main() {
var (
host = os.Getenv("HOST")
mail = os.Getenv("MAIL")
token = os.Getenv("TOKEN")
)
atlassian, err := agile.New(nil, host)
if err != nil {
return
}
atlassian.Auth.SetBasicAuth(mail, token)
atlassian.Auth.SetUserAgent("curl/7.54.0")
var (
filterID = 10016
startAt = 0
maxResult = 50
)
boards, response, err := atlassian.Board.Filter(context.Background(), filterID, startAt, maxResult)
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 _, board := range boards.Values {
log.Println(board.Name, board.ID, board.Type)
}
}
package main
import (
"context"
"fmt"
"github.com/ctreminiom/go-atlassian/jira/agile"
"log"
"os"
)
func main() {
var (
host = os.Getenv("HOST")
mail = os.Getenv("MAIL")
token = os.Getenv("TOKEN")
)
atlassian, err := agile.New(nil, host)
if err != nil {
return
}
atlassian.Auth.SetBasicAuth(mail, token)
atlassian.Auth.SetUserAgent("curl/7.54.0")
board, response, err := atlassian.Board.Get(context.Background(), 4)
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)
log.Println(board)
log.Println(board.Location)
fmt.Println(response.Bytes.String())
}
package main
import (
"context"
"github.com/ctreminiom/go-atlassian/jira/agile"
"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 := agile.New(nil, host)
if err != nil {
return
}
atlassian.Auth.SetBasicAuth(mail, token)
atlassian.Auth.SetUserAgent("curl/7.54.0")
var (
options = &models.IssueOptionScheme{
//JQL: "project = KP",
//ValidateQuery: true,
Fields: []string{"status", "issuetype", "summary"},
Expand: []string{"changelog"},
}
boardID = 4
startAt = 0
maxResult = 50
)
issuesPage, response, err := atlassian.Board.Issues(context.Background(), boardID, options, startAt, maxResult)
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 _, issue := range issuesPage.Issues {
log.Println(issue.Key)
}
}package main
import (
"context"
"github.com/ctreminiom/go-atlassian/jira/agile"
"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 := agile.New(nil, host)
if err != nil {
return
}
atlassian.Auth.SetBasicAuth(mail, token)
atlassian.Auth.SetUserAgent("curl/7.54.0")
var (
options = &models.IssueOptionScheme{
//JQL: "project = KP",
//ValidateQuery: true,
Fields: []string{"status", "issuetype", "summary"},
Expand: []string{"changelog"},
}
boardID = 4
epicID = 10029
startAt = 0
maxResult = 50
)
issuesPage, response, err := atlassian.Board.IssuesByEpic(context.Background(), boardID, epicID, options, startAt, maxResult)
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 _, issue := range issuesPage.Issues {
log.Println(issue.Key)
}
}package main
import (
"context"
"github.com/ctreminiom/go-atlassian/jira/agile"
"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 := agile.New(nil, host)
if err != nil {
return
}
atlassian.Auth.SetBasicAuth(mail, token)
atlassian.Auth.SetUserAgent("curl/7.54.0")
var (
options = &models.IssueOptionScheme{
//JQL: "project = KP",
//ValidateQuery: true,
Fields: []string{"status", "issuetype", "summary"},
Expand: []string{"changelog"},
}
boardID = 4
sprintID = 4
startAt = 0
maxResult = 50
)
issuesPage, response, err := atlassian.Board.IssuesBySprint(context.Background(), boardID, sprintID, options, startAt, maxResult)
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 _, issue := range issuesPage.Issues {
log.Println(issue.Key)
}
}package main
import (
"context"
"github.com/ctreminiom/go-atlassian/jira/agile"
"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 := agile.New(nil, host)
if err != nil {
return
}
atlassian.Auth.SetBasicAuth(mail, token)
atlassian.Auth.SetUserAgent("curl/7.54.0")
var (
options = &models.IssueOptionScheme{
JQL: "project = KP",
ValidateQuery: true,
Fields: []string{"status", "issuetype", "summary"},
Expand: []string{"changelog"},
}
boardID = 4
startAt = 0
maxResult = 50
)
issuesPage, response, err := atlassian.Board.IssuesWithoutEpic(context.Background(), boardID, options, startAt, maxResult)
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 _, issue := range issuesPage.Issues {
log.Println(issue.Key)
}
}package main
import (
"context"
"github.com/ctreminiom/go-atlassian/jira/agile"
"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 := agile.New(nil, host)
if err != nil {
return
}
atlassian.Auth.SetBasicAuth(mail, token)
atlassian.Auth.SetUserAgent("curl/7.54.0")
var (
boardID = 7
payload = &models.BoardMovementPayloadScheme{
Issues: []string{"KP-3"},
RankBeforeIssue: "",
RankAfterIssue: "",
}
)
response, err := atlassian.Board.Move(context.Background(), boardID, payload)
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)
}package main
import (
"context"
"github.com/ctreminiom/go-atlassian/jira/agile"
"log"
"os"
)
func main() {
var (
host = os.Getenv("HOST")
mail = os.Getenv("MAIL")
token = os.Getenv("TOKEN")
)
atlassian, err := agile.New(nil, host)
if err != nil {
return
}
atlassian.Auth.SetBasicAuth(mail, token)
atlassian.Auth.SetUserAgent("curl/7.54.0")
projects, response, err := atlassian.Board.Projects(context.Background(), 4, 0, 50)
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 _, project := range projects.Values {
log.Println(project)
}
}package main
import (
"context"
"fmt"
"github.com/ctreminiom/go-atlassian/jira/agile"
"log"
"os"
)
func main() {
var (
host = os.Getenv("HOST")
mail = os.Getenv("MAIL")
token = os.Getenv("TOKEN")
)
atlassian, err := agile.New(nil, host)
if err != nil {
return
}
atlassian.Auth.SetBasicAuth(mail, token)
atlassian.Auth.SetUserAgent("curl/7.54.0")
var (
boardID = 4
states = []string{"future", "active"} // valid values: future, active, closed
startAt = 0
maxResult = 50
)
sprints, response, err := atlassian.Board.Sprints(context.Background(), boardID, startAt, maxResult, states)
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 _, sprint := range sprints.Values {
log.Println(sprint)
}
fmt.Println(response.Bytes.String())
}package main
import (
"context"
"fmt"
"github.com/ctreminiom/go-atlassian/jira/agile"
"log"
"os"
)
func main() {
var (
host = os.Getenv("HOST")
mail = os.Getenv("MAIL")
token = os.Getenv("TOKEN")
)
atlassian, err := agile.New(nil, host)
if err != nil {
return
}
atlassian.Auth.SetBasicAuth(mail, token)
atlassian.Auth.SetUserAgent("curl/7.54.0")
var (
boardID = 4
startAt = 0
maxResults = 50
released = false
)
versionsPage, response, err := atlassian.Board.Versions(context.Background(), boardID, startAt, maxResults, released)
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 _, version := range versionsPage.Values {
log.Println(version)
}
fmt.Println(response.Bytes.String())
}package main
import (
"context"
"github.com/ctreminiom/go-atlassian/jira/agile"
"log"
"os"
)
func main() {
var (
host = os.Getenv("HOST")
mail = os.Getenv("MAIL")
token = os.Getenv("TOKEN")
)
atlassian, err := agile.New(nil, host)
if err != nil {
return
}
atlassian.Auth.SetBasicAuth(mail, token)
atlassian.Auth.SetUserAgent("curl/7.54.0")
response, err := atlassian.Board.Delete(context.Background(), 4)
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)
}package main
import (
"context"
"github.com/ctreminiom/go-atlassian/jira/agile"
"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 := agile.New(nil, host)
if err != nil {
return
}
atlassian.Auth.SetBasicAuth(mail, token)
atlassian.Auth.SetUserAgent("curl/7.54.0")
options := &models.GetBoardsOptions{
BoardType: "",
BoardName: "",
ProjectKeyOrID: "",
AccountIDLocation: "",
ProjectIDLocation: "",
IncludePrivate: true,
NegateLocationFiltering: false,
OrderBy: "",
Expand: "",
FilterID: 0,
}
boards, response, err := atlassian.Board.Gets(context.Background(), options, 0, 50)
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 _, board := range boards.Values {
log.Println(board)
}
}
{
"ruleKey": "system:validate-field-value",
"parameters": {
"ruleType": "fieldRequired",
"fieldsRequired": "assignee",
"ignoreContext": "true",
"errorMessage": "An assignee must be set!"
}
}{
Type: "RemoteOnlyCondition",
},{
Type: "BlockInProgressApprovalCondition",
}{
Type: "CompareNumberCFCondition",
Configuration: map[string]interface{}{
"comparator": "=",
"fieldId": "customfield_10029",
"fieldValue": 2,
},
}{
Type: "RemoteOnlyCondition",
}{
Type: "AllowOnlyAssignee",
}{
Type: "AllowOnlyReporter",
}{
Type: "PermissionCondition",
Configuration: map[string]interface{}{
"permissionKey": "BROWSE_PROJECTS",
},
},{
Type: "PreviousStatusCondition",
Configuration: map[string]interface{}{
"ignoreLoopTransitions": true,
"includeCurrentStatus": true,
"mostRecentStatusOnly": true,
"reverseCondition": true,
"previousStatus": map[string]interface{}{
"id": "5",
},
},
}{
Type: "SeparationOfDutiesCondition",
Configuration: map[string]interface{}{
"fromStatus": map[string]interface{}{"id": "5"},
"toStatus": map[string]interface{}{"id": "6"},
},
}{
Type: "SubTaskBlockingCondition",
Configuration: map[string]interface{}{
"statuses": []map[string]interface{}{
{
"id": "1",
},
{
"id": "3",
},
},
},
},{
Type: "UserInAnyGroupCondition",
Configuration: map[string]interface{}{
"groups": []string{"administrators", "atlassian-addons-admin"},
},
}{
Type: "InAnyProjectRoleCondition",
Configuration: map[string]interface{}{
"projectRoles": []map[string]interface{}{
{
"id": "10002",
},
{
"id": "10003",
},
{
"id": "10012",
},
{
"id": "10013",
},
},
},
}{
Type: "UserIsInCustomFieldCondition",
Configuration: map[string]interface{}{
"allowUserInField": false,
"fieldId": "customfield_10010",
},
}{
Type: "UserInGroupCondition",
Configuration: map[string]interface{}{
"group": "administrators",
},
}{
Type: "InGroupCFCondition",
Configuration: map[string]interface{}{
"fieldId": "customfield_10012",
},
}{
Type: "InProjectRoleCondition",
Configuration: map[string]interface{}{
"projectRole": map[string]interface{}{
"id": "10002",
},
},
}{
Type: "ValueFieldCondition",
Configuration: map[string]interface{}{
"fieldId": "assignee",
"fieldValue": "qm:6e1ecee6-8e64-4db6-8c85-916bb3275f51:54b56885-2bd2-4381-8239-78263442520f",
"comparisonType": "NUMBER",
"comparator": "=",
},
}{
Type: "DateFieldValidator",
Configuration: map[string]interface{}{
"comparator": ">",
"date1": "updated",
"date2": "created",
"expression": "1d",
"includeTime": true,
},
}{
Type: "WindowsDateValidator",
Configuration: map[string]interface{}{
"date1": "customfield_10009",
"date2": "created",
"windowsDays": 5,
},
}{
Type: "FieldRequiredValidator",
Configuration: map[string]interface{}{
"ignoreContext": true,
"errorMessage": "Hey",
"fieldIds": []string{
"versions",
"customfield_10037",
"customfield_10003",
},
},
}{
Type: "FieldChangedValidator",
Configuration: map[string]interface{}{
"fieldId": "comment",
"errorMessage": "Hey",
"exemptedGroups": []string{
"administrators",
"atlassian-addons-admin",
},
},
}{
Type: "FieldHasSingleValueValidator",
Configuration: map[string]interface{}{
"fieldId": "attachment",
"excludeSubtasks": true,
},
}{
Type: "ParentStatusValidator",
Configuration: map[string]interface{}{
"parentStatuses": []map[string]interface{}{
{
"id": "2",
},
{
"id": "1",
},
},
},
}{
Type: "PermissionValidator",
Configuration: map[string]interface{}{
"permissionKey": "ADMINISTER_PROJECTS",
},
},{
Type: "PreviousStatusValidator",
Configuration: map[string]interface{}{
"mostRecentStatusOnly": false,
"previousStatus": map[string]interface{}{"id": "15"},
},
},{
Type: "RegexpFieldValidator",
Configuration: map[string]interface{}{
"regExp": "[0-9]",
"fieldId": "customfield_10029",
},
},{
Type: "UserPermissionValidator",
Configuration: map[string]interface{}{
"permissionKey": "BROWSE_PROJECTS",
"nullAllowed": false,
"username": "TestUser",
},
},{
Type: "FireIssueEventFunction",
Configuration: map[string]interface{}{
"event": map[string]interface{}{"id": "1"},
},
},{
Type: "UpdateIssueStatusFunction",
}{
Type: "CreateCommentFunction",
}{
Type: "CreateCommentFunction",
}{
Type: "CreateCommentFunction",
}{
Type: "CreateCommentFunction",
}{
Type: "CreateCommentFunction",
}{
Type: "ClearFieldValuePostFunction",
Configuration: map[string]interface{}{
"fieldId": "assignee",
},
},{
Type: "CopyValueFromOtherFieldPostFunction",
Configuration: map[string]interface{}{
"sourceFieldId": "assignee",
"destinationFieldId": "creator",
"copyType": "same",
},
},{
Type: "UpdateIssueCustomFieldPostFunction",
Configuration: map[string]interface{}{
"mode": "append",
"fieldId": "customfield_10003",
"fieldValue": "yikes",
},
},{
Type: "UpdateIssueFieldFunction",
Configuration: map[string]interface{}{
"fieldId": "assignee",
"fieldValue": "5f0c277e70b8a90025a00776",
},
},package main
import (
"context"
v3 "github.com/ctreminiom/go-atlassian/jira/v3"
"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")
)
instance, err := v3.New(nil, host)
if err != nil {
log.Fatal(err)
}
instance.Auth.SetBasicAuth(mail, token)
instance.Auth.SetUserAgent("curl/7.54.0")
payload := &models.WorkflowPayloadScheme{
Name: "Workflow Sample",
Description: "description of the workflow sample",
Statuses: []*models.WorkflowTransitionScreenScheme{
{
ID: "1", // Open
Properties: map[string]interface{}{
"jira.issue.editable": true,
},
},
{
ID: "3", // In Progress
},
},
Transitions: []*models.WorkflowTransitionPayloadScheme{
{
Name: "Open",
To: "1",
Type: "initial",
},
{
Name: "Open",
From: []string{"1"},
Properties: map[string]interface{}{
"custom-property": "custom-value",
},
Rules: &models.WorkflowTransitionRulePayloadScheme{
Conditions: &models.WorkflowConditionScheme{
Conditions: []*models.WorkflowConditionScheme{
{
Type: "RemoteOnlyCondition",
},
{
Configuration: map[string]interface{}{
"groups": []string{"confluence-users", "scrum-masters"},
},
Type: "UserInAnyGroupCondition",
},
},
Operator: "AND",
},
},
To: "3",
Type: "directed",
},
},
}
newWorkflow, response, err := instance.Workflow.Create(context.Background(), payload)
if err != nil {
if response != nil {
log.Println(response.Bytes.String())
log.Println(response.Code)
}
log.Fatal(err)
}
log.Println(newWorkflow.Name)
log.Println(newWorkflow.EntityID)
}
package main
import (
"context"
"fmt"
v3 "github.com/ctreminiom/go-atlassian/jira/v3"
"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")
)
instance, err := v3.New(nil, host)
if err != nil {
log.Fatal(err)
}
instance.Auth.SetBasicAuth(mail, token)
instance.Auth.SetUserAgent("curl/7.54.0")
options := &models.WorkflowSearchOptions{
WorkflowName: nil,
Expand: []string{"transitions", "statuses", "default", "schemes", "projects", "hasDraftWorkflow", "operations"},
QueryString: "",
OrderBy: "name",
IsActive: false,
}
workflows, response, err := instance.Workflow.Gets(context.Background(), options, 0, 50)
if err != nil {
if response != nil {
log.Println(response.Bytes.String())
log.Println(response.Code)
}
log.Fatal(err)
}
for _, workflow := range workflows.Values {
fmt.Println(workflow.ID, workflow.Description, len(workflow.Statuses))
}
}package main
import (
"context"
v3 "github.com/ctreminiom/go-atlassian/jira/v3"
"log"
"os"
)
func main() {
var (
host = os.Getenv("HOST")
mail = os.Getenv("MAIL")
token = os.Getenv("TOKEN")
)
instance, err := v3.New(nil, host)
if err != nil {
log.Fatal(err)
}
instance.Auth.SetBasicAuth(mail, token)
instance.Auth.SetUserAgent("curl/7.54.0")
response, err := instance.Workflow.Delete(context.Background(), "6f2a8273-7f30-4444-96ad-7ddb5d4c9f8e")
if err != nil {
if response != nil {
log.Println(response.Bytes.String())
log.Println(response.Code)
}
log.Fatal(err)
}
}package main
import (
"context"
"encoding/json"
"fmt"
"github.com/ctreminiom/go-atlassian/v2/jira/v2"
"github.com/ctreminiom/go-atlassian/pkg/infra/models"
"log"
"os"
)
func main() {
var (
host = os.Getenv("SITE")
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)
options := &models.WorkflowSearchCriteria{
WorkflowIDs: nil, // The list of workflow IDs to query.
WorkflowNames: []string{"PV: Project Management Workflow"}, // The list of workflow names to query.
}
expand := []string{"workflows.usages", "statuses.usages"}
workflows, response, err := atlassian.Workflow.Search(context.Background(), options, expand, true)
if err != nil {
log.Println("Unable to search for workflows: ", err)
log.Println(response.Bytes.String())
log.Println(response.StatusCode)
log.Fatal(err)
}
for _, workflow := range workflows.Workflows {
workflowBuffer, _ := json.MarshalIndent(workflow, "", "\t")
fmt.Println(string(workflowBuffer))
}
for _, status := range workflows.Statuses {
statusBuffer, _ := json.MarshalIndent(status, "", "\t")
fmt.Println(string(statusBuffer))
}
}{
"ruleKey": "system:check-permission-validator",
"parameters": {
"permissionKey": "ADMINISTER_PROJECTS"
}
}{
"ruleKey" : "system:parent-or-child-blocking-validator"
"parameters" : {
"blocker" : "PARENT"
"statusIds" : "1,2,3"
}
}package main
import (
"context"
"encoding/json"
"fmt"
"github.com/ctreminiom/go-atlassian/v2/jira/v2"
"log"
"os"
)
func main() {
var (
host = os.Getenv("SITE")
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)
capabilities, response, err := atlassian.Workflow.Capabilities(context.Background(), "workflow-id", "project-id", "issuetype-id")
if err != nil {
log.Println(response.Bytes.String())
log.Println(response.StatusCode)
log.Fatal(err)
}
capabilitiesBuffer, _ := json.MarshalIndent(capabilities, "", "\t")
fmt.Println(string(capabilitiesBuffer))
}payload.AddStatus(&models.WorkflowStatusUpdateScheme{
ID: "10012",
Name: "To Do",
StatusCategory: "TODO",
StatusReference: "f0b24de5-25e7-4fab-ab94-63d81db6c0c0",
})// Adding a transition to the workflow
err := epicWorkflow.AddTransition(&models.TransitionUpdateDTOScheme{
ID: "1",
Type: "INITIAL",
Name: "Create",
To: &models.StatusReferenceAndPortScheme{
StatusReference: "f0b24de5-25e7-4fab-ab94-63d81db6c0c0",
},
})// Adding the workflow to the payload
err := payload.AddWorkflow(epicWorkflow)
if err != nil {
log.Fatal(err)
}
package main
import (
"context"
"encoding/json"
"fmt"
"github.com/ctreminiom/go-atlassian/v2/jira/v2"
"github.com/ctreminiom/go-atlassian/pkg/infra/models"
"log"
"os"
)
func main() {
var (
host = os.Getenv("SITE")
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)
// Create the workflow creation payload
payload := &models.WorkflowCreatesPayload{
Scope: &models.WorkflowScopeScheme{Type: "GLOBAL"},
}
// Add the status references on the payload
statuses := []struct {
ID, Name, StatusCategory, StatusReference string
}{
{"10012", "To Do", "TODO", "f0b24de5-25e7-4fab-ab94-63d81db6c0c0"},
{"3", "In Progress", "IN_PROGRESS", "c7a35bf0-c127-4aa6-869f-4033730c61d8"},
{"10002", "Done", "DONE", "6b3fc04d-3316-46c5-a257-65751aeb8849"},
}
for _, status := range statuses {
payload.AddStatus(&models.WorkflowStatusUpdateScheme{
ID: status.ID,
Name: status.Name,
StatusCategory: status.StatusCategory,
StatusReference: status.StatusReference,
})
}
epicWorkflow := &models.WorkflowCreateScheme{
Description: "This workflow represents the process of software development related to epics.",
Name: "Epic Software Development Workflow V4",
}
// Add the statuses to the workflow using the referenceID and the layout
layouts := []struct {
X, Y float64
StatusReference string
}{
{114.99993896484375, -16, "f0b24de5-25e7-4fab-ab94-63d81db6c0c0"},
{317.0000915527344, -16, "c7a35bf0-c127-4aa6-869f-4033730c61d8"},
{508.000244140625, -16, "6b3fc04d-3316-46c5-a257-65751aeb8849"},
}
for _, layout := range layouts {
epicWorkflow.AddStatus(&models.StatusLayoutUpdateScheme{
Layout: &models.WorkflowLayoutScheme{X: layout.X, Y: layout.Y},
StatusReference: layout.StatusReference,
})
}
// Add the transitions to the workflow
transitions := []struct {
ID, Type, Name, StatusReference string
}{
{"1", "INITIAL", "Create", "f0b24de5-25e7-4fab-ab94-63d81db6c0c0"},
{"21", "GLOBAL", "In Progress", "c7a35bf0-c127-4aa6-869f-4033730c61d8"},
{"31", "GLOBAL", "Done", "6b3fc04d-3316-46c5-a257-65751aeb8849"},
}
for _, transition := range transitions {
err = epicWorkflow.AddTransition(&models.TransitionUpdateDTOScheme{
ID: transition.ID,
Type: transition.Type,
Name: transition.Name,
To: &models.StatusReferenceAndPortScheme{
StatusReference: transition.StatusReference,
},
})
if err != nil {
log.Fatal(err)
}
}
// You can multiple workflows on the same payload
if err := payload.AddWorkflow(epicWorkflow); err != nil {
log.Fatal(err)
}
workflowsCreated, response, err := atlassian.Workflow.Creates(context.Background(), payload)
if err != nil {
log.Println("Unable to create workflows: ", err)
log.Println(response.Bytes.String())
log.Fatal(err)
}
workflowBuffer, _ := json.MarshalIndent(workflowsCreated, "", "\t")
fmt.Println(string(workflowBuffer))
}package main
import (
"context"
"encoding/json"
"fmt"
"github.com/ctreminiom/go-atlassian/v2/jira/v2"
"github.com/ctreminiom/go-atlassian/pkg/infra/models"
"log"
"os"
)
func main() {
var (
host = os.Getenv("SITE")
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)
// Create the workflow creation payload
payload := &models.WorkflowCreatesPayload{
Scope: &models.WorkflowScopeScheme{Type: "GLOBAL"},
}
// Add the status references on the payload
statuses := []struct {
ID, Name, StatusCategory, StatusReference string
}{
{"10012", "To Do", "TODO", "f0b24de5-25e7-4fab-ab94-63d81db6c0c0"},
{"3", "In Progress", "IN_PROGRESS", "c7a35bf0-c127-4aa6-869f-4033730c61d8"},
{"10002", "Done", "DONE", "6b3fc04d-3316-46c5-a257-65751aeb8849"},
}
for _, status := range statuses {
payload.AddStatus(&models.WorkflowStatusUpdateScheme{
ID: status.ID,
Name: status.Name,
StatusCategory: status.StatusCategory,
StatusReference: status.StatusReference,
})
}
epicWorkflow := &models.WorkflowCreateScheme{
Description: "This workflow represents the process of software development related to epics.",
Name: "Epic Software Development Workflow V4",
}
// Add the statuses to the workflow using the referenceID and the layout
layouts := []struct {
X, Y float64
StatusReference string
}{
{114.99993896484375, -16, "f0b24de5-25e7-4fab-ab94-63d81db6c0c0"},
{317.0000915527344, -16, "c7a35bf0-c127-4aa6-869f-4033730c61d8"},
{508.000244140625, -16, "6b3fc04d-3316-46c5-a257-65751aeb8849"},
}
for _, layout := range layouts {
epicWorkflow.AddStatus(&models.StatusLayoutUpdateScheme{
Layout: &models.WorkflowLayoutScheme{X: layout.X, Y: layout.Y},
StatusReference: layout.StatusReference,
})
}
// Add the transitions to the workflow
transitions := []struct {
ID, Type, Name, StatusReference string
}{
{"1", "INITIAL", "Create", "f0b24de5-25e7-4fab-ab94-63d81db6c0c0"},
{"21", "GLOBAL", "In Progress", "c7a35bf0-c127-4aa6-869f-4033730c61d8"},
{"31", "GLOBAL", "Done", "6b3fc04d-3316-46c5-a257-65751aeb8849"},
}
for _, transition := range transitions {
err = epicWorkflow.AddTransition(&models.TransitionUpdateDTOScheme{
ID: transition.ID,
Type: transition.Type,
Name: transition.Name,
To: &models.StatusReferenceAndPortScheme{
StatusReference: transition.StatusReference,
},
})
if err != nil {
log.Fatal(err)
}
}
// You can multiple workflows on the same payload
if err := payload.AddWorkflow(epicWorkflow); err != nil {
log.Fatal(err)
}
validationOptions := &models.ValidationOptionsForCreateScheme{
Payload: payload,
Options: &models.ValidationOptionsLevelScheme{
Levels: []string{"ERROR", "WARNING"},
},
}
validationErrors, response, err := atlassian.Workflow.ValidateCreateWorkflows(context.Background(), validationOptions)
if err != nil {
log.Println("Unable to create workflows: ", err)
log.Println(response.Bytes.String())
log.Fatal(err)
}
for _, validationError := range validationErrors.Errors {
buffer, _ := json.MarshalIndent(validationError, "", "\t")
fmt.Println(string(buffer))
}
}package main
import (
"context"
"encoding/json"
"fmt"
"github.com/ctreminiom/go-atlassian/v2/jira/v2"
"github.com/ctreminiom/go-atlassian/pkg/infra/models"
"log"
"os"
)
func main() {
var (
host = os.Getenv("SITE")
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.WorkflowUpdatesPayloadScheme{
Statuses: []*models.WorkflowStatusUpdateScheme{
{
ID: "10012",
Name: "To Do",
StatusCategory: "TODO",
StatusReference: "f0b24de5-25e7-4fab-ab94-63d81db6c0c0",
},
{
ID: "3",
Name: "In Progress",
StatusCategory: "IN_PROGRESS",
StatusReference: "c7a35bf0-c127-4aa6-869f-4033730c61d8",
},
{
ID: "10002",
Name: "Done",
StatusCategory: "DONE",
StatusReference: "6b3fc04d-3316-46c5-a257-65751aeb8849",
},
},
Workflows: []*models.WorkflowUpdateScheme{
{
DefaultStatusMappings: nil,
ID: "6c91af3d-2ae1-46c1-9009-eb93a10a54d1",
StartPointLayout: nil,
Version: &models.WorkflowDocumentVersionScheme{
ID: "c44b423d-89c9-458d-abb7-89ac4fefebd4",
VersionNumber: 0,
},
},
},
}
expand := []string{"workflows.usages", "statuses.usages"}
workflowsUpdated, response, err := atlassian.Workflow.Updates(context.Background(), payload, expand)
if err != nil {
log.Println("Unable to update the workflows(s): ", err)
log.Println(response.Bytes.String())
log.Fatal(err)
}
workflowBuffer, _ := json.MarshalIndent(workflowsUpdated, "", "\t")
fmt.Println(string(workflowBuffer))
}package main
import (
"context"
"encoding/json"
"fmt"
"github.com/ctreminiom/go-atlassian/v2/jira/v2"
"github.com/ctreminiom/go-atlassian/pkg/infra/models"
"log"
"os"
)
func main() {
var (
host = os.Getenv("SITE")
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.WorkflowUpdatesPayloadScheme{
Statuses: []*models.WorkflowStatusUpdateScheme{
{
ID: "10012",
Name: "To Do",
StatusCategory: "TODO",
StatusReference: "f0b24de5-25e7-4fab-ab94-63d81db6c0c0",
},
{
ID: "3",
Name: "In Progress",
StatusCategory: "IN_PROGRESS",
StatusReference: "c7a35bf0-c127-4aa6-869f-4033730c61d8",
},
{
ID: "10002",
Name: "Done",
StatusCategory: "DONE",
StatusReference: "6b3fc04d-3316-46c5-a257-65751aeb8849",
},
},
Workflows: []*models.WorkflowUpdateScheme{
{
DefaultStatusMappings: nil,
ID: "6c91af3d-2ae1-46c1-9009-eb93a10a54d1",
StartPointLayout: nil,
Version: &models.WorkflowDocumentVersionScheme{
ID: "c44b423d-89c9-458d-abb7-89ac4fefebd4",
VersionNumber: 0,
},
},
},
}
payload2 := &models.ValidationOptionsForUpdateScheme{
Payload: payload,
Options: &models.ValidationOptionsLevelScheme{
Levels: []string{"ERROR", "WARNING"},
},
}
messages, response, err := atlassian.Workflow.ValidateUpdateWorkflows(context.Background(), payload2)
if err != nil {
log.Println("Unable to update the workflows(s): ", err)
log.Println(response.Bytes.String())
log.Fatal(err)
}
workflowBuffer, _ := json.MarshalIndent(messages, "", "\t")
fmt.Println(string(workflowBuffer))
}{
"ruleKey": "system:previous-status-validator",
"parameters": {
"previousStatusIds": "10014",
"mostRecentStatusOnly": "true"
}
}