mirror of
https://github.com/dutchcoders/transfer.sh.git
synced 2024-11-24 05:00:18 +01:00
373 lines
10 KiB
Text
373 lines
10 KiB
Text
// Package paramrename provides access to the Example API.
|
|
//
|
|
// Usage example:
|
|
//
|
|
// import "google.golang.org/api/paramrename/v1"
|
|
// ...
|
|
// paramrenameService, err := paramrename.New(oauthHttpClient)
|
|
package paramrename // import "google.golang.org/api/paramrename/v1"
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
context "golang.org/x/net/context"
|
|
ctxhttp "golang.org/x/net/context/ctxhttp"
|
|
gensupport "google.golang.org/api/gensupport"
|
|
googleapi "google.golang.org/api/googleapi"
|
|
"io"
|
|
"net/http"
|
|
"net/url"
|
|
"strconv"
|
|
"strings"
|
|
)
|
|
|
|
// Always reference these packages, just in case the auto-generated code
|
|
// below doesn't.
|
|
var _ = bytes.NewBuffer
|
|
var _ = strconv.Itoa
|
|
var _ = fmt.Sprintf
|
|
var _ = json.NewDecoder
|
|
var _ = io.Copy
|
|
var _ = url.Parse
|
|
var _ = gensupport.MarshalJSON
|
|
var _ = googleapi.Version
|
|
var _ = errors.New
|
|
var _ = strings.Replace
|
|
var _ = context.Canceled
|
|
var _ = ctxhttp.Do
|
|
|
|
const apiId = "paramrename:v1"
|
|
const apiName = "paramrename"
|
|
const apiVersion = "v1"
|
|
const basePath = "https://www.googleapis.com/discovery/v1/apis"
|
|
|
|
func New(client *http.Client) (*Service, error) {
|
|
if client == nil {
|
|
return nil, errors.New("client is nil")
|
|
}
|
|
s := &Service{client: client, BasePath: basePath}
|
|
s.Events = NewEventsService(s)
|
|
s.Reports = NewReportsService(s)
|
|
return s, nil
|
|
}
|
|
|
|
type Service struct {
|
|
client *http.Client
|
|
BasePath string // API endpoint base URL
|
|
UserAgent string // optional additional User-Agent fragment
|
|
|
|
Events *EventsService
|
|
|
|
Reports *ReportsService
|
|
}
|
|
|
|
func (s *Service) userAgent() string {
|
|
if s.UserAgent == "" {
|
|
return googleapi.UserAgent
|
|
}
|
|
return googleapi.UserAgent + " " + s.UserAgent
|
|
}
|
|
|
|
func NewEventsService(s *Service) *EventsService {
|
|
rs := &EventsService{s: s}
|
|
return rs
|
|
}
|
|
|
|
type EventsService struct {
|
|
s *Service
|
|
}
|
|
|
|
func NewReportsService(s *Service) *ReportsService {
|
|
rs := &ReportsService{s: s}
|
|
return rs
|
|
}
|
|
|
|
type ReportsService struct {
|
|
s *Service
|
|
}
|
|
|
|
type Event string
|
|
|
|
type ResultTable string
|
|
|
|
// method id "calendar.events.move":
|
|
|
|
type EventsMoveCall struct {
|
|
s *Service
|
|
rightString string
|
|
urlParams_ gensupport.URLParams
|
|
ctx_ context.Context
|
|
header_ http.Header
|
|
}
|
|
|
|
// Move: Moves an event to another calendar, i.e. changes an event's
|
|
// organizer.
|
|
func (r *EventsService) Move(destinationid string, rightString string) *EventsMoveCall {
|
|
c := &EventsMoveCall{s: r.s, urlParams_: make(gensupport.URLParams)}
|
|
c.urlParams_.Set("destination", destinationid)
|
|
c.rightString = rightString
|
|
return c
|
|
}
|
|
|
|
// SourceParam sets the optional parameter "source-param": Some
|
|
// parameter.
|
|
func (c *EventsMoveCall) SourceParam(sourceParam string) *EventsMoveCall {
|
|
c.urlParams_.Set("source-param", sourceParam)
|
|
return c
|
|
}
|
|
|
|
// Fields allows partial responses to be retrieved. See
|
|
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse
|
|
// for more information.
|
|
func (c *EventsMoveCall) Fields(s ...googleapi.Field) *EventsMoveCall {
|
|
c.urlParams_.Set("fields", googleapi.CombineFields(s))
|
|
return c
|
|
}
|
|
|
|
// Context sets the context to be used in this call's Do method. Any
|
|
// pending HTTP request will be aborted if the provided context is
|
|
// canceled.
|
|
func (c *EventsMoveCall) Context(ctx context.Context) *EventsMoveCall {
|
|
c.ctx_ = ctx
|
|
return c
|
|
}
|
|
|
|
// Header returns an http.Header that can be modified by the caller to
|
|
// add HTTP headers to the request.
|
|
func (c *EventsMoveCall) Header() http.Header {
|
|
if c.header_ == nil {
|
|
c.header_ = make(http.Header)
|
|
}
|
|
return c.header_
|
|
}
|
|
|
|
func (c *EventsMoveCall) doRequest(alt string) (*http.Response, error) {
|
|
reqHeaders := make(http.Header)
|
|
for k, v := range c.header_ {
|
|
reqHeaders[k] = v
|
|
}
|
|
reqHeaders.Set("User-Agent", c.s.userAgent())
|
|
var body io.Reader = nil
|
|
c.urlParams_.Set("alt", alt)
|
|
urls := googleapi.ResolveRelative(c.s.BasePath, "calendars/{calendarId}/events/{eventId}/move")
|
|
urls += "?" + c.urlParams_.Encode()
|
|
req, _ := http.NewRequest("POST", urls, body)
|
|
req.Header = reqHeaders
|
|
googleapi.Expand(req.URL, map[string]string{
|
|
"right-string": c.rightString,
|
|
})
|
|
return gensupport.SendRequest(c.ctx_, c.s.client, req)
|
|
}
|
|
|
|
// Do executes the "calendar.events.move" call.
|
|
// Exactly one of *Event or error will be non-nil. Any non-2xx status
|
|
// code is an error. Response headers are in either
|
|
// *Event.ServerResponse.Header or (if a response was returned at all)
|
|
// in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to
|
|
// check whether the returned error was because http.StatusNotModified
|
|
// was returned.
|
|
func (c *EventsMoveCall) Do(opts ...googleapi.CallOption) (*Event, error) {
|
|
gensupport.SetOptions(c.urlParams_, opts...)
|
|
res, err := c.doRequest("json")
|
|
if res != nil && res.StatusCode == http.StatusNotModified {
|
|
if res.Body != nil {
|
|
res.Body.Close()
|
|
}
|
|
return nil, &googleapi.Error{
|
|
Code: res.StatusCode,
|
|
Header: res.Header,
|
|
}
|
|
}
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer googleapi.CloseBody(res)
|
|
if err := googleapi.CheckResponse(res); err != nil {
|
|
return nil, err
|
|
}
|
|
ret := &Event{
|
|
ServerResponse: googleapi.ServerResponse{
|
|
Header: res.Header,
|
|
HTTPStatusCode: res.StatusCode,
|
|
},
|
|
}
|
|
target := &ret
|
|
if err := gensupport.DecodeResponse(target, res); err != nil {
|
|
return nil, err
|
|
}
|
|
return ret, nil
|
|
// {
|
|
// "description": "Moves an event to another calendar, i.e. changes an event's organizer.",
|
|
// "httpMethod": "POST",
|
|
// "id": "calendar.events.move",
|
|
// "parameterOrder": [
|
|
// "destination",
|
|
// "right-string"
|
|
// ],
|
|
// "parameters": {
|
|
// "destination": {
|
|
// "description": "Calendar identifier of the target calendar where the event is to be moved to.",
|
|
// "location": "query",
|
|
// "required": true,
|
|
// "type": "string"
|
|
// },
|
|
// "right-string": {
|
|
// "description": "Yet another parameter.",
|
|
// "location": "path",
|
|
// "required": true,
|
|
// "type": "string"
|
|
// },
|
|
// "source-param": {
|
|
// "description": "Some parameter.",
|
|
// "location": "query",
|
|
// "required": false,
|
|
// "type": "string"
|
|
// }
|
|
// },
|
|
// "path": "calendars/{calendarId}/events/{eventId}/move",
|
|
// "response": {
|
|
// "$ref": "Event"
|
|
// },
|
|
// "scopes": [
|
|
// "https://www.googleapis.com/auth/calendar"
|
|
// ]
|
|
// }
|
|
|
|
}
|
|
|
|
// method id "youtubeAnalytics.reports.query":
|
|
|
|
type ReportsQueryCall struct {
|
|
s *Service
|
|
urlParams_ gensupport.URLParams
|
|
ifNoneMatch_ string
|
|
ctx_ context.Context
|
|
header_ http.Header
|
|
}
|
|
|
|
// Query: Retrieve your YouTube Analytics reports.
|
|
func (r *ReportsService) Query(startDate string) *ReportsQueryCall {
|
|
c := &ReportsQueryCall{s: r.s, urlParams_: make(gensupport.URLParams)}
|
|
c.urlParams_.Set("start-date", startDate)
|
|
return c
|
|
}
|
|
|
|
// Fields allows partial responses to be retrieved. See
|
|
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse
|
|
// for more information.
|
|
func (c *ReportsQueryCall) Fields(s ...googleapi.Field) *ReportsQueryCall {
|
|
c.urlParams_.Set("fields", googleapi.CombineFields(s))
|
|
return c
|
|
}
|
|
|
|
// IfNoneMatch sets the optional parameter which makes the operation
|
|
// fail if the object's ETag matches the given value. This is useful for
|
|
// getting updates only after the object has changed since the last
|
|
// request. Use googleapi.IsNotModified to check whether the response
|
|
// error from Do is the result of In-None-Match.
|
|
func (c *ReportsQueryCall) IfNoneMatch(entityTag string) *ReportsQueryCall {
|
|
c.ifNoneMatch_ = entityTag
|
|
return c
|
|
}
|
|
|
|
// Context sets the context to be used in this call's Do method. Any
|
|
// pending HTTP request will be aborted if the provided context is
|
|
// canceled.
|
|
func (c *ReportsQueryCall) Context(ctx context.Context) *ReportsQueryCall {
|
|
c.ctx_ = ctx
|
|
return c
|
|
}
|
|
|
|
// Header returns an http.Header that can be modified by the caller to
|
|
// add HTTP headers to the request.
|
|
func (c *ReportsQueryCall) Header() http.Header {
|
|
if c.header_ == nil {
|
|
c.header_ = make(http.Header)
|
|
}
|
|
return c.header_
|
|
}
|
|
|
|
func (c *ReportsQueryCall) doRequest(alt string) (*http.Response, error) {
|
|
reqHeaders := make(http.Header)
|
|
for k, v := range c.header_ {
|
|
reqHeaders[k] = v
|
|
}
|
|
reqHeaders.Set("User-Agent", c.s.userAgent())
|
|
if c.ifNoneMatch_ != "" {
|
|
reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
|
|
}
|
|
var body io.Reader = nil
|
|
c.urlParams_.Set("alt", alt)
|
|
urls := googleapi.ResolveRelative(c.s.BasePath, "reports")
|
|
urls += "?" + c.urlParams_.Encode()
|
|
req, _ := http.NewRequest("GET", urls, body)
|
|
req.Header = reqHeaders
|
|
return gensupport.SendRequest(c.ctx_, c.s.client, req)
|
|
}
|
|
|
|
// Do executes the "youtubeAnalytics.reports.query" call.
|
|
// Exactly one of *ResultTable or error will be non-nil. Any non-2xx
|
|
// status code is an error. Response headers are in either
|
|
// *ResultTable.ServerResponse.Header or (if a response was returned at
|
|
// all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified
|
|
// to check whether the returned error was because
|
|
// http.StatusNotModified was returned.
|
|
func (c *ReportsQueryCall) Do(opts ...googleapi.CallOption) (*ResultTable, error) {
|
|
gensupport.SetOptions(c.urlParams_, opts...)
|
|
res, err := c.doRequest("json")
|
|
if res != nil && res.StatusCode == http.StatusNotModified {
|
|
if res.Body != nil {
|
|
res.Body.Close()
|
|
}
|
|
return nil, &googleapi.Error{
|
|
Code: res.StatusCode,
|
|
Header: res.Header,
|
|
}
|
|
}
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer googleapi.CloseBody(res)
|
|
if err := googleapi.CheckResponse(res); err != nil {
|
|
return nil, err
|
|
}
|
|
ret := &ResultTable{
|
|
ServerResponse: googleapi.ServerResponse{
|
|
Header: res.Header,
|
|
HTTPStatusCode: res.StatusCode,
|
|
},
|
|
}
|
|
target := &ret
|
|
if err := gensupport.DecodeResponse(target, res); err != nil {
|
|
return nil, err
|
|
}
|
|
return ret, nil
|
|
// {
|
|
// "description": "Retrieve your YouTube Analytics reports.",
|
|
// "httpMethod": "GET",
|
|
// "id": "youtubeAnalytics.reports.query",
|
|
// "parameterOrder": [
|
|
// "start-date"
|
|
// ],
|
|
// "parameters": {
|
|
// "start-date": {
|
|
// "description": "The start date for fetching YouTube Analytics data. The value should be in YYYY-MM-DD format.",
|
|
// "location": "query",
|
|
// "pattern": "[0-9]{4}-[0-9]{2}-[0-9]{2}",
|
|
// "required": true,
|
|
// "type": "string"
|
|
// }
|
|
// },
|
|
// "path": "reports",
|
|
// "response": {
|
|
// "$ref": "ResultTable"
|
|
// },
|
|
// "scopes": [
|
|
// "https://www.googleapis.com/auth/yt-analytics-monetary.readonly",
|
|
// "https://www.googleapis.com/auth/yt-analytics.readonly"
|
|
// ]
|
|
// }
|
|
|
|
}
|