mirror of
https://github.com/restic/restic.git
synced 2024-09-07 11:59:25 +02:00
4454 lines
150 KiB
Go
4454 lines
150 KiB
Go
// Package adexchangebuyer provides access to the Ad Exchange Buyer API.
|
|
//
|
|
// See https://developers.google.com/ad-exchange/buyer-rest
|
|
//
|
|
// Usage example:
|
|
//
|
|
// import "google.golang.org/api/adexchangebuyer/v1.3"
|
|
// ...
|
|
// adexchangebuyerService, err := adexchangebuyer.New(oauthHttpClient)
|
|
package adexchangebuyer // import "google.golang.org/api/adexchangebuyer/v1.3"
|
|
|
|
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 = "adexchangebuyer:v1.3"
|
|
const apiName = "adexchangebuyer"
|
|
const apiVersion = "v1.3"
|
|
const basePath = "https://www.googleapis.com/adexchangebuyer/v1.3/"
|
|
|
|
// OAuth2 scopes used by this API.
|
|
const (
|
|
// Manage your Ad Exchange buyer account configuration
|
|
AdexchangeBuyerScope = "https://www.googleapis.com/auth/adexchange.buyer"
|
|
)
|
|
|
|
func New(client *http.Client) (*Service, error) {
|
|
if client == nil {
|
|
return nil, errors.New("client is nil")
|
|
}
|
|
s := &Service{client: client, BasePath: basePath}
|
|
s.Accounts = NewAccountsService(s)
|
|
s.BillingInfo = NewBillingInfoService(s)
|
|
s.Budget = NewBudgetService(s)
|
|
s.Creatives = NewCreativesService(s)
|
|
s.DirectDeals = NewDirectDealsService(s)
|
|
s.PerformanceReport = NewPerformanceReportService(s)
|
|
s.PretargetingConfig = NewPretargetingConfigService(s)
|
|
return s, nil
|
|
}
|
|
|
|
type Service struct {
|
|
client *http.Client
|
|
BasePath string // API endpoint base URL
|
|
UserAgent string // optional additional User-Agent fragment
|
|
|
|
Accounts *AccountsService
|
|
|
|
BillingInfo *BillingInfoService
|
|
|
|
Budget *BudgetService
|
|
|
|
Creatives *CreativesService
|
|
|
|
DirectDeals *DirectDealsService
|
|
|
|
PerformanceReport *PerformanceReportService
|
|
|
|
PretargetingConfig *PretargetingConfigService
|
|
}
|
|
|
|
func (s *Service) userAgent() string {
|
|
if s.UserAgent == "" {
|
|
return googleapi.UserAgent
|
|
}
|
|
return googleapi.UserAgent + " " + s.UserAgent
|
|
}
|
|
|
|
func NewAccountsService(s *Service) *AccountsService {
|
|
rs := &AccountsService{s: s}
|
|
return rs
|
|
}
|
|
|
|
type AccountsService struct {
|
|
s *Service
|
|
}
|
|
|
|
func NewBillingInfoService(s *Service) *BillingInfoService {
|
|
rs := &BillingInfoService{s: s}
|
|
return rs
|
|
}
|
|
|
|
type BillingInfoService struct {
|
|
s *Service
|
|
}
|
|
|
|
func NewBudgetService(s *Service) *BudgetService {
|
|
rs := &BudgetService{s: s}
|
|
return rs
|
|
}
|
|
|
|
type BudgetService struct {
|
|
s *Service
|
|
}
|
|
|
|
func NewCreativesService(s *Service) *CreativesService {
|
|
rs := &CreativesService{s: s}
|
|
return rs
|
|
}
|
|
|
|
type CreativesService struct {
|
|
s *Service
|
|
}
|
|
|
|
func NewDirectDealsService(s *Service) *DirectDealsService {
|
|
rs := &DirectDealsService{s: s}
|
|
return rs
|
|
}
|
|
|
|
type DirectDealsService struct {
|
|
s *Service
|
|
}
|
|
|
|
func NewPerformanceReportService(s *Service) *PerformanceReportService {
|
|
rs := &PerformanceReportService{s: s}
|
|
return rs
|
|
}
|
|
|
|
type PerformanceReportService struct {
|
|
s *Service
|
|
}
|
|
|
|
func NewPretargetingConfigService(s *Service) *PretargetingConfigService {
|
|
rs := &PretargetingConfigService{s: s}
|
|
return rs
|
|
}
|
|
|
|
type PretargetingConfigService struct {
|
|
s *Service
|
|
}
|
|
|
|
// Account: Configuration data for an Ad Exchange buyer account.
|
|
type Account struct {
|
|
// BidderLocation: Your bidder locations that have distinct URLs.
|
|
BidderLocation []*AccountBidderLocation `json:"bidderLocation,omitempty"`
|
|
|
|
// CookieMatchingNid: The nid parameter value used in cookie match
|
|
// requests. Please contact your technical account manager if you need
|
|
// to change this.
|
|
CookieMatchingNid string `json:"cookieMatchingNid,omitempty"`
|
|
|
|
// CookieMatchingUrl: The base URL used in cookie match requests.
|
|
CookieMatchingUrl string `json:"cookieMatchingUrl,omitempty"`
|
|
|
|
// Id: Account id.
|
|
Id int64 `json:"id,omitempty"`
|
|
|
|
// Kind: Resource type.
|
|
Kind string `json:"kind,omitempty"`
|
|
|
|
// MaximumActiveCreatives: The maximum number of active creatives that
|
|
// an account can have, where a creative is active if it was inserted or
|
|
// bid with in the last 30 days. Please contact your technical account
|
|
// manager if you need to change this.
|
|
MaximumActiveCreatives int64 `json:"maximumActiveCreatives,omitempty"`
|
|
|
|
// MaximumTotalQps: The sum of all bidderLocation.maximumQps values
|
|
// cannot exceed this. Please contact your technical account manager if
|
|
// you need to change this.
|
|
MaximumTotalQps int64 `json:"maximumTotalQps,omitempty"`
|
|
|
|
// NumberActiveCreatives: The number of creatives that this account
|
|
// inserted or bid with in the last 30 days.
|
|
NumberActiveCreatives int64 `json:"numberActiveCreatives,omitempty"`
|
|
|
|
// ServerResponse contains the HTTP response code and headers from the
|
|
// server.
|
|
googleapi.ServerResponse `json:"-"`
|
|
|
|
// ForceSendFields is a list of field names (e.g. "BidderLocation") to
|
|
// unconditionally include in API requests. By default, fields with
|
|
// empty values are omitted from API requests. However, any non-pointer,
|
|
// non-interface field appearing in ForceSendFields will be sent to the
|
|
// server regardless of whether the field is empty or not. This may be
|
|
// used to include empty fields in Patch requests.
|
|
ForceSendFields []string `json:"-"`
|
|
|
|
// NullFields is a list of field names (e.g. "BidderLocation") to
|
|
// include in API requests with the JSON null value. By default, fields
|
|
// with empty values are omitted from API requests. However, any field
|
|
// with an empty value appearing in NullFields will be sent to the
|
|
// server as null. It is an error if a field in this list has a
|
|
// non-empty value. This may be used to include null fields in Patch
|
|
// requests.
|
|
NullFields []string `json:"-"`
|
|
}
|
|
|
|
func (s *Account) MarshalJSON() ([]byte, error) {
|
|
type noMethod Account
|
|
raw := noMethod(*s)
|
|
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
|
|
}
|
|
|
|
type AccountBidderLocation struct {
|
|
// MaximumQps: The maximum queries per second the Ad Exchange will send.
|
|
MaximumQps int64 `json:"maximumQps,omitempty"`
|
|
|
|
// Region: The geographical region the Ad Exchange should send requests
|
|
// from. Only used by some quota systems, but always setting the value
|
|
// is recommended. Allowed values:
|
|
// - ASIA
|
|
// - EUROPE
|
|
// - US_EAST
|
|
// - US_WEST
|
|
Region string `json:"region,omitempty"`
|
|
|
|
// Url: The URL to which the Ad Exchange will send bid requests.
|
|
Url string `json:"url,omitempty"`
|
|
|
|
// ForceSendFields is a list of field names (e.g. "MaximumQps") to
|
|
// unconditionally include in API requests. By default, fields with
|
|
// empty values are omitted from API requests. However, any non-pointer,
|
|
// non-interface field appearing in ForceSendFields will be sent to the
|
|
// server regardless of whether the field is empty or not. This may be
|
|
// used to include empty fields in Patch requests.
|
|
ForceSendFields []string `json:"-"`
|
|
|
|
// NullFields is a list of field names (e.g. "MaximumQps") to include in
|
|
// API requests with the JSON null value. By default, fields with empty
|
|
// values are omitted from API requests. However, any field with an
|
|
// empty value appearing in NullFields will be sent to the server as
|
|
// null. It is an error if a field in this list has a non-empty value.
|
|
// This may be used to include null fields in Patch requests.
|
|
NullFields []string `json:"-"`
|
|
}
|
|
|
|
func (s *AccountBidderLocation) MarshalJSON() ([]byte, error) {
|
|
type noMethod AccountBidderLocation
|
|
raw := noMethod(*s)
|
|
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
|
|
}
|
|
|
|
// AccountsList: An account feed lists Ad Exchange buyer accounts that
|
|
// the user has access to. Each entry in the feed corresponds to a
|
|
// single buyer account.
|
|
type AccountsList struct {
|
|
// Items: A list of accounts.
|
|
Items []*Account `json:"items,omitempty"`
|
|
|
|
// Kind: Resource type.
|
|
Kind string `json:"kind,omitempty"`
|
|
|
|
// ServerResponse contains the HTTP response code and headers from the
|
|
// server.
|
|
googleapi.ServerResponse `json:"-"`
|
|
|
|
// ForceSendFields is a list of field names (e.g. "Items") to
|
|
// unconditionally include in API requests. By default, fields with
|
|
// empty values are omitted from API requests. However, any non-pointer,
|
|
// non-interface field appearing in ForceSendFields will be sent to the
|
|
// server regardless of whether the field is empty or not. This may be
|
|
// used to include empty fields in Patch requests.
|
|
ForceSendFields []string `json:"-"`
|
|
|
|
// NullFields is a list of field names (e.g. "Items") to include in API
|
|
// requests with the JSON null value. By default, fields with empty
|
|
// values are omitted from API requests. However, any field with an
|
|
// empty value appearing in NullFields will be sent to the server as
|
|
// null. It is an error if a field in this list has a non-empty value.
|
|
// This may be used to include null fields in Patch requests.
|
|
NullFields []string `json:"-"`
|
|
}
|
|
|
|
func (s *AccountsList) MarshalJSON() ([]byte, error) {
|
|
type noMethod AccountsList
|
|
raw := noMethod(*s)
|
|
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
|
|
}
|
|
|
|
// BillingInfo: The configuration data for an Ad Exchange billing info.
|
|
type BillingInfo struct {
|
|
// AccountId: Account id.
|
|
AccountId int64 `json:"accountId,omitempty"`
|
|
|
|
// AccountName: Account name.
|
|
AccountName string `json:"accountName,omitempty"`
|
|
|
|
// BillingId: A list of adgroup IDs associated with this particular
|
|
// account. These IDs may show up as part of a realtime bidding
|
|
// BidRequest, which indicates a bid request for this account.
|
|
BillingId []string `json:"billingId,omitempty"`
|
|
|
|
// Kind: Resource type.
|
|
Kind string `json:"kind,omitempty"`
|
|
|
|
// ServerResponse contains the HTTP response code and headers from the
|
|
// server.
|
|
googleapi.ServerResponse `json:"-"`
|
|
|
|
// ForceSendFields is a list of field names (e.g. "AccountId") to
|
|
// unconditionally include in API requests. By default, fields with
|
|
// empty values are omitted from API requests. However, any non-pointer,
|
|
// non-interface field appearing in ForceSendFields will be sent to the
|
|
// server regardless of whether the field is empty or not. This may be
|
|
// used to include empty fields in Patch requests.
|
|
ForceSendFields []string `json:"-"`
|
|
|
|
// NullFields is a list of field names (e.g. "AccountId") to include in
|
|
// API requests with the JSON null value. By default, fields with empty
|
|
// values are omitted from API requests. However, any field with an
|
|
// empty value appearing in NullFields will be sent to the server as
|
|
// null. It is an error if a field in this list has a non-empty value.
|
|
// This may be used to include null fields in Patch requests.
|
|
NullFields []string `json:"-"`
|
|
}
|
|
|
|
func (s *BillingInfo) MarshalJSON() ([]byte, error) {
|
|
type noMethod BillingInfo
|
|
raw := noMethod(*s)
|
|
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
|
|
}
|
|
|
|
// BillingInfoList: A billing info feed lists Billing Info the Ad
|
|
// Exchange buyer account has access to. Each entry in the feed
|
|
// corresponds to a single billing info.
|
|
type BillingInfoList struct {
|
|
// Items: A list of billing info relevant for your account.
|
|
Items []*BillingInfo `json:"items,omitempty"`
|
|
|
|
// Kind: Resource type.
|
|
Kind string `json:"kind,omitempty"`
|
|
|
|
// ServerResponse contains the HTTP response code and headers from the
|
|
// server.
|
|
googleapi.ServerResponse `json:"-"`
|
|
|
|
// ForceSendFields is a list of field names (e.g. "Items") to
|
|
// unconditionally include in API requests. By default, fields with
|
|
// empty values are omitted from API requests. However, any non-pointer,
|
|
// non-interface field appearing in ForceSendFields will be sent to the
|
|
// server regardless of whether the field is empty or not. This may be
|
|
// used to include empty fields in Patch requests.
|
|
ForceSendFields []string `json:"-"`
|
|
|
|
// NullFields is a list of field names (e.g. "Items") to include in API
|
|
// requests with the JSON null value. By default, fields with empty
|
|
// values are omitted from API requests. However, any field with an
|
|
// empty value appearing in NullFields will be sent to the server as
|
|
// null. It is an error if a field in this list has a non-empty value.
|
|
// This may be used to include null fields in Patch requests.
|
|
NullFields []string `json:"-"`
|
|
}
|
|
|
|
func (s *BillingInfoList) MarshalJSON() ([]byte, error) {
|
|
type noMethod BillingInfoList
|
|
raw := noMethod(*s)
|
|
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
|
|
}
|
|
|
|
// Budget: The configuration data for Ad Exchange RTB - Budget API.
|
|
type Budget struct {
|
|
// AccountId: The id of the account. This is required for get and update
|
|
// requests.
|
|
AccountId int64 `json:"accountId,omitempty,string"`
|
|
|
|
// BillingId: The billing id to determine which adgroup to provide
|
|
// budget information for. This is required for get and update requests.
|
|
BillingId int64 `json:"billingId,omitempty,string"`
|
|
|
|
// BudgetAmount: The daily budget amount in unit amount of the account
|
|
// currency to apply for the billingId provided. This is required for
|
|
// update requests.
|
|
BudgetAmount int64 `json:"budgetAmount,omitempty,string"`
|
|
|
|
// CurrencyCode: The currency code for the buyer. This cannot be altered
|
|
// here.
|
|
CurrencyCode string `json:"currencyCode,omitempty"`
|
|
|
|
// Id: The unique id that describes this item.
|
|
Id string `json:"id,omitempty"`
|
|
|
|
// Kind: The kind of the resource, i.e. "adexchangebuyer#budget".
|
|
Kind string `json:"kind,omitempty"`
|
|
|
|
// ServerResponse contains the HTTP response code and headers from the
|
|
// server.
|
|
googleapi.ServerResponse `json:"-"`
|
|
|
|
// ForceSendFields is a list of field names (e.g. "AccountId") to
|
|
// unconditionally include in API requests. By default, fields with
|
|
// empty values are omitted from API requests. However, any non-pointer,
|
|
// non-interface field appearing in ForceSendFields will be sent to the
|
|
// server regardless of whether the field is empty or not. This may be
|
|
// used to include empty fields in Patch requests.
|
|
ForceSendFields []string `json:"-"`
|
|
|
|
// NullFields is a list of field names (e.g. "AccountId") to include in
|
|
// API requests with the JSON null value. By default, fields with empty
|
|
// values are omitted from API requests. However, any field with an
|
|
// empty value appearing in NullFields will be sent to the server as
|
|
// null. It is an error if a field in this list has a non-empty value.
|
|
// This may be used to include null fields in Patch requests.
|
|
NullFields []string `json:"-"`
|
|
}
|
|
|
|
func (s *Budget) MarshalJSON() ([]byte, error) {
|
|
type noMethod Budget
|
|
raw := noMethod(*s)
|
|
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
|
|
}
|
|
|
|
// Creative: A creative and its classification data.
|
|
type Creative struct {
|
|
// HTMLSnippet: The HTML snippet that displays the ad when inserted in
|
|
// the web page. If set, videoURL should not be set.
|
|
HTMLSnippet string `json:"HTMLSnippet,omitempty"`
|
|
|
|
// AccountId: Account id.
|
|
AccountId int64 `json:"accountId,omitempty"`
|
|
|
|
// AdvertiserId: Detected advertiser id, if any. Read-only. This field
|
|
// should not be set in requests.
|
|
AdvertiserId googleapi.Int64s `json:"advertiserId,omitempty"`
|
|
|
|
// AdvertiserName: The name of the company being advertised in the
|
|
// creative.
|
|
AdvertiserName string `json:"advertiserName,omitempty"`
|
|
|
|
// AgencyId: The agency id for this creative.
|
|
AgencyId int64 `json:"agencyId,omitempty,string"`
|
|
|
|
// ApiUploadTimestamp: The last upload timestamp of this creative if it
|
|
// was uploaded via API. Read-only. The value of this field is
|
|
// generated, and will be ignored for uploads. (formatted RFC 3339
|
|
// timestamp).
|
|
ApiUploadTimestamp string `json:"apiUploadTimestamp,omitempty"`
|
|
|
|
// Attribute: All attributes for the ads that may be shown from this
|
|
// snippet.
|
|
Attribute []int64 `json:"attribute,omitempty"`
|
|
|
|
// BuyerCreativeId: A buyer-specific id identifying the creative in this
|
|
// ad.
|
|
BuyerCreativeId string `json:"buyerCreativeId,omitempty"`
|
|
|
|
// ClickThroughUrl: The set of destination urls for the snippet.
|
|
ClickThroughUrl []string `json:"clickThroughUrl,omitempty"`
|
|
|
|
// Corrections: Shows any corrections that were applied to this
|
|
// creative. Read-only. This field should not be set in requests.
|
|
Corrections []*CreativeCorrections `json:"corrections,omitempty"`
|
|
|
|
// DisapprovalReasons: The reasons for disapproval, if any. Note that
|
|
// not all disapproval reasons may be categorized, so it is possible for
|
|
// the creative to have a status of DISAPPROVED with an empty list for
|
|
// disapproval_reasons. In this case, please reach out to your TAM to
|
|
// help debug the issue. Read-only. This field should not be set in
|
|
// requests.
|
|
DisapprovalReasons []*CreativeDisapprovalReasons `json:"disapprovalReasons,omitempty"`
|
|
|
|
// FilteringReasons: The filtering reasons for the creative. Read-only.
|
|
// This field should not be set in requests.
|
|
FilteringReasons *CreativeFilteringReasons `json:"filteringReasons,omitempty"`
|
|
|
|
// Height: Ad height.
|
|
Height int64 `json:"height,omitempty"`
|
|
|
|
// ImpressionTrackingUrl: The set of urls to be called to record an
|
|
// impression.
|
|
ImpressionTrackingUrl []string `json:"impressionTrackingUrl,omitempty"`
|
|
|
|
// Kind: Resource type.
|
|
Kind string `json:"kind,omitempty"`
|
|
|
|
// NativeAd: If nativeAd is set, HTMLSnippet and videoURL should not be
|
|
// set.
|
|
NativeAd *CreativeNativeAd `json:"nativeAd,omitempty"`
|
|
|
|
// ProductCategories: Detected product categories, if any. Read-only.
|
|
// This field should not be set in requests.
|
|
ProductCategories []int64 `json:"productCategories,omitempty"`
|
|
|
|
// RestrictedCategories: All restricted categories for the ads that may
|
|
// be shown from this snippet.
|
|
RestrictedCategories []int64 `json:"restrictedCategories,omitempty"`
|
|
|
|
// SensitiveCategories: Detected sensitive categories, if any.
|
|
// Read-only. This field should not be set in requests.
|
|
SensitiveCategories []int64 `json:"sensitiveCategories,omitempty"`
|
|
|
|
// Status: Creative serving status. Read-only. This field should not be
|
|
// set in requests.
|
|
Status string `json:"status,omitempty"`
|
|
|
|
// VendorType: All vendor types for the ads that may be shown from this
|
|
// snippet.
|
|
VendorType []int64 `json:"vendorType,omitempty"`
|
|
|
|
// Version: The version for this creative. Read-only. This field should
|
|
// not be set in requests.
|
|
Version int64 `json:"version,omitempty"`
|
|
|
|
// VideoURL: The URL to fetch a video ad. If set, HTMLSnippet and the
|
|
// nativeAd should not be set.
|
|
VideoURL string `json:"videoURL,omitempty"`
|
|
|
|
// Width: Ad width.
|
|
Width int64 `json:"width,omitempty"`
|
|
|
|
// ServerResponse contains the HTTP response code and headers from the
|
|
// server.
|
|
googleapi.ServerResponse `json:"-"`
|
|
|
|
// ForceSendFields is a list of field names (e.g. "HTMLSnippet") to
|
|
// unconditionally include in API requests. By default, fields with
|
|
// empty values are omitted from API requests. However, any non-pointer,
|
|
// non-interface field appearing in ForceSendFields will be sent to the
|
|
// server regardless of whether the field is empty or not. This may be
|
|
// used to include empty fields in Patch requests.
|
|
ForceSendFields []string `json:"-"`
|
|
|
|
// NullFields is a list of field names (e.g. "HTMLSnippet") to include
|
|
// in API requests with the JSON null value. By default, fields with
|
|
// empty values are omitted from API requests. However, any field with
|
|
// an empty value appearing in NullFields will be sent to the server as
|
|
// null. It is an error if a field in this list has a non-empty value.
|
|
// This may be used to include null fields in Patch requests.
|
|
NullFields []string `json:"-"`
|
|
}
|
|
|
|
func (s *Creative) MarshalJSON() ([]byte, error) {
|
|
type noMethod Creative
|
|
raw := noMethod(*s)
|
|
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
|
|
}
|
|
|
|
type CreativeCorrections struct {
|
|
// Details: Additional details about the correction.
|
|
Details []string `json:"details,omitempty"`
|
|
|
|
// Reason: The type of correction that was applied to the creative.
|
|
Reason string `json:"reason,omitempty"`
|
|
|
|
// ForceSendFields is a list of field names (e.g. "Details") to
|
|
// unconditionally include in API requests. By default, fields with
|
|
// empty values are omitted from API requests. However, any non-pointer,
|
|
// non-interface field appearing in ForceSendFields will be sent to the
|
|
// server regardless of whether the field is empty or not. This may be
|
|
// used to include empty fields in Patch requests.
|
|
ForceSendFields []string `json:"-"`
|
|
|
|
// NullFields is a list of field names (e.g. "Details") to include in
|
|
// API requests with the JSON null value. By default, fields with empty
|
|
// values are omitted from API requests. However, any field with an
|
|
// empty value appearing in NullFields will be sent to the server as
|
|
// null. It is an error if a field in this list has a non-empty value.
|
|
// This may be used to include null fields in Patch requests.
|
|
NullFields []string `json:"-"`
|
|
}
|
|
|
|
func (s *CreativeCorrections) MarshalJSON() ([]byte, error) {
|
|
type noMethod CreativeCorrections
|
|
raw := noMethod(*s)
|
|
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
|
|
}
|
|
|
|
type CreativeDisapprovalReasons struct {
|
|
// Details: Additional details about the reason for disapproval.
|
|
Details []string `json:"details,omitempty"`
|
|
|
|
// Reason: The categorized reason for disapproval.
|
|
Reason string `json:"reason,omitempty"`
|
|
|
|
// ForceSendFields is a list of field names (e.g. "Details") to
|
|
// unconditionally include in API requests. By default, fields with
|
|
// empty values are omitted from API requests. However, any non-pointer,
|
|
// non-interface field appearing in ForceSendFields will be sent to the
|
|
// server regardless of whether the field is empty or not. This may be
|
|
// used to include empty fields in Patch requests.
|
|
ForceSendFields []string `json:"-"`
|
|
|
|
// NullFields is a list of field names (e.g. "Details") to include in
|
|
// API requests with the JSON null value. By default, fields with empty
|
|
// values are omitted from API requests. However, any field with an
|
|
// empty value appearing in NullFields will be sent to the server as
|
|
// null. It is an error if a field in this list has a non-empty value.
|
|
// This may be used to include null fields in Patch requests.
|
|
NullFields []string `json:"-"`
|
|
}
|
|
|
|
func (s *CreativeDisapprovalReasons) MarshalJSON() ([]byte, error) {
|
|
type noMethod CreativeDisapprovalReasons
|
|
raw := noMethod(*s)
|
|
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
|
|
}
|
|
|
|
// CreativeFilteringReasons: The filtering reasons for the creative.
|
|
// Read-only. This field should not be set in requests.
|
|
type CreativeFilteringReasons struct {
|
|
// Date: The date in ISO 8601 format for the data. The data is collected
|
|
// from 00:00:00 to 23:59:59 in PST.
|
|
Date string `json:"date,omitempty"`
|
|
|
|
// Reasons: The filtering reasons.
|
|
Reasons []*CreativeFilteringReasonsReasons `json:"reasons,omitempty"`
|
|
|
|
// ForceSendFields is a list of field names (e.g. "Date") to
|
|
// unconditionally include in API requests. By default, fields with
|
|
// empty values are omitted from API requests. However, any non-pointer,
|
|
// non-interface field appearing in ForceSendFields will be sent to the
|
|
// server regardless of whether the field is empty or not. This may be
|
|
// used to include empty fields in Patch requests.
|
|
ForceSendFields []string `json:"-"`
|
|
|
|
// NullFields is a list of field names (e.g. "Date") to include in API
|
|
// requests with the JSON null value. By default, fields with empty
|
|
// values are omitted from API requests. However, any field with an
|
|
// empty value appearing in NullFields will be sent to the server as
|
|
// null. It is an error if a field in this list has a non-empty value.
|
|
// This may be used to include null fields in Patch requests.
|
|
NullFields []string `json:"-"`
|
|
}
|
|
|
|
func (s *CreativeFilteringReasons) MarshalJSON() ([]byte, error) {
|
|
type noMethod CreativeFilteringReasons
|
|
raw := noMethod(*s)
|
|
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
|
|
}
|
|
|
|
type CreativeFilteringReasonsReasons struct {
|
|
// FilteringCount: The number of times the creative was filtered for the
|
|
// status. The count is aggregated across all publishers on the
|
|
// exchange.
|
|
FilteringCount int64 `json:"filteringCount,omitempty,string"`
|
|
|
|
// FilteringStatus: The filtering status code. Please refer to the
|
|
// creative-status-codes.txt file for different statuses.
|
|
FilteringStatus int64 `json:"filteringStatus,omitempty"`
|
|
|
|
// ForceSendFields is a list of field names (e.g. "FilteringCount") to
|
|
// unconditionally include in API requests. By default, fields with
|
|
// empty values are omitted from API requests. However, any non-pointer,
|
|
// non-interface field appearing in ForceSendFields will be sent to the
|
|
// server regardless of whether the field is empty or not. This may be
|
|
// used to include empty fields in Patch requests.
|
|
ForceSendFields []string `json:"-"`
|
|
|
|
// NullFields is a list of field names (e.g. "FilteringCount") to
|
|
// include in API requests with the JSON null value. By default, fields
|
|
// with empty values are omitted from API requests. However, any field
|
|
// with an empty value appearing in NullFields will be sent to the
|
|
// server as null. It is an error if a field in this list has a
|
|
// non-empty value. This may be used to include null fields in Patch
|
|
// requests.
|
|
NullFields []string `json:"-"`
|
|
}
|
|
|
|
func (s *CreativeFilteringReasonsReasons) MarshalJSON() ([]byte, error) {
|
|
type noMethod CreativeFilteringReasonsReasons
|
|
raw := noMethod(*s)
|
|
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
|
|
}
|
|
|
|
// CreativeNativeAd: If nativeAd is set, HTMLSnippet and videoURL should
|
|
// not be set.
|
|
type CreativeNativeAd struct {
|
|
Advertiser string `json:"advertiser,omitempty"`
|
|
|
|
// AppIcon: The app icon, for app download ads.
|
|
AppIcon *CreativeNativeAdAppIcon `json:"appIcon,omitempty"`
|
|
|
|
// Body: A long description of the ad.
|
|
Body string `json:"body,omitempty"`
|
|
|
|
// CallToAction: A label for the button that the user is supposed to
|
|
// click.
|
|
CallToAction string `json:"callToAction,omitempty"`
|
|
|
|
// ClickTrackingUrl: The URL to use for click tracking.
|
|
ClickTrackingUrl string `json:"clickTrackingUrl,omitempty"`
|
|
|
|
// Headline: A short title for the ad.
|
|
Headline string `json:"headline,omitempty"`
|
|
|
|
// Image: A large image.
|
|
Image *CreativeNativeAdImage `json:"image,omitempty"`
|
|
|
|
// ImpressionTrackingUrl: The URLs are called when the impression is
|
|
// rendered.
|
|
ImpressionTrackingUrl []string `json:"impressionTrackingUrl,omitempty"`
|
|
|
|
// Logo: A smaller image, for the advertiser logo.
|
|
Logo *CreativeNativeAdLogo `json:"logo,omitempty"`
|
|
|
|
// Price: The price of the promoted app including the currency info.
|
|
Price string `json:"price,omitempty"`
|
|
|
|
// StarRating: The app rating in the app store. Must be in the range
|
|
// [0-5].
|
|
StarRating float64 `json:"starRating,omitempty"`
|
|
|
|
// Store: The URL to the app store to purchase/download the promoted
|
|
// app.
|
|
Store string `json:"store,omitempty"`
|
|
|
|
// ForceSendFields is a list of field names (e.g. "Advertiser") to
|
|
// unconditionally include in API requests. By default, fields with
|
|
// empty values are omitted from API requests. However, any non-pointer,
|
|
// non-interface field appearing in ForceSendFields will be sent to the
|
|
// server regardless of whether the field is empty or not. This may be
|
|
// used to include empty fields in Patch requests.
|
|
ForceSendFields []string `json:"-"`
|
|
|
|
// NullFields is a list of field names (e.g. "Advertiser") to include in
|
|
// API requests with the JSON null value. By default, fields with empty
|
|
// values are omitted from API requests. However, any field with an
|
|
// empty value appearing in NullFields will be sent to the server as
|
|
// null. It is an error if a field in this list has a non-empty value.
|
|
// This may be used to include null fields in Patch requests.
|
|
NullFields []string `json:"-"`
|
|
}
|
|
|
|
func (s *CreativeNativeAd) MarshalJSON() ([]byte, error) {
|
|
type noMethod CreativeNativeAd
|
|
raw := noMethod(*s)
|
|
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
|
|
}
|
|
|
|
func (s *CreativeNativeAd) UnmarshalJSON(data []byte) error {
|
|
type noMethod CreativeNativeAd
|
|
var s1 struct {
|
|
StarRating gensupport.JSONFloat64 `json:"starRating"`
|
|
*noMethod
|
|
}
|
|
s1.noMethod = (*noMethod)(s)
|
|
if err := json.Unmarshal(data, &s1); err != nil {
|
|
return err
|
|
}
|
|
s.StarRating = float64(s1.StarRating)
|
|
return nil
|
|
}
|
|
|
|
// CreativeNativeAdAppIcon: The app icon, for app download ads.
|
|
type CreativeNativeAdAppIcon struct {
|
|
Height int64 `json:"height,omitempty"`
|
|
|
|
Url string `json:"url,omitempty"`
|
|
|
|
Width int64 `json:"width,omitempty"`
|
|
|
|
// ForceSendFields is a list of field names (e.g. "Height") to
|
|
// unconditionally include in API requests. By default, fields with
|
|
// empty values are omitted from API requests. However, any non-pointer,
|
|
// non-interface field appearing in ForceSendFields will be sent to the
|
|
// server regardless of whether the field is empty or not. This may be
|
|
// used to include empty fields in Patch requests.
|
|
ForceSendFields []string `json:"-"`
|
|
|
|
// NullFields is a list of field names (e.g. "Height") to include in API
|
|
// requests with the JSON null value. By default, fields with empty
|
|
// values are omitted from API requests. However, any field with an
|
|
// empty value appearing in NullFields will be sent to the server as
|
|
// null. It is an error if a field in this list has a non-empty value.
|
|
// This may be used to include null fields in Patch requests.
|
|
NullFields []string `json:"-"`
|
|
}
|
|
|
|
func (s *CreativeNativeAdAppIcon) MarshalJSON() ([]byte, error) {
|
|
type noMethod CreativeNativeAdAppIcon
|
|
raw := noMethod(*s)
|
|
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
|
|
}
|
|
|
|
// CreativeNativeAdImage: A large image.
|
|
type CreativeNativeAdImage struct {
|
|
Height int64 `json:"height,omitempty"`
|
|
|
|
Url string `json:"url,omitempty"`
|
|
|
|
Width int64 `json:"width,omitempty"`
|
|
|
|
// ForceSendFields is a list of field names (e.g. "Height") to
|
|
// unconditionally include in API requests. By default, fields with
|
|
// empty values are omitted from API requests. However, any non-pointer,
|
|
// non-interface field appearing in ForceSendFields will be sent to the
|
|
// server regardless of whether the field is empty or not. This may be
|
|
// used to include empty fields in Patch requests.
|
|
ForceSendFields []string `json:"-"`
|
|
|
|
// NullFields is a list of field names (e.g. "Height") to include in API
|
|
// requests with the JSON null value. By default, fields with empty
|
|
// values are omitted from API requests. However, any field with an
|
|
// empty value appearing in NullFields will be sent to the server as
|
|
// null. It is an error if a field in this list has a non-empty value.
|
|
// This may be used to include null fields in Patch requests.
|
|
NullFields []string `json:"-"`
|
|
}
|
|
|
|
func (s *CreativeNativeAdImage) MarshalJSON() ([]byte, error) {
|
|
type noMethod CreativeNativeAdImage
|
|
raw := noMethod(*s)
|
|
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
|
|
}
|
|
|
|
// CreativeNativeAdLogo: A smaller image, for the advertiser logo.
|
|
type CreativeNativeAdLogo struct {
|
|
Height int64 `json:"height,omitempty"`
|
|
|
|
Url string `json:"url,omitempty"`
|
|
|
|
Width int64 `json:"width,omitempty"`
|
|
|
|
// ForceSendFields is a list of field names (e.g. "Height") to
|
|
// unconditionally include in API requests. By default, fields with
|
|
// empty values are omitted from API requests. However, any non-pointer,
|
|
// non-interface field appearing in ForceSendFields will be sent to the
|
|
// server regardless of whether the field is empty or not. This may be
|
|
// used to include empty fields in Patch requests.
|
|
ForceSendFields []string `json:"-"`
|
|
|
|
// NullFields is a list of field names (e.g. "Height") to include in API
|
|
// requests with the JSON null value. By default, fields with empty
|
|
// values are omitted from API requests. However, any field with an
|
|
// empty value appearing in NullFields will be sent to the server as
|
|
// null. It is an error if a field in this list has a non-empty value.
|
|
// This may be used to include null fields in Patch requests.
|
|
NullFields []string `json:"-"`
|
|
}
|
|
|
|
func (s *CreativeNativeAdLogo) MarshalJSON() ([]byte, error) {
|
|
type noMethod CreativeNativeAdLogo
|
|
raw := noMethod(*s)
|
|
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
|
|
}
|
|
|
|
// CreativesList: The creatives feed lists the active creatives for the
|
|
// Ad Exchange buyer accounts that the user has access to. Each entry in
|
|
// the feed corresponds to a single creative.
|
|
type CreativesList struct {
|
|
// Items: A list of creatives.
|
|
Items []*Creative `json:"items,omitempty"`
|
|
|
|
// Kind: Resource type.
|
|
Kind string `json:"kind,omitempty"`
|
|
|
|
// NextPageToken: Continuation token used to page through creatives. To
|
|
// retrieve the next page of results, set the next request's "pageToken"
|
|
// value to this.
|
|
NextPageToken string `json:"nextPageToken,omitempty"`
|
|
|
|
// ServerResponse contains the HTTP response code and headers from the
|
|
// server.
|
|
googleapi.ServerResponse `json:"-"`
|
|
|
|
// ForceSendFields is a list of field names (e.g. "Items") to
|
|
// unconditionally include in API requests. By default, fields with
|
|
// empty values are omitted from API requests. However, any non-pointer,
|
|
// non-interface field appearing in ForceSendFields will be sent to the
|
|
// server regardless of whether the field is empty or not. This may be
|
|
// used to include empty fields in Patch requests.
|
|
ForceSendFields []string `json:"-"`
|
|
|
|
// NullFields is a list of field names (e.g. "Items") to include in API
|
|
// requests with the JSON null value. By default, fields with empty
|
|
// values are omitted from API requests. However, any field with an
|
|
// empty value appearing in NullFields will be sent to the server as
|
|
// null. It is an error if a field in this list has a non-empty value.
|
|
// This may be used to include null fields in Patch requests.
|
|
NullFields []string `json:"-"`
|
|
}
|
|
|
|
func (s *CreativesList) MarshalJSON() ([]byte, error) {
|
|
type noMethod CreativesList
|
|
raw := noMethod(*s)
|
|
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
|
|
}
|
|
|
|
// DirectDeal: The configuration data for an Ad Exchange direct deal.
|
|
type DirectDeal struct {
|
|
// AccountId: The account id of the buyer this deal is for.
|
|
AccountId int64 `json:"accountId,omitempty"`
|
|
|
|
// Advertiser: The name of the advertiser this deal is for.
|
|
Advertiser string `json:"advertiser,omitempty"`
|
|
|
|
// AllowsAlcohol: Whether the publisher for this deal is eligible for
|
|
// alcohol ads.
|
|
AllowsAlcohol bool `json:"allowsAlcohol,omitempty"`
|
|
|
|
// BuyerAccountId: The account id that this deal was negotiated for. It
|
|
// is either the buyer or the client that this deal was negotiated on
|
|
// behalf of.
|
|
BuyerAccountId int64 `json:"buyerAccountId,omitempty,string"`
|
|
|
|
// CurrencyCode: The currency code that applies to the fixed_cpm value.
|
|
// If not set then assumed to be USD.
|
|
CurrencyCode string `json:"currencyCode,omitempty"`
|
|
|
|
// DealTier: The deal type such as programmatic reservation or fixed
|
|
// price and so on.
|
|
DealTier string `json:"dealTier,omitempty"`
|
|
|
|
// EndTime: End time for when this deal stops being active. If not set
|
|
// then this deal is valid until manually disabled by the publisher. In
|
|
// seconds since the epoch.
|
|
EndTime int64 `json:"endTime,omitempty,string"`
|
|
|
|
// FixedCpm: The fixed price for this direct deal. In cpm micros of
|
|
// currency according to currency_code. If set, then this deal is
|
|
// eligible for the fixed price tier of buying (highest priority, pay
|
|
// exactly the configured fixed price).
|
|
FixedCpm int64 `json:"fixedCpm,omitempty,string"`
|
|
|
|
// Id: Deal id.
|
|
Id int64 `json:"id,omitempty,string"`
|
|
|
|
// Kind: Resource type.
|
|
Kind string `json:"kind,omitempty"`
|
|
|
|
// Name: Deal name.
|
|
Name string `json:"name,omitempty"`
|
|
|
|
// PrivateExchangeMinCpm: The minimum price for this direct deal. In cpm
|
|
// micros of currency according to currency_code. If set, then this deal
|
|
// is eligible for the private exchange tier of buying (below fixed
|
|
// price priority, run as a second price auction).
|
|
PrivateExchangeMinCpm int64 `json:"privateExchangeMinCpm,omitempty,string"`
|
|
|
|
// PublisherBlocksOverriden: If true, the publisher has opted to have
|
|
// their blocks ignored when a creative is bid with for this deal.
|
|
PublisherBlocksOverriden bool `json:"publisherBlocksOverriden,omitempty"`
|
|
|
|
// SellerNetwork: The name of the publisher offering this direct deal.
|
|
SellerNetwork string `json:"sellerNetwork,omitempty"`
|
|
|
|
// StartTime: Start time for when this deal becomes active. If not set
|
|
// then this deal is active immediately upon creation. In seconds since
|
|
// the epoch.
|
|
StartTime int64 `json:"startTime,omitempty,string"`
|
|
|
|
// ServerResponse contains the HTTP response code and headers from the
|
|
// server.
|
|
googleapi.ServerResponse `json:"-"`
|
|
|
|
// ForceSendFields is a list of field names (e.g. "AccountId") to
|
|
// unconditionally include in API requests. By default, fields with
|
|
// empty values are omitted from API requests. However, any non-pointer,
|
|
// non-interface field appearing in ForceSendFields will be sent to the
|
|
// server regardless of whether the field is empty or not. This may be
|
|
// used to include empty fields in Patch requests.
|
|
ForceSendFields []string `json:"-"`
|
|
|
|
// NullFields is a list of field names (e.g. "AccountId") to include in
|
|
// API requests with the JSON null value. By default, fields with empty
|
|
// values are omitted from API requests. However, any field with an
|
|
// empty value appearing in NullFields will be sent to the server as
|
|
// null. It is an error if a field in this list has a non-empty value.
|
|
// This may be used to include null fields in Patch requests.
|
|
NullFields []string `json:"-"`
|
|
}
|
|
|
|
func (s *DirectDeal) MarshalJSON() ([]byte, error) {
|
|
type noMethod DirectDeal
|
|
raw := noMethod(*s)
|
|
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
|
|
}
|
|
|
|
// DirectDealsList: A direct deals feed lists Direct Deals the Ad
|
|
// Exchange buyer account has access to. This includes direct deals set
|
|
// up for the buyer account as well as its merged stream seats.
|
|
type DirectDealsList struct {
|
|
// DirectDeals: A list of direct deals relevant for your account.
|
|
DirectDeals []*DirectDeal `json:"directDeals,omitempty"`
|
|
|
|
// Kind: Resource type.
|
|
Kind string `json:"kind,omitempty"`
|
|
|
|
// ServerResponse contains the HTTP response code and headers from the
|
|
// server.
|
|
googleapi.ServerResponse `json:"-"`
|
|
|
|
// ForceSendFields is a list of field names (e.g. "DirectDeals") to
|
|
// unconditionally include in API requests. By default, fields with
|
|
// empty values are omitted from API requests. However, any non-pointer,
|
|
// non-interface field appearing in ForceSendFields will be sent to the
|
|
// server regardless of whether the field is empty or not. This may be
|
|
// used to include empty fields in Patch requests.
|
|
ForceSendFields []string `json:"-"`
|
|
|
|
// NullFields is a list of field names (e.g. "DirectDeals") to include
|
|
// in API requests with the JSON null value. By default, fields with
|
|
// empty values are omitted from API requests. However, any field with
|
|
// an empty value appearing in NullFields will be sent to the server as
|
|
// null. It is an error if a field in this list has a non-empty value.
|
|
// This may be used to include null fields in Patch requests.
|
|
NullFields []string `json:"-"`
|
|
}
|
|
|
|
func (s *DirectDealsList) MarshalJSON() ([]byte, error) {
|
|
type noMethod DirectDealsList
|
|
raw := noMethod(*s)
|
|
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
|
|
}
|
|
|
|
// PerformanceReport: The configuration data for an Ad Exchange
|
|
// performance report list.
|
|
type PerformanceReport struct {
|
|
// BidRate: The number of bid responses with an ad.
|
|
BidRate float64 `json:"bidRate,omitempty"`
|
|
|
|
// BidRequestRate: The number of bid requests sent to your bidder.
|
|
BidRequestRate float64 `json:"bidRequestRate,omitempty"`
|
|
|
|
// CalloutStatusRate: Rate of various prefiltering statuses per match.
|
|
// Please refer to the callout-status-codes.txt file for different
|
|
// statuses.
|
|
CalloutStatusRate []interface{} `json:"calloutStatusRate,omitempty"`
|
|
|
|
// CookieMatcherStatusRate: Average QPS for cookie matcher operations.
|
|
CookieMatcherStatusRate []interface{} `json:"cookieMatcherStatusRate,omitempty"`
|
|
|
|
// CreativeStatusRate: Rate of ads with a given status. Please refer to
|
|
// the creative-status-codes.txt file for different statuses.
|
|
CreativeStatusRate []interface{} `json:"creativeStatusRate,omitempty"`
|
|
|
|
// FilteredBidRate: The number of bid responses that were filtered due
|
|
// to a policy violation or other errors.
|
|
FilteredBidRate float64 `json:"filteredBidRate,omitempty"`
|
|
|
|
// HostedMatchStatusRate: Average QPS for hosted match operations.
|
|
HostedMatchStatusRate []interface{} `json:"hostedMatchStatusRate,omitempty"`
|
|
|
|
// InventoryMatchRate: The number of potential queries based on your
|
|
// pretargeting settings.
|
|
InventoryMatchRate float64 `json:"inventoryMatchRate,omitempty"`
|
|
|
|
// Kind: Resource type.
|
|
Kind string `json:"kind,omitempty"`
|
|
|
|
// Latency50thPercentile: The 50th percentile round trip latency(ms) as
|
|
// perceived from Google servers for the duration period covered by the
|
|
// report.
|
|
Latency50thPercentile float64 `json:"latency50thPercentile,omitempty"`
|
|
|
|
// Latency85thPercentile: The 85th percentile round trip latency(ms) as
|
|
// perceived from Google servers for the duration period covered by the
|
|
// report.
|
|
Latency85thPercentile float64 `json:"latency85thPercentile,omitempty"`
|
|
|
|
// Latency95thPercentile: The 95th percentile round trip latency(ms) as
|
|
// perceived from Google servers for the duration period covered by the
|
|
// report.
|
|
Latency95thPercentile float64 `json:"latency95thPercentile,omitempty"`
|
|
|
|
// NoQuotaInRegion: Rate of various quota account statuses per quota
|
|
// check.
|
|
NoQuotaInRegion float64 `json:"noQuotaInRegion,omitempty"`
|
|
|
|
// OutOfQuota: Rate of various quota account statuses per quota check.
|
|
OutOfQuota float64 `json:"outOfQuota,omitempty"`
|
|
|
|
// PixelMatchRequests: Average QPS for pixel match requests from
|
|
// clients.
|
|
PixelMatchRequests float64 `json:"pixelMatchRequests,omitempty"`
|
|
|
|
// PixelMatchResponses: Average QPS for pixel match responses from
|
|
// clients.
|
|
PixelMatchResponses float64 `json:"pixelMatchResponses,omitempty"`
|
|
|
|
// QuotaConfiguredLimit: The configured quota limits for this account.
|
|
QuotaConfiguredLimit float64 `json:"quotaConfiguredLimit,omitempty"`
|
|
|
|
// QuotaThrottledLimit: The throttled quota limits for this account.
|
|
QuotaThrottledLimit float64 `json:"quotaThrottledLimit,omitempty"`
|
|
|
|
// Region: The trading location of this data.
|
|
Region string `json:"region,omitempty"`
|
|
|
|
// SuccessfulRequestRate: The number of properly formed bid responses
|
|
// received by our servers within the deadline.
|
|
SuccessfulRequestRate float64 `json:"successfulRequestRate,omitempty"`
|
|
|
|
// Timestamp: The unix timestamp of the starting time of this
|
|
// performance data.
|
|
Timestamp int64 `json:"timestamp,omitempty,string"`
|
|
|
|
// UnsuccessfulRequestRate: The number of bid responses that were
|
|
// unsuccessful due to timeouts, incorrect formatting, etc.
|
|
UnsuccessfulRequestRate float64 `json:"unsuccessfulRequestRate,omitempty"`
|
|
|
|
// ForceSendFields is a list of field names (e.g. "BidRate") to
|
|
// unconditionally include in API requests. By default, fields with
|
|
// empty values are omitted from API requests. However, any non-pointer,
|
|
// non-interface field appearing in ForceSendFields will be sent to the
|
|
// server regardless of whether the field is empty or not. This may be
|
|
// used to include empty fields in Patch requests.
|
|
ForceSendFields []string `json:"-"`
|
|
|
|
// NullFields is a list of field names (e.g. "BidRate") to include in
|
|
// API requests with the JSON null value. By default, fields with empty
|
|
// values are omitted from API requests. However, any field with an
|
|
// empty value appearing in NullFields will be sent to the server as
|
|
// null. It is an error if a field in this list has a non-empty value.
|
|
// This may be used to include null fields in Patch requests.
|
|
NullFields []string `json:"-"`
|
|
}
|
|
|
|
func (s *PerformanceReport) MarshalJSON() ([]byte, error) {
|
|
type noMethod PerformanceReport
|
|
raw := noMethod(*s)
|
|
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
|
|
}
|
|
|
|
func (s *PerformanceReport) UnmarshalJSON(data []byte) error {
|
|
type noMethod PerformanceReport
|
|
var s1 struct {
|
|
BidRate gensupport.JSONFloat64 `json:"bidRate"`
|
|
BidRequestRate gensupport.JSONFloat64 `json:"bidRequestRate"`
|
|
FilteredBidRate gensupport.JSONFloat64 `json:"filteredBidRate"`
|
|
InventoryMatchRate gensupport.JSONFloat64 `json:"inventoryMatchRate"`
|
|
Latency50thPercentile gensupport.JSONFloat64 `json:"latency50thPercentile"`
|
|
Latency85thPercentile gensupport.JSONFloat64 `json:"latency85thPercentile"`
|
|
Latency95thPercentile gensupport.JSONFloat64 `json:"latency95thPercentile"`
|
|
NoQuotaInRegion gensupport.JSONFloat64 `json:"noQuotaInRegion"`
|
|
OutOfQuota gensupport.JSONFloat64 `json:"outOfQuota"`
|
|
PixelMatchRequests gensupport.JSONFloat64 `json:"pixelMatchRequests"`
|
|
PixelMatchResponses gensupport.JSONFloat64 `json:"pixelMatchResponses"`
|
|
QuotaConfiguredLimit gensupport.JSONFloat64 `json:"quotaConfiguredLimit"`
|
|
QuotaThrottledLimit gensupport.JSONFloat64 `json:"quotaThrottledLimit"`
|
|
SuccessfulRequestRate gensupport.JSONFloat64 `json:"successfulRequestRate"`
|
|
UnsuccessfulRequestRate gensupport.JSONFloat64 `json:"unsuccessfulRequestRate"`
|
|
*noMethod
|
|
}
|
|
s1.noMethod = (*noMethod)(s)
|
|
if err := json.Unmarshal(data, &s1); err != nil {
|
|
return err
|
|
}
|
|
s.BidRate = float64(s1.BidRate)
|
|
s.BidRequestRate = float64(s1.BidRequestRate)
|
|
s.FilteredBidRate = float64(s1.FilteredBidRate)
|
|
s.InventoryMatchRate = float64(s1.InventoryMatchRate)
|
|
s.Latency50thPercentile = float64(s1.Latency50thPercentile)
|
|
s.Latency85thPercentile = float64(s1.Latency85thPercentile)
|
|
s.Latency95thPercentile = float64(s1.Latency95thPercentile)
|
|
s.NoQuotaInRegion = float64(s1.NoQuotaInRegion)
|
|
s.OutOfQuota = float64(s1.OutOfQuota)
|
|
s.PixelMatchRequests = float64(s1.PixelMatchRequests)
|
|
s.PixelMatchResponses = float64(s1.PixelMatchResponses)
|
|
s.QuotaConfiguredLimit = float64(s1.QuotaConfiguredLimit)
|
|
s.QuotaThrottledLimit = float64(s1.QuotaThrottledLimit)
|
|
s.SuccessfulRequestRate = float64(s1.SuccessfulRequestRate)
|
|
s.UnsuccessfulRequestRate = float64(s1.UnsuccessfulRequestRate)
|
|
return nil
|
|
}
|
|
|
|
// PerformanceReportList: The configuration data for an Ad Exchange
|
|
// performance report list.
|
|
type PerformanceReportList struct {
|
|
// Kind: Resource type.
|
|
Kind string `json:"kind,omitempty"`
|
|
|
|
// PerformanceReport: A list of performance reports relevant for the
|
|
// account.
|
|
PerformanceReport []*PerformanceReport `json:"performanceReport,omitempty"`
|
|
|
|
// ServerResponse contains the HTTP response code and headers from the
|
|
// server.
|
|
googleapi.ServerResponse `json:"-"`
|
|
|
|
// ForceSendFields is a list of field names (e.g. "Kind") to
|
|
// unconditionally include in API requests. By default, fields with
|
|
// empty values are omitted from API requests. However, any non-pointer,
|
|
// non-interface field appearing in ForceSendFields will be sent to the
|
|
// server regardless of whether the field is empty or not. This may be
|
|
// used to include empty fields in Patch requests.
|
|
ForceSendFields []string `json:"-"`
|
|
|
|
// NullFields is a list of field names (e.g. "Kind") to include in API
|
|
// requests with the JSON null value. By default, fields with empty
|
|
// values are omitted from API requests. However, any field with an
|
|
// empty value appearing in NullFields will be sent to the server as
|
|
// null. It is an error if a field in this list has a non-empty value.
|
|
// This may be used to include null fields in Patch requests.
|
|
NullFields []string `json:"-"`
|
|
}
|
|
|
|
func (s *PerformanceReportList) MarshalJSON() ([]byte, error) {
|
|
type noMethod PerformanceReportList
|
|
raw := noMethod(*s)
|
|
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
|
|
}
|
|
|
|
type PretargetingConfig struct {
|
|
// BillingId: The id for billing purposes, provided for reference. Leave
|
|
// this field blank for insert requests; the id will be generated
|
|
// automatically.
|
|
BillingId int64 `json:"billingId,omitempty,string"`
|
|
|
|
// ConfigId: The config id; generated automatically. Leave this field
|
|
// blank for insert requests.
|
|
ConfigId int64 `json:"configId,omitempty,string"`
|
|
|
|
// ConfigName: The name of the config. Must be unique. Required for all
|
|
// requests.
|
|
ConfigName string `json:"configName,omitempty"`
|
|
|
|
// CreativeType: List must contain exactly one of
|
|
// PRETARGETING_CREATIVE_TYPE_HTML or PRETARGETING_CREATIVE_TYPE_VIDEO.
|
|
CreativeType []string `json:"creativeType,omitempty"`
|
|
|
|
// Dimensions: Requests which allow one of these (width, height) pairs
|
|
// will match. All pairs must be supported ad dimensions.
|
|
Dimensions []*PretargetingConfigDimensions `json:"dimensions,omitempty"`
|
|
|
|
// ExcludedContentLabels: Requests with any of these content labels will
|
|
// not match. Values are from content-labels.txt in the downloadable
|
|
// files section.
|
|
ExcludedContentLabels googleapi.Int64s `json:"excludedContentLabels,omitempty"`
|
|
|
|
// ExcludedGeoCriteriaIds: Requests containing any of these geo criteria
|
|
// ids will not match.
|
|
ExcludedGeoCriteriaIds googleapi.Int64s `json:"excludedGeoCriteriaIds,omitempty"`
|
|
|
|
// ExcludedPlacements: Requests containing any of these placements will
|
|
// not match.
|
|
ExcludedPlacements []*PretargetingConfigExcludedPlacements `json:"excludedPlacements,omitempty"`
|
|
|
|
// ExcludedUserLists: Requests containing any of these users list ids
|
|
// will not match.
|
|
ExcludedUserLists googleapi.Int64s `json:"excludedUserLists,omitempty"`
|
|
|
|
// ExcludedVerticals: Requests containing any of these vertical ids will
|
|
// not match. Values are from the publisher-verticals.txt file in the
|
|
// downloadable files section.
|
|
ExcludedVerticals googleapi.Int64s `json:"excludedVerticals,omitempty"`
|
|
|
|
// GeoCriteriaIds: Requests containing any of these geo criteria ids
|
|
// will match.
|
|
GeoCriteriaIds googleapi.Int64s `json:"geoCriteriaIds,omitempty"`
|
|
|
|
// IsActive: Whether this config is active. Required for all requests.
|
|
IsActive bool `json:"isActive,omitempty"`
|
|
|
|
// Kind: The kind of the resource, i.e.
|
|
// "adexchangebuyer#pretargetingConfig".
|
|
Kind string `json:"kind,omitempty"`
|
|
|
|
// Languages: Request containing any of these language codes will match.
|
|
Languages []string `json:"languages,omitempty"`
|
|
|
|
// MobileCarriers: Requests containing any of these mobile carrier ids
|
|
// will match. Values are from mobile-carriers.csv in the downloadable
|
|
// files section.
|
|
MobileCarriers googleapi.Int64s `json:"mobileCarriers,omitempty"`
|
|
|
|
// MobileDevices: Requests containing any of these mobile device ids
|
|
// will match. Values are from mobile-devices.csv in the downloadable
|
|
// files section.
|
|
MobileDevices googleapi.Int64s `json:"mobileDevices,omitempty"`
|
|
|
|
// MobileOperatingSystemVersions: Requests containing any of these
|
|
// mobile operating system version ids will match. Values are from
|
|
// mobile-os.csv in the downloadable files section.
|
|
MobileOperatingSystemVersions googleapi.Int64s `json:"mobileOperatingSystemVersions,omitempty"`
|
|
|
|
// Placements: Requests containing any of these placements will match.
|
|
Placements []*PretargetingConfigPlacements `json:"placements,omitempty"`
|
|
|
|
// Platforms: Requests matching any of these platforms will match.
|
|
// Possible values are PRETARGETING_PLATFORM_MOBILE,
|
|
// PRETARGETING_PLATFORM_DESKTOP, and PRETARGETING_PLATFORM_TABLET.
|
|
Platforms []string `json:"platforms,omitempty"`
|
|
|
|
// SupportedCreativeAttributes: Creative attributes should be declared
|
|
// here if all creatives corresponding to this pretargeting
|
|
// configuration have that creative attribute. Values are from
|
|
// pretargetable-creative-attributes.txt in the downloadable files
|
|
// section.
|
|
SupportedCreativeAttributes googleapi.Int64s `json:"supportedCreativeAttributes,omitempty"`
|
|
|
|
// UserLists: Requests containing any of these user list ids will match.
|
|
UserLists googleapi.Int64s `json:"userLists,omitempty"`
|
|
|
|
// VendorTypes: Requests that allow any of these vendor ids will match.
|
|
// Values are from vendors.txt in the downloadable files section.
|
|
VendorTypes googleapi.Int64s `json:"vendorTypes,omitempty"`
|
|
|
|
// Verticals: Requests containing any of these vertical ids will match.
|
|
Verticals googleapi.Int64s `json:"verticals,omitempty"`
|
|
|
|
// ServerResponse contains the HTTP response code and headers from the
|
|
// server.
|
|
googleapi.ServerResponse `json:"-"`
|
|
|
|
// ForceSendFields is a list of field names (e.g. "BillingId") to
|
|
// unconditionally include in API requests. By default, fields with
|
|
// empty values are omitted from API requests. However, any non-pointer,
|
|
// non-interface field appearing in ForceSendFields will be sent to the
|
|
// server regardless of whether the field is empty or not. This may be
|
|
// used to include empty fields in Patch requests.
|
|
ForceSendFields []string `json:"-"`
|
|
|
|
// NullFields is a list of field names (e.g. "BillingId") to include in
|
|
// API requests with the JSON null value. By default, fields with empty
|
|
// values are omitted from API requests. However, any field with an
|
|
// empty value appearing in NullFields will be sent to the server as
|
|
// null. It is an error if a field in this list has a non-empty value.
|
|
// This may be used to include null fields in Patch requests.
|
|
NullFields []string `json:"-"`
|
|
}
|
|
|
|
func (s *PretargetingConfig) MarshalJSON() ([]byte, error) {
|
|
type noMethod PretargetingConfig
|
|
raw := noMethod(*s)
|
|
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
|
|
}
|
|
|
|
type PretargetingConfigDimensions struct {
|
|
// Height: Height in pixels.
|
|
Height int64 `json:"height,omitempty,string"`
|
|
|
|
// Width: Width in pixels.
|
|
Width int64 `json:"width,omitempty,string"`
|
|
|
|
// ForceSendFields is a list of field names (e.g. "Height") to
|
|
// unconditionally include in API requests. By default, fields with
|
|
// empty values are omitted from API requests. However, any non-pointer,
|
|
// non-interface field appearing in ForceSendFields will be sent to the
|
|
// server regardless of whether the field is empty or not. This may be
|
|
// used to include empty fields in Patch requests.
|
|
ForceSendFields []string `json:"-"`
|
|
|
|
// NullFields is a list of field names (e.g. "Height") to include in API
|
|
// requests with the JSON null value. By default, fields with empty
|
|
// values are omitted from API requests. However, any field with an
|
|
// empty value appearing in NullFields will be sent to the server as
|
|
// null. It is an error if a field in this list has a non-empty value.
|
|
// This may be used to include null fields in Patch requests.
|
|
NullFields []string `json:"-"`
|
|
}
|
|
|
|
func (s *PretargetingConfigDimensions) MarshalJSON() ([]byte, error) {
|
|
type noMethod PretargetingConfigDimensions
|
|
raw := noMethod(*s)
|
|
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
|
|
}
|
|
|
|
type PretargetingConfigExcludedPlacements struct {
|
|
// Token: The value of the placement. Interpretation depends on the
|
|
// placement type, e.g. URL for a site placement, channel name for a
|
|
// channel placement, app id for a mobile app placement.
|
|
Token string `json:"token,omitempty"`
|
|
|
|
// Type: The type of the placement.
|
|
Type string `json:"type,omitempty"`
|
|
|
|
// ForceSendFields is a list of field names (e.g. "Token") to
|
|
// unconditionally include in API requests. By default, fields with
|
|
// empty values are omitted from API requests. However, any non-pointer,
|
|
// non-interface field appearing in ForceSendFields will be sent to the
|
|
// server regardless of whether the field is empty or not. This may be
|
|
// used to include empty fields in Patch requests.
|
|
ForceSendFields []string `json:"-"`
|
|
|
|
// NullFields is a list of field names (e.g. "Token") to include in API
|
|
// requests with the JSON null value. By default, fields with empty
|
|
// values are omitted from API requests. However, any field with an
|
|
// empty value appearing in NullFields will be sent to the server as
|
|
// null. It is an error if a field in this list has a non-empty value.
|
|
// This may be used to include null fields in Patch requests.
|
|
NullFields []string `json:"-"`
|
|
}
|
|
|
|
func (s *PretargetingConfigExcludedPlacements) MarshalJSON() ([]byte, error) {
|
|
type noMethod PretargetingConfigExcludedPlacements
|
|
raw := noMethod(*s)
|
|
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
|
|
}
|
|
|
|
type PretargetingConfigPlacements struct {
|
|
// Token: The value of the placement. Interpretation depends on the
|
|
// placement type, e.g. URL for a site placement, channel name for a
|
|
// channel placement, app id for a mobile app placement.
|
|
Token string `json:"token,omitempty"`
|
|
|
|
// Type: The type of the placement.
|
|
Type string `json:"type,omitempty"`
|
|
|
|
// ForceSendFields is a list of field names (e.g. "Token") to
|
|
// unconditionally include in API requests. By default, fields with
|
|
// empty values are omitted from API requests. However, any non-pointer,
|
|
// non-interface field appearing in ForceSendFields will be sent to the
|
|
// server regardless of whether the field is empty or not. This may be
|
|
// used to include empty fields in Patch requests.
|
|
ForceSendFields []string `json:"-"`
|
|
|
|
// NullFields is a list of field names (e.g. "Token") to include in API
|
|
// requests with the JSON null value. By default, fields with empty
|
|
// values are omitted from API requests. However, any field with an
|
|
// empty value appearing in NullFields will be sent to the server as
|
|
// null. It is an error if a field in this list has a non-empty value.
|
|
// This may be used to include null fields in Patch requests.
|
|
NullFields []string `json:"-"`
|
|
}
|
|
|
|
func (s *PretargetingConfigPlacements) MarshalJSON() ([]byte, error) {
|
|
type noMethod PretargetingConfigPlacements
|
|
raw := noMethod(*s)
|
|
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
|
|
}
|
|
|
|
type PretargetingConfigList struct {
|
|
// Items: A list of pretargeting configs
|
|
Items []*PretargetingConfig `json:"items,omitempty"`
|
|
|
|
// Kind: Resource type.
|
|
Kind string `json:"kind,omitempty"`
|
|
|
|
// ServerResponse contains the HTTP response code and headers from the
|
|
// server.
|
|
googleapi.ServerResponse `json:"-"`
|
|
|
|
// ForceSendFields is a list of field names (e.g. "Items") to
|
|
// unconditionally include in API requests. By default, fields with
|
|
// empty values are omitted from API requests. However, any non-pointer,
|
|
// non-interface field appearing in ForceSendFields will be sent to the
|
|
// server regardless of whether the field is empty or not. This may be
|
|
// used to include empty fields in Patch requests.
|
|
ForceSendFields []string `json:"-"`
|
|
|
|
// NullFields is a list of field names (e.g. "Items") to include in API
|
|
// requests with the JSON null value. By default, fields with empty
|
|
// values are omitted from API requests. However, any field with an
|
|
// empty value appearing in NullFields will be sent to the server as
|
|
// null. It is an error if a field in this list has a non-empty value.
|
|
// This may be used to include null fields in Patch requests.
|
|
NullFields []string `json:"-"`
|
|
}
|
|
|
|
func (s *PretargetingConfigList) MarshalJSON() ([]byte, error) {
|
|
type noMethod PretargetingConfigList
|
|
raw := noMethod(*s)
|
|
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
|
|
}
|
|
|
|
// method id "adexchangebuyer.accounts.get":
|
|
|
|
type AccountsGetCall struct {
|
|
s *Service
|
|
id int64
|
|
urlParams_ gensupport.URLParams
|
|
ifNoneMatch_ string
|
|
ctx_ context.Context
|
|
header_ http.Header
|
|
}
|
|
|
|
// Get: Gets one account by ID.
|
|
func (r *AccountsService) Get(id int64) *AccountsGetCall {
|
|
c := &AccountsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
|
|
c.id = id
|
|
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 *AccountsGetCall) Fields(s ...googleapi.Field) *AccountsGetCall {
|
|
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 *AccountsGetCall) IfNoneMatch(entityTag string) *AccountsGetCall {
|
|
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 *AccountsGetCall) Context(ctx context.Context) *AccountsGetCall {
|
|
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 *AccountsGetCall) Header() http.Header {
|
|
if c.header_ == nil {
|
|
c.header_ = make(http.Header)
|
|
}
|
|
return c.header_
|
|
}
|
|
|
|
func (c *AccountsGetCall) 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, "accounts/{id}")
|
|
urls += "?" + c.urlParams_.Encode()
|
|
req, _ := http.NewRequest("GET", urls, body)
|
|
req.Header = reqHeaders
|
|
googleapi.Expand(req.URL, map[string]string{
|
|
"id": strconv.FormatInt(c.id, 10),
|
|
})
|
|
return gensupport.SendRequest(c.ctx_, c.s.client, req)
|
|
}
|
|
|
|
// Do executes the "adexchangebuyer.accounts.get" call.
|
|
// Exactly one of *Account or error will be non-nil. Any non-2xx status
|
|
// code is an error. Response headers are in either
|
|
// *Account.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 *AccountsGetCall) Do(opts ...googleapi.CallOption) (*Account, 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 := &Account{
|
|
ServerResponse: googleapi.ServerResponse{
|
|
Header: res.Header,
|
|
HTTPStatusCode: res.StatusCode,
|
|
},
|
|
}
|
|
target := &ret
|
|
if err := json.NewDecoder(res.Body).Decode(target); 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"
|
|
// ]
|
|
// }
|
|
|
|
}
|
|
|
|
// method id "adexchangebuyer.accounts.list":
|
|
|
|
type AccountsListCall struct {
|
|
s *Service
|
|
urlParams_ gensupport.URLParams
|
|
ifNoneMatch_ string
|
|
ctx_ context.Context
|
|
header_ http.Header
|
|
}
|
|
|
|
// List: Retrieves the authenticated user's list of accounts.
|
|
func (r *AccountsService) List() *AccountsListCall {
|
|
c := &AccountsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
|
|
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 *AccountsListCall) Fields(s ...googleapi.Field) *AccountsListCall {
|
|
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 *AccountsListCall) IfNoneMatch(entityTag string) *AccountsListCall {
|
|
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 *AccountsListCall) Context(ctx context.Context) *AccountsListCall {
|
|
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 *AccountsListCall) Header() http.Header {
|
|
if c.header_ == nil {
|
|
c.header_ = make(http.Header)
|
|
}
|
|
return c.header_
|
|
}
|
|
|
|
func (c *AccountsListCall) 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, "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 "adexchangebuyer.accounts.list" call.
|
|
// Exactly one of *AccountsList or error will be non-nil. Any non-2xx
|
|
// status code is an error. Response headers are in either
|
|
// *AccountsList.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 *AccountsListCall) Do(opts ...googleapi.CallOption) (*AccountsList, 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 := &AccountsList{
|
|
ServerResponse: googleapi.ServerResponse{
|
|
Header: res.Header,
|
|
HTTPStatusCode: res.StatusCode,
|
|
},
|
|
}
|
|
target := &ret
|
|
if err := json.NewDecoder(res.Body).Decode(target); err != nil {
|
|
return nil, err
|
|
}
|
|
return ret, nil
|
|
// {
|
|
// "description": "Retrieves the authenticated user's list of accounts.",
|
|
// "httpMethod": "GET",
|
|
// "id": "adexchangebuyer.accounts.list",
|
|
// "path": "accounts",
|
|
// "response": {
|
|
// "$ref": "AccountsList"
|
|
// },
|
|
// "scopes": [
|
|
// "https://www.googleapis.com/auth/adexchange.buyer"
|
|
// ]
|
|
// }
|
|
|
|
}
|
|
|
|
// method id "adexchangebuyer.accounts.patch":
|
|
|
|
type AccountsPatchCall struct {
|
|
s *Service
|
|
id int64
|
|
account *Account
|
|
urlParams_ gensupport.URLParams
|
|
ctx_ context.Context
|
|
header_ http.Header
|
|
}
|
|
|
|
// Patch: Updates an existing account. This method supports patch
|
|
// semantics.
|
|
func (r *AccountsService) Patch(id int64, account *Account) *AccountsPatchCall {
|
|
c := &AccountsPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
|
|
c.id = id
|
|
c.account = account
|
|
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 *AccountsPatchCall) Fields(s ...googleapi.Field) *AccountsPatchCall {
|
|
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 *AccountsPatchCall) Context(ctx context.Context) *AccountsPatchCall {
|
|
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 *AccountsPatchCall) Header() http.Header {
|
|
if c.header_ == nil {
|
|
c.header_ = make(http.Header)
|
|
}
|
|
return c.header_
|
|
}
|
|
|
|
func (c *AccountsPatchCall) 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
|
|
body, err := googleapi.WithoutDataWrapper.JSONReader(c.account)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
reqHeaders.Set("Content-Type", "application/json")
|
|
c.urlParams_.Set("alt", alt)
|
|
urls := googleapi.ResolveRelative(c.s.BasePath, "accounts/{id}")
|
|
urls += "?" + c.urlParams_.Encode()
|
|
req, _ := http.NewRequest("PATCH", urls, body)
|
|
req.Header = reqHeaders
|
|
googleapi.Expand(req.URL, map[string]string{
|
|
"id": strconv.FormatInt(c.id, 10),
|
|
})
|
|
return gensupport.SendRequest(c.ctx_, c.s.client, req)
|
|
}
|
|
|
|
// Do executes the "adexchangebuyer.accounts.patch" call.
|
|
// Exactly one of *Account or error will be non-nil. Any non-2xx status
|
|
// code is an error. Response headers are in either
|
|
// *Account.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 *AccountsPatchCall) Do(opts ...googleapi.CallOption) (*Account, 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 := &Account{
|
|
ServerResponse: googleapi.ServerResponse{
|
|
Header: res.Header,
|
|
HTTPStatusCode: res.StatusCode,
|
|
},
|
|
}
|
|
target := &ret
|
|
if err := json.NewDecoder(res.Body).Decode(target); err != nil {
|
|
return nil, err
|
|
}
|
|
return ret, nil
|
|
// {
|
|
// "description": "Updates an existing account. This method supports patch semantics.",
|
|
// "httpMethod": "PATCH",
|
|
// "id": "adexchangebuyer.accounts.patch",
|
|
// "parameterOrder": [
|
|
// "id"
|
|
// ],
|
|
// "parameters": {
|
|
// "id": {
|
|
// "description": "The account id",
|
|
// "format": "int32",
|
|
// "location": "path",
|
|
// "required": true,
|
|
// "type": "integer"
|
|
// }
|
|
// },
|
|
// "path": "accounts/{id}",
|
|
// "request": {
|
|
// "$ref": "Account"
|
|
// },
|
|
// "response": {
|
|
// "$ref": "Account"
|
|
// },
|
|
// "scopes": [
|
|
// "https://www.googleapis.com/auth/adexchange.buyer"
|
|
// ]
|
|
// }
|
|
|
|
}
|
|
|
|
// method id "adexchangebuyer.accounts.update":
|
|
|
|
type AccountsUpdateCall struct {
|
|
s *Service
|
|
id int64
|
|
account *Account
|
|
urlParams_ gensupport.URLParams
|
|
ctx_ context.Context
|
|
header_ http.Header
|
|
}
|
|
|
|
// Update: Updates an existing account.
|
|
func (r *AccountsService) Update(id int64, account *Account) *AccountsUpdateCall {
|
|
c := &AccountsUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
|
|
c.id = id
|
|
c.account = account
|
|
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 *AccountsUpdateCall) Fields(s ...googleapi.Field) *AccountsUpdateCall {
|
|
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 *AccountsUpdateCall) Context(ctx context.Context) *AccountsUpdateCall {
|
|
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 *AccountsUpdateCall) Header() http.Header {
|
|
if c.header_ == nil {
|
|
c.header_ = make(http.Header)
|
|
}
|
|
return c.header_
|
|
}
|
|
|
|
func (c *AccountsUpdateCall) 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
|
|
body, err := googleapi.WithoutDataWrapper.JSONReader(c.account)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
reqHeaders.Set("Content-Type", "application/json")
|
|
c.urlParams_.Set("alt", alt)
|
|
urls := googleapi.ResolveRelative(c.s.BasePath, "accounts/{id}")
|
|
urls += "?" + c.urlParams_.Encode()
|
|
req, _ := http.NewRequest("PUT", urls, body)
|
|
req.Header = reqHeaders
|
|
googleapi.Expand(req.URL, map[string]string{
|
|
"id": strconv.FormatInt(c.id, 10),
|
|
})
|
|
return gensupport.SendRequest(c.ctx_, c.s.client, req)
|
|
}
|
|
|
|
// Do executes the "adexchangebuyer.accounts.update" call.
|
|
// Exactly one of *Account or error will be non-nil. Any non-2xx status
|
|
// code is an error. Response headers are in either
|
|
// *Account.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 *AccountsUpdateCall) Do(opts ...googleapi.CallOption) (*Account, 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 := &Account{
|
|
ServerResponse: googleapi.ServerResponse{
|
|
Header: res.Header,
|
|
HTTPStatusCode: res.StatusCode,
|
|
},
|
|
}
|
|
target := &ret
|
|
if err := json.NewDecoder(res.Body).Decode(target); err != nil {
|
|
return nil, err
|
|
}
|
|
return ret, nil
|
|
// {
|
|
// "description": "Updates an existing account.",
|
|
// "httpMethod": "PUT",
|
|
// "id": "adexchangebuyer.accounts.update",
|
|
// "parameterOrder": [
|
|
// "id"
|
|
// ],
|
|
// "parameters": {
|
|
// "id": {
|
|
// "description": "The account id",
|
|
// "format": "int32",
|
|
// "location": "path",
|
|
// "required": true,
|
|
// "type": "integer"
|
|
// }
|
|
// },
|
|
// "path": "accounts/{id}",
|
|
// "request": {
|
|
// "$ref": "Account"
|
|
// },
|
|
// "response": {
|
|
// "$ref": "Account"
|
|
// },
|
|
// "scopes": [
|
|
// "https://www.googleapis.com/auth/adexchange.buyer"
|
|
// ]
|
|
// }
|
|
|
|
}
|
|
|
|
// method id "adexchangebuyer.billingInfo.get":
|
|
|
|
type BillingInfoGetCall struct {
|
|
s *Service
|
|
accountId int64
|
|
urlParams_ gensupport.URLParams
|
|
ifNoneMatch_ string
|
|
ctx_ context.Context
|
|
header_ http.Header
|
|
}
|
|
|
|
// Get: Returns the billing information for one account specified by
|
|
// account ID.
|
|
func (r *BillingInfoService) Get(accountId int64) *BillingInfoGetCall {
|
|
c := &BillingInfoGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
|
|
c.accountId = accountId
|
|
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 *BillingInfoGetCall) Fields(s ...googleapi.Field) *BillingInfoGetCall {
|
|
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 *BillingInfoGetCall) IfNoneMatch(entityTag string) *BillingInfoGetCall {
|
|
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 *BillingInfoGetCall) Context(ctx context.Context) *BillingInfoGetCall {
|
|
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 *BillingInfoGetCall) Header() http.Header {
|
|
if c.header_ == nil {
|
|
c.header_ = make(http.Header)
|
|
}
|
|
return c.header_
|
|
}
|
|
|
|
func (c *BillingInfoGetCall) 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, "billinginfo/{accountId}")
|
|
urls += "?" + c.urlParams_.Encode()
|
|
req, _ := http.NewRequest("GET", urls, body)
|
|
req.Header = reqHeaders
|
|
googleapi.Expand(req.URL, map[string]string{
|
|
"accountId": strconv.FormatInt(c.accountId, 10),
|
|
})
|
|
return gensupport.SendRequest(c.ctx_, c.s.client, req)
|
|
}
|
|
|
|
// Do executes the "adexchangebuyer.billingInfo.get" call.
|
|
// Exactly one of *BillingInfo or error will be non-nil. Any non-2xx
|
|
// status code is an error. Response headers are in either
|
|
// *BillingInfo.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 *BillingInfoGetCall) Do(opts ...googleapi.CallOption) (*BillingInfo, 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 := &BillingInfo{
|
|
ServerResponse: googleapi.ServerResponse{
|
|
Header: res.Header,
|
|
HTTPStatusCode: res.StatusCode,
|
|
},
|
|
}
|
|
target := &ret
|
|
if err := json.NewDecoder(res.Body).Decode(target); err != nil {
|
|
return nil, err
|
|
}
|
|
return ret, nil
|
|
// {
|
|
// "description": "Returns the billing information for one account specified by account ID.",
|
|
// "httpMethod": "GET",
|
|
// "id": "adexchangebuyer.billingInfo.get",
|
|
// "parameterOrder": [
|
|
// "accountId"
|
|
// ],
|
|
// "parameters": {
|
|
// "accountId": {
|
|
// "description": "The account id.",
|
|
// "format": "int32",
|
|
// "location": "path",
|
|
// "required": true,
|
|
// "type": "integer"
|
|
// }
|
|
// },
|
|
// "path": "billinginfo/{accountId}",
|
|
// "response": {
|
|
// "$ref": "BillingInfo"
|
|
// },
|
|
// "scopes": [
|
|
// "https://www.googleapis.com/auth/adexchange.buyer"
|
|
// ]
|
|
// }
|
|
|
|
}
|
|
|
|
// method id "adexchangebuyer.billingInfo.list":
|
|
|
|
type BillingInfoListCall struct {
|
|
s *Service
|
|
urlParams_ gensupport.URLParams
|
|
ifNoneMatch_ string
|
|
ctx_ context.Context
|
|
header_ http.Header
|
|
}
|
|
|
|
// List: Retrieves a list of billing information for all accounts of the
|
|
// authenticated user.
|
|
func (r *BillingInfoService) List() *BillingInfoListCall {
|
|
c := &BillingInfoListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
|
|
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 *BillingInfoListCall) Fields(s ...googleapi.Field) *BillingInfoListCall {
|
|
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 *BillingInfoListCall) IfNoneMatch(entityTag string) *BillingInfoListCall {
|
|
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 *BillingInfoListCall) Context(ctx context.Context) *BillingInfoListCall {
|
|
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 *BillingInfoListCall) Header() http.Header {
|
|
if c.header_ == nil {
|
|
c.header_ = make(http.Header)
|
|
}
|
|
return c.header_
|
|
}
|
|
|
|
func (c *BillingInfoListCall) 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, "billinginfo")
|
|
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 "adexchangebuyer.billingInfo.list" call.
|
|
// Exactly one of *BillingInfoList or error will be non-nil. Any non-2xx
|
|
// status code is an error. Response headers are in either
|
|
// *BillingInfoList.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 *BillingInfoListCall) Do(opts ...googleapi.CallOption) (*BillingInfoList, 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 := &BillingInfoList{
|
|
ServerResponse: googleapi.ServerResponse{
|
|
Header: res.Header,
|
|
HTTPStatusCode: res.StatusCode,
|
|
},
|
|
}
|
|
target := &ret
|
|
if err := json.NewDecoder(res.Body).Decode(target); err != nil {
|
|
return nil, err
|
|
}
|
|
return ret, nil
|
|
// {
|
|
// "description": "Retrieves a list of billing information for all accounts of the authenticated user.",
|
|
// "httpMethod": "GET",
|
|
// "id": "adexchangebuyer.billingInfo.list",
|
|
// "path": "billinginfo",
|
|
// "response": {
|
|
// "$ref": "BillingInfoList"
|
|
// },
|
|
// "scopes": [
|
|
// "https://www.googleapis.com/auth/adexchange.buyer"
|
|
// ]
|
|
// }
|
|
|
|
}
|
|
|
|
// method id "adexchangebuyer.budget.get":
|
|
|
|
type BudgetGetCall struct {
|
|
s *Service
|
|
accountId int64
|
|
billingId int64
|
|
urlParams_ gensupport.URLParams
|
|
ifNoneMatch_ string
|
|
ctx_ context.Context
|
|
header_ http.Header
|
|
}
|
|
|
|
// Get: Returns the budget information for the adgroup specified by the
|
|
// accountId and billingId.
|
|
func (r *BudgetService) Get(accountId int64, billingId int64) *BudgetGetCall {
|
|
c := &BudgetGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
|
|
c.accountId = accountId
|
|
c.billingId = billingId
|
|
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 *BudgetGetCall) Fields(s ...googleapi.Field) *BudgetGetCall {
|
|
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 *BudgetGetCall) IfNoneMatch(entityTag string) *BudgetGetCall {
|
|
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 *BudgetGetCall) Context(ctx context.Context) *BudgetGetCall {
|
|
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 *BudgetGetCall) Header() http.Header {
|
|
if c.header_ == nil {
|
|
c.header_ = make(http.Header)
|
|
}
|
|
return c.header_
|
|
}
|
|
|
|
func (c *BudgetGetCall) 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, "billinginfo/{accountId}/{billingId}")
|
|
urls += "?" + c.urlParams_.Encode()
|
|
req, _ := http.NewRequest("GET", urls, body)
|
|
req.Header = reqHeaders
|
|
googleapi.Expand(req.URL, map[string]string{
|
|
"accountId": strconv.FormatInt(c.accountId, 10),
|
|
"billingId": strconv.FormatInt(c.billingId, 10),
|
|
})
|
|
return gensupport.SendRequest(c.ctx_, c.s.client, req)
|
|
}
|
|
|
|
// Do executes the "adexchangebuyer.budget.get" call.
|
|
// Exactly one of *Budget or error will be non-nil. Any non-2xx status
|
|
// code is an error. Response headers are in either
|
|
// *Budget.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 *BudgetGetCall) Do(opts ...googleapi.CallOption) (*Budget, 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 := &Budget{
|
|
ServerResponse: googleapi.ServerResponse{
|
|
Header: res.Header,
|
|
HTTPStatusCode: res.StatusCode,
|
|
},
|
|
}
|
|
target := &ret
|
|
if err := json.NewDecoder(res.Body).Decode(target); err != nil {
|
|
return nil, err
|
|
}
|
|
return ret, nil
|
|
// {
|
|
// "description": "Returns the budget information for the adgroup specified by the accountId and billingId.",
|
|
// "httpMethod": "GET",
|
|
// "id": "adexchangebuyer.budget.get",
|
|
// "parameterOrder": [
|
|
// "accountId",
|
|
// "billingId"
|
|
// ],
|
|
// "parameters": {
|
|
// "accountId": {
|
|
// "description": "The account id to get the budget information for.",
|
|
// "format": "int64",
|
|
// "location": "path",
|
|
// "required": true,
|
|
// "type": "string"
|
|
// },
|
|
// "billingId": {
|
|
// "description": "The billing id to get the budget information for.",
|
|
// "format": "int64",
|
|
// "location": "path",
|
|
// "required": true,
|
|
// "type": "string"
|
|
// }
|
|
// },
|
|
// "path": "billinginfo/{accountId}/{billingId}",
|
|
// "response": {
|
|
// "$ref": "Budget"
|
|
// },
|
|
// "scopes": [
|
|
// "https://www.googleapis.com/auth/adexchange.buyer"
|
|
// ]
|
|
// }
|
|
|
|
}
|
|
|
|
// method id "adexchangebuyer.budget.patch":
|
|
|
|
type BudgetPatchCall struct {
|
|
s *Service
|
|
accountId int64
|
|
billingId int64
|
|
budget *Budget
|
|
urlParams_ gensupport.URLParams
|
|
ctx_ context.Context
|
|
header_ http.Header
|
|
}
|
|
|
|
// Patch: Updates the budget amount for the budget of the adgroup
|
|
// specified by the accountId and billingId, with the budget amount in
|
|
// the request. This method supports patch semantics.
|
|
func (r *BudgetService) Patch(accountId int64, billingId int64, budget *Budget) *BudgetPatchCall {
|
|
c := &BudgetPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
|
|
c.accountId = accountId
|
|
c.billingId = billingId
|
|
c.budget = budget
|
|
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 *BudgetPatchCall) Fields(s ...googleapi.Field) *BudgetPatchCall {
|
|
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 *BudgetPatchCall) Context(ctx context.Context) *BudgetPatchCall {
|
|
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 *BudgetPatchCall) Header() http.Header {
|
|
if c.header_ == nil {
|
|
c.header_ = make(http.Header)
|
|
}
|
|
return c.header_
|
|
}
|
|
|
|
func (c *BudgetPatchCall) 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
|
|
body, err := googleapi.WithoutDataWrapper.JSONReader(c.budget)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
reqHeaders.Set("Content-Type", "application/json")
|
|
c.urlParams_.Set("alt", alt)
|
|
urls := googleapi.ResolveRelative(c.s.BasePath, "billinginfo/{accountId}/{billingId}")
|
|
urls += "?" + c.urlParams_.Encode()
|
|
req, _ := http.NewRequest("PATCH", urls, body)
|
|
req.Header = reqHeaders
|
|
googleapi.Expand(req.URL, map[string]string{
|
|
"accountId": strconv.FormatInt(c.accountId, 10),
|
|
"billingId": strconv.FormatInt(c.billingId, 10),
|
|
})
|
|
return gensupport.SendRequest(c.ctx_, c.s.client, req)
|
|
}
|
|
|
|
// Do executes the "adexchangebuyer.budget.patch" call.
|
|
// Exactly one of *Budget or error will be non-nil. Any non-2xx status
|
|
// code is an error. Response headers are in either
|
|
// *Budget.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 *BudgetPatchCall) Do(opts ...googleapi.CallOption) (*Budget, 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 := &Budget{
|
|
ServerResponse: googleapi.ServerResponse{
|
|
Header: res.Header,
|
|
HTTPStatusCode: res.StatusCode,
|
|
},
|
|
}
|
|
target := &ret
|
|
if err := json.NewDecoder(res.Body).Decode(target); err != nil {
|
|
return nil, err
|
|
}
|
|
return ret, nil
|
|
// {
|
|
// "description": "Updates the budget amount for the budget of the adgroup specified by the accountId and billingId, with the budget amount in the request. This method supports patch semantics.",
|
|
// "httpMethod": "PATCH",
|
|
// "id": "adexchangebuyer.budget.patch",
|
|
// "parameterOrder": [
|
|
// "accountId",
|
|
// "billingId"
|
|
// ],
|
|
// "parameters": {
|
|
// "accountId": {
|
|
// "description": "The account id associated with the budget being updated.",
|
|
// "format": "int64",
|
|
// "location": "path",
|
|
// "required": true,
|
|
// "type": "string"
|
|
// },
|
|
// "billingId": {
|
|
// "description": "The billing id associated with the budget being updated.",
|
|
// "format": "int64",
|
|
// "location": "path",
|
|
// "required": true,
|
|
// "type": "string"
|
|
// }
|
|
// },
|
|
// "path": "billinginfo/{accountId}/{billingId}",
|
|
// "request": {
|
|
// "$ref": "Budget"
|
|
// },
|
|
// "response": {
|
|
// "$ref": "Budget"
|
|
// },
|
|
// "scopes": [
|
|
// "https://www.googleapis.com/auth/adexchange.buyer"
|
|
// ]
|
|
// }
|
|
|
|
}
|
|
|
|
// method id "adexchangebuyer.budget.update":
|
|
|
|
type BudgetUpdateCall struct {
|
|
s *Service
|
|
accountId int64
|
|
billingId int64
|
|
budget *Budget
|
|
urlParams_ gensupport.URLParams
|
|
ctx_ context.Context
|
|
header_ http.Header
|
|
}
|
|
|
|
// Update: Updates the budget amount for the budget of the adgroup
|
|
// specified by the accountId and billingId, with the budget amount in
|
|
// the request.
|
|
func (r *BudgetService) Update(accountId int64, billingId int64, budget *Budget) *BudgetUpdateCall {
|
|
c := &BudgetUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
|
|
c.accountId = accountId
|
|
c.billingId = billingId
|
|
c.budget = budget
|
|
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 *BudgetUpdateCall) Fields(s ...googleapi.Field) *BudgetUpdateCall {
|
|
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 *BudgetUpdateCall) Context(ctx context.Context) *BudgetUpdateCall {
|
|
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 *BudgetUpdateCall) Header() http.Header {
|
|
if c.header_ == nil {
|
|
c.header_ = make(http.Header)
|
|
}
|
|
return c.header_
|
|
}
|
|
|
|
func (c *BudgetUpdateCall) 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
|
|
body, err := googleapi.WithoutDataWrapper.JSONReader(c.budget)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
reqHeaders.Set("Content-Type", "application/json")
|
|
c.urlParams_.Set("alt", alt)
|
|
urls := googleapi.ResolveRelative(c.s.BasePath, "billinginfo/{accountId}/{billingId}")
|
|
urls += "?" + c.urlParams_.Encode()
|
|
req, _ := http.NewRequest("PUT", urls, body)
|
|
req.Header = reqHeaders
|
|
googleapi.Expand(req.URL, map[string]string{
|
|
"accountId": strconv.FormatInt(c.accountId, 10),
|
|
"billingId": strconv.FormatInt(c.billingId, 10),
|
|
})
|
|
return gensupport.SendRequest(c.ctx_, c.s.client, req)
|
|
}
|
|
|
|
// Do executes the "adexchangebuyer.budget.update" call.
|
|
// Exactly one of *Budget or error will be non-nil. Any non-2xx status
|
|
// code is an error. Response headers are in either
|
|
// *Budget.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 *BudgetUpdateCall) Do(opts ...googleapi.CallOption) (*Budget, 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 := &Budget{
|
|
ServerResponse: googleapi.ServerResponse{
|
|
Header: res.Header,
|
|
HTTPStatusCode: res.StatusCode,
|
|
},
|
|
}
|
|
target := &ret
|
|
if err := json.NewDecoder(res.Body).Decode(target); err != nil {
|
|
return nil, err
|
|
}
|
|
return ret, nil
|
|
// {
|
|
// "description": "Updates the budget amount for the budget of the adgroup specified by the accountId and billingId, with the budget amount in the request.",
|
|
// "httpMethod": "PUT",
|
|
// "id": "adexchangebuyer.budget.update",
|
|
// "parameterOrder": [
|
|
// "accountId",
|
|
// "billingId"
|
|
// ],
|
|
// "parameters": {
|
|
// "accountId": {
|
|
// "description": "The account id associated with the budget being updated.",
|
|
// "format": "int64",
|
|
// "location": "path",
|
|
// "required": true,
|
|
// "type": "string"
|
|
// },
|
|
// "billingId": {
|
|
// "description": "The billing id associated with the budget being updated.",
|
|
// "format": "int64",
|
|
// "location": "path",
|
|
// "required": true,
|
|
// "type": "string"
|
|
// }
|
|
// },
|
|
// "path": "billinginfo/{accountId}/{billingId}",
|
|
// "request": {
|
|
// "$ref": "Budget"
|
|
// },
|
|
// "response": {
|
|
// "$ref": "Budget"
|
|
// },
|
|
// "scopes": [
|
|
// "https://www.googleapis.com/auth/adexchange.buyer"
|
|
// ]
|
|
// }
|
|
|
|
}
|
|
|
|
// method id "adexchangebuyer.creatives.get":
|
|
|
|
type CreativesGetCall struct {
|
|
s *Service
|
|
accountId int64
|
|
buyerCreativeId string
|
|
urlParams_ gensupport.URLParams
|
|
ifNoneMatch_ string
|
|
ctx_ context.Context
|
|
header_ http.Header
|
|
}
|
|
|
|
// Get: Gets the status for a single creative. A creative will be
|
|
// available 30-40 minutes after submission.
|
|
func (r *CreativesService) Get(accountId int64, buyerCreativeId string) *CreativesGetCall {
|
|
c := &CreativesGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
|
|
c.accountId = accountId
|
|
c.buyerCreativeId = buyerCreativeId
|
|
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 *CreativesGetCall) Fields(s ...googleapi.Field) *CreativesGetCall {
|
|
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 *CreativesGetCall) IfNoneMatch(entityTag string) *CreativesGetCall {
|
|
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 *CreativesGetCall) Context(ctx context.Context) *CreativesGetCall {
|
|
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 *CreativesGetCall) Header() http.Header {
|
|
if c.header_ == nil {
|
|
c.header_ = make(http.Header)
|
|
}
|
|
return c.header_
|
|
}
|
|
|
|
func (c *CreativesGetCall) 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, "creatives/{accountId}/{buyerCreativeId}")
|
|
urls += "?" + c.urlParams_.Encode()
|
|
req, _ := http.NewRequest("GET", urls, body)
|
|
req.Header = reqHeaders
|
|
googleapi.Expand(req.URL, map[string]string{
|
|
"accountId": strconv.FormatInt(c.accountId, 10),
|
|
"buyerCreativeId": c.buyerCreativeId,
|
|
})
|
|
return gensupport.SendRequest(c.ctx_, c.s.client, req)
|
|
}
|
|
|
|
// Do executes the "adexchangebuyer.creatives.get" call.
|
|
// Exactly one of *Creative or error will be non-nil. Any non-2xx status
|
|
// code is an error. Response headers are in either
|
|
// *Creative.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 *CreativesGetCall) Do(opts ...googleapi.CallOption) (*Creative, 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 := &Creative{
|
|
ServerResponse: googleapi.ServerResponse{
|
|
Header: res.Header,
|
|
HTTPStatusCode: res.StatusCode,
|
|
},
|
|
}
|
|
target := &ret
|
|
if err := json.NewDecoder(res.Body).Decode(target); err != nil {
|
|
return nil, err
|
|
}
|
|
return ret, nil
|
|
// {
|
|
// "description": "Gets the status for a single creative. A creative will be available 30-40 minutes after submission.",
|
|
// "httpMethod": "GET",
|
|
// "id": "adexchangebuyer.creatives.get",
|
|
// "parameterOrder": [
|
|
// "accountId",
|
|
// "buyerCreativeId"
|
|
// ],
|
|
// "parameters": {
|
|
// "accountId": {
|
|
// "description": "The id for the account that will serve this creative.",
|
|
// "format": "int32",
|
|
// "location": "path",
|
|
// "required": true,
|
|
// "type": "integer"
|
|
// },
|
|
// "buyerCreativeId": {
|
|
// "description": "The buyer-specific id for this creative.",
|
|
// "location": "path",
|
|
// "required": true,
|
|
// "type": "string"
|
|
// }
|
|
// },
|
|
// "path": "creatives/{accountId}/{buyerCreativeId}",
|
|
// "response": {
|
|
// "$ref": "Creative"
|
|
// },
|
|
// "scopes": [
|
|
// "https://www.googleapis.com/auth/adexchange.buyer"
|
|
// ]
|
|
// }
|
|
|
|
}
|
|
|
|
// method id "adexchangebuyer.creatives.insert":
|
|
|
|
type CreativesInsertCall struct {
|
|
s *Service
|
|
creative *Creative
|
|
urlParams_ gensupport.URLParams
|
|
ctx_ context.Context
|
|
header_ http.Header
|
|
}
|
|
|
|
// Insert: Submit a new creative.
|
|
func (r *CreativesService) Insert(creative *Creative) *CreativesInsertCall {
|
|
c := &CreativesInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)}
|
|
c.creative = creative
|
|
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 *CreativesInsertCall) Fields(s ...googleapi.Field) *CreativesInsertCall {
|
|
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 *CreativesInsertCall) Context(ctx context.Context) *CreativesInsertCall {
|
|
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 *CreativesInsertCall) Header() http.Header {
|
|
if c.header_ == nil {
|
|
c.header_ = make(http.Header)
|
|
}
|
|
return c.header_
|
|
}
|
|
|
|
func (c *CreativesInsertCall) 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
|
|
body, err := googleapi.WithoutDataWrapper.JSONReader(c.creative)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
reqHeaders.Set("Content-Type", "application/json")
|
|
c.urlParams_.Set("alt", alt)
|
|
urls := googleapi.ResolveRelative(c.s.BasePath, "creatives")
|
|
urls += "?" + c.urlParams_.Encode()
|
|
req, _ := http.NewRequest("POST", urls, body)
|
|
req.Header = reqHeaders
|
|
return gensupport.SendRequest(c.ctx_, c.s.client, req)
|
|
}
|
|
|
|
// Do executes the "adexchangebuyer.creatives.insert" call.
|
|
// Exactly one of *Creative or error will be non-nil. Any non-2xx status
|
|
// code is an error. Response headers are in either
|
|
// *Creative.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 *CreativesInsertCall) Do(opts ...googleapi.CallOption) (*Creative, 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 := &Creative{
|
|
ServerResponse: googleapi.ServerResponse{
|
|
Header: res.Header,
|
|
HTTPStatusCode: res.StatusCode,
|
|
},
|
|
}
|
|
target := &ret
|
|
if err := json.NewDecoder(res.Body).Decode(target); err != nil {
|
|
return nil, err
|
|
}
|
|
return ret, nil
|
|
// {
|
|
// "description": "Submit a new creative.",
|
|
// "httpMethod": "POST",
|
|
// "id": "adexchangebuyer.creatives.insert",
|
|
// "path": "creatives",
|
|
// "request": {
|
|
// "$ref": "Creative"
|
|
// },
|
|
// "response": {
|
|
// "$ref": "Creative"
|
|
// },
|
|
// "scopes": [
|
|
// "https://www.googleapis.com/auth/adexchange.buyer"
|
|
// ]
|
|
// }
|
|
|
|
}
|
|
|
|
// method id "adexchangebuyer.creatives.list":
|
|
|
|
type CreativesListCall struct {
|
|
s *Service
|
|
urlParams_ gensupport.URLParams
|
|
ifNoneMatch_ string
|
|
ctx_ context.Context
|
|
header_ http.Header
|
|
}
|
|
|
|
// List: Retrieves a list of the authenticated user's active creatives.
|
|
// A creative will be available 30-40 minutes after submission.
|
|
func (r *CreativesService) List() *CreativesListCall {
|
|
c := &CreativesListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
|
|
return c
|
|
}
|
|
|
|
// AccountId sets the optional parameter "accountId": When specified,
|
|
// only creatives for the given account ids are returned.
|
|
func (c *CreativesListCall) AccountId(accountId ...int64) *CreativesListCall {
|
|
var accountId_ []string
|
|
for _, v := range accountId {
|
|
accountId_ = append(accountId_, fmt.Sprint(v))
|
|
}
|
|
c.urlParams_.SetMulti("accountId", accountId_)
|
|
return c
|
|
}
|
|
|
|
// BuyerCreativeId sets the optional parameter "buyerCreativeId": When
|
|
// specified, only creatives for the given buyer creative ids are
|
|
// returned.
|
|
func (c *CreativesListCall) BuyerCreativeId(buyerCreativeId ...string) *CreativesListCall {
|
|
c.urlParams_.SetMulti("buyerCreativeId", append([]string{}, buyerCreativeId...))
|
|
return c
|
|
}
|
|
|
|
// MaxResults sets the optional parameter "maxResults": Maximum number
|
|
// of entries returned on one result page. If not set, the default is
|
|
// 100.
|
|
func (c *CreativesListCall) MaxResults(maxResults int64) *CreativesListCall {
|
|
c.urlParams_.Set("maxResults", fmt.Sprint(maxResults))
|
|
return c
|
|
}
|
|
|
|
// PageToken sets the optional parameter "pageToken": A continuation
|
|
// token, used to page through ad clients. To retrieve the next page,
|
|
// set this parameter to the value of "nextPageToken" from the previous
|
|
// response.
|
|
func (c *CreativesListCall) PageToken(pageToken string) *CreativesListCall {
|
|
c.urlParams_.Set("pageToken", pageToken)
|
|
return c
|
|
}
|
|
|
|
// StatusFilter sets the optional parameter "statusFilter": When
|
|
// specified, only creatives having the given status are returned.
|
|
//
|
|
// Possible values:
|
|
// "approved" - Creatives which have been approved.
|
|
// "disapproved" - Creatives which have been disapproved.
|
|
// "not_checked" - Creatives whose status is not yet checked.
|
|
func (c *CreativesListCall) StatusFilter(statusFilter string) *CreativesListCall {
|
|
c.urlParams_.Set("statusFilter", statusFilter)
|
|
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 *CreativesListCall) Fields(s ...googleapi.Field) *CreativesListCall {
|
|
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 *CreativesListCall) IfNoneMatch(entityTag string) *CreativesListCall {
|
|
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 *CreativesListCall) Context(ctx context.Context) *CreativesListCall {
|
|
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 *CreativesListCall) Header() http.Header {
|
|
if c.header_ == nil {
|
|
c.header_ = make(http.Header)
|
|
}
|
|
return c.header_
|
|
}
|
|
|
|
func (c *CreativesListCall) 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, "creatives")
|
|
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 "adexchangebuyer.creatives.list" call.
|
|
// Exactly one of *CreativesList or error will be non-nil. Any non-2xx
|
|
// status code is an error. Response headers are in either
|
|
// *CreativesList.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 *CreativesListCall) Do(opts ...googleapi.CallOption) (*CreativesList, 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 := &CreativesList{
|
|
ServerResponse: googleapi.ServerResponse{
|
|
Header: res.Header,
|
|
HTTPStatusCode: res.StatusCode,
|
|
},
|
|
}
|
|
target := &ret
|
|
if err := json.NewDecoder(res.Body).Decode(target); err != nil {
|
|
return nil, err
|
|
}
|
|
return ret, nil
|
|
// {
|
|
// "description": "Retrieves a list of the authenticated user's active creatives. A creative will be available 30-40 minutes after submission.",
|
|
// "httpMethod": "GET",
|
|
// "id": "adexchangebuyer.creatives.list",
|
|
// "parameters": {
|
|
// "accountId": {
|
|
// "description": "When specified, only creatives for the given account ids are returned.",
|
|
// "format": "int32",
|
|
// "location": "query",
|
|
// "repeated": true,
|
|
// "type": "integer"
|
|
// },
|
|
// "buyerCreativeId": {
|
|
// "description": "When specified, only creatives for the given buyer creative ids are returned.",
|
|
// "location": "query",
|
|
// "repeated": true,
|
|
// "type": "string"
|
|
// },
|
|
// "maxResults": {
|
|
// "description": "Maximum number of entries returned on one result page. If not set, the default is 100. Optional.",
|
|
// "format": "uint32",
|
|
// "location": "query",
|
|
// "maximum": "1000",
|
|
// "minimum": "1",
|
|
// "type": "integer"
|
|
// },
|
|
// "pageToken": {
|
|
// "description": "A continuation token, used to page through ad clients. To retrieve the next page, set this parameter to the value of \"nextPageToken\" from the previous response. Optional.",
|
|
// "location": "query",
|
|
// "type": "string"
|
|
// },
|
|
// "statusFilter": {
|
|
// "description": "When specified, only creatives having the given status are returned.",
|
|
// "enum": [
|
|
// "approved",
|
|
// "disapproved",
|
|
// "not_checked"
|
|
// ],
|
|
// "enumDescriptions": [
|
|
// "Creatives which have been approved.",
|
|
// "Creatives which have been disapproved.",
|
|
// "Creatives whose status is not yet checked."
|
|
// ],
|
|
// "location": "query",
|
|
// "type": "string"
|
|
// }
|
|
// },
|
|
// "path": "creatives",
|
|
// "response": {
|
|
// "$ref": "CreativesList"
|
|
// },
|
|
// "scopes": [
|
|
// "https://www.googleapis.com/auth/adexchange.buyer"
|
|
// ]
|
|
// }
|
|
|
|
}
|
|
|
|
// Pages invokes f for each page of results.
|
|
// A non-nil error returned from f will halt the iteration.
|
|
// The provided context supersedes any context provided to the Context method.
|
|
func (c *CreativesListCall) Pages(ctx context.Context, f func(*CreativesList) error) error {
|
|
c.ctx_ = ctx
|
|
defer c.PageToken(c.urlParams_.Get("pageToken")) // reset paging to original point
|
|
for {
|
|
x, err := c.Do()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if err := f(x); err != nil {
|
|
return err
|
|
}
|
|
if x.NextPageToken == "" {
|
|
return nil
|
|
}
|
|
c.PageToken(x.NextPageToken)
|
|
}
|
|
}
|
|
|
|
// method id "adexchangebuyer.directDeals.get":
|
|
|
|
type DirectDealsGetCall struct {
|
|
s *Service
|
|
id int64
|
|
urlParams_ gensupport.URLParams
|
|
ifNoneMatch_ string
|
|
ctx_ context.Context
|
|
header_ http.Header
|
|
}
|
|
|
|
// Get: Gets one direct deal by ID.
|
|
func (r *DirectDealsService) Get(id int64) *DirectDealsGetCall {
|
|
c := &DirectDealsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
|
|
c.id = id
|
|
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 *DirectDealsGetCall) Fields(s ...googleapi.Field) *DirectDealsGetCall {
|
|
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 *DirectDealsGetCall) IfNoneMatch(entityTag string) *DirectDealsGetCall {
|
|
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 *DirectDealsGetCall) Context(ctx context.Context) *DirectDealsGetCall {
|
|
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 *DirectDealsGetCall) Header() http.Header {
|
|
if c.header_ == nil {
|
|
c.header_ = make(http.Header)
|
|
}
|
|
return c.header_
|
|
}
|
|
|
|
func (c *DirectDealsGetCall) 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, "directdeals/{id}")
|
|
urls += "?" + c.urlParams_.Encode()
|
|
req, _ := http.NewRequest("GET", urls, body)
|
|
req.Header = reqHeaders
|
|
googleapi.Expand(req.URL, map[string]string{
|
|
"id": strconv.FormatInt(c.id, 10),
|
|
})
|
|
return gensupport.SendRequest(c.ctx_, c.s.client, req)
|
|
}
|
|
|
|
// Do executes the "adexchangebuyer.directDeals.get" call.
|
|
// Exactly one of *DirectDeal or error will be non-nil. Any non-2xx
|
|
// status code is an error. Response headers are in either
|
|
// *DirectDeal.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 *DirectDealsGetCall) Do(opts ...googleapi.CallOption) (*DirectDeal, 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 := &DirectDeal{
|
|
ServerResponse: googleapi.ServerResponse{
|
|
Header: res.Header,
|
|
HTTPStatusCode: res.StatusCode,
|
|
},
|
|
}
|
|
target := &ret
|
|
if err := json.NewDecoder(res.Body).Decode(target); err != nil {
|
|
return nil, err
|
|
}
|
|
return ret, nil
|
|
// {
|
|
// "description": "Gets one direct deal by ID.",
|
|
// "httpMethod": "GET",
|
|
// "id": "adexchangebuyer.directDeals.get",
|
|
// "parameterOrder": [
|
|
// "id"
|
|
// ],
|
|
// "parameters": {
|
|
// "id": {
|
|
// "description": "The direct deal id",
|
|
// "format": "int64",
|
|
// "location": "path",
|
|
// "required": true,
|
|
// "type": "string"
|
|
// }
|
|
// },
|
|
// "path": "directdeals/{id}",
|
|
// "response": {
|
|
// "$ref": "DirectDeal"
|
|
// },
|
|
// "scopes": [
|
|
// "https://www.googleapis.com/auth/adexchange.buyer"
|
|
// ]
|
|
// }
|
|
|
|
}
|
|
|
|
// method id "adexchangebuyer.directDeals.list":
|
|
|
|
type DirectDealsListCall struct {
|
|
s *Service
|
|
urlParams_ gensupport.URLParams
|
|
ifNoneMatch_ string
|
|
ctx_ context.Context
|
|
header_ http.Header
|
|
}
|
|
|
|
// List: Retrieves the authenticated user's list of direct deals.
|
|
func (r *DirectDealsService) List() *DirectDealsListCall {
|
|
c := &DirectDealsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
|
|
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 *DirectDealsListCall) Fields(s ...googleapi.Field) *DirectDealsListCall {
|
|
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 *DirectDealsListCall) IfNoneMatch(entityTag string) *DirectDealsListCall {
|
|
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 *DirectDealsListCall) Context(ctx context.Context) *DirectDealsListCall {
|
|
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 *DirectDealsListCall) Header() http.Header {
|
|
if c.header_ == nil {
|
|
c.header_ = make(http.Header)
|
|
}
|
|
return c.header_
|
|
}
|
|
|
|
func (c *DirectDealsListCall) 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, "directdeals")
|
|
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 "adexchangebuyer.directDeals.list" call.
|
|
// Exactly one of *DirectDealsList or error will be non-nil. Any non-2xx
|
|
// status code is an error. Response headers are in either
|
|
// *DirectDealsList.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 *DirectDealsListCall) Do(opts ...googleapi.CallOption) (*DirectDealsList, 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 := &DirectDealsList{
|
|
ServerResponse: googleapi.ServerResponse{
|
|
Header: res.Header,
|
|
HTTPStatusCode: res.StatusCode,
|
|
},
|
|
}
|
|
target := &ret
|
|
if err := json.NewDecoder(res.Body).Decode(target); err != nil {
|
|
return nil, err
|
|
}
|
|
return ret, nil
|
|
// {
|
|
// "description": "Retrieves the authenticated user's list of direct deals.",
|
|
// "httpMethod": "GET",
|
|
// "id": "adexchangebuyer.directDeals.list",
|
|
// "path": "directdeals",
|
|
// "response": {
|
|
// "$ref": "DirectDealsList"
|
|
// },
|
|
// "scopes": [
|
|
// "https://www.googleapis.com/auth/adexchange.buyer"
|
|
// ]
|
|
// }
|
|
|
|
}
|
|
|
|
// method id "adexchangebuyer.performanceReport.list":
|
|
|
|
type PerformanceReportListCall struct {
|
|
s *Service
|
|
urlParams_ gensupport.URLParams
|
|
ifNoneMatch_ string
|
|
ctx_ context.Context
|
|
header_ http.Header
|
|
}
|
|
|
|
// List: Retrieves the authenticated user's list of performance metrics.
|
|
func (r *PerformanceReportService) List(accountId int64, endDateTime string, startDateTime string) *PerformanceReportListCall {
|
|
c := &PerformanceReportListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
|
|
c.urlParams_.Set("accountId", fmt.Sprint(accountId))
|
|
c.urlParams_.Set("endDateTime", endDateTime)
|
|
c.urlParams_.Set("startDateTime", startDateTime)
|
|
return c
|
|
}
|
|
|
|
// MaxResults sets the optional parameter "maxResults": Maximum number
|
|
// of entries returned on one result page. If not set, the default is
|
|
// 100.
|
|
func (c *PerformanceReportListCall) MaxResults(maxResults int64) *PerformanceReportListCall {
|
|
c.urlParams_.Set("maxResults", fmt.Sprint(maxResults))
|
|
return c
|
|
}
|
|
|
|
// PageToken sets the optional parameter "pageToken": A continuation
|
|
// token, used to page through performance reports. To retrieve the next
|
|
// page, set this parameter to the value of "nextPageToken" from the
|
|
// previous response.
|
|
func (c *PerformanceReportListCall) PageToken(pageToken string) *PerformanceReportListCall {
|
|
c.urlParams_.Set("pageToken", pageToken)
|
|
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 *PerformanceReportListCall) Fields(s ...googleapi.Field) *PerformanceReportListCall {
|
|
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 *PerformanceReportListCall) IfNoneMatch(entityTag string) *PerformanceReportListCall {
|
|
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 *PerformanceReportListCall) Context(ctx context.Context) *PerformanceReportListCall {
|
|
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 *PerformanceReportListCall) Header() http.Header {
|
|
if c.header_ == nil {
|
|
c.header_ = make(http.Header)
|
|
}
|
|
return c.header_
|
|
}
|
|
|
|
func (c *PerformanceReportListCall) 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, "performancereport")
|
|
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 "adexchangebuyer.performanceReport.list" call.
|
|
// Exactly one of *PerformanceReportList or error will be non-nil. Any
|
|
// non-2xx status code is an error. Response headers are in either
|
|
// *PerformanceReportList.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 *PerformanceReportListCall) Do(opts ...googleapi.CallOption) (*PerformanceReportList, 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 := &PerformanceReportList{
|
|
ServerResponse: googleapi.ServerResponse{
|
|
Header: res.Header,
|
|
HTTPStatusCode: res.StatusCode,
|
|
},
|
|
}
|
|
target := &ret
|
|
if err := json.NewDecoder(res.Body).Decode(target); err != nil {
|
|
return nil, err
|
|
}
|
|
return ret, nil
|
|
// {
|
|
// "description": "Retrieves the authenticated user's list of performance metrics.",
|
|
// "httpMethod": "GET",
|
|
// "id": "adexchangebuyer.performanceReport.list",
|
|
// "parameterOrder": [
|
|
// "accountId",
|
|
// "endDateTime",
|
|
// "startDateTime"
|
|
// ],
|
|
// "parameters": {
|
|
// "accountId": {
|
|
// "description": "The account id to get the reports.",
|
|
// "format": "int64",
|
|
// "location": "query",
|
|
// "required": true,
|
|
// "type": "string"
|
|
// },
|
|
// "endDateTime": {
|
|
// "description": "The end time of the report in ISO 8601 timestamp format using UTC.",
|
|
// "location": "query",
|
|
// "required": true,
|
|
// "type": "string"
|
|
// },
|
|
// "maxResults": {
|
|
// "description": "Maximum number of entries returned on one result page. If not set, the default is 100. Optional.",
|
|
// "format": "uint32",
|
|
// "location": "query",
|
|
// "maximum": "1000",
|
|
// "minimum": "1",
|
|
// "type": "integer"
|
|
// },
|
|
// "pageToken": {
|
|
// "description": "A continuation token, used to page through performance reports. To retrieve the next page, set this parameter to the value of \"nextPageToken\" from the previous response. Optional.",
|
|
// "location": "query",
|
|
// "type": "string"
|
|
// },
|
|
// "startDateTime": {
|
|
// "description": "The start time of the report in ISO 8601 timestamp format using UTC.",
|
|
// "location": "query",
|
|
// "required": true,
|
|
// "type": "string"
|
|
// }
|
|
// },
|
|
// "path": "performancereport",
|
|
// "response": {
|
|
// "$ref": "PerformanceReportList"
|
|
// },
|
|
// "scopes": [
|
|
// "https://www.googleapis.com/auth/adexchange.buyer"
|
|
// ]
|
|
// }
|
|
|
|
}
|
|
|
|
// method id "adexchangebuyer.pretargetingConfig.delete":
|
|
|
|
type PretargetingConfigDeleteCall struct {
|
|
s *Service
|
|
accountId int64
|
|
configId int64
|
|
urlParams_ gensupport.URLParams
|
|
ctx_ context.Context
|
|
header_ http.Header
|
|
}
|
|
|
|
// Delete: Deletes an existing pretargeting config.
|
|
func (r *PretargetingConfigService) Delete(accountId int64, configId int64) *PretargetingConfigDeleteCall {
|
|
c := &PretargetingConfigDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
|
|
c.accountId = accountId
|
|
c.configId = configId
|
|
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 *PretargetingConfigDeleteCall) Fields(s ...googleapi.Field) *PretargetingConfigDeleteCall {
|
|
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 *PretargetingConfigDeleteCall) Context(ctx context.Context) *PretargetingConfigDeleteCall {
|
|
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 *PretargetingConfigDeleteCall) Header() http.Header {
|
|
if c.header_ == nil {
|
|
c.header_ = make(http.Header)
|
|
}
|
|
return c.header_
|
|
}
|
|
|
|
func (c *PretargetingConfigDeleteCall) 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, "pretargetingconfigs/{accountId}/{configId}")
|
|
urls += "?" + c.urlParams_.Encode()
|
|
req, _ := http.NewRequest("DELETE", urls, body)
|
|
req.Header = reqHeaders
|
|
googleapi.Expand(req.URL, map[string]string{
|
|
"accountId": strconv.FormatInt(c.accountId, 10),
|
|
"configId": strconv.FormatInt(c.configId, 10),
|
|
})
|
|
return gensupport.SendRequest(c.ctx_, c.s.client, req)
|
|
}
|
|
|
|
// Do executes the "adexchangebuyer.pretargetingConfig.delete" call.
|
|
func (c *PretargetingConfigDeleteCall) 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": "Deletes an existing pretargeting config.",
|
|
// "httpMethod": "DELETE",
|
|
// "id": "adexchangebuyer.pretargetingConfig.delete",
|
|
// "parameterOrder": [
|
|
// "accountId",
|
|
// "configId"
|
|
// ],
|
|
// "parameters": {
|
|
// "accountId": {
|
|
// "description": "The account id to delete the pretargeting config for.",
|
|
// "format": "int64",
|
|
// "location": "path",
|
|
// "required": true,
|
|
// "type": "string"
|
|
// },
|
|
// "configId": {
|
|
// "description": "The specific id of the configuration to delete.",
|
|
// "format": "int64",
|
|
// "location": "path",
|
|
// "required": true,
|
|
// "type": "string"
|
|
// }
|
|
// },
|
|
// "path": "pretargetingconfigs/{accountId}/{configId}",
|
|
// "scopes": [
|
|
// "https://www.googleapis.com/auth/adexchange.buyer"
|
|
// ]
|
|
// }
|
|
|
|
}
|
|
|
|
// method id "adexchangebuyer.pretargetingConfig.get":
|
|
|
|
type PretargetingConfigGetCall struct {
|
|
s *Service
|
|
accountId int64
|
|
configId int64
|
|
urlParams_ gensupport.URLParams
|
|
ifNoneMatch_ string
|
|
ctx_ context.Context
|
|
header_ http.Header
|
|
}
|
|
|
|
// Get: Gets a specific pretargeting configuration
|
|
func (r *PretargetingConfigService) Get(accountId int64, configId int64) *PretargetingConfigGetCall {
|
|
c := &PretargetingConfigGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
|
|
c.accountId = accountId
|
|
c.configId = configId
|
|
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 *PretargetingConfigGetCall) Fields(s ...googleapi.Field) *PretargetingConfigGetCall {
|
|
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 *PretargetingConfigGetCall) IfNoneMatch(entityTag string) *PretargetingConfigGetCall {
|
|
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 *PretargetingConfigGetCall) Context(ctx context.Context) *PretargetingConfigGetCall {
|
|
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 *PretargetingConfigGetCall) Header() http.Header {
|
|
if c.header_ == nil {
|
|
c.header_ = make(http.Header)
|
|
}
|
|
return c.header_
|
|
}
|
|
|
|
func (c *PretargetingConfigGetCall) 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, "pretargetingconfigs/{accountId}/{configId}")
|
|
urls += "?" + c.urlParams_.Encode()
|
|
req, _ := http.NewRequest("GET", urls, body)
|
|
req.Header = reqHeaders
|
|
googleapi.Expand(req.URL, map[string]string{
|
|
"accountId": strconv.FormatInt(c.accountId, 10),
|
|
"configId": strconv.FormatInt(c.configId, 10),
|
|
})
|
|
return gensupport.SendRequest(c.ctx_, c.s.client, req)
|
|
}
|
|
|
|
// Do executes the "adexchangebuyer.pretargetingConfig.get" call.
|
|
// Exactly one of *PretargetingConfig or error will be non-nil. Any
|
|
// non-2xx status code is an error. Response headers are in either
|
|
// *PretargetingConfig.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 *PretargetingConfigGetCall) Do(opts ...googleapi.CallOption) (*PretargetingConfig, 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 := &PretargetingConfig{
|
|
ServerResponse: googleapi.ServerResponse{
|
|
Header: res.Header,
|
|
HTTPStatusCode: res.StatusCode,
|
|
},
|
|
}
|
|
target := &ret
|
|
if err := json.NewDecoder(res.Body).Decode(target); err != nil {
|
|
return nil, err
|
|
}
|
|
return ret, nil
|
|
// {
|
|
// "description": "Gets a specific pretargeting configuration",
|
|
// "httpMethod": "GET",
|
|
// "id": "adexchangebuyer.pretargetingConfig.get",
|
|
// "parameterOrder": [
|
|
// "accountId",
|
|
// "configId"
|
|
// ],
|
|
// "parameters": {
|
|
// "accountId": {
|
|
// "description": "The account id to get the pretargeting config for.",
|
|
// "format": "int64",
|
|
// "location": "path",
|
|
// "required": true,
|
|
// "type": "string"
|
|
// },
|
|
// "configId": {
|
|
// "description": "The specific id of the configuration to retrieve.",
|
|
// "format": "int64",
|
|
// "location": "path",
|
|
// "required": true,
|
|
// "type": "string"
|
|
// }
|
|
// },
|
|
// "path": "pretargetingconfigs/{accountId}/{configId}",
|
|
// "response": {
|
|
// "$ref": "PretargetingConfig"
|
|
// },
|
|
// "scopes": [
|
|
// "https://www.googleapis.com/auth/adexchange.buyer"
|
|
// ]
|
|
// }
|
|
|
|
}
|
|
|
|
// method id "adexchangebuyer.pretargetingConfig.insert":
|
|
|
|
type PretargetingConfigInsertCall struct {
|
|
s *Service
|
|
accountId int64
|
|
pretargetingconfig *PretargetingConfig
|
|
urlParams_ gensupport.URLParams
|
|
ctx_ context.Context
|
|
header_ http.Header
|
|
}
|
|
|
|
// Insert: Inserts a new pretargeting configuration.
|
|
func (r *PretargetingConfigService) Insert(accountId int64, pretargetingconfig *PretargetingConfig) *PretargetingConfigInsertCall {
|
|
c := &PretargetingConfigInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)}
|
|
c.accountId = accountId
|
|
c.pretargetingconfig = pretargetingconfig
|
|
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 *PretargetingConfigInsertCall) Fields(s ...googleapi.Field) *PretargetingConfigInsertCall {
|
|
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 *PretargetingConfigInsertCall) Context(ctx context.Context) *PretargetingConfigInsertCall {
|
|
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 *PretargetingConfigInsertCall) Header() http.Header {
|
|
if c.header_ == nil {
|
|
c.header_ = make(http.Header)
|
|
}
|
|
return c.header_
|
|
}
|
|
|
|
func (c *PretargetingConfigInsertCall) 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
|
|
body, err := googleapi.WithoutDataWrapper.JSONReader(c.pretargetingconfig)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
reqHeaders.Set("Content-Type", "application/json")
|
|
c.urlParams_.Set("alt", alt)
|
|
urls := googleapi.ResolveRelative(c.s.BasePath, "pretargetingconfigs/{accountId}")
|
|
urls += "?" + c.urlParams_.Encode()
|
|
req, _ := http.NewRequest("POST", urls, body)
|
|
req.Header = reqHeaders
|
|
googleapi.Expand(req.URL, map[string]string{
|
|
"accountId": strconv.FormatInt(c.accountId, 10),
|
|
})
|
|
return gensupport.SendRequest(c.ctx_, c.s.client, req)
|
|
}
|
|
|
|
// Do executes the "adexchangebuyer.pretargetingConfig.insert" call.
|
|
// Exactly one of *PretargetingConfig or error will be non-nil. Any
|
|
// non-2xx status code is an error. Response headers are in either
|
|
// *PretargetingConfig.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 *PretargetingConfigInsertCall) Do(opts ...googleapi.CallOption) (*PretargetingConfig, 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 := &PretargetingConfig{
|
|
ServerResponse: googleapi.ServerResponse{
|
|
Header: res.Header,
|
|
HTTPStatusCode: res.StatusCode,
|
|
},
|
|
}
|
|
target := &ret
|
|
if err := json.NewDecoder(res.Body).Decode(target); err != nil {
|
|
return nil, err
|
|
}
|
|
return ret, nil
|
|
// {
|
|
// "description": "Inserts a new pretargeting configuration.",
|
|
// "httpMethod": "POST",
|
|
// "id": "adexchangebuyer.pretargetingConfig.insert",
|
|
// "parameterOrder": [
|
|
// "accountId"
|
|
// ],
|
|
// "parameters": {
|
|
// "accountId": {
|
|
// "description": "The account id to insert the pretargeting config for.",
|
|
// "format": "int64",
|
|
// "location": "path",
|
|
// "required": true,
|
|
// "type": "string"
|
|
// }
|
|
// },
|
|
// "path": "pretargetingconfigs/{accountId}",
|
|
// "request": {
|
|
// "$ref": "PretargetingConfig"
|
|
// },
|
|
// "response": {
|
|
// "$ref": "PretargetingConfig"
|
|
// },
|
|
// "scopes": [
|
|
// "https://www.googleapis.com/auth/adexchange.buyer"
|
|
// ]
|
|
// }
|
|
|
|
}
|
|
|
|
// method id "adexchangebuyer.pretargetingConfig.list":
|
|
|
|
type PretargetingConfigListCall struct {
|
|
s *Service
|
|
accountId int64
|
|
urlParams_ gensupport.URLParams
|
|
ifNoneMatch_ string
|
|
ctx_ context.Context
|
|
header_ http.Header
|
|
}
|
|
|
|
// List: Retrieves a list of the authenticated user's pretargeting
|
|
// configurations.
|
|
func (r *PretargetingConfigService) List(accountId int64) *PretargetingConfigListCall {
|
|
c := &PretargetingConfigListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
|
|
c.accountId = accountId
|
|
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 *PretargetingConfigListCall) Fields(s ...googleapi.Field) *PretargetingConfigListCall {
|
|
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 *PretargetingConfigListCall) IfNoneMatch(entityTag string) *PretargetingConfigListCall {
|
|
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 *PretargetingConfigListCall) Context(ctx context.Context) *PretargetingConfigListCall {
|
|
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 *PretargetingConfigListCall) Header() http.Header {
|
|
if c.header_ == nil {
|
|
c.header_ = make(http.Header)
|
|
}
|
|
return c.header_
|
|
}
|
|
|
|
func (c *PretargetingConfigListCall) 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, "pretargetingconfigs/{accountId}")
|
|
urls += "?" + c.urlParams_.Encode()
|
|
req, _ := http.NewRequest("GET", urls, body)
|
|
req.Header = reqHeaders
|
|
googleapi.Expand(req.URL, map[string]string{
|
|
"accountId": strconv.FormatInt(c.accountId, 10),
|
|
})
|
|
return gensupport.SendRequest(c.ctx_, c.s.client, req)
|
|
}
|
|
|
|
// Do executes the "adexchangebuyer.pretargetingConfig.list" call.
|
|
// Exactly one of *PretargetingConfigList or error will be non-nil. Any
|
|
// non-2xx status code is an error. Response headers are in either
|
|
// *PretargetingConfigList.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 *PretargetingConfigListCall) Do(opts ...googleapi.CallOption) (*PretargetingConfigList, 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 := &PretargetingConfigList{
|
|
ServerResponse: googleapi.ServerResponse{
|
|
Header: res.Header,
|
|
HTTPStatusCode: res.StatusCode,
|
|
},
|
|
}
|
|
target := &ret
|
|
if err := json.NewDecoder(res.Body).Decode(target); err != nil {
|
|
return nil, err
|
|
}
|
|
return ret, nil
|
|
// {
|
|
// "description": "Retrieves a list of the authenticated user's pretargeting configurations.",
|
|
// "httpMethod": "GET",
|
|
// "id": "adexchangebuyer.pretargetingConfig.list",
|
|
// "parameterOrder": [
|
|
// "accountId"
|
|
// ],
|
|
// "parameters": {
|
|
// "accountId": {
|
|
// "description": "The account id to get the pretargeting configs for.",
|
|
// "format": "int64",
|
|
// "location": "path",
|
|
// "required": true,
|
|
// "type": "string"
|
|
// }
|
|
// },
|
|
// "path": "pretargetingconfigs/{accountId}",
|
|
// "response": {
|
|
// "$ref": "PretargetingConfigList"
|
|
// },
|
|
// "scopes": [
|
|
// "https://www.googleapis.com/auth/adexchange.buyer"
|
|
// ]
|
|
// }
|
|
|
|
}
|
|
|
|
// method id "adexchangebuyer.pretargetingConfig.patch":
|
|
|
|
type PretargetingConfigPatchCall struct {
|
|
s *Service
|
|
accountId int64
|
|
configId int64
|
|
pretargetingconfig *PretargetingConfig
|
|
urlParams_ gensupport.URLParams
|
|
ctx_ context.Context
|
|
header_ http.Header
|
|
}
|
|
|
|
// Patch: Updates an existing pretargeting config. This method supports
|
|
// patch semantics.
|
|
func (r *PretargetingConfigService) Patch(accountId int64, configId int64, pretargetingconfig *PretargetingConfig) *PretargetingConfigPatchCall {
|
|
c := &PretargetingConfigPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
|
|
c.accountId = accountId
|
|
c.configId = configId
|
|
c.pretargetingconfig = pretargetingconfig
|
|
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 *PretargetingConfigPatchCall) Fields(s ...googleapi.Field) *PretargetingConfigPatchCall {
|
|
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 *PretargetingConfigPatchCall) Context(ctx context.Context) *PretargetingConfigPatchCall {
|
|
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 *PretargetingConfigPatchCall) Header() http.Header {
|
|
if c.header_ == nil {
|
|
c.header_ = make(http.Header)
|
|
}
|
|
return c.header_
|
|
}
|
|
|
|
func (c *PretargetingConfigPatchCall) 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
|
|
body, err := googleapi.WithoutDataWrapper.JSONReader(c.pretargetingconfig)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
reqHeaders.Set("Content-Type", "application/json")
|
|
c.urlParams_.Set("alt", alt)
|
|
urls := googleapi.ResolveRelative(c.s.BasePath, "pretargetingconfigs/{accountId}/{configId}")
|
|
urls += "?" + c.urlParams_.Encode()
|
|
req, _ := http.NewRequest("PATCH", urls, body)
|
|
req.Header = reqHeaders
|
|
googleapi.Expand(req.URL, map[string]string{
|
|
"accountId": strconv.FormatInt(c.accountId, 10),
|
|
"configId": strconv.FormatInt(c.configId, 10),
|
|
})
|
|
return gensupport.SendRequest(c.ctx_, c.s.client, req)
|
|
}
|
|
|
|
// Do executes the "adexchangebuyer.pretargetingConfig.patch" call.
|
|
// Exactly one of *PretargetingConfig or error will be non-nil. Any
|
|
// non-2xx status code is an error. Response headers are in either
|
|
// *PretargetingConfig.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 *PretargetingConfigPatchCall) Do(opts ...googleapi.CallOption) (*PretargetingConfig, 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 := &PretargetingConfig{
|
|
ServerResponse: googleapi.ServerResponse{
|
|
Header: res.Header,
|
|
HTTPStatusCode: res.StatusCode,
|
|
},
|
|
}
|
|
target := &ret
|
|
if err := json.NewDecoder(res.Body).Decode(target); err != nil {
|
|
return nil, err
|
|
}
|
|
return ret, nil
|
|
// {
|
|
// "description": "Updates an existing pretargeting config. This method supports patch semantics.",
|
|
// "httpMethod": "PATCH",
|
|
// "id": "adexchangebuyer.pretargetingConfig.patch",
|
|
// "parameterOrder": [
|
|
// "accountId",
|
|
// "configId"
|
|
// ],
|
|
// "parameters": {
|
|
// "accountId": {
|
|
// "description": "The account id to update the pretargeting config for.",
|
|
// "format": "int64",
|
|
// "location": "path",
|
|
// "required": true,
|
|
// "type": "string"
|
|
// },
|
|
// "configId": {
|
|
// "description": "The specific id of the configuration to update.",
|
|
// "format": "int64",
|
|
// "location": "path",
|
|
// "required": true,
|
|
// "type": "string"
|
|
// }
|
|
// },
|
|
// "path": "pretargetingconfigs/{accountId}/{configId}",
|
|
// "request": {
|
|
// "$ref": "PretargetingConfig"
|
|
// },
|
|
// "response": {
|
|
// "$ref": "PretargetingConfig"
|
|
// },
|
|
// "scopes": [
|
|
// "https://www.googleapis.com/auth/adexchange.buyer"
|
|
// ]
|
|
// }
|
|
|
|
}
|
|
|
|
// method id "adexchangebuyer.pretargetingConfig.update":
|
|
|
|
type PretargetingConfigUpdateCall struct {
|
|
s *Service
|
|
accountId int64
|
|
configId int64
|
|
pretargetingconfig *PretargetingConfig
|
|
urlParams_ gensupport.URLParams
|
|
ctx_ context.Context
|
|
header_ http.Header
|
|
}
|
|
|
|
// Update: Updates an existing pretargeting config.
|
|
func (r *PretargetingConfigService) Update(accountId int64, configId int64, pretargetingconfig *PretargetingConfig) *PretargetingConfigUpdateCall {
|
|
c := &PretargetingConfigUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
|
|
c.accountId = accountId
|
|
c.configId = configId
|
|
c.pretargetingconfig = pretargetingconfig
|
|
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 *PretargetingConfigUpdateCall) Fields(s ...googleapi.Field) *PretargetingConfigUpdateCall {
|
|
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 *PretargetingConfigUpdateCall) Context(ctx context.Context) *PretargetingConfigUpdateCall {
|
|
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 *PretargetingConfigUpdateCall) Header() http.Header {
|
|
if c.header_ == nil {
|
|
c.header_ = make(http.Header)
|
|
}
|
|
return c.header_
|
|
}
|
|
|
|
func (c *PretargetingConfigUpdateCall) 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
|
|
body, err := googleapi.WithoutDataWrapper.JSONReader(c.pretargetingconfig)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
reqHeaders.Set("Content-Type", "application/json")
|
|
c.urlParams_.Set("alt", alt)
|
|
urls := googleapi.ResolveRelative(c.s.BasePath, "pretargetingconfigs/{accountId}/{configId}")
|
|
urls += "?" + c.urlParams_.Encode()
|
|
req, _ := http.NewRequest("PUT", urls, body)
|
|
req.Header = reqHeaders
|
|
googleapi.Expand(req.URL, map[string]string{
|
|
"accountId": strconv.FormatInt(c.accountId, 10),
|
|
"configId": strconv.FormatInt(c.configId, 10),
|
|
})
|
|
return gensupport.SendRequest(c.ctx_, c.s.client, req)
|
|
}
|
|
|
|
// Do executes the "adexchangebuyer.pretargetingConfig.update" call.
|
|
// Exactly one of *PretargetingConfig or error will be non-nil. Any
|
|
// non-2xx status code is an error. Response headers are in either
|
|
// *PretargetingConfig.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 *PretargetingConfigUpdateCall) Do(opts ...googleapi.CallOption) (*PretargetingConfig, 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 := &PretargetingConfig{
|
|
ServerResponse: googleapi.ServerResponse{
|
|
Header: res.Header,
|
|
HTTPStatusCode: res.StatusCode,
|
|
},
|
|
}
|
|
target := &ret
|
|
if err := json.NewDecoder(res.Body).Decode(target); err != nil {
|
|
return nil, err
|
|
}
|
|
return ret, nil
|
|
// {
|
|
// "description": "Updates an existing pretargeting config.",
|
|
// "httpMethod": "PUT",
|
|
// "id": "adexchangebuyer.pretargetingConfig.update",
|
|
// "parameterOrder": [
|
|
// "accountId",
|
|
// "configId"
|
|
// ],
|
|
// "parameters": {
|
|
// "accountId": {
|
|
// "description": "The account id to update the pretargeting config for.",
|
|
// "format": "int64",
|
|
// "location": "path",
|
|
// "required": true,
|
|
// "type": "string"
|
|
// },
|
|
// "configId": {
|
|
// "description": "The specific id of the configuration to update.",
|
|
// "format": "int64",
|
|
// "location": "path",
|
|
// "required": true,
|
|
// "type": "string"
|
|
// }
|
|
// },
|
|
// "path": "pretargetingconfigs/{accountId}/{configId}",
|
|
// "request": {
|
|
// "$ref": "PretargetingConfig"
|
|
// },
|
|
// "response": {
|
|
// "$ref": "PretargetingConfig"
|
|
// },
|
|
// "scopes": [
|
|
// "https://www.googleapis.com/auth/adexchange.buyer"
|
|
// ]
|
|
// }
|
|
|
|
}
|