mirror of
https://github.com/fnproject/fn.git
synced 2022-10-28 21:29:17 +03:00
9eaf824398
* add jaeger support, link hot container & req span * adds jaeger support now with FN_JAEGER_URL, there's a simple tutorial in the operating/metrics.md file now and it's pretty easy to get up and running. * links a hot request span to a hot container span. when we change this to sample at a lower ratio we'll need to finagle the hot container span to always sample or something, otherwise we'll hide that info. at least, since we're sampling at 100% for now if this is flipped on, can see freeze/unfreeze etc. if they hit. this is useful for debugging. note that zipkin's exporter does not follow the link at all, hence jaeger... and they're backed by the Cloud Empire now (CNCF) so we'll probably use it anyway. * vendor: add thrift for jaeger
1068 lines
35 KiB
Go
1068 lines
35 KiB
Go
// Package analytics provides access to the Google Analytics API.
|
|
//
|
|
// See https://developers.google.com/analytics/
|
|
//
|
|
// Usage example:
|
|
//
|
|
// import "google.golang.org/api/analytics/v2.4"
|
|
// ...
|
|
// analyticsService, err := analytics.New(oauthHttpClient)
|
|
package analytics // import "google.golang.org/api/analytics/v2.4"
|
|
|
|
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 = "analytics:v2.4"
|
|
const apiName = "analytics"
|
|
const apiVersion = "v2.4"
|
|
const basePath = "https://www.googleapis.com/analytics/v2.4/"
|
|
|
|
// OAuth2 scopes used by this API.
|
|
const (
|
|
// View and manage your Google Analytics data
|
|
AnalyticsScope = "https://www.googleapis.com/auth/analytics"
|
|
|
|
// View your Google Analytics data
|
|
AnalyticsReadonlyScope = "https://www.googleapis.com/auth/analytics.readonly"
|
|
)
|
|
|
|
func New(client *http.Client) (*Service, error) {
|
|
if client == nil {
|
|
return nil, errors.New("client is nil")
|
|
}
|
|
s := &Service{client: client, BasePath: basePath}
|
|
s.Data = NewDataService(s)
|
|
s.Management = NewManagementService(s)
|
|
return s, nil
|
|
}
|
|
|
|
type Service struct {
|
|
client *http.Client
|
|
BasePath string // API endpoint base URL
|
|
UserAgent string // optional additional User-Agent fragment
|
|
|
|
Data *DataService
|
|
|
|
Management *ManagementService
|
|
}
|
|
|
|
func (s *Service) userAgent() string {
|
|
if s.UserAgent == "" {
|
|
return googleapi.UserAgent
|
|
}
|
|
return googleapi.UserAgent + " " + s.UserAgent
|
|
}
|
|
|
|
func NewDataService(s *Service) *DataService {
|
|
rs := &DataService{s: s}
|
|
return rs
|
|
}
|
|
|
|
type DataService struct {
|
|
s *Service
|
|
}
|
|
|
|
func NewManagementService(s *Service) *ManagementService {
|
|
rs := &ManagementService{s: s}
|
|
rs.Accounts = NewManagementAccountsService(s)
|
|
rs.Goals = NewManagementGoalsService(s)
|
|
rs.Profiles = NewManagementProfilesService(s)
|
|
rs.Segments = NewManagementSegmentsService(s)
|
|
rs.Webproperties = NewManagementWebpropertiesService(s)
|
|
return rs
|
|
}
|
|
|
|
type ManagementService struct {
|
|
s *Service
|
|
|
|
Accounts *ManagementAccountsService
|
|
|
|
Goals *ManagementGoalsService
|
|
|
|
Profiles *ManagementProfilesService
|
|
|
|
Segments *ManagementSegmentsService
|
|
|
|
Webproperties *ManagementWebpropertiesService
|
|
}
|
|
|
|
func NewManagementAccountsService(s *Service) *ManagementAccountsService {
|
|
rs := &ManagementAccountsService{s: s}
|
|
return rs
|
|
}
|
|
|
|
type ManagementAccountsService struct {
|
|
s *Service
|
|
}
|
|
|
|
func NewManagementGoalsService(s *Service) *ManagementGoalsService {
|
|
rs := &ManagementGoalsService{s: s}
|
|
return rs
|
|
}
|
|
|
|
type ManagementGoalsService struct {
|
|
s *Service
|
|
}
|
|
|
|
func NewManagementProfilesService(s *Service) *ManagementProfilesService {
|
|
rs := &ManagementProfilesService{s: s}
|
|
return rs
|
|
}
|
|
|
|
type ManagementProfilesService struct {
|
|
s *Service
|
|
}
|
|
|
|
func NewManagementSegmentsService(s *Service) *ManagementSegmentsService {
|
|
rs := &ManagementSegmentsService{s: s}
|
|
return rs
|
|
}
|
|
|
|
type ManagementSegmentsService struct {
|
|
s *Service
|
|
}
|
|
|
|
func NewManagementWebpropertiesService(s *Service) *ManagementWebpropertiesService {
|
|
rs := &ManagementWebpropertiesService{s: s}
|
|
return rs
|
|
}
|
|
|
|
type ManagementWebpropertiesService struct {
|
|
s *Service
|
|
}
|
|
|
|
// method id "analytics.data.get":
|
|
|
|
type DataGetCall struct {
|
|
s *Service
|
|
urlParams_ gensupport.URLParams
|
|
ifNoneMatch_ string
|
|
ctx_ context.Context
|
|
header_ http.Header
|
|
}
|
|
|
|
// Get: Returns Analytics report data for a view (profile).
|
|
func (r *DataService) Get(ids string, startDate string, endDate string, metrics string) *DataGetCall {
|
|
c := &DataGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
|
|
c.urlParams_.Set("ids", ids)
|
|
c.urlParams_.Set("start-date", startDate)
|
|
c.urlParams_.Set("end-date", endDate)
|
|
c.urlParams_.Set("metrics", metrics)
|
|
return c
|
|
}
|
|
|
|
// Dimensions sets the optional parameter "dimensions": A
|
|
// comma-separated list of Analytics dimensions. E.g.,
|
|
// 'ga:browser,ga:city'.
|
|
func (c *DataGetCall) Dimensions(dimensions string) *DataGetCall {
|
|
c.urlParams_.Set("dimensions", dimensions)
|
|
return c
|
|
}
|
|
|
|
// Filters sets the optional parameter "filters": A comma-separated list
|
|
// of dimension or metric filters to be applied to the report data.
|
|
func (c *DataGetCall) Filters(filters string) *DataGetCall {
|
|
c.urlParams_.Set("filters", filters)
|
|
return c
|
|
}
|
|
|
|
// MaxResults sets the optional parameter "max-results": The maximum
|
|
// number of entries to include in this feed.
|
|
func (c *DataGetCall) MaxResults(maxResults int64) *DataGetCall {
|
|
c.urlParams_.Set("max-results", fmt.Sprint(maxResults))
|
|
return c
|
|
}
|
|
|
|
// Segment sets the optional parameter "segment": An Analytics advanced
|
|
// segment to be applied to the report data.
|
|
func (c *DataGetCall) Segment(segment string) *DataGetCall {
|
|
c.urlParams_.Set("segment", segment)
|
|
return c
|
|
}
|
|
|
|
// Sort sets the optional parameter "sort": A comma-separated list of
|
|
// dimensions or metrics that determine the sort order for the report
|
|
// data.
|
|
func (c *DataGetCall) Sort(sort string) *DataGetCall {
|
|
c.urlParams_.Set("sort", sort)
|
|
return c
|
|
}
|
|
|
|
// StartIndex sets the optional parameter "start-index": An index of the
|
|
// first entity to retrieve. Use this parameter as a pagination
|
|
// mechanism along with the max-results parameter.
|
|
func (c *DataGetCall) StartIndex(startIndex int64) *DataGetCall {
|
|
c.urlParams_.Set("start-index", fmt.Sprint(startIndex))
|
|
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 *DataGetCall) Fields(s ...googleapi.Field) *DataGetCall {
|
|
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 *DataGetCall) IfNoneMatch(entityTag string) *DataGetCall {
|
|
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 *DataGetCall) Context(ctx context.Context) *DataGetCall {
|
|
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 *DataGetCall) Header() http.Header {
|
|
if c.header_ == nil {
|
|
c.header_ = make(http.Header)
|
|
}
|
|
return c.header_
|
|
}
|
|
|
|
func (c *DataGetCall) 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, "data")
|
|
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 "analytics.data.get" call.
|
|
func (c *DataGetCall) Do(opts ...googleapi.CallOption) error {
|
|
gensupport.SetOptions(c.urlParams_, opts...)
|
|
res, err := c.doRequest("json")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer googleapi.CloseBody(res)
|
|
if err := googleapi.CheckResponse(res); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
// {
|
|
// "description": "Returns Analytics report data for a view (profile).",
|
|
// "httpMethod": "GET",
|
|
// "id": "analytics.data.get",
|
|
// "parameterOrder": [
|
|
// "ids",
|
|
// "start-date",
|
|
// "end-date",
|
|
// "metrics"
|
|
// ],
|
|
// "parameters": {
|
|
// "dimensions": {
|
|
// "description": "A comma-separated list of Analytics dimensions. E.g., 'ga:browser,ga:city'.",
|
|
// "location": "query",
|
|
// "pattern": "(ga:.+)?",
|
|
// "type": "string"
|
|
// },
|
|
// "end-date": {
|
|
// "description": "End date for fetching report data. All requests should specify an end date formatted as YYYY-MM-DD.",
|
|
// "location": "query",
|
|
// "pattern": "[0-9]{4}-[0-9]{2}-[0-9]{2}",
|
|
// "required": true,
|
|
// "type": "string"
|
|
// },
|
|
// "filters": {
|
|
// "description": "A comma-separated list of dimension or metric filters to be applied to the report data.",
|
|
// "location": "query",
|
|
// "pattern": "ga:.+",
|
|
// "type": "string"
|
|
// },
|
|
// "ids": {
|
|
// "description": "Unique table ID for retrieving report data. Table ID is of the form ga:XXXX, where XXXX is the Analytics view (profile) ID.",
|
|
// "location": "query",
|
|
// "pattern": "ga:[0-9]+",
|
|
// "required": true,
|
|
// "type": "string"
|
|
// },
|
|
// "max-results": {
|
|
// "description": "The maximum number of entries to include in this feed.",
|
|
// "format": "int32",
|
|
// "location": "query",
|
|
// "type": "integer"
|
|
// },
|
|
// "metrics": {
|
|
// "description": "A comma-separated list of Analytics metrics. E.g., 'ga:sessions,ga:pageviews'. At least one metric must be specified to retrieve a valid Analytics report.",
|
|
// "location": "query",
|
|
// "pattern": "ga:.+",
|
|
// "required": true,
|
|
// "type": "string"
|
|
// },
|
|
// "segment": {
|
|
// "description": "An Analytics advanced segment to be applied to the report data.",
|
|
// "location": "query",
|
|
// "type": "string"
|
|
// },
|
|
// "sort": {
|
|
// "description": "A comma-separated list of dimensions or metrics that determine the sort order for the report data.",
|
|
// "location": "query",
|
|
// "pattern": "(-)?ga:.+",
|
|
// "type": "string"
|
|
// },
|
|
// "start-date": {
|
|
// "description": "Start date for fetching report data. All requests should specify a start date formatted as YYYY-MM-DD.",
|
|
// "location": "query",
|
|
// "pattern": "[0-9]{4}-[0-9]{2}-[0-9]{2}",
|
|
// "required": true,
|
|
// "type": "string"
|
|
// },
|
|
// "start-index": {
|
|
// "description": "An index of the first entity to retrieve. Use this parameter as a pagination mechanism along with the max-results parameter.",
|
|
// "format": "int32",
|
|
// "location": "query",
|
|
// "minimum": "1",
|
|
// "type": "integer"
|
|
// }
|
|
// },
|
|
// "path": "data",
|
|
// "scopes": [
|
|
// "https://www.googleapis.com/auth/analytics",
|
|
// "https://www.googleapis.com/auth/analytics.readonly"
|
|
// ]
|
|
// }
|
|
|
|
}
|
|
|
|
// method id "analytics.management.accounts.list":
|
|
|
|
type ManagementAccountsListCall struct {
|
|
s *Service
|
|
urlParams_ gensupport.URLParams
|
|
ifNoneMatch_ string
|
|
ctx_ context.Context
|
|
header_ http.Header
|
|
}
|
|
|
|
// List: Lists all accounts to which the user has access.
|
|
func (r *ManagementAccountsService) List() *ManagementAccountsListCall {
|
|
c := &ManagementAccountsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
|
|
return c
|
|
}
|
|
|
|
// MaxResults sets the optional parameter "max-results": The maximum
|
|
// number of accounts to include in this response.
|
|
func (c *ManagementAccountsListCall) MaxResults(maxResults int64) *ManagementAccountsListCall {
|
|
c.urlParams_.Set("max-results", fmt.Sprint(maxResults))
|
|
return c
|
|
}
|
|
|
|
// StartIndex sets the optional parameter "start-index": An index of the
|
|
// first account to retrieve. Use this parameter as a pagination
|
|
// mechanism along with the max-results parameter.
|
|
func (c *ManagementAccountsListCall) StartIndex(startIndex int64) *ManagementAccountsListCall {
|
|
c.urlParams_.Set("start-index", fmt.Sprint(startIndex))
|
|
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 *ManagementAccountsListCall) Fields(s ...googleapi.Field) *ManagementAccountsListCall {
|
|
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 *ManagementAccountsListCall) IfNoneMatch(entityTag string) *ManagementAccountsListCall {
|
|
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 *ManagementAccountsListCall) Context(ctx context.Context) *ManagementAccountsListCall {
|
|
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 *ManagementAccountsListCall) Header() http.Header {
|
|
if c.header_ == nil {
|
|
c.header_ = make(http.Header)
|
|
}
|
|
return c.header_
|
|
}
|
|
|
|
func (c *ManagementAccountsListCall) 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, "management/accounts")
|
|
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 "analytics.management.accounts.list" call.
|
|
func (c *ManagementAccountsListCall) Do(opts ...googleapi.CallOption) error {
|
|
gensupport.SetOptions(c.urlParams_, opts...)
|
|
res, err := c.doRequest("json")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer googleapi.CloseBody(res)
|
|
if err := googleapi.CheckResponse(res); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
// {
|
|
// "description": "Lists all accounts to which the user has access.",
|
|
// "httpMethod": "GET",
|
|
// "id": "analytics.management.accounts.list",
|
|
// "parameters": {
|
|
// "max-results": {
|
|
// "description": "The maximum number of accounts to include in this response.",
|
|
// "format": "int32",
|
|
// "location": "query",
|
|
// "type": "integer"
|
|
// },
|
|
// "start-index": {
|
|
// "description": "An index of the first account to retrieve. Use this parameter as a pagination mechanism along with the max-results parameter.",
|
|
// "format": "int32",
|
|
// "location": "query",
|
|
// "minimum": "1",
|
|
// "type": "integer"
|
|
// }
|
|
// },
|
|
// "path": "management/accounts",
|
|
// "scopes": [
|
|
// "https://www.googleapis.com/auth/analytics",
|
|
// "https://www.googleapis.com/auth/analytics.readonly"
|
|
// ]
|
|
// }
|
|
|
|
}
|
|
|
|
// method id "analytics.management.goals.list":
|
|
|
|
type ManagementGoalsListCall struct {
|
|
s *Service
|
|
accountId string
|
|
webPropertyId string
|
|
profileId string
|
|
urlParams_ gensupport.URLParams
|
|
ifNoneMatch_ string
|
|
ctx_ context.Context
|
|
header_ http.Header
|
|
}
|
|
|
|
// List: Lists goals to which the user has access.
|
|
func (r *ManagementGoalsService) List(accountId string, webPropertyId string, profileId string) *ManagementGoalsListCall {
|
|
c := &ManagementGoalsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
|
|
c.accountId = accountId
|
|
c.webPropertyId = webPropertyId
|
|
c.profileId = profileId
|
|
return c
|
|
}
|
|
|
|
// MaxResults sets the optional parameter "max-results": The maximum
|
|
// number of goals to include in this response.
|
|
func (c *ManagementGoalsListCall) MaxResults(maxResults int64) *ManagementGoalsListCall {
|
|
c.urlParams_.Set("max-results", fmt.Sprint(maxResults))
|
|
return c
|
|
}
|
|
|
|
// StartIndex sets the optional parameter "start-index": An index of the
|
|
// first goal to retrieve. Use this parameter as a pagination mechanism
|
|
// along with the max-results parameter.
|
|
func (c *ManagementGoalsListCall) StartIndex(startIndex int64) *ManagementGoalsListCall {
|
|
c.urlParams_.Set("start-index", fmt.Sprint(startIndex))
|
|
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 *ManagementGoalsListCall) Fields(s ...googleapi.Field) *ManagementGoalsListCall {
|
|
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 *ManagementGoalsListCall) IfNoneMatch(entityTag string) *ManagementGoalsListCall {
|
|
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 *ManagementGoalsListCall) Context(ctx context.Context) *ManagementGoalsListCall {
|
|
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 *ManagementGoalsListCall) Header() http.Header {
|
|
if c.header_ == nil {
|
|
c.header_ = make(http.Header)
|
|
}
|
|
return c.header_
|
|
}
|
|
|
|
func (c *ManagementGoalsListCall) 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, "management/accounts/{accountId}/webproperties/{webPropertyId}/profiles/{profileId}/goals")
|
|
urls += "?" + c.urlParams_.Encode()
|
|
req, _ := http.NewRequest("GET", urls, body)
|
|
req.Header = reqHeaders
|
|
googleapi.Expand(req.URL, map[string]string{
|
|
"accountId": c.accountId,
|
|
"webPropertyId": c.webPropertyId,
|
|
"profileId": c.profileId,
|
|
})
|
|
return gensupport.SendRequest(c.ctx_, c.s.client, req)
|
|
}
|
|
|
|
// Do executes the "analytics.management.goals.list" call.
|
|
func (c *ManagementGoalsListCall) Do(opts ...googleapi.CallOption) error {
|
|
gensupport.SetOptions(c.urlParams_, opts...)
|
|
res, err := c.doRequest("json")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer googleapi.CloseBody(res)
|
|
if err := googleapi.CheckResponse(res); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
// {
|
|
// "description": "Lists goals to which the user has access.",
|
|
// "httpMethod": "GET",
|
|
// "id": "analytics.management.goals.list",
|
|
// "parameterOrder": [
|
|
// "accountId",
|
|
// "webPropertyId",
|
|
// "profileId"
|
|
// ],
|
|
// "parameters": {
|
|
// "accountId": {
|
|
// "description": "Account ID to retrieve goals for. Can either be a specific account ID or '~all', which refers to all the accounts that user has access to.",
|
|
// "location": "path",
|
|
// "required": true,
|
|
// "type": "string"
|
|
// },
|
|
// "max-results": {
|
|
// "description": "The maximum number of goals to include in this response.",
|
|
// "format": "int32",
|
|
// "location": "query",
|
|
// "type": "integer"
|
|
// },
|
|
// "profileId": {
|
|
// "description": "View (Profile) ID to retrieve goals for. Can either be a specific view (profile) ID or '~all', which refers to all the views (profiles) that user has access to.",
|
|
// "location": "path",
|
|
// "required": true,
|
|
// "type": "string"
|
|
// },
|
|
// "start-index": {
|
|
// "description": "An index of the first goal to retrieve. Use this parameter as a pagination mechanism along with the max-results parameter.",
|
|
// "format": "int32",
|
|
// "location": "query",
|
|
// "minimum": "1",
|
|
// "type": "integer"
|
|
// },
|
|
// "webPropertyId": {
|
|
// "description": "Web property ID to retrieve goals for. Can either be a specific web property ID or '~all', which refers to all the web properties that user has access to.",
|
|
// "location": "path",
|
|
// "required": true,
|
|
// "type": "string"
|
|
// }
|
|
// },
|
|
// "path": "management/accounts/{accountId}/webproperties/{webPropertyId}/profiles/{profileId}/goals",
|
|
// "scopes": [
|
|
// "https://www.googleapis.com/auth/analytics",
|
|
// "https://www.googleapis.com/auth/analytics.readonly"
|
|
// ]
|
|
// }
|
|
|
|
}
|
|
|
|
// method id "analytics.management.profiles.list":
|
|
|
|
type ManagementProfilesListCall struct {
|
|
s *Service
|
|
accountId string
|
|
webPropertyId string
|
|
urlParams_ gensupport.URLParams
|
|
ifNoneMatch_ string
|
|
ctx_ context.Context
|
|
header_ http.Header
|
|
}
|
|
|
|
// List: Lists views (profiles) to which the user has access.
|
|
func (r *ManagementProfilesService) List(accountId string, webPropertyId string) *ManagementProfilesListCall {
|
|
c := &ManagementProfilesListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
|
|
c.accountId = accountId
|
|
c.webPropertyId = webPropertyId
|
|
return c
|
|
}
|
|
|
|
// MaxResults sets the optional parameter "max-results": The maximum
|
|
// number of views (profiles) to include in this response.
|
|
func (c *ManagementProfilesListCall) MaxResults(maxResults int64) *ManagementProfilesListCall {
|
|
c.urlParams_.Set("max-results", fmt.Sprint(maxResults))
|
|
return c
|
|
}
|
|
|
|
// StartIndex sets the optional parameter "start-index": An index of the
|
|
// first entity to retrieve. Use this parameter as a pagination
|
|
// mechanism along with the max-results parameter.
|
|
func (c *ManagementProfilesListCall) StartIndex(startIndex int64) *ManagementProfilesListCall {
|
|
c.urlParams_.Set("start-index", fmt.Sprint(startIndex))
|
|
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 *ManagementProfilesListCall) Fields(s ...googleapi.Field) *ManagementProfilesListCall {
|
|
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 *ManagementProfilesListCall) IfNoneMatch(entityTag string) *ManagementProfilesListCall {
|
|
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 *ManagementProfilesListCall) Context(ctx context.Context) *ManagementProfilesListCall {
|
|
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 *ManagementProfilesListCall) Header() http.Header {
|
|
if c.header_ == nil {
|
|
c.header_ = make(http.Header)
|
|
}
|
|
return c.header_
|
|
}
|
|
|
|
func (c *ManagementProfilesListCall) 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, "management/accounts/{accountId}/webproperties/{webPropertyId}/profiles")
|
|
urls += "?" + c.urlParams_.Encode()
|
|
req, _ := http.NewRequest("GET", urls, body)
|
|
req.Header = reqHeaders
|
|
googleapi.Expand(req.URL, map[string]string{
|
|
"accountId": c.accountId,
|
|
"webPropertyId": c.webPropertyId,
|
|
})
|
|
return gensupport.SendRequest(c.ctx_, c.s.client, req)
|
|
}
|
|
|
|
// Do executes the "analytics.management.profiles.list" call.
|
|
func (c *ManagementProfilesListCall) Do(opts ...googleapi.CallOption) error {
|
|
gensupport.SetOptions(c.urlParams_, opts...)
|
|
res, err := c.doRequest("json")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer googleapi.CloseBody(res)
|
|
if err := googleapi.CheckResponse(res); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
// {
|
|
// "description": "Lists views (profiles) to which the user has access.",
|
|
// "httpMethod": "GET",
|
|
// "id": "analytics.management.profiles.list",
|
|
// "parameterOrder": [
|
|
// "accountId",
|
|
// "webPropertyId"
|
|
// ],
|
|
// "parameters": {
|
|
// "accountId": {
|
|
// "description": "Account ID for the views (profiles) to retrieve. Can either be a specific account ID or '~all', which refers to all the accounts to which the user has access.",
|
|
// "location": "path",
|
|
// "required": true,
|
|
// "type": "string"
|
|
// },
|
|
// "max-results": {
|
|
// "description": "The maximum number of views (profiles) to include in this response.",
|
|
// "format": "int32",
|
|
// "location": "query",
|
|
// "type": "integer"
|
|
// },
|
|
// "start-index": {
|
|
// "description": "An index of the first entity to retrieve. Use this parameter as a pagination mechanism along with the max-results parameter.",
|
|
// "format": "int32",
|
|
// "location": "query",
|
|
// "minimum": "1",
|
|
// "type": "integer"
|
|
// },
|
|
// "webPropertyId": {
|
|
// "description": "Web property ID for the views (profiles) to retrieve. Can either be a specific web property ID or '~all', which refers to all the web properties to which the user has access.",
|
|
// "location": "path",
|
|
// "required": true,
|
|
// "type": "string"
|
|
// }
|
|
// },
|
|
// "path": "management/accounts/{accountId}/webproperties/{webPropertyId}/profiles",
|
|
// "scopes": [
|
|
// "https://www.googleapis.com/auth/analytics",
|
|
// "https://www.googleapis.com/auth/analytics.readonly"
|
|
// ]
|
|
// }
|
|
|
|
}
|
|
|
|
// method id "analytics.management.segments.list":
|
|
|
|
type ManagementSegmentsListCall struct {
|
|
s *Service
|
|
urlParams_ gensupport.URLParams
|
|
ifNoneMatch_ string
|
|
ctx_ context.Context
|
|
header_ http.Header
|
|
}
|
|
|
|
// List: Lists advanced segments to which the user has access.
|
|
func (r *ManagementSegmentsService) List() *ManagementSegmentsListCall {
|
|
c := &ManagementSegmentsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
|
|
return c
|
|
}
|
|
|
|
// MaxResults sets the optional parameter "max-results": The maximum
|
|
// number of advanced segments to include in this response.
|
|
func (c *ManagementSegmentsListCall) MaxResults(maxResults int64) *ManagementSegmentsListCall {
|
|
c.urlParams_.Set("max-results", fmt.Sprint(maxResults))
|
|
return c
|
|
}
|
|
|
|
// StartIndex sets the optional parameter "start-index": An index of the
|
|
// first advanced segment to retrieve. Use this parameter as a
|
|
// pagination mechanism along with the max-results parameter.
|
|
func (c *ManagementSegmentsListCall) StartIndex(startIndex int64) *ManagementSegmentsListCall {
|
|
c.urlParams_.Set("start-index", fmt.Sprint(startIndex))
|
|
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 *ManagementSegmentsListCall) Fields(s ...googleapi.Field) *ManagementSegmentsListCall {
|
|
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 *ManagementSegmentsListCall) IfNoneMatch(entityTag string) *ManagementSegmentsListCall {
|
|
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 *ManagementSegmentsListCall) Context(ctx context.Context) *ManagementSegmentsListCall {
|
|
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 *ManagementSegmentsListCall) Header() http.Header {
|
|
if c.header_ == nil {
|
|
c.header_ = make(http.Header)
|
|
}
|
|
return c.header_
|
|
}
|
|
|
|
func (c *ManagementSegmentsListCall) 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, "management/segments")
|
|
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 "analytics.management.segments.list" call.
|
|
func (c *ManagementSegmentsListCall) Do(opts ...googleapi.CallOption) error {
|
|
gensupport.SetOptions(c.urlParams_, opts...)
|
|
res, err := c.doRequest("json")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer googleapi.CloseBody(res)
|
|
if err := googleapi.CheckResponse(res); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
// {
|
|
// "description": "Lists advanced segments to which the user has access.",
|
|
// "httpMethod": "GET",
|
|
// "id": "analytics.management.segments.list",
|
|
// "parameters": {
|
|
// "max-results": {
|
|
// "description": "The maximum number of advanced segments to include in this response.",
|
|
// "format": "int32",
|
|
// "location": "query",
|
|
// "type": "integer"
|
|
// },
|
|
// "start-index": {
|
|
// "description": "An index of the first advanced segment to retrieve. Use this parameter as a pagination mechanism along with the max-results parameter.",
|
|
// "format": "int32",
|
|
// "location": "query",
|
|
// "minimum": "1",
|
|
// "type": "integer"
|
|
// }
|
|
// },
|
|
// "path": "management/segments",
|
|
// "scopes": [
|
|
// "https://www.googleapis.com/auth/analytics",
|
|
// "https://www.googleapis.com/auth/analytics.readonly"
|
|
// ]
|
|
// }
|
|
|
|
}
|
|
|
|
// method id "analytics.management.webproperties.list":
|
|
|
|
type ManagementWebpropertiesListCall struct {
|
|
s *Service
|
|
accountId string
|
|
urlParams_ gensupport.URLParams
|
|
ifNoneMatch_ string
|
|
ctx_ context.Context
|
|
header_ http.Header
|
|
}
|
|
|
|
// List: Lists web properties to which the user has access.
|
|
func (r *ManagementWebpropertiesService) List(accountId string) *ManagementWebpropertiesListCall {
|
|
c := &ManagementWebpropertiesListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
|
|
c.accountId = accountId
|
|
return c
|
|
}
|
|
|
|
// MaxResults sets the optional parameter "max-results": The maximum
|
|
// number of web properties to include in this response.
|
|
func (c *ManagementWebpropertiesListCall) MaxResults(maxResults int64) *ManagementWebpropertiesListCall {
|
|
c.urlParams_.Set("max-results", fmt.Sprint(maxResults))
|
|
return c
|
|
}
|
|
|
|
// StartIndex sets the optional parameter "start-index": An index of the
|
|
// first entity to retrieve. Use this parameter as a pagination
|
|
// mechanism along with the max-results parameter.
|
|
func (c *ManagementWebpropertiesListCall) StartIndex(startIndex int64) *ManagementWebpropertiesListCall {
|
|
c.urlParams_.Set("start-index", fmt.Sprint(startIndex))
|
|
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 *ManagementWebpropertiesListCall) Fields(s ...googleapi.Field) *ManagementWebpropertiesListCall {
|
|
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 *ManagementWebpropertiesListCall) IfNoneMatch(entityTag string) *ManagementWebpropertiesListCall {
|
|
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 *ManagementWebpropertiesListCall) Context(ctx context.Context) *ManagementWebpropertiesListCall {
|
|
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 *ManagementWebpropertiesListCall) Header() http.Header {
|
|
if c.header_ == nil {
|
|
c.header_ = make(http.Header)
|
|
}
|
|
return c.header_
|
|
}
|
|
|
|
func (c *ManagementWebpropertiesListCall) 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, "management/accounts/{accountId}/webproperties")
|
|
urls += "?" + c.urlParams_.Encode()
|
|
req, _ := http.NewRequest("GET", urls, body)
|
|
req.Header = reqHeaders
|
|
googleapi.Expand(req.URL, map[string]string{
|
|
"accountId": c.accountId,
|
|
})
|
|
return gensupport.SendRequest(c.ctx_, c.s.client, req)
|
|
}
|
|
|
|
// Do executes the "analytics.management.webproperties.list" call.
|
|
func (c *ManagementWebpropertiesListCall) Do(opts ...googleapi.CallOption) error {
|
|
gensupport.SetOptions(c.urlParams_, opts...)
|
|
res, err := c.doRequest("json")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer googleapi.CloseBody(res)
|
|
if err := googleapi.CheckResponse(res); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
// {
|
|
// "description": "Lists web properties to which the user has access.",
|
|
// "httpMethod": "GET",
|
|
// "id": "analytics.management.webproperties.list",
|
|
// "parameterOrder": [
|
|
// "accountId"
|
|
// ],
|
|
// "parameters": {
|
|
// "accountId": {
|
|
// "description": "Account ID to retrieve web properties for. Can either be a specific account ID or '~all', which refers to all the accounts that user has access to.",
|
|
// "location": "path",
|
|
// "required": true,
|
|
// "type": "string"
|
|
// },
|
|
// "max-results": {
|
|
// "description": "The maximum number of web properties to include in this response.",
|
|
// "format": "int32",
|
|
// "location": "query",
|
|
// "type": "integer"
|
|
// },
|
|
// "start-index": {
|
|
// "description": "An index of the first entity to retrieve. Use this parameter as a pagination mechanism along with the max-results parameter.",
|
|
// "format": "int32",
|
|
// "location": "query",
|
|
// "minimum": "1",
|
|
// "type": "integer"
|
|
// }
|
|
// },
|
|
// "path": "management/accounts/{accountId}/webproperties",
|
|
// "scopes": [
|
|
// "https://www.googleapis.com/auth/analytics",
|
|
// "https://www.googleapis.com/auth/analytics.readonly"
|
|
// ]
|
|
// }
|
|
|
|
}
|