deploy_tokens.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  // DeployTokensService handles communication with the deploy tokens related methods
    26  // of the GitLab API.
    27  //
    28  // GitLab API docs: https://docs.gitlab.com/ee/api/deploy_tokens.html
    29  type DeployTokensService struct {
    30  	client *Client
    31  }
    32  
    33  // DeployToken represents a GitLab deploy token.
    34  type DeployToken struct {
    35  	ID        int        `json:"id"`
    36  	Name      string     `json:"name"`
    37  	Username  string     `json:"username"`
    38  	ExpiresAt *time.Time `json:"expires_at"`
    39  	Revoked   bool       `json:"revoked"`
    40  	Expired   bool       `json:"expired"`
    41  	Token     string     `json:"token,omitempty"`
    42  	Scopes    []string   `json:"scopes"`
    43  }
    44  
    45  func (k DeployToken) String() string {
    46  	return Stringify(k)
    47  }
    48  
    49  // ListAllDeployTokens gets a list of all deploy tokens.
    50  //
    51  // GitLab API docs:
    52  // https://docs.gitlab.com/ee/api/deploy_tokens.html#list-all-deploy-tokens
    53  func (s *DeployTokensService) ListAllDeployTokens(options ...RequestOptionFunc) ([]*DeployToken, *Response, error) {
    54  	req, err := s.client.NewRequest(http.MethodGet, "deploy_tokens", nil, options)
    55  	if err != nil {
    56  		return nil, nil, err
    57  	}
    58  
    59  	var ts []*DeployToken
    60  	resp, err := s.client.Do(req, &ts)
    61  	if err != nil {
    62  		return nil, resp, err
    63  	}
    64  
    65  	return ts, resp, nil
    66  }
    67  
    68  // ListProjectDeployTokensOptions represents the available ListProjectDeployTokens()
    69  // options.
    70  //
    71  // GitLab API docs:
    72  // https://docs.gitlab.com/ee/api/deploy_tokens.html#list-project-deploy-tokens
    73  type ListProjectDeployTokensOptions ListOptions
    74  
    75  // ListProjectDeployTokens gets a list of a project's deploy tokens.
    76  //
    77  // GitLab API docs:
    78  // https://docs.gitlab.com/ee/api/deploy_tokens.html#list-project-deploy-tokens
    79  func (s *DeployTokensService) ListProjectDeployTokens(pid interface{}, opt *ListProjectDeployTokensOptions, options ...RequestOptionFunc) ([]*DeployToken, *Response, error) {
    80  	project, err := parseID(pid)
    81  	if err != nil {
    82  		return nil, nil, err
    83  	}
    84  	u := fmt.Sprintf("projects/%s/deploy_tokens", PathEscape(project))
    85  
    86  	req, err := s.client.NewRequest(http.MethodGet, u, opt, options)
    87  	if err != nil {
    88  		return nil, nil, err
    89  	}
    90  
    91  	var ts []*DeployToken
    92  	resp, err := s.client.Do(req, &ts)
    93  	if err != nil {
    94  		return nil, resp, err
    95  	}
    96  
    97  	return ts, resp, nil
    98  }
    99  
   100  // GetProjectDeployToken gets a single deploy token.
   101  //
   102  // GitLab API docs:
   103  // https://docs.gitlab.com/ee/api/deploy_tokens.html#get-a-project-deploy-token
   104  func (s *DeployTokensService) GetProjectDeployToken(pid interface{}, deployToken int, options ...RequestOptionFunc) (*DeployToken, *Response, error) {
   105  	project, err := parseID(pid)
   106  	if err != nil {
   107  		return nil, nil, err
   108  	}
   109  	u := fmt.Sprintf("projects/%s/deploy_tokens/%d", PathEscape(project), deployToken)
   110  
   111  	req, err := s.client.NewRequest(http.MethodGet, u, nil, options)
   112  	if err != nil {
   113  		return nil, nil, err
   114  	}
   115  
   116  	t := new(DeployToken)
   117  	resp, err := s.client.Do(req, t)
   118  	if err != nil {
   119  		return nil, resp, err
   120  	}
   121  
   122  	return t, resp, nil
   123  }
   124  
   125  // CreateProjectDeployTokenOptions represents the available CreateProjectDeployToken() options.
   126  //
   127  // GitLab API docs:
   128  // https://docs.gitlab.com/ee/api/deploy_tokens.html#create-a-project-deploy-token
   129  type CreateProjectDeployTokenOptions struct {
   130  	Name      *string    `url:"name,omitempty" json:"name,omitempty"`
   131  	ExpiresAt *time.Time `url:"expires_at,omitempty" json:"expires_at,omitempty"`
   132  	Username  *string    `url:"username,omitempty" json:"username,omitempty"`
   133  	Scopes    *[]string  `url:"scopes,omitempty" json:"scopes,omitempty"`
   134  }
   135  
   136  // CreateProjectDeployToken creates a new deploy token for a project.
   137  //
   138  // GitLab API docs:
   139  // https://docs.gitlab.com/ee/api/deploy_tokens.html#create-a-project-deploy-token
   140  func (s *DeployTokensService) CreateProjectDeployToken(pid interface{}, opt *CreateProjectDeployTokenOptions, options ...RequestOptionFunc) (*DeployToken, *Response, error) {
   141  	project, err := parseID(pid)
   142  	if err != nil {
   143  		return nil, nil, err
   144  	}
   145  	u := fmt.Sprintf("projects/%s/deploy_tokens", PathEscape(project))
   146  
   147  	req, err := s.client.NewRequest(http.MethodPost, u, opt, options)
   148  	if err != nil {
   149  		return nil, nil, err
   150  	}
   151  
   152  	t := new(DeployToken)
   153  	resp, err := s.client.Do(req, t)
   154  	if err != nil {
   155  		return nil, resp, err
   156  	}
   157  
   158  	return t, resp, nil
   159  }
   160  
   161  // DeleteProjectDeployToken removes a deploy token from the project.
   162  //
   163  // GitLab API docs:
   164  // https://docs.gitlab.com/ee/api/deploy_tokens.html#delete-a-project-deploy-token
   165  func (s *DeployTokensService) DeleteProjectDeployToken(pid interface{}, deployToken int, options ...RequestOptionFunc) (*Response, error) {
   166  	project, err := parseID(pid)
   167  	if err != nil {
   168  		return nil, err
   169  	}
   170  	u := fmt.Sprintf("projects/%s/deploy_tokens/%d", PathEscape(project), deployToken)
   171  
   172  	req, err := s.client.NewRequest(http.MethodDelete, u, nil, options)
   173  	if err != nil {
   174  		return nil, err
   175  	}
   176  
   177  	return s.client.Do(req, nil)
   178  }
   179  
   180  // ListGroupDeployTokensOptions represents the available ListGroupDeployTokens()
   181  // options.
   182  //
   183  // GitLab API docs:
   184  // https://docs.gitlab.com/ee/api/deploy_tokens.html#list-group-deploy-tokens
   185  type ListGroupDeployTokensOptions ListOptions
   186  
   187  // ListGroupDeployTokens gets a list of a group’s deploy tokens.
   188  //
   189  // GitLab API docs:
   190  // https://docs.gitlab.com/ee/api/deploy_tokens.html#list-group-deploy-tokens
   191  func (s *DeployTokensService) ListGroupDeployTokens(gid interface{}, opt *ListGroupDeployTokensOptions, options ...RequestOptionFunc) ([]*DeployToken, *Response, error) {
   192  	group, err := parseID(gid)
   193  	if err != nil {
   194  		return nil, nil, err
   195  	}
   196  	u := fmt.Sprintf("groups/%s/deploy_tokens", PathEscape(group))
   197  
   198  	req, err := s.client.NewRequest(http.MethodGet, u, opt, options)
   199  	if err != nil {
   200  		return nil, nil, err
   201  	}
   202  
   203  	var ts []*DeployToken
   204  	resp, err := s.client.Do(req, &ts)
   205  	if err != nil {
   206  		return nil, resp, err
   207  	}
   208  
   209  	return ts, resp, nil
   210  }
   211  
   212  // GetGroupDeployToken gets a single deploy token.
   213  //
   214  // GitLab API docs:
   215  // https://docs.gitlab.com/ee/api/deploy_tokens.html#get-a-group-deploy-token
   216  func (s *DeployTokensService) GetGroupDeployToken(gid interface{}, deployToken int, options ...RequestOptionFunc) (*DeployToken, *Response, error) {
   217  	group, err := parseID(gid)
   218  	if err != nil {
   219  		return nil, nil, err
   220  	}
   221  	u := fmt.Sprintf("groups/%s/deploy_tokens/%d", PathEscape(group), deployToken)
   222  
   223  	req, err := s.client.NewRequest(http.MethodGet, u, nil, options)
   224  	if err != nil {
   225  		return nil, nil, err
   226  	}
   227  
   228  	t := new(DeployToken)
   229  	resp, err := s.client.Do(req, t)
   230  	if err != nil {
   231  		return nil, resp, err
   232  	}
   233  
   234  	return t, resp, nil
   235  }
   236  
   237  // CreateGroupDeployTokenOptions represents the available CreateGroupDeployToken() options.
   238  //
   239  // GitLab API docs:
   240  // https://docs.gitlab.com/ee/api/deploy_tokens.html#create-a-group-deploy-token
   241  type CreateGroupDeployTokenOptions struct {
   242  	Name      *string    `url:"name,omitempty" json:"name,omitempty"`
   243  	ExpiresAt *time.Time `url:"expires_at,omitempty" json:"expires_at,omitempty"`
   244  	Username  *string    `url:"username,omitempty" json:"username,omitempty"`
   245  	Scopes    *[]string  `url:"scopes,omitempty" json:"scopes,omitempty"`
   246  }
   247  
   248  // CreateGroupDeployToken creates a new deploy token for a group.
   249  //
   250  // GitLab API docs:
   251  // https://docs.gitlab.com/ee/api/deploy_tokens.html#create-a-group-deploy-token
   252  func (s *DeployTokensService) CreateGroupDeployToken(gid interface{}, opt *CreateGroupDeployTokenOptions, options ...RequestOptionFunc) (*DeployToken, *Response, error) {
   253  	group, err := parseID(gid)
   254  	if err != nil {
   255  		return nil, nil, err
   256  	}
   257  	u := fmt.Sprintf("groups/%s/deploy_tokens", PathEscape(group))
   258  
   259  	req, err := s.client.NewRequest(http.MethodPost, u, opt, options)
   260  	if err != nil {
   261  		return nil, nil, err
   262  	}
   263  
   264  	t := new(DeployToken)
   265  	resp, err := s.client.Do(req, t)
   266  	if err != nil {
   267  		return nil, resp, err
   268  	}
   269  
   270  	return t, resp, nil
   271  }
   272  
   273  // DeleteGroupDeployToken removes a deploy token from the group.
   274  //
   275  // GitLab API docs:
   276  // https://docs.gitlab.com/ee/api/deploy_tokens.html#delete-a-group-deploy-token
   277  func (s *DeployTokensService) DeleteGroupDeployToken(gid interface{}, deployToken int, options ...RequestOptionFunc) (*Response, error) {
   278  	group, err := parseID(gid)
   279  	if err != nil {
   280  		return nil, err
   281  	}
   282  	u := fmt.Sprintf("groups/%s/deploy_tokens/%d", PathEscape(group), deployToken)
   283  
   284  	req, err := s.client.NewRequest(http.MethodDelete, u, nil, options)
   285  	if err != nil {
   286  		return nil, err
   287  	}
   288  
   289  	return s.client.Do(req, nil)
   290  }
   291
View as plain text