freeze_periods.go

Documentation: github.com/xanzy/go-gitlab

     1  //
     2  // Copyright 2021 Paul Cioanca
     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  // FreezePeriodsService handles the communication with the freeze periods
    26  // related methods of the GitLab API.
    27  //
    28  // https://docs.gitlab.com/ee/api/freeze_periods.html
    29  type FreezePeriodsService struct {
    30  	client *Client
    31  }
    32  
    33  // FreezePeriod represents a freeze period object.
    34  //
    35  // GitLab API docs:
    36  // https://docs.gitlab.com/ee/api/freeze_periods.html#list-freeze-periods
    37  type FreezePeriod struct {
    38  	ID           int        `json:"id"`
    39  	FreezeStart  string     `json:"freeze_start"`
    40  	FreezeEnd    string     `json:"freeze_end"`
    41  	CronTimezone string     `json:"cron_timezone"`
    42  	CreatedAt    *time.Time `json:"created_at"`
    43  	UpdatedAt    *time.Time `json:"updated_at"`
    44  }
    45  
    46  // ListFreezePeriodsOptions represents the available ListFreezePeriodsOptions()
    47  // options.
    48  //
    49  // GitLab API docs:
    50  // https://docs.gitlab.com/ee/api/freeze_periods.html#list-freeze-periods
    51  type ListFreezePeriodsOptions ListOptions
    52  
    53  // ListFreezePeriods gets a list of project project freeze periods.
    54  //
    55  // GitLab API docs:
    56  // https://docs.gitlab.com/ee/api/freeze_periods.html#list-freeze-periods
    57  func (s *FreezePeriodsService) ListFreezePeriods(pid interface{}, opt *ListFreezePeriodsOptions, options ...RequestOptionFunc) ([]*FreezePeriod, *Response, error) {
    58  	project, err := parseID(pid)
    59  	if err != nil {
    60  		return nil, nil, err
    61  	}
    62  	u := fmt.Sprintf("projects/%s/freeze_periods", PathEscape(project))
    63  
    64  	req, err := s.client.NewRequest(http.MethodGet, u, opt, options)
    65  	if err != nil {
    66  		return nil, nil, err
    67  	}
    68  
    69  	var fp []*FreezePeriod
    70  	resp, err := s.client.Do(req, &fp)
    71  	if err != nil {
    72  		return nil, resp, err
    73  	}
    74  
    75  	return fp, resp, nil
    76  }
    77  
    78  // GetFreezePeriod gets a specific freeze period for a project.
    79  //
    80  // GitLab API docs:
    81  // https://docs.gitlab.com/ee/api/freeze_periods.html#get-a-freeze-period-by-a-freeze_period_id
    82  func (s *FreezePeriodsService) GetFreezePeriod(pid interface{}, freezePeriod int, options ...RequestOptionFunc) (*FreezePeriod, *Response, error) {
    83  	project, err := parseID(pid)
    84  	if err != nil {
    85  		return nil, nil, err
    86  	}
    87  	u := fmt.Sprintf("projects/%s/freeze_periods/%d", PathEscape(project), freezePeriod)
    88  
    89  	req, err := s.client.NewRequest(http.MethodGet, u, nil, options)
    90  	if err != nil {
    91  		return nil, nil, err
    92  	}
    93  
    94  	fp := new(FreezePeriod)
    95  	resp, err := s.client.Do(req, fp)
    96  	if err != nil {
    97  		return nil, resp, err
    98  	}
    99  
   100  	return fp, resp, nil
   101  }
   102  
   103  // CreateFreezePeriodOptions represents the available CreateFreezePeriodOptions()
   104  // options.
   105  //
   106  // GitLab API docs:
   107  // https://docs.gitlab.com/ee/api/freeze_periods.html#create-a-freeze-period
   108  type CreateFreezePeriodOptions struct {
   109  	FreezeStart  *string `url:"freeze_start,omitempty" json:"freeze_start,omitempty"`
   110  	FreezeEnd    *string `url:"freeze_end,omitempty" json:"freeze_end,omitempty"`
   111  	CronTimezone *string `url:"cron_timezone,omitempty" json:"cron_timezone,omitempty"`
   112  }
   113  
   114  // CreateFreezePeriodOptions adds a freeze period to a specified project.
   115  //
   116  // GitLab API docs:
   117  // https://docs.gitlab.com/ee/api/freeze_periods.html#create-a-freeze-period
   118  func (s *FreezePeriodsService) CreateFreezePeriodOptions(pid interface{}, opt *CreateFreezePeriodOptions, options ...RequestOptionFunc) (*FreezePeriod, *Response, error) {
   119  	project, err := parseID(pid)
   120  	if err != nil {
   121  		return nil, nil, err
   122  	}
   123  	u := fmt.Sprintf("projects/%s/freeze_periods", PathEscape(project))
   124  
   125  	req, err := s.client.NewRequest(http.MethodPost, u, opt, options)
   126  	if err != nil {
   127  		return nil, nil, err
   128  	}
   129  
   130  	fp := new(FreezePeriod)
   131  	resp, err := s.client.Do(req, fp)
   132  	if err != nil {
   133  		return nil, resp, err
   134  	}
   135  
   136  	return fp, resp, nil
   137  }
   138  
   139  // UpdateFreezePeriodOptions represents the available UpdateFreezePeriodOptions()
   140  // options.
   141  //
   142  // GitLab API docs:
   143  // https://docs.gitlab.com/ee/api/freeze_periods.html#update-a-freeze-period
   144  type UpdateFreezePeriodOptions struct {
   145  	FreezeStart  *string `url:"freeze_start,omitempty" json:"freeze_start,omitempty"`
   146  	FreezeEnd    *string `url:"freeze_end,omitempty" json:"freeze_end,omitempty"`
   147  	CronTimezone *string `url:"cron_timezone,omitempty" json:"cron_timezone,omitempty"`
   148  }
   149  
   150  // UpdateFreezePeriodOptions edits a freeze period for a specified project.
   151  //
   152  // GitLab API docs:
   153  // https://docs.gitlab.com/ee/api/freeze_periods.html#update-a-freeze-period
   154  func (s *FreezePeriodsService) UpdateFreezePeriodOptions(pid interface{}, freezePeriod int, opt *UpdateFreezePeriodOptions, options ...RequestOptionFunc) (*FreezePeriod, *Response, error) {
   155  	project, err := parseID(pid)
   156  	if err != nil {
   157  		return nil, nil, err
   158  	}
   159  	u := fmt.Sprintf("projects/%s/freeze_periods/%d", PathEscape(project), freezePeriod)
   160  
   161  	req, err := s.client.NewRequest(http.MethodPut, u, opt, options)
   162  	if err != nil {
   163  		return nil, nil, err
   164  	}
   165  
   166  	fp := new(FreezePeriod)
   167  	resp, err := s.client.Do(req, fp)
   168  	if err != nil {
   169  		return nil, resp, err
   170  	}
   171  
   172  	return fp, resp, nil
   173  }
   174  
   175  // DeleteFreezePeriod removes a freeze period from a project. This is an
   176  // idempotent method and can be called multiple times. Either the hook is
   177  // available or not.
   178  //
   179  // GitLab API docs:
   180  // https://docs.gitlab.com/ee/api/freeze_periods.html#delete-a-freeze-period
   181  func (s *FreezePeriodsService) DeleteFreezePeriod(pid interface{}, freezePeriod int, options ...RequestOptionFunc) (*Response, error) {
   182  	project, err := parseID(pid)
   183  	if err != nil {
   184  		return nil, err
   185  	}
   186  	u := fmt.Sprintf("projects/%s/freeze_periods/%d", PathEscape(project), freezePeriod)
   187  
   188  	req, err := s.client.NewRequest(http.MethodDelete, u, nil, options)
   189  	if err != nil {
   190  		return nil, err
   191  	}
   192  
   193  	return s.client.Do(req, nil)
   194  }
   195
View as plain text