pipeline_triggers.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  // PipelineTriggersService handles Project pipeline triggers.
    26  //
    27  // GitLab API docs:
    28  // https://docs.gitlab.com/ee/api/pipeline_triggers.html
    29  type PipelineTriggersService struct {
    30  	client *Client
    31  }
    32  
    33  // PipelineTrigger represents a project pipeline trigger.
    34  //
    35  // GitLab API docs:
    36  // https://docs.gitlab.com/ee/api/pipeline_triggers.html
    37  type PipelineTrigger struct {
    38  	ID          int        `json:"id"`
    39  	Description string     `json:"description"`
    40  	CreatedAt   *time.Time `json:"created_at"`
    41  	DeletedAt   *time.Time `json:"deleted_at"`
    42  	LastUsed    *time.Time `json:"last_used"`
    43  	Token       string     `json:"token"`
    44  	UpdatedAt   *time.Time `json:"updated_at"`
    45  	Owner       *User      `json:"owner"`
    46  }
    47  
    48  // ListPipelineTriggersOptions represents the available ListPipelineTriggers() options.
    49  //
    50  // GitLab API docs:
    51  // https://docs.gitlab.com/ee/api/pipeline_triggers.html#list-project-trigger-tokens
    52  type ListPipelineTriggersOptions ListOptions
    53  
    54  // ListPipelineTriggers gets a list of project triggers.
    55  //
    56  // GitLab API docs:
    57  // https://docs.gitlab.com/ee/api/pipeline_triggers.html#list-project-trigger-tokens
    58  func (s *PipelineTriggersService) ListPipelineTriggers(pid interface{}, opt *ListPipelineTriggersOptions, options ...RequestOptionFunc) ([]*PipelineTrigger, *Response, error) {
    59  	project, err := parseID(pid)
    60  	if err != nil {
    61  		return nil, nil, err
    62  	}
    63  	u := fmt.Sprintf("projects/%s/triggers", PathEscape(project))
    64  
    65  	req, err := s.client.NewRequest(http.MethodGet, u, opt, options)
    66  	if err != nil {
    67  		return nil, nil, err
    68  	}
    69  
    70  	var pt []*PipelineTrigger
    71  	resp, err := s.client.Do(req, &pt)
    72  	if err != nil {
    73  		return nil, resp, err
    74  	}
    75  
    76  	return pt, resp, nil
    77  }
    78  
    79  // GetPipelineTrigger gets a specific pipeline trigger for a project.
    80  //
    81  // GitLab API docs:
    82  // https://docs.gitlab.com/ee/api/pipeline_triggers.html#get-trigger-token-details
    83  func (s *PipelineTriggersService) GetPipelineTrigger(pid interface{}, trigger int, options ...RequestOptionFunc) (*PipelineTrigger, *Response, error) {
    84  	project, err := parseID(pid)
    85  	if err != nil {
    86  		return nil, nil, err
    87  	}
    88  	u := fmt.Sprintf("projects/%s/triggers/%d", PathEscape(project), trigger)
    89  
    90  	req, err := s.client.NewRequest(http.MethodGet, u, nil, options)
    91  	if err != nil {
    92  		return nil, nil, err
    93  	}
    94  
    95  	pt := new(PipelineTrigger)
    96  	resp, err := s.client.Do(req, pt)
    97  	if err != nil {
    98  		return nil, resp, err
    99  	}
   100  
   101  	return pt, resp, nil
   102  }
   103  
   104  // AddPipelineTriggerOptions represents the available AddPipelineTrigger() options.
   105  //
   106  // GitLab API docs:
   107  // https://docs.gitlab.com/ee/api/pipeline_triggers.html#create-a-trigger-token
   108  type AddPipelineTriggerOptions struct {
   109  	Description *string `url:"description,omitempty" json:"description,omitempty"`
   110  }
   111  
   112  // AddPipelineTrigger adds a pipeline trigger to a specified project.
   113  //
   114  // GitLab API docs:
   115  // https://docs.gitlab.com/ee/api/pipeline_triggers.html#create-a-trigger-token
   116  func (s *PipelineTriggersService) AddPipelineTrigger(pid interface{}, opt *AddPipelineTriggerOptions, options ...RequestOptionFunc) (*PipelineTrigger, *Response, error) {
   117  	project, err := parseID(pid)
   118  	if err != nil {
   119  		return nil, nil, err
   120  	}
   121  	u := fmt.Sprintf("projects/%s/triggers", PathEscape(project))
   122  
   123  	req, err := s.client.NewRequest(http.MethodPost, u, opt, options)
   124  	if err != nil {
   125  		return nil, nil, err
   126  	}
   127  
   128  	pt := new(PipelineTrigger)
   129  	resp, err := s.client.Do(req, pt)
   130  	if err != nil {
   131  		return nil, resp, err
   132  	}
   133  
   134  	return pt, resp, nil
   135  }
   136  
   137  // EditPipelineTriggerOptions represents the available EditPipelineTrigger() options.
   138  //
   139  // GitLab API docs:
   140  // https://docs.gitlab.com/ee/api/pipeline_triggers.html#update-a-project-trigger-token
   141  type EditPipelineTriggerOptions struct {
   142  	Description *string `url:"description,omitempty" json:"description,omitempty"`
   143  }
   144  
   145  // EditPipelineTrigger edits a trigger for a specified project.
   146  //
   147  // GitLab API docs:
   148  // https://docs.gitlab.com/ee/api/pipeline_triggers.html#update-a-project-trigger-token
   149  func (s *PipelineTriggersService) EditPipelineTrigger(pid interface{}, trigger int, opt *EditPipelineTriggerOptions, options ...RequestOptionFunc) (*PipelineTrigger, *Response, error) {
   150  	project, err := parseID(pid)
   151  	if err != nil {
   152  		return nil, nil, err
   153  	}
   154  	u := fmt.Sprintf("projects/%s/triggers/%d", PathEscape(project), trigger)
   155  
   156  	req, err := s.client.NewRequest(http.MethodPut, u, opt, options)
   157  	if err != nil {
   158  		return nil, nil, err
   159  	}
   160  
   161  	pt := new(PipelineTrigger)
   162  	resp, err := s.client.Do(req, pt)
   163  	if err != nil {
   164  		return nil, resp, err
   165  	}
   166  
   167  	return pt, resp, nil
   168  }
   169  
   170  // TakeOwnershipOfPipelineTrigger sets the owner of the specified
   171  // pipeline trigger to the user issuing the request.
   172  //
   173  // GitLab API docs:
   174  // https://docs.gitlab.com/ee/api/pipeline_triggers.html#take-ownership-of-a-project-trigger
   175  func (s *PipelineTriggersService) TakeOwnershipOfPipelineTrigger(pid interface{}, trigger int, options ...RequestOptionFunc) (*PipelineTrigger, *Response, error) {
   176  	project, err := parseID(pid)
   177  	if err != nil {
   178  		return nil, nil, err
   179  	}
   180  	u := fmt.Sprintf("projects/%s/triggers/%d/take_ownership", PathEscape(project), trigger)
   181  
   182  	req, err := s.client.NewRequest(http.MethodPost, u, nil, options)
   183  	if err != nil {
   184  		return nil, nil, err
   185  	}
   186  
   187  	pt := new(PipelineTrigger)
   188  	resp, err := s.client.Do(req, pt)
   189  	if err != nil {
   190  		return nil, resp, err
   191  	}
   192  
   193  	return pt, resp, nil
   194  }
   195  
   196  // DeletePipelineTrigger removes a trigger from a project.
   197  //
   198  // GitLab API docs:
   199  // https://docs.gitlab.com/ee/api/pipeline_triggers.html#remove-a-project-trigger-token
   200  func (s *PipelineTriggersService) DeletePipelineTrigger(pid interface{}, trigger int, options ...RequestOptionFunc) (*Response, error) {
   201  	project, err := parseID(pid)
   202  	if err != nil {
   203  		return nil, err
   204  	}
   205  	u := fmt.Sprintf("projects/%s/triggers/%d", PathEscape(project), trigger)
   206  
   207  	req, err := s.client.NewRequest(http.MethodDelete, u, nil, options)
   208  	if err != nil {
   209  		return nil, err
   210  	}
   211  
   212  	return s.client.Do(req, nil)
   213  }
   214  
   215  // RunPipelineTriggerOptions represents the available RunPipelineTrigger() options.
   216  //
   217  // GitLab API docs:
   218  // https://docs.gitlab.com/ee/api/pipeline_triggers.html#trigger-a-pipeline-with-a-token
   219  type RunPipelineTriggerOptions struct {
   220  	Ref       *string           `url:"ref" json:"ref"`
   221  	Token     *string           `url:"token" json:"token"`
   222  	Variables map[string]string `url:"variables,omitempty" json:"variables,omitempty"`
   223  }
   224  
   225  // RunPipelineTrigger starts a trigger from a project.
   226  //
   227  // GitLab API docs:
   228  // https://docs.gitlab.com/ee/api/pipeline_triggers.html#trigger-a-pipeline-with-a-token
   229  func (s *PipelineTriggersService) RunPipelineTrigger(pid interface{}, opt *RunPipelineTriggerOptions, options ...RequestOptionFunc) (*Pipeline, *Response, error) {
   230  	project, err := parseID(pid)
   231  	if err != nil {
   232  		return nil, nil, err
   233  	}
   234  	u := fmt.Sprintf("projects/%s/trigger/pipeline", PathEscape(project))
   235  
   236  	req, err := s.client.NewRequest(http.MethodPost, u, opt, options)
   237  	if err != nil {
   238  		return nil, nil, err
   239  	}
   240  
   241  	pt := new(Pipeline)
   242  	resp, err := s.client.Do(req, pt)
   243  	if err != nil {
   244  		return nil, resp, err
   245  	}
   246  
   247  	return pt, resp, nil
   248  }
   249
View as plain text