group_access_tokens.go

Documentation: github.com/xanzy/go-gitlab

     1  //
     2  // Copyright 2022, Masahiro Yoshida
     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  // GroupAccessTokensService handles communication with the
    26  // groups access tokens related methods of the GitLab API.
    27  //
    28  // GitLab API docs: https://docs.gitlab.com/ee/api/group_access_tokens.html
    29  type GroupAccessTokensService struct {
    30  	client *Client
    31  }
    32  
    33  // GroupAccessToken represents a GitLab group access token.
    34  //
    35  // GitLab API docs: https://docs.gitlab.com/ee/api/group_access_tokens.html
    36  type GroupAccessToken struct {
    37  	ID          int              `json:"id"`
    38  	UserID      int              `json:"user_id"`
    39  	Name        string           `json:"name"`
    40  	Scopes      []string         `json:"scopes"`
    41  	CreatedAt   *time.Time       `json:"created_at"`
    42  	ExpiresAt   *ISOTime         `json:"expires_at"`
    43  	LastUsedAt  *time.Time       `json:"last_used_at"`
    44  	Active      bool             `json:"active"`
    45  	Revoked     bool             `json:"revoked"`
    46  	Token       string           `json:"token"`
    47  	AccessLevel AccessLevelValue `json:"access_level"`
    48  }
    49  
    50  func (v GroupAccessToken) String() string {
    51  	return Stringify(v)
    52  }
    53  
    54  // ListGroupAccessTokensOptions represents the available options for
    55  // listing variables in a group.
    56  //
    57  // GitLab API docs:
    58  // https://docs.gitlab.com/ee/api/group_access_tokens.html#list-group-access-tokens
    59  type ListGroupAccessTokensOptions ListOptions
    60  
    61  // ListGroupAccessTokens gets a list of all group access tokens in a group.
    62  //
    63  // GitLab API docs:
    64  // https://docs.gitlab.com/ee/api/group_access_tokens.html#list-group-access-tokens
    65  func (s *GroupAccessTokensService) ListGroupAccessTokens(gid interface{}, opt *ListGroupAccessTokensOptions, options ...RequestOptionFunc) ([]*GroupAccessToken, *Response, error) {
    66  	groups, err := parseID(gid)
    67  	if err != nil {
    68  		return nil, nil, err
    69  	}
    70  	u := fmt.Sprintf("groups/%s/access_tokens", PathEscape(groups))
    71  
    72  	req, err := s.client.NewRequest(http.MethodGet, u, opt, options)
    73  	if err != nil {
    74  		return nil, nil, err
    75  	}
    76  
    77  	var gats []*GroupAccessToken
    78  	resp, err := s.client.Do(req, &gats)
    79  	if err != nil {
    80  		return nil, resp, err
    81  	}
    82  
    83  	return gats, resp, nil
    84  }
    85  
    86  // GetGroupAccessToken gets a single group access tokens in a group.
    87  //
    88  // GitLab API docs:
    89  // https://docs.gitlab.com/ee/api/group_access_tokens.html#get-a-group-access-token
    90  func (s *GroupAccessTokensService) GetGroupAccessToken(gid interface{}, id int, options ...RequestOptionFunc) (*GroupAccessToken, *Response, error) {
    91  	groups, err := parseID(gid)
    92  	if err != nil {
    93  		return nil, nil, err
    94  	}
    95  	u := fmt.Sprintf("groups/%s/access_tokens/%d", PathEscape(groups), id)
    96  
    97  	req, err := s.client.NewRequest(http.MethodGet, u, nil, options)
    98  	if err != nil {
    99  		return nil, nil, err
   100  	}
   101  
   102  	gat := new(GroupAccessToken)
   103  	resp, err := s.client.Do(req, &gat)
   104  	if err != nil {
   105  		return nil, resp, err
   106  	}
   107  
   108  	return gat, resp, nil
   109  }
   110  
   111  // CreateGroupAccessTokenOptions represents the available CreateVariable()
   112  // options.
   113  //
   114  // GitLab API docs:
   115  // https://docs.gitlab.com/ee/api/group_access_tokens.html#create-a-group-access-token
   116  type CreateGroupAccessTokenOptions struct {
   117  	Name        *string           `url:"name,omitempty" json:"name,omitempty"`
   118  	Scopes      *[]string         `url:"scopes,omitempty" json:"scopes,omitempty"`
   119  	AccessLevel *AccessLevelValue `url:"access_level,omitempty" json:"access_level,omitempty"`
   120  	ExpiresAt   *ISOTime          `url:"expires_at,omitempty" json:"expires_at,omitempty"`
   121  }
   122  
   123  // CreateGroupAccessToken creates a new group access token.
   124  //
   125  // GitLab API docs:
   126  // https://docs.gitlab.com/ee/api/group_access_tokens.html#create-a-group-access-token
   127  func (s *GroupAccessTokensService) CreateGroupAccessToken(gid interface{}, opt *CreateGroupAccessTokenOptions, options ...RequestOptionFunc) (*GroupAccessToken, *Response, error) {
   128  	groups, err := parseID(gid)
   129  	if err != nil {
   130  		return nil, nil, err
   131  	}
   132  	u := fmt.Sprintf("groups/%s/access_tokens", PathEscape(groups))
   133  
   134  	req, err := s.client.NewRequest(http.MethodPost, u, opt, options)
   135  	if err != nil {
   136  		return nil, nil, err
   137  	}
   138  
   139  	pat := new(GroupAccessToken)
   140  	resp, err := s.client.Do(req, pat)
   141  	if err != nil {
   142  		return nil, resp, err
   143  	}
   144  
   145  	return pat, resp, nil
   146  }
   147  
   148  // RotateGroupAccessTokenOptions represents the available RotateGroupAccessToken()
   149  // options.
   150  //
   151  // GitLab API docs:
   152  // https://docs.gitlab.com/ee/api/group_access_tokens.html#rotate-a-group-access-token
   153  type RotateGroupAccessTokenOptions struct {
   154  	ExpiresAt *ISOTime `url:"expires_at,omitempty" json:"expires_at,omitempty"`
   155  }
   156  
   157  // RotateGroupAccessToken revokes a group access token and returns a new group
   158  // access token that expires in one week per default.
   159  //
   160  // GitLab API docs:
   161  // https://docs.gitlab.com/ee/api/group_access_tokens.html#rotate-a-group-access-token
   162  func (s *GroupAccessTokensService) RotateGroupAccessToken(gid interface{}, id int, opt *RotateGroupAccessTokenOptions, options ...RequestOptionFunc) (*GroupAccessToken, *Response, error) {
   163  	groups, err := parseID(gid)
   164  	if err != nil {
   165  		return nil, nil, err
   166  	}
   167  	u := fmt.Sprintf("groups/%s/access_tokens/%d/rotate", PathEscape(groups), id)
   168  	req, err := s.client.NewRequest(http.MethodPost, u, opt, options)
   169  	if err != nil {
   170  		return nil, nil, err
   171  	}
   172  
   173  	gat := new(GroupAccessToken)
   174  	resp, err := s.client.Do(req, gat)
   175  	if err != nil {
   176  		return nil, resp, err
   177  	}
   178  
   179  	return gat, resp, nil
   180  }
   181  
   182  // RevokeGroupAccessToken revokes a group access token.
   183  //
   184  // GitLab API docs:
   185  // https://docs.gitlab.com/ee/api/group_access_tokens.html#revoke-a-group-access-token
   186  func (s *GroupAccessTokensService) RevokeGroupAccessToken(gid interface{}, id int, options ...RequestOptionFunc) (*Response, error) {
   187  	groups, err := parseID(gid)
   188  	if err != nil {
   189  		return nil, err
   190  	}
   191  	u := fmt.Sprintf("groups/%s/access_tokens/%d", PathEscape(groups), id)
   192  
   193  	req, err := s.client.NewRequest(http.MethodDelete, u, nil, options)
   194  	if err != nil {
   195  		return nil, err
   196  	}
   197  
   198  	return s.client.Do(req, nil)
   199  }
   200
View as plain text