googleapi

type Call ¶

type Call struct {
	// Payload is the value to be marshalled into
	// the request body.
	Payload interface{}

	// http method for request.
	Method string

	// URL for request, not including querystring.
	URL *url.URL

	// Params contain the values for the call's querystring.
	Params url.Values

	// Result is used to return data back to the calling function.
	// It may contain a pointer to a struct for unmarshalling json
	// in the response, or an *http.Response for a MediaDownload call.
	Result interface{}
}

Call contains data needed by Caller. The client api calls create the struct in their Do() commands. The developer would not use this directly.

func (c Call) Error() string

func (c Call) GetParams() url.Values

func (c Call) PayloadReader() (io.Reader, error)

type Caller ¶

type Caller interface {
	Do(context.Context, *http.Client, *Call) error
}

Caller is the interface used to execute api calls

*http.Client parameter should perform oauth2.0 authorization *Call contains url and payload data inteface{} parameter should be a ptr to a struct that the function will unmarshal the http.Response into. If the value is an *http.Response, the function will set the value to the response.

type ContentTyper ¶

type ContentTyper interface {
	ContentType() string
}

ContentTyper is an interface for Readers which know (or would like to override) their Content-Type. If a media body doesn't implement ContentTyper, the type is sniffed from the content using http.DetectContentType.

type Error ¶

type Error struct {
	// Code is the HTTP response status code and will always be populated.
	Code int `json:"code"`
	// Message is the server response message and is only populated when
	// explicitly referenced by the JSON server response.
	Message string `json:"message"`
	// Body is the raw response returned by the server.
	// It is often but not always JSON, depending on how the request fails.
	Body string

	Errors []ErrorItem
}

Error contains an error response from the server.

func (e *Error) Error() string

type ErrorItem ¶

type ErrorItem struct {
	// Reason is the typed error code. For example: "some_example".
	Reason string `json:"reason"`
	// Message is the human-readable description of the error.
	Message string `json:"message"`
}

ErrorItem is a detailed error code & message from the Google API frontend.

type Field ¶

type Field string

A Field names a field to be retrieved with a partial response. See https://developers.google.com/gdata/docs/2.0/basics#PartialResponse

Partial responses can dramatically reduce the amount of data that must be sent to your application. In order to request partial responses, you can specify the full list of fields that your application needs by adding the Fields option to your request.

Field strings use camelCase with leading lower-case characters to identify fields within the response.

For example, if your response has a "NextPageToken" and a slice of "Items" with "Id" fields, you could request just those fields like this:

svc.Events.List().Fields("nextPageToken", "items/id").Do()

or if you were also interested in each Item's "Updated" field, you can combine them like this:

svc.Events.List().Fields("nextPageToken", "items(id,updated)").Do()

More information about field formatting can be found here: https://developers.google.com/+/api/#fields-syntax

Another way to find field names is through the Google API explorer: https://developers.google.com/apis-explorer/#p/

type Float64s ¶

type Float64s []float64

Float64s is a slice of float64s that marshal as quoted strings in JSON.

func (s Float64s) MarshalJSON() ([]byte, error)

func (q *Float64s) UnmarshalJSON(raw []byte) error

type Int32s ¶

type Int32s []int32

Int32s is a slice of int32s that marshal as quoted strings in JSON.

func (s Int32s) MarshalJSON() ([]byte, error)

func (q *Int32s) UnmarshalJSON(raw []byte) error

type Int64s ¶

type Int64s []int64

Int64s is a slice of int64s that marshal as quoted strings in JSON.

func (s Int64s) MarshalJSON() ([]byte, error)

func (q *Int64s) UnmarshalJSON(raw []byte) error

type JSONCall ¶

type JSONCall struct{}

JSONCall is the default caller used by apis. The developer does not use it directly.

func (p JSONCall) Do(ctx context.Context, cl *http.Client, c *Call) error

type MediaUpload ¶

type MediaUpload struct {
	Media     io.Reader
	MediaType string
}

MediaUpload is a caller that executes simple and multipart uploads

func (m *MediaUpload) Do(ctx context.Context, cl *http.Client, c *Call) error

type ProgressUpdater ¶

type ProgressUpdater func(current, total int64, err error)

ProgressUpdater is a function that is called upon every progress update of a resumable upload. This is the only part of a resumable upload (from googleapi) that is usable by the developer.

type ResumableUpload ¶

type ResumableUpload struct {
	// URL is the resumable resource destination provided by the server after specifying "&uploadType=resumable".
	URL string
	// Media is the object being uploaded.
	Media io.ReaderAt
	// MediaType defines the media type, e.g. "image/jpeg".
	MediaType string
	// ContentLength is the full size of the object being uploaded.
	ContentLength int64
	// ChunkSize is the size of the chunks created during a resumable upload and should be a power of two.
	// 1<<18 is the minimum size supported by the Google uploader, and there is no maximum.
	// If ChunkSize is zero, chunking is ignored.
	ChunkSize int64
	// MaxRetries is the number of times the upload will retry after 5XX errors.
	MaxRetries int

	// Callback is an optional function that will be called upon every progress update.
	Callback ProgressUpdater
	// Error causing the upload to stop.  If set to
	Err error
	// contains filtered or unexported fields
}

ResumableUpload is used by the generated APIs to provide resumable uploads.

func NewResumableUpload(r io.ReaderAt, mediaType string, size int64, opts ...option) (*ResumableUpload, error)

func (rx *ResumableUpload) Do(ctx context.Context, cl *http.Client, c *Call) error

func (rx *ResumableUpload) Error() string

func (rx *ResumableUpload) Resume(ctx context.Context, client *http.Client, v interface{}) error

func (rx *ResumableUpload) Upload(ctx context.Context, client *http.Client, v interface{}) error

type SizeReaderAt ¶

type SizeReaderAt interface {
	io.Reader
	io.ReaderAt
	Size() int64
}

A SizeReaderAt is a ReaderAt with a Size method. An io.SectionReader implements SizeReaderAt.

type Uint32s ¶

type Uint32s []uint32

Uint32s is a slice of uint32s that marshal as quoted strings in JSON.

func (s Uint32s) MarshalJSON() ([]byte, error)

func (q *Uint32s) UnmarshalJSON(raw []byte) error

type Uint64s ¶

type Uint64s []uint64

Uint64s is a slice of uint64s that marshal as quoted strings in JSON.

func (s Uint64s) MarshalJSON() ([]byte, error)

func (q *Uint64s) UnmarshalJSON(raw []byte) error

type UploadCaller ¶

type UploadCaller interface {
	Caller
	// contains filtered or unexported methods
}

UploadCaller is a Caller that can also upload media.