releases.go

Documentation: github.com/xanzy/go-gitlab

     1  //
     2  // Copyright 2021, Sander van Harmelen
     3  //
     4  // Licensed under the Apache License, Version 2.0 (the "License");
     5  // you may not use this file except in compliance with the License.
     6  // You may obtain a copy of the License at
     7  //
     8  //     http://www.apache.org/licenses/LICENSE-2.0
     9  //
    10  // Unless required by applicable law or agreed to in writing, software
    11  // distributed under the License is distributed on an "AS IS" BASIS,
    12  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    13  // See the License for the specific language governing permissions and
    14  // limitations under the License.
    15  //
    16  
    17  package gitlab
    18  
    19  import (
    20  	"fmt"
    21  	"net/http"
    22  	"time"
    23  )
    24  
    25  // ReleasesService handles communication with the releases methods
    26  // of the GitLab API.
    27  //
    28  // GitLab API docs: https://docs.gitlab.com/ee/api/releases/index.html
    29  type ReleasesService struct {
    30  	client *Client
    31  }
    32  
    33  // Release represents a project release.
    34  //
    35  // GitLab API docs:
    36  // https://docs.gitlab.com/ee/api/releases/index.html#list-releases
    37  type Release struct {
    38  	TagName         string     `json:"tag_name"`
    39  	Name            string     `json:"name"`
    40  	Description     string     `json:"description"`
    41  	DescriptionHTML string     `json:"description_html"`
    42  	CreatedAt       *time.Time `json:"created_at"`
    43  	ReleasedAt      *time.Time `json:"released_at"`
    44  	Author          struct {
    45  		ID        int    `json:"id"`
    46  		Name      string `json:"name"`
    47  		Username  string `json:"username"`
    48  		State     string `json:"state"`
    49  		AvatarURL string `json:"avatar_url"`
    50  		WebURL    string `json:"web_url"`
    51  	} `json:"author"`
    52  	Commit          Commit `json:"commit"`
    53  	UpcomingRelease bool   `json:"upcoming_release"`
    54  	CommitPath      string `json:"commit_path"`
    55  	TagPath         string `json:"tag_path"`
    56  	Assets          struct {
    57  		Count   int `json:"count"`
    58  		Sources []struct {
    59  			Format string `json:"format"`
    60  			URL    string `json:"url"`
    61  		} `json:"sources"`
    62  		Links []*ReleaseLink `json:"links"`
    63  	} `json:"assets"`
    64  	Links struct {
    65  		ClosedIssueURL     string `json:"closed_issues_url"`
    66  		ClosedMergeRequest string `json:"closed_merge_requests_url"`
    67  		EditURL            string `json:"edit_url"`
    68  		MergedMergeRequest string `json:"merged_merge_requests_url"`
    69  		OpenedIssues       string `json:"opened_issues_url"`
    70  		OpenedMergeRequest string `json:"opened_merge_requests_url"`
    71  		Self               string `json:"self"`
    72  	} `json:"_links"`
    73  }
    74  
    75  // ListReleasesOptions represents ListReleases() options.
    76  //
    77  // GitLab API docs:
    78  // https://docs.gitlab.com/ee/api/releases/index.html#list-releases
    79  type ListReleasesOptions struct {
    80  	ListOptions
    81  	OrderBy                *string `url:"order_by,omitempty" json:"order_by,omitempty"`
    82  	Sort                   *string `url:"sort,omitempty" json:"sort,omitempty"`
    83  	IncludeHTMLDescription *bool   `url:"include_html_description,omitempty" json:"include_html_description,omitempty"`
    84  }
    85  
    86  // ListReleases gets a pagenated of releases accessible by the authenticated user.
    87  //
    88  // GitLab API docs:
    89  // https://docs.gitlab.com/ee/api/releases/index.html#list-releases
    90  func (s *ReleasesService) ListReleases(pid interface{}, opt *ListReleasesOptions, options ...RequestOptionFunc) ([]*Release, *Response, error) {
    91  	project, err := parseID(pid)
    92  	if err != nil {
    93  		return nil, nil, err
    94  	}
    95  	u := fmt.Sprintf("projects/%s/releases", PathEscape(project))
    96  
    97  	req, err := s.client.NewRequest(http.MethodGet, u, opt, options)
    98  	if err != nil {
    99  		return nil, nil, err
   100  	}
   101  
   102  	var rs []*Release
   103  	resp, err := s.client.Do(req, &rs)
   104  	if err != nil {
   105  		return nil, resp, err
   106  	}
   107  
   108  	return rs, resp, nil
   109  }
   110  
   111  // GetRelease returns a single release, identified by a tag name.
   112  //
   113  // GitLab API docs:
   114  // https://docs.gitlab.com/ee/api/releases/index.html#get-a-release-by-a-tag-name
   115  func (s *ReleasesService) GetRelease(pid interface{}, tagName string, options ...RequestOptionFunc) (*Release, *Response, error) {
   116  	project, err := parseID(pid)
   117  	if err != nil {
   118  		return nil, nil, err
   119  	}
   120  	u := fmt.Sprintf("projects/%s/releases/%s", PathEscape(project), PathEscape(tagName))
   121  
   122  	req, err := s.client.NewRequest(http.MethodGet, u, nil, options)
   123  	if err != nil {
   124  		return nil, nil, err
   125  	}
   126  
   127  	r := new(Release)
   128  	resp, err := s.client.Do(req, r)
   129  	if err != nil {
   130  		return nil, resp, err
   131  	}
   132  
   133  	return r, resp, nil
   134  }
   135  
   136  // GetLatestRelease returns the latest release for the project.
   137  //
   138  // GitLab API docs:
   139  // https://docs.gitlab.com/ee/api/releases/#get-the-latest-release
   140  func (s *ReleasesService) GetLatestRelease(pid interface{}, options ...RequestOptionFunc) (*Release, *Response, error) {
   141  	project, err := parseID(pid)
   142  	if err != nil {
   143  		return nil, nil, err
   144  	}
   145  	u := fmt.Sprintf("projects/%s/releases/permalink/latest", PathEscape(project))
   146  
   147  	req, err := s.client.NewRequest(http.MethodGet, u, nil, options)
   148  	if err != nil {
   149  		return nil, nil, err
   150  	}
   151  
   152  	r := new(Release)
   153  	resp, err := s.client.Do(req, r)
   154  	if err != nil {
   155  		return nil, resp, err
   156  	}
   157  
   158  	return r, resp, err
   159  }
   160  
   161  // CreateReleaseOptions represents CreateRelease() options.
   162  //
   163  // GitLab API docs:
   164  // https://docs.gitlab.com/ee/api/releases/index.html#create-a-release
   165  type CreateReleaseOptions struct {
   166  	Name        *string               `url:"name,omitempty" json:"name,omitempty"`
   167  	TagName     *string               `url:"tag_name,omitempty" json:"tag_name,omitempty"`
   168  	TagMessage  *string               `url:"tag_message,omitempty" json:"tag_message,omitempty"`
   169  	Description *string               `url:"description,omitempty" json:"description,omitempty"`
   170  	Ref         *string               `url:"ref,omitempty" json:"ref,omitempty"`
   171  	Milestones  *[]string             `url:"milestones,omitempty" json:"milestones,omitempty"`
   172  	Assets      *ReleaseAssetsOptions `url:"assets,omitempty" json:"assets,omitempty"`
   173  	ReleasedAt  *time.Time            `url:"released_at,omitempty" json:"released_at,omitempty"`
   174  }
   175  
   176  // ReleaseAssetsOptions represents release assets in CreateRelease() options.
   177  //
   178  // GitLab API docs:
   179  // https://docs.gitlab.com/ee/api/releases/index.html#create-a-release
   180  type ReleaseAssetsOptions struct {
   181  	Links []*ReleaseAssetLinkOptions `url:"links,omitempty" json:"links,omitempty"`
   182  }
   183  
   184  // ReleaseAssetLinkOptions represents release asset link in CreateRelease()
   185  // options.
   186  //
   187  // GitLab API docs:
   188  // https://docs.gitlab.com/ee/api/releases/index.html#create-a-release
   189  type ReleaseAssetLinkOptions struct {
   190  	Name     *string        `url:"name,omitempty" json:"name,omitempty"`
   191  	URL      *string        `url:"url,omitempty" json:"url,omitempty"`
   192  	FilePath *string        `url:"filepath,omitempty" json:"filepath,omitempty"`
   193  	LinkType *LinkTypeValue `url:"link_type,omitempty" json:"link_type,omitempty"`
   194  }
   195  
   196  // CreateRelease creates a release.
   197  //
   198  // GitLab API docs:
   199  // https://docs.gitlab.com/ee/api/releases/index.html#create-a-release
   200  func (s *ReleasesService) CreateRelease(pid interface{}, opts *CreateReleaseOptions, options ...RequestOptionFunc) (*Release, *Response, error) {
   201  	project, err := parseID(pid)
   202  	if err != nil {
   203  		return nil, nil, err
   204  	}
   205  	u := fmt.Sprintf("projects/%s/releases", PathEscape(project))
   206  
   207  	req, err := s.client.NewRequest(http.MethodPost, u, opts, options)
   208  	if err != nil {
   209  		return nil, nil, err
   210  	}
   211  
   212  	r := new(Release)
   213  	resp, err := s.client.Do(req, r)
   214  	if err != nil {
   215  		return nil, resp, err
   216  	}
   217  
   218  	return r, resp, nil
   219  }
   220  
   221  // UpdateReleaseOptions represents UpdateRelease() options.
   222  //
   223  // GitLab API docs:
   224  // https://docs.gitlab.com/ee/api/releases/index.html#update-a-release
   225  type UpdateReleaseOptions struct {
   226  	Name        *string    `url:"name" json:"name"`
   227  	Description *string    `url:"description" json:"description"`
   228  	Milestones  *[]string  `url:"milestones,omitempty" json:"milestones,omitempty"`
   229  	ReleasedAt  *time.Time `url:"released_at,omitempty" json:"released_at,omitempty"`
   230  }
   231  
   232  // UpdateRelease updates a release.
   233  //
   234  // GitLab API docs:
   235  // https://docs.gitlab.com/ee/api/releases/index.html#update-a-release
   236  func (s *ReleasesService) UpdateRelease(pid interface{}, tagName string, opts *UpdateReleaseOptions, options ...RequestOptionFunc) (*Release, *Response, error) {
   237  	project, err := parseID(pid)
   238  	if err != nil {
   239  		return nil, nil, err
   240  	}
   241  	u := fmt.Sprintf("projects/%s/releases/%s", PathEscape(project), PathEscape(tagName))
   242  
   243  	req, err := s.client.NewRequest(http.MethodPut, u, opts, options)
   244  	if err != nil {
   245  		return nil, nil, err
   246  	}
   247  
   248  	r := new(Release)
   249  	resp, err := s.client.Do(req, &r)
   250  	if err != nil {
   251  		return nil, resp, err
   252  	}
   253  
   254  	return r, resp, nil
   255  }
   256  
   257  // DeleteRelease deletes a release.
   258  //
   259  // GitLab API docs:
   260  // https://docs.gitlab.com/ee/api/releases/index.html#delete-a-release
   261  func (s *ReleasesService) DeleteRelease(pid interface{}, tagName string, options ...RequestOptionFunc) (*Release, *Response, error) {
   262  	project, err := parseID(pid)
   263  	if err != nil {
   264  		return nil, nil, err
   265  	}
   266  	u := fmt.Sprintf("projects/%s/releases/%s", PathEscape(project), PathEscape(tagName))
   267  
   268  	req, err := s.client.NewRequest(http.MethodDelete, u, nil, options)
   269  	if err != nil {
   270  		return nil, nil, err
   271  	}
   272  
   273  	r := new(Release)
   274  	resp, err := s.client.Do(req, r)
   275  	if err != nil {
   276  		return nil, resp, err
   277  	}
   278  
   279  	return r, resp, nil
   280  }
   281
View as plain text