func (c *TrainedmodelsGetCall) Do() (*Insert2, error) {
var body io.Reader = nil
params := make(url.Values)
params.Set("alt", "json")
if v, ok := c.opt_["fields"]; ok {
params.Set("fields", fmt.Sprintf("%v", v))
}
urls := googleapi.ResolveRelative(c.s.BasePath, "{project}/trainedmodels/{id}")
urls += "?" + params.Encode()
req, _ := http.NewRequest("GET", urls, body)
googleapi.Expand(req.URL, map[string]string{
"project": c.project,
"id": c.id,
})
req.Header.Set("User-Agent", "google-api-go-client/0.5")
res, err := c.s.client.Do(req)
if err != nil {
return nil, err
}
defer googleapi.CloseBody(res)
if err := googleapi.CheckResponse(res); err != nil {
return nil, err
}
var ret *Insert2
if err := json.NewDecoder(res.Body).Decode(&ret); err != nil {
return nil, err
}
return ret, nil
// {
// "description": "Check training status of your model.",
// "httpMethod": "GET",
// "id": "prediction.trainedmodels.get",
// "parameterOrder": [
// "project",
// "id"
// ],
// "parameters": {
// "id": {
// "description": "The unique name for the predictive model.",
// "location": "path",
// "required": true,
// "type": "string"
// },
// "project": {
// "description": "The project associated with the model.",
// "location": "path",
// "required": true,
// "type": "string"
// }
// },
// "path": "{project}/trainedmodels/{id}",
// "response": {
// "$ref": "Insert2"
// },
// "scopes": [
// "https://www.googleapis.com/auth/prediction"
// ]
// }
}
func (c *PagesGetCall) Do() (*Page, error) {
var body io.Reader = nil
params := make(url.Values)
params.Set("alt", "json")
if v, ok := c.opt_["fields"]; ok {
params.Set("fields", fmt.Sprintf("%v", v))
}
urls := googleapi.ResolveRelative(c.s.BasePath, "blogs/{blogId}/pages/{pageId}")
urls += "?" + params.Encode()
req, _ := http.NewRequest("GET", urls, body)
googleapi.Expand(req.URL, map[string]string{
"blogId": c.blogId,
"pageId": c.pageId,
})
req.Header.Set("User-Agent", "google-api-go-client/0.5")
res, err := c.s.client.Do(req)
if err != nil {
return nil, err
}
defer googleapi.CloseBody(res)
if err := googleapi.CheckResponse(res); err != nil {
return nil, err
}
var ret *Page
if err := json.NewDecoder(res.Body).Decode(&ret); err != nil {
return nil, err
}
return ret, nil
// {
// "description": "Gets one blog page by id.",
// "httpMethod": "GET",
// "id": "blogger.pages.get",
// "parameterOrder": [
// "blogId",
// "pageId"
// ],
// "parameters": {
// "blogId": {
// "description": "ID of the blog containing the page.",
// "location": "path",
// "required": true,
// "type": "string"
// },
// "pageId": {
// "description": "The ID of the page to get.",
// "location": "path",
// "required": true,
// "type": "string"
// }
// },
// "path": "blogs/{blogId}/pages/{pageId}",
// "response": {
// "$ref": "Page"
// },
// "scopes": [
// "https://www.googleapis.com/auth/blogger"
// ]
// }
}
func (c *PagesListCall) Do() (*PageList, error) {
var body io.Reader = nil
params := make(url.Values)
params.Set("alt", "json")
if v, ok := c.opt_["fetchBodies"]; ok {
params.Set("fetchBodies", fmt.Sprintf("%v", v))
}
if v, ok := c.opt_["fields"]; ok {
params.Set("fields", fmt.Sprintf("%v", v))
}
urls := googleapi.ResolveRelative(c.s.BasePath, "blogs/{blogId}/pages")
urls += "?" + params.Encode()
req, _ := http.NewRequest("GET", urls, body)
googleapi.Expand(req.URL, map[string]string{
"blogId": c.blogId,
})
req.Header.Set("User-Agent", "google-api-go-client/0.5")
res, err := c.s.client.Do(req)
if err != nil {
return nil, err
}
defer googleapi.CloseBody(res)
if err := googleapi.CheckResponse(res); err != nil {
return nil, err
}
var ret *PageList
if err := json.NewDecoder(res.Body).Decode(&ret); err != nil {
return nil, err
}
return ret, nil
// {
// "description": "Retrieves pages for a blog, possibly filtered.",
// "httpMethod": "GET",
// "id": "blogger.pages.list",
// "parameterOrder": [
// "blogId"
// ],
// "parameters": {
// "blogId": {
// "description": "ID of the blog to fetch pages from.",
// "location": "path",
// "required": true,
// "type": "string"
// },
// "fetchBodies": {
// "description": "Whether to retrieve the Page bodies.",
// "location": "query",
// "type": "boolean"
// }
// },
// "path": "blogs/{blogId}/pages",
// "response": {
// "$ref": "PageList"
// },
// "scopes": [
// "https://www.googleapis.com/auth/blogger"
// ]
// }
}
func (c *SubscriptionsActivateCall) Do() (*Subscription, error) {
var body io.Reader = nil
params := make(url.Values)
params.Set("alt", "json")
if v, ok := c.opt_["fields"]; ok {
params.Set("fields", fmt.Sprintf("%v", v))
}
urls := googleapi.ResolveRelative(c.s.BasePath, "customers/{customerId}/subscriptions/{subscriptionId}/activate")
urls += "?" + params.Encode()
req, _ := http.NewRequest("POST", urls, body)
googleapi.Expand(req.URL, map[string]string{
"customerId": c.customerId,
"subscriptionId": c.subscriptionId,
})
req.Header.Set("User-Agent", "google-api-go-client/0.5")
res, err := c.s.client.Do(req)
if err != nil {
return nil, err
}
defer googleapi.CloseBody(res)
if err := googleapi.CheckResponse(res); err != nil {
return nil, err
}
var ret *Subscription
if err := json.NewDecoder(res.Body).Decode(&ret); err != nil {
return nil, err
}
return ret, nil
// {
// "description": "Activates a subscription previously suspended by the reseller",
// "httpMethod": "POST",
// "id": "reseller.subscriptions.activate",
// "parameterOrder": [
// "customerId",
// "subscriptionId"
// ],
// "parameters": {
// "customerId": {
// "description": "Id of the Customer",
// "location": "path",
// "required": true,
// "type": "string"
// },
// "subscriptionId": {
// "description": "Id of the subscription, which is unique for a customer",
// "location": "path",
// "required": true,
// "type": "string"
// }
// },
// "path": "customers/{customerId}/subscriptions/{subscriptionId}/activate",
// "response": {
// "$ref": "Subscription"
// },
// "scopes": [
// "https://www.googleapis.com/auth/apps.order"
// ]
// }
}
func (c *StatesClearCall) Do() (*WriteResult, error) {
var body io.Reader = nil
params := make(url.Values)
params.Set("alt", "json")
if v, ok := c.opt_["currentDataVersion"]; ok {
params.Set("currentDataVersion", fmt.Sprintf("%v", v))
}
urls := googleapi.ResolveRelative(c.s.BasePath, "states/{stateKey}/clear")
urls += "?" + params.Encode()
req, _ := http.NewRequest("POST", urls, body)
googleapi.Expand(req.URL, map[string]string{
"stateKey": strconv.FormatInt(c.stateKey, 10),
})
req.Header.Set("User-Agent", "google-api-go-client/0.5")
res, err := c.s.client.Do(req)
if err != nil {
return nil, err
}
defer googleapi.CloseBody(res)
if err := googleapi.CheckResponse(res); err != nil {
return nil, err
}
var ret *WriteResult
if err := json.NewDecoder(res.Body).Decode(&ret); err != nil {
return nil, err
}
return ret, nil
// {
// "description": "Clears (sets to empty) the data for the passed key if and only if the passed version matches the currently stored version. This method results in a conflict error on version mismatch.",
// "httpMethod": "POST",
// "id": "appstate.states.clear",
// "parameterOrder": [
// "stateKey"
// ],
// "parameters": {
// "currentDataVersion": {
// "description": "The version of the data to be cleared. Version strings are returned by the server.",
// "location": "query",
// "type": "string"
// },
// "stateKey": {
// "description": "The key for the data to be retrieved.",
// "format": "int32",
// "location": "path",
// "maximum": "3",
// "minimum": "0",
// "required": true,
// "type": "integer"
// }
// },
// "path": "states/{stateKey}/clear",
// "response": {
// "$ref": "WriteResult"
// },
// "scopes": [
// "https://www.googleapis.com/auth/appstate"
// ]
// }
}
func (c *ProjectsZonesOperationsListCall) Do() (*ListOperationsResponse, error) {
var body io.Reader = nil
params := make(url.Values)
params.Set("alt", "json")
if v, ok := c.opt_["fields"]; ok {
params.Set("fields", fmt.Sprintf("%v", v))
}
urls := googleapi.ResolveRelative(c.s.BasePath, "{projectId}/zones/{zoneId}/operations")
urls += "?" + params.Encode()
req, _ := http.NewRequest("GET", urls, body)
googleapi.Expand(req.URL, map[string]string{
"projectId": c.projectId,
"zoneId": c.zoneId,
})
req.Header.Set("User-Agent", "google-api-go-client/0.5")
res, err := c.s.client.Do(req)
if err != nil {
return nil, err
}
defer googleapi.CloseBody(res)
if err := googleapi.CheckResponse(res); err != nil {
return nil, err
}
var ret *ListOperationsResponse
if err := json.NewDecoder(res.Body).Decode(&ret); err != nil {
return nil, err
}
return ret, nil
// {
// "description": "Lists all operations in a project in a specific zone.",
// "httpMethod": "GET",
// "id": "container.projects.zones.operations.list",
// "parameterOrder": [
// "projectId",
// "zoneId"
// ],
// "parameters": {
// "projectId": {
// "description": "The Google Developers Console project ID or project number.",
// "location": "path",
// "required": true,
// "type": "string"
// },
// "zoneId": {
// "description": "The name of the Google Compute Engine zone to return operations for.",
// "location": "path",
// "required": true,
// "type": "string"
// }
// },
// "path": "{projectId}/zones/{zoneId}/operations",
// "response": {
// "$ref": "ListOperationsResponse"
// },
// "scopes": [
// "https://www.googleapis.com/auth/cloud-platform"
// ]
// }
}
func (c *DatasetsRunQueryCall) Do() (*RunQueryResponse, error) {
var body io.Reader = nil
body, err := googleapi.WithoutDataWrapper.JSONReader(c.runqueryrequest)
if err != nil {
return nil, err
}
ctype := "application/json"
params := make(url.Values)
params.Set("alt", "json")
urls := googleapi.ResolveRelative(c.s.BasePath, "{datasetId}/runQuery")
urls += "?" + params.Encode()
req, _ := http.NewRequest("POST", urls, body)
googleapi.Expand(req.URL, map[string]string{
"datasetId": c.datasetId,
})
req.Header.Set("Content-Type", ctype)
req.Header.Set("User-Agent", "google-api-go-client/0.5")
res, err := c.s.client.Do(req)
if err != nil {
return nil, err
}
defer googleapi.CloseBody(res)
if err := googleapi.CheckResponse(res); err != nil {
return nil, err
}
var ret *RunQueryResponse
if err := json.NewDecoder(res.Body).Decode(&ret); err != nil {
return nil, err
}
return ret, nil
// {
// "description": "Query for entities.",
// "httpMethod": "POST",
// "id": "datastore.datasets.runQuery",
// "parameterOrder": [
// "datasetId"
// ],
// "parameters": {
// "datasetId": {
// "description": "Identifies the dataset.",
// "location": "path",
// "required": true,
// "type": "string"
// }
// },
// "path": "{datasetId}/runQuery",
// "request": {
// "$ref": "RunQueryRequest"
// },
// "response": {
// "$ref": "RunQueryResponse"
// },
// "scopes": [
// "https://www.googleapis.com/auth/datastore",
// "https://www.googleapis.com/auth/userinfo.email"
// ]
// }
}
func (c *ManagedZonesGetCall) Do() (*ManagedZone, error) {
var body io.Reader = nil
params := make(url.Values)
params.Set("alt", "json")
urls := googleapi.ResolveRelative(c.s.BasePath, "{project}/managedZones/{managedZone}")
urls += "?" + params.Encode()
req, _ := http.NewRequest("GET", urls, body)
googleapi.Expand(req.URL, map[string]string{
"project": c.project,
"managedZone": c.managedZone,
})
req.Header.Set("User-Agent", "google-api-go-client/0.5")
res, err := c.s.client.Do(req)
if err != nil {
return nil, err
}
defer googleapi.CloseBody(res)
if err := googleapi.CheckResponse(res); err != nil {
return nil, err
}
var ret *ManagedZone
if err := json.NewDecoder(res.Body).Decode(&ret); err != nil {
return nil, err
}
return ret, nil
// {
// "description": "Fetch the representation of an existing ManagedZone.",
// "httpMethod": "GET",
// "id": "dns.managedZones.get",
// "parameterOrder": [
// "project",
// "managedZone"
// ],
// "parameters": {
// "managedZone": {
// "description": "Identifies the managed zone addressed by this request. Can be the managed zone name or id.",
// "location": "path",
// "required": true,
// "type": "string"
// },
// "project": {
// "description": "Identifies the project addressed by this request.",
// "location": "path",
// "required": true,
// "type": "string"
// }
// },
// "path": "{project}/managedZones/{managedZone}",
// "response": {
// "$ref": "ManagedZone"
// },
// "scopes": [
// "https://www.googleapis.com/auth/cloud-platform",
// "https://www.googleapis.com/auth/ndev.clouddns.readonly",
// "https://www.googleapis.com/auth/ndev.clouddns.readwrite"
// ]
// }
}
func (c *ManagedZonesCreateCall) Do() (*ManagedZone, error) {
var body io.Reader = nil
body, err := googleapi.WithoutDataWrapper.JSONReader(c.managedzone)
if err != nil {
return nil, err
}
ctype := "application/json"
params := make(url.Values)
params.Set("alt", "json")
urls := googleapi.ResolveRelative(c.s.BasePath, "{project}/managedZones")
urls += "?" + params.Encode()
req, _ := http.NewRequest("POST", urls, body)
googleapi.Expand(req.URL, map[string]string{
"project": c.project,
})
req.Header.Set("Content-Type", ctype)
req.Header.Set("User-Agent", "google-api-go-client/0.5")
res, err := c.s.client.Do(req)
if err != nil {
return nil, err
}
defer googleapi.CloseBody(res)
if err := googleapi.CheckResponse(res); err != nil {
return nil, err
}
var ret *ManagedZone
if err := json.NewDecoder(res.Body).Decode(&ret); err != nil {
return nil, err
}
return ret, nil
// {
// "description": "Create a new ManagedZone.",
// "httpMethod": "POST",
// "id": "dns.managedZones.create",
// "parameterOrder": [
// "project"
// ],
// "parameters": {
// "project": {
// "description": "Identifies the project addressed by this request.",
// "location": "path",
// "required": true,
// "type": "string"
// }
// },
// "path": "{project}/managedZones",
// "request": {
// "$ref": "ManagedZone"
// },
// "response": {
// "$ref": "ManagedZone"
// },
// "scopes": [
// "https://www.googleapis.com/auth/cloud-platform",
// "https://www.googleapis.com/auth/ndev.clouddns.readwrite"
// ]
// }
}
func (c *TasksDeleteCall) Do() error {
var body io.Reader = nil
params := make(url.Values)
params.Set("alt", "json")
urls := googleapi.ResolveRelative(c.s.BasePath, "{project}/taskqueues/{taskqueue}/tasks/{task}")
urls += "?" + params.Encode()
req, _ := http.NewRequest("DELETE", urls, body)
googleapi.Expand(req.URL, map[string]string{
"project": c.project,
"taskqueue": c.taskqueue,
"task": c.task,
})
req.Header.Set("User-Agent", "google-api-go-client/0.5")
res, err := c.s.client.Do(req)
if err != nil {
return err
}
defer googleapi.CloseBody(res)
if err := googleapi.CheckResponse(res); err != nil {
return err
}
return nil
// {
// "description": "Delete a task from a TaskQueue.",
// "httpMethod": "DELETE",
// "id": "taskqueue.tasks.delete",
// "parameterOrder": [
// "project",
// "taskqueue",
// "task"
// ],
// "parameters": {
// "project": {
// "description": "The project under which the queue lies.",
// "location": "path",
// "required": true,
// "type": "string"
// },
// "task": {
// "description": "The id of the task to delete.",
// "location": "path",
// "required": true,
// "type": "string"
// },
// "taskqueue": {
// "description": "The taskqueue to delete a task from.",
// "location": "path",
// "required": true,
// "type": "string"
// }
// },
// "path": "{project}/taskqueues/{taskqueue}/tasks/{task}",
// "scopes": [
// "https://www.googleapis.com/auth/taskqueue",
// "https://www.googleapis.com/auth/taskqueue.consumer"
// ]
// }
}
func (c *ReportsInsertCall) Do() (*Report, error) {
var body io.Reader = nil
body, err := googleapi.WithoutDataWrapper.JSONReader(c.report)
if err != nil {
return nil, err
}
ctype := "application/json"
params := make(url.Values)
params.Set("alt", "json")
urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/reports")
urls += "?" + params.Encode()
req, _ := http.NewRequest("POST", urls, body)
googleapi.Expand(req.URL, map[string]string{
"profileId": strconv.FormatInt(c.profileId, 10),
})
req.Header.Set("Content-Type", ctype)
req.Header.Set("User-Agent", "google-api-go-client/0.5")
res, err := c.s.client.Do(req)
if err != nil {
return nil, err
}
defer googleapi.CloseBody(res)
if err := googleapi.CheckResponse(res); err != nil {
return nil, err
}
var ret *Report
if err := json.NewDecoder(res.Body).Decode(&ret); err != nil {
return nil, err
}
return ret, nil
// {
// "description": "Creates a report.",
// "httpMethod": "POST",
// "id": "dfareporting.reports.insert",
// "parameterOrder": [
// "profileId"
// ],
// "parameters": {
// "profileId": {
// "description": "The DFA user profile id.",
// "format": "int64",
// "location": "path",
// "required": true,
// "type": "string"
// }
// },
// "path": "userprofiles/{profileId}/reports",
// "request": {
// "$ref": "Report"
// },
// "response": {
// "$ref": "Report"
// },
// "scopes": [
// "https://www.googleapis.com/auth/dfareporting"
// ]
// }
}
func (c *TrainingUpdateCall) Do() (*Training, error) {
var body io.Reader = nil
body, err := googleapi.WithoutDataWrapper.JSONReader(c.update)
if err != nil {
return nil, err
}
ctype := "application/json"
params := make(url.Values)
params.Set("alt", "json")
urls := googleapi.ResolveRelative(c.s.BasePath, "training/{data}")
urls += "?" + params.Encode()
req, _ := http.NewRequest("PUT", urls, body)
googleapi.Expand(req.URL, map[string]string{
"data": c.data,
})
req.Header.Set("Content-Type", ctype)
req.Header.Set("User-Agent", "google-api-go-client/0.5")
res, err := c.s.client.Do(req)
if err != nil {
return nil, err
}
defer googleapi.CloseBody(res)
if err := googleapi.CheckResponse(res); err != nil {
return nil, err
}
var ret *Training
if err := json.NewDecoder(res.Body).Decode(&ret); err != nil {
return nil, err
}
return ret, nil
// {
// "description": "Add new data to a trained model",
// "httpMethod": "PUT",
// "id": "prediction.training.update",
// "parameterOrder": [
// "data"
// ],
// "parameters": {
// "data": {
// "description": "mybucket/mydata resource in Google Storage",
// "location": "path",
// "required": true,
// "type": "string"
// }
// },
// "path": "training/{data}",
// "request": {
// "$ref": "Update"
// },
// "response": {
// "$ref": "Training"
// },
// "scopes": [
// "https://www.googleapis.com/auth/prediction"
// ]
// }
}
func (c *HostedmodelsPredictCall) Do() (*Output, error) {
var body io.Reader = nil
body, err := googleapi.WithoutDataWrapper.JSONReader(c.input)
if err != nil {
return nil, err
}
ctype := "application/json"
params := make(url.Values)
params.Set("alt", "json")
urls := googleapi.ResolveRelative(c.s.BasePath, "hostedmodels/{hostedModelName}/predict")
urls += "?" + params.Encode()
req, _ := http.NewRequest("POST", urls, body)
googleapi.Expand(req.URL, map[string]string{
"hostedModelName": c.hostedModelName,
})
req.Header.Set("Content-Type", ctype)
req.Header.Set("User-Agent", "google-api-go-client/0.5")
res, err := c.s.client.Do(req)
if err != nil {
return nil, err
}
defer googleapi.CloseBody(res)
if err := googleapi.CheckResponse(res); err != nil {
return nil, err
}
var ret *Output
if err := json.NewDecoder(res.Body).Decode(&ret); err != nil {
return nil, err
}
return ret, nil
// {
// "description": "Submit input and request an output against a hosted model",
// "httpMethod": "POST",
// "id": "prediction.hostedmodels.predict",
// "parameterOrder": [
// "hostedModelName"
// ],
// "parameters": {
// "hostedModelName": {
// "description": "The name of a hosted model",
// "location": "path",
// "required": true,
// "type": "string"
// }
// },
// "path": "hostedmodels/{hostedModelName}/predict",
// "request": {
// "$ref": "Input"
// },
// "response": {
// "$ref": "Output"
// },
// "scopes": [
// "https://www.googleapis.com/auth/prediction"
// ]
// }
}
func (c *LicenseAssignmentsDeleteCall) Do() error {
var body io.Reader = nil
params := make(url.Values)
params.Set("alt", "json")
if v, ok := c.opt_["fields"]; ok {
params.Set("fields", fmt.Sprintf("%v", v))
}
urls := googleapi.ResolveRelative(c.s.BasePath, "{productId}/sku/{skuId}/user/{userId}")
urls += "?" + params.Encode()
req, _ := http.NewRequest("DELETE", urls, body)
googleapi.Expand(req.URL, map[string]string{
"productId": c.productId,
"skuId": c.skuId,
"userId": c.userId,
})
req.Header.Set("User-Agent", "google-api-go-client/0.5")
res, err := c.s.client.Do(req)
if err != nil {
return err
}
defer googleapi.CloseBody(res)
if err := googleapi.CheckResponse(res); err != nil {
return err
}
return nil
// {
// "description": "Revoke License.",
// "httpMethod": "DELETE",
// "id": "licensing.licenseAssignments.delete",
// "parameterOrder": [
// "productId",
// "skuId",
// "userId"
// ],
// "parameters": {
// "productId": {
// "description": "Name for product",
// "location": "path",
// "required": true,
// "type": "string"
// },
// "skuId": {
// "description": "Name for sku",
// "location": "path",
// "required": true,
// "type": "string"
// },
// "userId": {
// "description": "email id or unique Id of the user",
// "location": "path",
// "required": true,
// "type": "string"
// }
// },
// "path": "{productId}/sku/{skuId}/user/{userId}"
// }
}
func (c *GroupsUpdateCall) Do() (*Groups, error) {
var body io.Reader = nil
body, err := googleapi.WithoutDataWrapper.JSONReader(c.groups)
if err != nil {
return nil, err
}
ctype := "application/json"
params := make(url.Values)
params.Set("alt", "json")
urls := googleapi.ResolveRelative(c.s.BasePath, "{groupUniqueId}")
urls += "?" + params.Encode()
req, _ := http.NewRequest("PUT", urls, body)
googleapi.Expand(req.URL, map[string]string{
"groupUniqueId": c.groupUniqueId,
})
req.Header.Set("Content-Type", ctype)
req.Header.Set("User-Agent", "google-api-go-client/0.5")
res, err := c.s.client.Do(req)
if err != nil {
return nil, err
}
defer googleapi.CloseBody(res)
if err := googleapi.CheckResponse(res); err != nil {
return nil, err
}
var ret *Groups
if err := json.NewDecoder(res.Body).Decode(&ret); err != nil {
return nil, err
}
return ret, nil
// {
// "description": "Updates an existing resource.",
// "httpMethod": "PUT",
// "id": "groupsSettings.groups.update",
// "parameterOrder": [
// "groupUniqueId"
// ],
// "parameters": {
// "groupUniqueId": {
// "description": "The resource ID",
// "location": "path",
// "required": true,
// "type": "string"
// }
// },
// "path": "{groupUniqueId}",
// "request": {
// "$ref": "Groups"
// },
// "response": {
// "$ref": "Groups"
// },
// "scopes": [
// "https://www.googleapis.com/auth/apps.groups.settings"
// ]
// }
}
func (c *TasksListCall) Do() (*Tasks2, error) {
var body io.Reader = nil
params := make(url.Values)
params.Set("alt", "json")
urls := googleapi.ResolveRelative(c.s.BasePath, "{project}/taskqueues/{taskqueue}/tasks")
urls += "?" + params.Encode()
req, _ := http.NewRequest("GET", urls, body)
googleapi.Expand(req.URL, map[string]string{
"project": c.project,
"taskqueue": c.taskqueue,
})
req.Header.Set("User-Agent", "google-api-go-client/0.5")
res, err := c.s.client.Do(req)
if err != nil {
return nil, err
}
defer googleapi.CloseBody(res)
if err := googleapi.CheckResponse(res); err != nil {
return nil, err
}
var ret *Tasks2
if err := json.NewDecoder(res.Body).Decode(&ret); err != nil {
return nil, err
}
return ret, nil
// {
// "description": "List Tasks in a TaskQueue",
// "httpMethod": "GET",
// "id": "taskqueue.tasks.list",
// "parameterOrder": [
// "project",
// "taskqueue"
// ],
// "parameters": {
// "project": {
// "description": "The project under which the queue lies.",
// "location": "path",
// "required": true,
// "type": "string"
// },
// "taskqueue": {
// "description": "The id of the taskqueue to list tasks from.",
// "location": "path",
// "required": true,
// "type": "string"
// }
// },
// "path": "{project}/taskqueues/{taskqueue}/tasks",
// "response": {
// "$ref": "Tasks2"
// },
// "scopes": [
// "https://www.googleapis.com/auth/taskqueue",
// "https://www.googleapis.com/auth/taskqueue.consumer"
// ]
// }
}
func (c *ApisGetRestCall) Do() (*RestDescription, error) {
var body io.Reader = nil
params := make(url.Values)
params.Set("alt", "json")
if v, ok := c.opt_["fields"]; ok {
params.Set("fields", fmt.Sprintf("%v", v))
}
urls := googleapi.ResolveRelative(c.s.BasePath, "apis/{api}/{version}/rest")
urls += "?" + params.Encode()
req, _ := http.NewRequest("GET", urls, body)
googleapi.Expand(req.URL, map[string]string{
"api": c.api,
"version": c.version,
})
req.Header.Set("User-Agent", "google-api-go-client/0.5")
res, err := c.s.client.Do(req)
if err != nil {
return nil, err
}
defer googleapi.CloseBody(res)
if err := googleapi.CheckResponse(res); err != nil {
return nil, err
}
var ret *RestDescription
if err := json.NewDecoder(res.Body).Decode(&ret); err != nil {
return nil, err
}
return ret, nil
// {
// "description": "Retrieve the description of a particular version of an api.",
// "httpMethod": "GET",
// "id": "discovery.apis.getRest",
// "parameterOrder": [
// "api",
// "version"
// ],
// "parameters": {
// "api": {
// "description": "The name of the API.",
// "location": "path",
// "required": true,
// "type": "string"
// },
// "version": {
// "description": "The version of the API.",
// "location": "path",
// "required": true,
// "type": "string"
// }
// },
// "path": "apis/{api}/{version}/rest",
// "response": {
// "$ref": "RestDescription"
// }
// }
}
func (c *ReportsGetFileCall) Do() error {
var body io.Reader = nil
params := make(url.Values)
params.Set("alt", "json")
if v, ok := c.opt_["fields"]; ok {
params.Set("fields", fmt.Sprintf("%v", v))
}
urls := googleapi.ResolveRelative(c.s.BasePath, "reports/{reportId}/files/{reportFragment}")
urls += "?" + params.Encode()
req, _ := http.NewRequest("GET", urls, body)
googleapi.Expand(req.URL, map[string]string{
"reportId": c.reportId,
"reportFragment": strconv.FormatInt(c.reportFragment, 10),
})
req.Header.Set("User-Agent", "google-api-go-client/0.5")
res, err := c.s.client.Do(req)
if err != nil {
return err
}
defer googleapi.CloseBody(res)
if err := googleapi.CheckResponse(res); err != nil {
return err
}
return nil
// {
// "description": "Downloads a report file.",
// "httpMethod": "GET",
// "id": "doubleclicksearch.reports.getFile",
// "parameterOrder": [
// "reportId",
// "reportFragment"
// ],
// "parameters": {
// "reportFragment": {
// "description": "The index of the report fragment to download.",
// "format": "int32",
// "location": "path",
// "minimum": "0",
// "required": true,
// "type": "integer"
// },
// "reportId": {
// "description": "ID of the report.",
// "location": "path",
// "required": true,
// "type": "string"
// }
// },
// "path": "reports/{reportId}/files/{reportFragment}",
// "scopes": [
// "https://www.googleapis.com/auth/doubleclicksearch"
// ],
// "supportsMediaDownload": true
// }
}
func (c *StatesGetCall) Do() (*GetResponse, error) {
var body io.Reader = nil
params := make(url.Values)
params.Set("alt", "json")
if v, ok := c.opt_["fields"]; ok {
params.Set("fields", fmt.Sprintf("%v", v))
}
urls := googleapi.ResolveRelative(c.s.BasePath, "states/{stateKey}")
urls += "?" + params.Encode()
req, _ := http.NewRequest("GET", urls, body)
googleapi.Expand(req.URL, map[string]string{
"stateKey": strconv.FormatInt(c.stateKey, 10),
})
req.Header.Set("User-Agent", "google-api-go-client/0.5")
res, err := c.s.client.Do(req)
if err != nil {
return nil, err
}
defer googleapi.CloseBody(res)
if err := googleapi.CheckResponse(res); err != nil {
return nil, err
}
var ret *GetResponse
if err := json.NewDecoder(res.Body).Decode(&ret); err != nil {
return nil, err
}
return ret, nil
// {
// "description": "Retrieves the data corresponding to the passed key. If the key does not exist on the server, an HTTP 404 will be returned.",
// "httpMethod": "GET",
// "id": "appstate.states.get",
// "parameterOrder": [
// "stateKey"
// ],
// "parameters": {
// "stateKey": {
// "description": "The key for the data to be retrieved.",
// "format": "int32",
// "location": "path",
// "maximum": "3",
// "minimum": "0",
// "required": true,
// "type": "integer"
// }
// },
// "path": "states/{stateKey}",
// "response": {
// "$ref": "GetResponse"
// },
// "scopes": [
// "https://www.googleapis.com/auth/appstate"
// ]
// }
}
func (c *ManagedZonesDeleteCall) Do() error {
var body io.Reader = nil
params := make(url.Values)
params.Set("alt", "json")
if v, ok := c.opt_["fields"]; ok {
params.Set("fields", fmt.Sprintf("%v", v))
}
urls := googleapi.ResolveRelative(c.s.BasePath, "{project}/managedZones/{managedZone}")
urls += "?" + params.Encode()
req, _ := http.NewRequest("DELETE", urls, body)
googleapi.Expand(req.URL, map[string]string{
"project": c.project,
"managedZone": c.managedZone,
})
req.Header.Set("User-Agent", "google-api-go-client/0.5")
res, err := c.s.client.Do(req)
if err != nil {
return err
}
defer googleapi.CloseBody(res)
if err := googleapi.CheckResponse(res); err != nil {
return err
}
return nil
// {
// "description": "Delete a previously created ManagedZone.",
// "httpMethod": "DELETE",
// "id": "dns.managedZones.delete",
// "parameterOrder": [
// "project",
// "managedZone"
// ],
// "parameters": {
// "managedZone": {
// "description": "Identifies the managed zone addressed by this request. Can be the managed zone name or id.",
// "location": "path",
// "required": true,
// "type": "string"
// },
// "project": {
// "description": "Identifies the project addressed by this request.",
// "location": "path",
// "required": true,
// "type": "string"
// }
// },
// "path": "{project}/managedZones/{managedZone}",
// "scopes": [
// "https://www.googleapis.com/auth/cloud-platform",
// "https://www.googleapis.com/auth/ndev.clouddns.readwrite"
// ]
// }
}
func (c *SitemapsSubmitCall) Do() error {
var body io.Reader = nil
params := make(url.Values)
params.Set("alt", "json")
if v, ok := c.opt_["fields"]; ok {
params.Set("fields", fmt.Sprintf("%v", v))
}
urls := googleapi.ResolveRelative(c.s.BasePath, "sites/{siteUrl}/sitemaps/{feedpath}")
urls += "?" + params.Encode()
req, _ := http.NewRequest("PUT", urls, body)
googleapi.Expand(req.URL, map[string]string{
"siteUrl": c.siteUrl,
"feedpath": c.feedpath,
})
req.Header.Set("User-Agent", "google-api-go-client/0.5")
res, err := c.s.client.Do(req)
if err != nil {
return err
}
defer googleapi.CloseBody(res)
if err := googleapi.CheckResponse(res); err != nil {
return err
}
return nil
// {
// "description": "Submits a sitemap for a site.",
// "httpMethod": "PUT",
// "id": "webmasters.sitemaps.submit",
// "parameterOrder": [
// "siteUrl",
// "feedpath"
// ],
// "parameters": {
// "feedpath": {
// "description": "The URL of the sitemap to add.",
// "location": "path",
// "required": true,
// "type": "string"
// },
// "siteUrl": {
// "description": "The site's URL, including protocol, for example 'http://www.example.com/'",
// "location": "path",
// "required": true,
// "type": "string"
// }
// },
// "path": "sites/{siteUrl}/sitemaps/{feedpath}",
// "scopes": [
// "https://www.googleapis.com/auth/webmasters"
// ]
// }
}
func (c *SitesGetCall) Do() (*WmxSite, error) {
var body io.Reader = nil
params := make(url.Values)
params.Set("alt", "json")
if v, ok := c.opt_["fields"]; ok {
params.Set("fields", fmt.Sprintf("%v", v))
}
urls := googleapi.ResolveRelative(c.s.BasePath, "sites/{siteUrl}")
urls += "?" + params.Encode()
req, _ := http.NewRequest("GET", urls, body)
googleapi.Expand(req.URL, map[string]string{
"siteUrl": c.siteUrl,
})
req.Header.Set("User-Agent", "google-api-go-client/0.5")
res, err := c.s.client.Do(req)
if err != nil {
return nil, err
}
defer googleapi.CloseBody(res)
if err := googleapi.CheckResponse(res); err != nil {
return nil, err
}
var ret *WmxSite
if err := json.NewDecoder(res.Body).Decode(&ret); err != nil {
return nil, err
}
return ret, nil
// {
// "description": "Retrieves information about specific site.",
// "httpMethod": "GET",
// "id": "webmasters.sites.get",
// "parameterOrder": [
// "siteUrl"
// ],
// "parameters": {
// "siteUrl": {
// "description": "The site's URL, including protocol, for example 'http://www.example.com/'",
// "location": "path",
// "required": true,
// "type": "string"
// }
// },
// "path": "sites/{siteUrl}",
// "response": {
// "$ref": "WmxSite"
// },
// "scopes": [
// "https://www.googleapis.com/auth/webmasters",
// "https://www.googleapis.com/auth/webmasters.readonly"
// ]
// }
}
func (c *TasklistsGetCall) Do() (*TaskList, error) {
var body io.Reader = nil
params := make(url.Values)
params.Set("alt", "json")
if v, ok := c.opt_["fields"]; ok {
params.Set("fields", fmt.Sprintf("%v", v))
}
urls := googleapi.ResolveRelative(c.s.BasePath, "users/@me/lists/{tasklist}")
urls += "?" + params.Encode()
req, _ := http.NewRequest("GET", urls, body)
googleapi.Expand(req.URL, map[string]string{
"tasklist": c.tasklistid,
})
req.Header.Set("User-Agent", "google-api-go-client/0.5")
res, err := c.s.client.Do(req)
if err != nil {
return nil, err
}
defer googleapi.CloseBody(res)
if err := googleapi.CheckResponse(res); err != nil {
return nil, err
}
var ret *TaskList
if err := json.NewDecoder(res.Body).Decode(&ret); err != nil {
return nil, err
}
return ret, nil
// {
// "description": "Returns the authenticated user's specified task list.",
// "httpMethod": "GET",
// "id": "tasks.tasklists.get",
// "parameterOrder": [
// "tasklist"
// ],
// "parameters": {
// "tasklist": {
// "description": "Task list identifier.",
// "location": "path",
// "required": true,
// "type": "string"
// }
// },
// "path": "users/@me/lists/{tasklist}",
// "response": {
// "$ref": "TaskList"
// },
// "scopes": [
// "https://www.googleapis.com/auth/tasks",
// "https://www.googleapis.com/auth/tasks.readonly"
// ]
// }
}
func (c *CustomersGetCall) Do() (*Customer, error) {
var body io.Reader = nil
params := make(url.Values)
params.Set("alt", "json")
if v, ok := c.opt_["fields"]; ok {
params.Set("fields", fmt.Sprintf("%v", v))
}
urls := googleapi.ResolveRelative(c.s.BasePath, "customers/{customerId}")
urls += "?" + params.Encode()
req, _ := http.NewRequest("GET", urls, body)
googleapi.Expand(req.URL, map[string]string{
"customerId": c.customerId,
})
req.Header.Set("User-Agent", "google-api-go-client/0.5")
res, err := c.s.client.Do(req)
if err != nil {
return nil, err
}
defer googleapi.CloseBody(res)
if err := googleapi.CheckResponse(res); err != nil {
return nil, err
}
var ret *Customer
if err := json.NewDecoder(res.Body).Decode(&ret); err != nil {
return nil, err
}
return ret, nil
// {
// "description": "Gets a customer resource if one exists and is owned by the reseller.",
// "httpMethod": "GET",
// "id": "reseller.customers.get",
// "parameterOrder": [
// "customerId"
// ],
// "parameters": {
// "customerId": {
// "description": "Id of the Customer",
// "location": "path",
// "required": true,
// "type": "string"
// }
// },
// "path": "customers/{customerId}",
// "response": {
// "$ref": "Customer"
// },
// "scopes": [
// "https://www.googleapis.com/auth/apps.order",
// "https://www.googleapis.com/auth/apps.order.readonly"
// ]
// }
}
func (c *TasksDeleteCall) Do() error {
var body io.Reader = nil
params := make(url.Values)
params.Set("alt", "json")
if v, ok := c.opt_["fields"]; ok {
params.Set("fields", fmt.Sprintf("%v", v))
}
urls := googleapi.ResolveRelative(c.s.BasePath, "lists/{tasklist}/tasks/{task}")
urls += "?" + params.Encode()
req, _ := http.NewRequest("DELETE", urls, body)
googleapi.Expand(req.URL, map[string]string{
"tasklist": c.tasklistid,
"task": c.taskid,
})
req.Header.Set("User-Agent", "google-api-go-client/0.5")
res, err := c.s.client.Do(req)
if err != nil {
return err
}
defer googleapi.CloseBody(res)
if err := googleapi.CheckResponse(res); err != nil {
return err
}
return nil
// {
// "description": "Deletes the specified task from the task list.",
// "httpMethod": "DELETE",
// "id": "tasks.tasks.delete",
// "parameterOrder": [
// "tasklist",
// "task"
// ],
// "parameters": {
// "task": {
// "description": "Task identifier.",
// "location": "path",
// "required": true,
// "type": "string"
// },
// "tasklist": {
// "description": "Task list identifier.",
// "location": "path",
// "required": true,
// "type": "string"
// }
// },
// "path": "lists/{tasklist}/tasks/{task}",
// "scopes": [
// "https://www.googleapis.com/auth/tasks"
// ]
// }
}
func (c *SubscriptionsGetCall) Do() (*Subscription, error) {
var body io.Reader = nil
params := make(url.Values)
params.Set("alt", "json")
if v, ok := c.opt_["fields"]; ok {
params.Set("fields", fmt.Sprintf("%v", v))
}
urls := googleapi.ResolveRelative(c.s.BasePath, "subscriptions/{+subscription}")
urls += "?" + params.Encode()
req, _ := http.NewRequest("GET", urls, body)
googleapi.Expand(req.URL, map[string]string{
"subscription": c.subscription,
})
req.Header.Set("User-Agent", "google-api-go-client/0.5")
res, err := c.s.client.Do(req)
if err != nil {
return nil, err
}
defer googleapi.CloseBody(res)
if err := googleapi.CheckResponse(res); err != nil {
return nil, err
}
var ret *Subscription
if err := json.NewDecoder(res.Body).Decode(&ret); err != nil {
return nil, err
}
return ret, nil
// {
// "description": "Gets the configuration details of a subscription.",
// "httpMethod": "GET",
// "id": "pubsub.subscriptions.get",
// "parameterOrder": [
// "subscription"
// ],
// "parameters": {
// "subscription": {
// "description": "The name of the subscription to get.",
// "location": "path",
// "required": true,
// "type": "string"
// }
// },
// "path": "subscriptions/{+subscription}",
// "response": {
// "$ref": "Subscription"
// },
// "scopes": [
// "https://www.googleapis.com/auth/cloud-platform",
// "https://www.googleapis.com/auth/pubsub"
// ]
// }
}
func (c *TopicsGetCall) Do() (*Topic, error) {
var body io.Reader = nil
params := make(url.Values)
params.Set("alt", "json")
if v, ok := c.opt_["fields"]; ok {
params.Set("fields", fmt.Sprintf("%v", v))
}
urls := googleapi.ResolveRelative(c.s.BasePath, "topics/{+topic}")
urls += "?" + params.Encode()
req, _ := http.NewRequest("GET", urls, body)
googleapi.Expand(req.URL, map[string]string{
"topic": c.topic,
})
req.Header.Set("User-Agent", "google-api-go-client/0.5")
res, err := c.s.client.Do(req)
if err != nil {
return nil, err
}
defer googleapi.CloseBody(res)
if err := googleapi.CheckResponse(res); err != nil {
return nil, err
}
var ret *Topic
if err := json.NewDecoder(res.Body).Decode(&ret); err != nil {
return nil, err
}
return ret, nil
// {
// "description": "Gets the configuration of a topic. Since the topic only has the name attribute, this method is only useful to check the existence of a topic. If other attributes are added in the future, they will be returned here.",
// "httpMethod": "GET",
// "id": "pubsub.topics.get",
// "parameterOrder": [
// "topic"
// ],
// "parameters": {
// "topic": {
// "description": "The name of the topic to get.",
// "location": "path",
// "required": true,
// "type": "string"
// }
// },
// "path": "topics/{+topic}",
// "response": {
// "$ref": "Topic"
// },
// "scopes": [
// "https://www.googleapis.com/auth/cloud-platform",
// "https://www.googleapis.com/auth/pubsub"
// ]
// }
}
func (c *AccountsGetCall) Do() (*Account, error) {
var body io.Reader = nil
params := make(url.Values)
params.Set("alt", "json")
if v, ok := c.opt_["fields"]; ok {
params.Set("fields", fmt.Sprintf("%v", v))
}
urls := googleapi.ResolveRelative(c.s.BasePath, "accounts/{id}")
urls += "?" + params.Encode()
req, _ := http.NewRequest("GET", urls, body)
googleapi.Expand(req.URL, map[string]string{
"id": strconv.FormatInt(c.id, 10),
})
req.Header.Set("User-Agent", "google-api-go-client/0.5")
res, err := c.s.client.Do(req)
if err != nil {
return nil, err
}
defer googleapi.CloseBody(res)
if err := googleapi.CheckResponse(res); err != nil {
return nil, err
}
var ret *Account
if err := json.NewDecoder(res.Body).Decode(&ret); err != nil {
return nil, err
}
return ret, nil
// {
// "description": "Gets one account by ID.",
// "httpMethod": "GET",
// "id": "adexchangebuyer.accounts.get",
// "parameterOrder": [
// "id"
// ],
// "parameters": {
// "id": {
// "description": "The account id",
// "format": "int32",
// "location": "path",
// "required": true,
// "type": "integer"
// }
// },
// "path": "accounts/{id}",
// "response": {
// "$ref": "Account"
// },
// "scopes": [
// "https://www.googleapis.com/auth/adexchange.buyer"
// ]
// }
}
func (c *TrainingGetCall) Do() (*Training, error) {
var body io.Reader = nil
params := make(url.Values)
params.Set("alt", "json")
if v, ok := c.opt_["fields"]; ok {
params.Set("fields", fmt.Sprintf("%v", v))
}
urls := googleapi.ResolveRelative(c.s.BasePath, "training/{data}")
urls += "?" + params.Encode()
req, _ := http.NewRequest("GET", urls, body)
googleapi.Expand(req.URL, map[string]string{
"data": c.data,
})
req.Header.Set("User-Agent", "google-api-go-client/0.5")
res, err := c.s.client.Do(req)
if err != nil {
return nil, err
}
defer googleapi.CloseBody(res)
if err := googleapi.CheckResponse(res); err != nil {
return nil, err
}
var ret *Training
if err := json.NewDecoder(res.Body).Decode(&ret); err != nil {
return nil, err
}
return ret, nil
// {
// "description": "Check training status of your model",
// "httpMethod": "GET",
// "id": "prediction.training.get",
// "parameterOrder": [
// "data"
// ],
// "parameters": {
// "data": {
// "description": "mybucket/mydata resource in Google Storage",
// "location": "path",
// "required": true,
// "type": "string"
// }
// },
// "path": "training/{data}",
// "response": {
// "$ref": "Training"
// },
// "scopes": [
// "https://www.googleapis.com/auth/prediction"
// ]
// }
}
func (c *ReportsDeleteCall) Do() error {
var body io.Reader = nil
params := make(url.Values)
params.Set("alt", "json")
urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/reports/{reportId}")
urls += "?" + params.Encode()
req, _ := http.NewRequest("DELETE", urls, body)
googleapi.Expand(req.URL, map[string]string{
"profileId": strconv.FormatInt(c.profileId, 10),
"reportId": strconv.FormatInt(c.reportId, 10),
})
req.Header.Set("User-Agent", "google-api-go-client/0.5")
res, err := c.s.client.Do(req)
if err != nil {
return err
}
defer googleapi.CloseBody(res)
if err := googleapi.CheckResponse(res); err != nil {
return err
}
return nil
// {
// "description": "Deletes a report by its id.",
// "httpMethod": "DELETE",
// "id": "dfareporting.reports.delete",
// "parameterOrder": [
// "profileId",
// "reportId"
// ],
// "parameters": {
// "profileId": {
// "description": "The DFA user profile id.",
// "format": "int64",
// "location": "path",
// "required": true,
// "type": "string"
// },
// "reportId": {
// "description": "The id of the report.",
// "format": "int64",
// "location": "path",
// "required": true,
// "type": "string"
// }
// },
// "path": "userprofiles/{profileId}/reports/{reportId}",
// "scopes": [
// "https://www.googleapis.com/auth/dfareporting"
// ]
// }
}
