2016-05-16 16:49:15 +00:00
|
|
|
# Copyright 2015 Google Inc.
|
|
|
|
#
|
|
|
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
|
|
|
# you may not use this file except in compliance with the License.
|
|
|
|
# You may obtain a copy of the License at
|
|
|
|
#
|
|
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
#
|
|
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
|
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
|
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
|
|
# See the License for the specific language governing permissions and
|
|
|
|
# limitations under the License.
|
|
|
|
|
|
|
|
require 'date'
|
|
|
|
require 'google/apis/core/base_service'
|
|
|
|
require 'google/apis/core/json_representation'
|
|
|
|
require 'google/apis/core/hashable'
|
|
|
|
require 'google/apis/errors'
|
|
|
|
|
|
|
|
module Google
|
|
|
|
module Apis
|
|
|
|
module AnalyticsreportingV4
|
|
|
|
|
2019-03-20 00:37:12 +00:00
|
|
|
# An Activity represents data for an activity of a user. Note that an
|
|
|
|
# Activity is different from a hit.
|
|
|
|
# A hit might result in multiple Activity's. For example, if a hit
|
|
|
|
# includes a transaction and a goal completion, there will be two
|
|
|
|
# Activity protos for this hit, one for ECOMMERCE and one for GOAL.
|
|
|
|
# Conversely, multiple hits can also construct one Activity. In classic
|
|
|
|
# e-commerce, data for one transaction might be sent through multiple hits.
|
|
|
|
# These hits will be merged into one ECOMMERCE Activity.
|
|
|
|
class Activity
|
|
|
|
include Google::Apis::Core::Hashable
|
|
|
|
|
|
|
|
# Timestamp of the activity.
|
|
|
|
# Corresponds to the JSON property `activityTime`
|
|
|
|
# @return [String]
|
|
|
|
attr_accessor :activity_time
|
|
|
|
|
|
|
|
# Type of this activity.
|
|
|
|
# Corresponds to the JSON property `activityType`
|
|
|
|
# @return [String]
|
|
|
|
attr_accessor :activity_type
|
|
|
|
|
|
|
|
# This will be set if `activity_type` equals `SCREEN_VIEW`.
|
|
|
|
# Corresponds to the JSON property `appview`
|
|
|
|
# @return [Google::Apis::AnalyticsreportingV4::ScreenviewData]
|
|
|
|
attr_accessor :appview
|
|
|
|
|
|
|
|
# For manual campaign tracking, it is the value of the utm_campaign campaign
|
|
|
|
# tracking parameter. For AdWords autotagging, it is the name(s) of the
|
|
|
|
# online ad campaign(s) you use for the property. If you use neither, its
|
|
|
|
# value is (not set).
|
|
|
|
# Corresponds to the JSON property `campaign`
|
|
|
|
# @return [String]
|
|
|
|
attr_accessor :campaign
|
|
|
|
|
|
|
|
# The Channel Group associated with an end user's session for this View
|
|
|
|
# (defined by the View's Channel Groupings).
|
|
|
|
# Corresponds to the JSON property `channelGrouping`
|
|
|
|
# @return [String]
|
|
|
|
attr_accessor :channel_grouping
|
|
|
|
|
|
|
|
# A list of all custom dimensions associated with this activity.
|
|
|
|
# Corresponds to the JSON property `customDimension`
|
|
|
|
# @return [Array<Google::Apis::AnalyticsreportingV4::CustomDimension>]
|
|
|
|
attr_accessor :custom_dimension
|
|
|
|
|
|
|
|
# E-commerce details associated with the user activity.
|
|
|
|
# Corresponds to the JSON property `ecommerce`
|
|
|
|
# @return [Google::Apis::AnalyticsreportingV4::EcommerceData]
|
|
|
|
attr_accessor :ecommerce
|
|
|
|
|
|
|
|
# Represents all the details pertaining to an event.
|
|
|
|
# Corresponds to the JSON property `event`
|
|
|
|
# @return [Google::Apis::AnalyticsreportingV4::EventData]
|
|
|
|
attr_accessor :event
|
|
|
|
|
|
|
|
# Represents a set of goals that were reached in an activity.
|
|
|
|
# Corresponds to the JSON property `goals`
|
|
|
|
# @return [Google::Apis::AnalyticsreportingV4::GoalSetData]
|
|
|
|
attr_accessor :goals
|
|
|
|
|
|
|
|
# The hostname from which the tracking request was made.
|
|
|
|
# Corresponds to the JSON property `hostname`
|
|
|
|
# @return [String]
|
|
|
|
attr_accessor :hostname
|
|
|
|
|
|
|
|
# For manual campaign tracking, it is the value of the utm_term campaign
|
|
|
|
# tracking parameter. For AdWords traffic, it contains the best matching
|
|
|
|
# targeting criteria. For the display network, where multiple targeting
|
|
|
|
# criteria could have caused the ad to show up, it returns the best matching
|
|
|
|
# targeting criteria as selected by Ads. This could be display_keyword, site
|
|
|
|
# placement, boomuserlist, user_interest, age, or gender. Otherwise its value
|
|
|
|
# is (not set).
|
|
|
|
# Corresponds to the JSON property `keyword`
|
|
|
|
# @return [String]
|
|
|
|
attr_accessor :keyword
|
|
|
|
|
|
|
|
# The first page in users' sessions, or the landing page.
|
|
|
|
# Corresponds to the JSON property `landingPagePath`
|
|
|
|
# @return [String]
|
|
|
|
attr_accessor :landing_page_path
|
|
|
|
|
|
|
|
# The type of referrals. For manual campaign tracking, it is the value of the
|
|
|
|
# utm_medium campaign tracking parameter. For AdWords autotagging, it is cpc.
|
|
|
|
# If users came from a search engine detected by Google Analytics, it is
|
|
|
|
# organic. If the referrer is not a search engine, it is referral. If users
|
|
|
|
# came directly to the property and document.referrer is empty, its value is
|
|
|
|
# (none).
|
|
|
|
# Corresponds to the JSON property `medium`
|
|
|
|
# @return [String]
|
|
|
|
attr_accessor :medium
|
|
|
|
|
|
|
|
# Represents details collected when the visitor views a page.
|
|
|
|
# Corresponds to the JSON property `pageview`
|
|
|
|
# @return [Google::Apis::AnalyticsreportingV4::PageviewData]
|
|
|
|
attr_accessor :pageview
|
|
|
|
|
|
|
|
# The source of referrals. For manual campaign tracking, it is the value of
|
|
|
|
# the utm_source campaign tracking parameter. For AdWords autotagging, it is
|
|
|
|
# google. If you use neither, it is the domain of the source
|
|
|
|
# (e.g., document.referrer) referring the users. It may also contain a port
|
|
|
|
# address. If users arrived without a referrer, its value is (direct).
|
|
|
|
# Corresponds to the JSON property `source`
|
|
|
|
# @return [String]
|
|
|
|
attr_accessor :source
|
|
|
|
|
|
|
|
def initialize(**args)
|
|
|
|
update!(**args)
|
|
|
|
end
|
|
|
|
|
|
|
|
# Update properties of this object
|
|
|
|
def update!(**args)
|
|
|
|
@activity_time = args[:activity_time] if args.key?(:activity_time)
|
|
|
|
@activity_type = args[:activity_type] if args.key?(:activity_type)
|
|
|
|
@appview = args[:appview] if args.key?(:appview)
|
|
|
|
@campaign = args[:campaign] if args.key?(:campaign)
|
|
|
|
@channel_grouping = args[:channel_grouping] if args.key?(:channel_grouping)
|
|
|
|
@custom_dimension = args[:custom_dimension] if args.key?(:custom_dimension)
|
|
|
|
@ecommerce = args[:ecommerce] if args.key?(:ecommerce)
|
|
|
|
@event = args[:event] if args.key?(:event)
|
|
|
|
@goals = args[:goals] if args.key?(:goals)
|
|
|
|
@hostname = args[:hostname] if args.key?(:hostname)
|
|
|
|
@keyword = args[:keyword] if args.key?(:keyword)
|
|
|
|
@landing_page_path = args[:landing_page_path] if args.key?(:landing_page_path)
|
|
|
|
@medium = args[:medium] if args.key?(:medium)
|
|
|
|
@pageview = args[:pageview] if args.key?(:pageview)
|
|
|
|
@source = args[:source] if args.key?(:source)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# Defines a cohort. A cohort is a group of users who share a common
|
|
|
|
# characteristic. For example, all users with the same acquisition date
|
|
|
|
# belong to the same cohort.
|
|
|
|
class Cohort
|
2017-07-12 20:10:42 +00:00
|
|
|
include Google::Apis::Core::Hashable
|
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# A contiguous set of days: startDate, startDate + 1 day, ..., endDate.
|
|
|
|
# The start and end dates are specified in
|
|
|
|
# [ISO8601](https://en.wikipedia.org/wiki/ISO_8601) date format `YYYY-MM-DD`.
|
|
|
|
# Corresponds to the JSON property `dateRange`
|
|
|
|
# @return [Google::Apis::AnalyticsreportingV4::DateRange]
|
|
|
|
attr_accessor :date_range
|
2017-07-12 20:10:42 +00:00
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# A unique name for the cohort. If not defined name will be auto-generated
|
|
|
|
# with values cohort_[1234...].
|
|
|
|
# Corresponds to the JSON property `name`
|
2017-07-12 20:10:42 +00:00
|
|
|
# @return [String]
|
2017-08-25 19:54:22 +00:00
|
|
|
attr_accessor :name
|
|
|
|
|
|
|
|
# Type of the cohort. The only supported type as of now is
|
|
|
|
# `FIRST_VISIT_DATE`. If this field is unspecified the cohort is treated
|
|
|
|
# as `FIRST_VISIT_DATE` type cohort.
|
|
|
|
# Corresponds to the JSON property `type`
|
|
|
|
# @return [String]
|
|
|
|
attr_accessor :type
|
2017-07-12 20:10:42 +00:00
|
|
|
|
|
|
|
def initialize(**args)
|
|
|
|
update!(**args)
|
|
|
|
end
|
|
|
|
|
|
|
|
# Update properties of this object
|
|
|
|
def update!(**args)
|
2017-08-25 19:54:22 +00:00
|
|
|
@date_range = args[:date_range] if args.key?(:date_range)
|
|
|
|
@name = args[:name] if args.key?(:name)
|
|
|
|
@type = args[:type] if args.key?(:type)
|
2017-07-12 20:10:42 +00:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# Defines a cohort group.
|
|
|
|
# For example:
|
|
|
|
# "cohortGroup": `
|
|
|
|
# "cohorts": [`
|
|
|
|
# "name": "cohort 1",
|
|
|
|
# "type": "FIRST_VISIT_DATE",
|
|
|
|
# "dateRange": ` "startDate": "2015-08-01", "endDate": "2015-08-01" `
|
|
|
|
# `,`
|
|
|
|
# "name": "cohort 2"
|
|
|
|
# "type": "FIRST_VISIT_DATE"
|
|
|
|
# "dateRange": ` "startDate": "2015-07-01", "endDate": "2015-07-01" `
|
|
|
|
# `]
|
|
|
|
# `
|
|
|
|
class CohortGroup
|
2017-07-12 20:10:42 +00:00
|
|
|
include Google::Apis::Core::Hashable
|
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# The definition for the cohort.
|
|
|
|
# Corresponds to the JSON property `cohorts`
|
|
|
|
# @return [Array<Google::Apis::AnalyticsreportingV4::Cohort>]
|
|
|
|
attr_accessor :cohorts
|
2017-07-12 20:10:42 +00:00
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# Enable Life Time Value (LTV). LTV measures lifetime value for users
|
|
|
|
# acquired through different channels.
|
|
|
|
# Please see:
|
|
|
|
# [Cohort Analysis](https://support.google.com/analytics/answer/6074676) and
|
|
|
|
# [Lifetime Value](https://support.google.com/analytics/answer/6182550)
|
|
|
|
# If the value of lifetimeValue is false:
|
|
|
|
# - The metric values are similar to the values in the web interface cohort
|
|
|
|
# report.
|
|
|
|
# - The cohort definition date ranges must be aligned to the calendar week
|
|
|
|
# and month. i.e. while requesting `ga:cohortNthWeek` the `startDate` in
|
|
|
|
# the cohort definition should be a Sunday and the `endDate` should be the
|
|
|
|
# following Saturday, and for `ga:cohortNthMonth`, the `startDate`
|
|
|
|
# should be the 1st of the month and `endDate` should be the last day
|
|
|
|
# of the month.
|
|
|
|
# When the lifetimeValue is true:
|
|
|
|
# - The metric values will correspond to the values in the web interface
|
|
|
|
# LifeTime value report.
|
|
|
|
# - The Lifetime Value report shows you how user value (Revenue) and
|
|
|
|
# engagement (Appviews, Goal Completions, Sessions, and Session Duration)
|
|
|
|
# grow during the 90 days after a user is acquired.
|
|
|
|
# - The metrics are calculated as a cumulative average per user per the time
|
|
|
|
# increment.
|
|
|
|
# - The cohort definition date ranges need not be aligned to the calendar
|
|
|
|
# week and month boundaries.
|
|
|
|
# - The `viewId` must be an
|
2019-07-11 00:38:42 +00:00
|
|
|
# [app view
|
|
|
|
# ID](https://support.google.com/analytics/answer/2649553#WebVersusAppViews)
|
2017-08-25 19:54:22 +00:00
|
|
|
# Corresponds to the JSON property `lifetimeValue`
|
|
|
|
# @return [Boolean]
|
|
|
|
attr_accessor :lifetime_value
|
|
|
|
alias_method :lifetime_value?, :lifetime_value
|
2017-07-12 20:10:42 +00:00
|
|
|
|
|
|
|
def initialize(**args)
|
|
|
|
update!(**args)
|
|
|
|
end
|
|
|
|
|
|
|
|
# Update properties of this object
|
|
|
|
def update!(**args)
|
2017-08-25 19:54:22 +00:00
|
|
|
@cohorts = args[:cohorts] if args.key?(:cohorts)
|
|
|
|
@lifetime_value = args[:lifetime_value] if args.key?(:lifetime_value)
|
2017-07-12 20:10:42 +00:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# Column headers.
|
|
|
|
class ColumnHeader
|
2017-07-12 20:10:42 +00:00
|
|
|
include Google::Apis::Core::Hashable
|
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# The dimension names in the response.
|
|
|
|
# Corresponds to the JSON property `dimensions`
|
2017-07-12 20:10:42 +00:00
|
|
|
# @return [Array<String>]
|
2017-08-25 19:54:22 +00:00
|
|
|
attr_accessor :dimensions
|
|
|
|
|
|
|
|
# The headers for the metrics.
|
|
|
|
# Corresponds to the JSON property `metricHeader`
|
|
|
|
# @return [Google::Apis::AnalyticsreportingV4::MetricHeader]
|
|
|
|
attr_accessor :metric_header
|
2017-07-12 20:10:42 +00:00
|
|
|
|
|
|
|
def initialize(**args)
|
|
|
|
update!(**args)
|
|
|
|
end
|
|
|
|
|
|
|
|
# Update properties of this object
|
|
|
|
def update!(**args)
|
2017-08-25 19:54:22 +00:00
|
|
|
@dimensions = args[:dimensions] if args.key?(:dimensions)
|
|
|
|
@metric_header = args[:metric_header] if args.key?(:metric_header)
|
2017-07-12 20:10:42 +00:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2019-03-20 00:37:12 +00:00
|
|
|
# Custom dimension.
|
|
|
|
class CustomDimension
|
|
|
|
include Google::Apis::Core::Hashable
|
|
|
|
|
|
|
|
# Slot number of custom dimension.
|
|
|
|
# Corresponds to the JSON property `index`
|
|
|
|
# @return [Fixnum]
|
|
|
|
attr_accessor :index
|
|
|
|
|
|
|
|
# Value of the custom dimension. Default value (i.e. empty string) indicates
|
|
|
|
# clearing sesion/visitor scope custom dimension value.
|
|
|
|
# Corresponds to the JSON property `value`
|
|
|
|
# @return [String]
|
|
|
|
attr_accessor :value
|
|
|
|
|
|
|
|
def initialize(**args)
|
|
|
|
update!(**args)
|
|
|
|
end
|
|
|
|
|
|
|
|
# Update properties of this object
|
|
|
|
def update!(**args)
|
|
|
|
@index = args[:index] if args.key?(:index)
|
|
|
|
@value = args[:value] if args.key?(:value)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# A contiguous set of days: startDate, startDate + 1 day, ..., endDate.
|
|
|
|
# The start and end dates are specified in
|
|
|
|
# [ISO8601](https://en.wikipedia.org/wiki/ISO_8601) date format `YYYY-MM-DD`.
|
|
|
|
class DateRange
|
2017-07-12 20:10:42 +00:00
|
|
|
include Google::Apis::Core::Hashable
|
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# The end date for the query in the format `YYYY-MM-DD`.
|
|
|
|
# Corresponds to the JSON property `endDate`
|
2017-07-12 20:10:42 +00:00
|
|
|
# @return [String]
|
2017-08-25 19:54:22 +00:00
|
|
|
attr_accessor :end_date
|
2017-07-12 20:10:42 +00:00
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# The start date for the query in the format `YYYY-MM-DD`.
|
|
|
|
# Corresponds to the JSON property `startDate`
|
|
|
|
# @return [String]
|
|
|
|
attr_accessor :start_date
|
2017-07-12 20:10:42 +00:00
|
|
|
|
|
|
|
def initialize(**args)
|
|
|
|
update!(**args)
|
|
|
|
end
|
|
|
|
|
|
|
|
# Update properties of this object
|
|
|
|
def update!(**args)
|
2017-08-25 19:54:22 +00:00
|
|
|
@end_date = args[:end_date] if args.key?(:end_date)
|
|
|
|
@start_date = args[:start_date] if args.key?(:start_date)
|
2017-07-12 20:10:42 +00:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# Used to return a list of metrics for a single DateRange / dimension
|
|
|
|
# combination
|
|
|
|
class DateRangeValues
|
2017-03-30 22:30:51 +00:00
|
|
|
include Google::Apis::Core::Hashable
|
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# The values of each pivot region.
|
|
|
|
# Corresponds to the JSON property `pivotValueRegions`
|
|
|
|
# @return [Array<Google::Apis::AnalyticsreportingV4::PivotValueRegion>]
|
|
|
|
attr_accessor :pivot_value_regions
|
2017-05-04 19:35:56 +00:00
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# Each value corresponds to each Metric in the request.
|
|
|
|
# Corresponds to the JSON property `values`
|
|
|
|
# @return [Array<String>]
|
|
|
|
attr_accessor :values
|
2017-07-12 20:10:42 +00:00
|
|
|
|
2017-05-04 19:35:56 +00:00
|
|
|
def initialize(**args)
|
|
|
|
update!(**args)
|
|
|
|
end
|
|
|
|
|
|
|
|
# Update properties of this object
|
|
|
|
def update!(**args)
|
2017-08-25 19:54:22 +00:00
|
|
|
@pivot_value_regions = args[:pivot_value_regions] if args.key?(:pivot_value_regions)
|
|
|
|
@values = args[:values] if args.key?(:values)
|
2017-05-04 19:35:56 +00:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# [Dimensions](https://support.google.com/analytics/answer/1033861)
|
|
|
|
# are attributes of your data. For example, the dimension `ga:city`
|
|
|
|
# indicates the city, for example, "Paris" or "New York", from which
|
|
|
|
# a session originates.
|
|
|
|
class Dimension
|
2017-05-04 19:35:56 +00:00
|
|
|
include Google::Apis::Core::Hashable
|
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# If non-empty, we place dimension values into buckets after string to
|
|
|
|
# int64. Dimension values that are not the string representation of an
|
|
|
|
# integral value will be converted to zero. The bucket values have to be in
|
|
|
|
# increasing order. Each bucket is closed on the lower end, and open on the
|
|
|
|
# upper end. The "first" bucket includes all values less than the first
|
|
|
|
# boundary, the "last" bucket includes all values up to infinity. Dimension
|
|
|
|
# values that fall in a bucket get transformed to a new dimension value. For
|
|
|
|
# example, if one gives a list of "0, 1, 3, 4, 7", then we return the
|
|
|
|
# following buckets:
|
|
|
|
# - bucket #1: values < 0, dimension value "<0"
|
|
|
|
# - bucket #2: values in [0,1), dimension value "0"
|
|
|
|
# - bucket #3: values in [1,3), dimension value "1-2"
|
|
|
|
# - bucket #4: values in [3,4), dimension value "3"
|
|
|
|
# - bucket #5: values in [4,7), dimension value "4-6"
|
|
|
|
# - bucket #6: values >= 7, dimension value "7+"
|
|
|
|
# NOTE: If you are applying histogram mutation on any dimension, and using
|
|
|
|
# that dimension in sort, you will want to use the sort type
|
|
|
|
# `HISTOGRAM_BUCKET` for that purpose. Without that the dimension values
|
|
|
|
# will be sorted according to dictionary
|
|
|
|
# (lexicographic) order. For example the ascending dictionary order is:
|
|
|
|
# "<50", "1001+", "121-1000", "50-120"
|
|
|
|
# And the ascending `HISTOGRAM_BUCKET` order is:
|
|
|
|
# "<50", "50-120", "121-1000", "1001+"
|
|
|
|
# The client has to explicitly request `"orderType": "HISTOGRAM_BUCKET"`
|
|
|
|
# for a histogram-mutated dimension.
|
|
|
|
# Corresponds to the JSON property `histogramBuckets`
|
|
|
|
# @return [Array<Fixnum>]
|
|
|
|
attr_accessor :histogram_buckets
|
2017-05-04 19:35:56 +00:00
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# Name of the dimension to fetch, for example `ga:browser`.
|
|
|
|
# Corresponds to the JSON property `name`
|
2017-06-02 06:11:31 +00:00
|
|
|
# @return [String]
|
2017-08-25 19:54:22 +00:00
|
|
|
attr_accessor :name
|
2017-03-31 19:53:27 +00:00
|
|
|
|
2017-03-30 22:30:51 +00:00
|
|
|
def initialize(**args)
|
|
|
|
update!(**args)
|
|
|
|
end
|
|
|
|
|
|
|
|
# Update properties of this object
|
|
|
|
def update!(**args)
|
2017-08-25 19:54:22 +00:00
|
|
|
@histogram_buckets = args[:histogram_buckets] if args.key?(:histogram_buckets)
|
|
|
|
@name = args[:name] if args.key?(:name)
|
2017-03-30 22:30:51 +00:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# Dimension filter specifies the filtering options on a dimension.
|
|
|
|
class DimensionFilter
|
2016-05-16 16:49:15 +00:00
|
|
|
include Google::Apis::Core::Hashable
|
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# Should the match be case sensitive? Default is false.
|
|
|
|
# Corresponds to the JSON property `caseSensitive`
|
2017-07-12 20:10:42 +00:00
|
|
|
# @return [Boolean]
|
2017-08-25 19:54:22 +00:00
|
|
|
attr_accessor :case_sensitive
|
|
|
|
alias_method :case_sensitive?, :case_sensitive
|
2017-03-10 21:11:09 +00:00
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# The dimension to filter on. A DimensionFilter must contain a dimension.
|
|
|
|
# Corresponds to the JSON property `dimensionName`
|
|
|
|
# @return [String]
|
|
|
|
attr_accessor :dimension_name
|
2017-03-10 21:11:09 +00:00
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# Strings or regular expression to match against. Only the first value of
|
|
|
|
# the list is used for comparison unless the operator is `IN_LIST`.
|
|
|
|
# If `IN_LIST` operator, then the entire list is used to filter the
|
|
|
|
# dimensions as explained in the description of the `IN_LIST` operator.
|
|
|
|
# Corresponds to the JSON property `expressions`
|
|
|
|
# @return [Array<String>]
|
|
|
|
attr_accessor :expressions
|
2017-03-10 21:11:09 +00:00
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# Logical `NOT` operator. If this boolean is set to true, then the matching
|
|
|
|
# dimension values will be excluded in the report. The default is false.
|
|
|
|
# Corresponds to the JSON property `not`
|
2017-06-14 17:02:03 +00:00
|
|
|
# @return [Boolean]
|
2017-08-25 19:54:22 +00:00
|
|
|
attr_accessor :not
|
|
|
|
alias_method :not?, :not
|
2017-06-02 06:11:31 +00:00
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# How to match the dimension to the expression. The default is REGEXP.
|
|
|
|
# Corresponds to the JSON property `operator`
|
2017-06-02 06:11:31 +00:00
|
|
|
# @return [String]
|
2017-08-25 19:54:22 +00:00
|
|
|
attr_accessor :operator
|
2017-06-14 17:02:03 +00:00
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
def initialize(**args)
|
|
|
|
update!(**args)
|
|
|
|
end
|
2017-06-14 17:02:03 +00:00
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# Update properties of this object
|
|
|
|
def update!(**args)
|
|
|
|
@case_sensitive = args[:case_sensitive] if args.key?(:case_sensitive)
|
|
|
|
@dimension_name = args[:dimension_name] if args.key?(:dimension_name)
|
|
|
|
@expressions = args[:expressions] if args.key?(:expressions)
|
|
|
|
@not = args[:not] if args.key?(:not)
|
|
|
|
@operator = args[:operator] if args.key?(:operator)
|
|
|
|
end
|
|
|
|
end
|
2017-06-14 17:02:03 +00:00
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# A group of dimension filters. Set the operator value to specify how
|
|
|
|
# the filters are logically combined.
|
|
|
|
class DimensionFilterClause
|
|
|
|
include Google::Apis::Core::Hashable
|
2017-06-14 17:02:03 +00:00
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# The repeated set of filters. They are logically combined based on the
|
|
|
|
# operator specified.
|
|
|
|
# Corresponds to the JSON property `filters`
|
|
|
|
# @return [Array<Google::Apis::AnalyticsreportingV4::DimensionFilter>]
|
|
|
|
attr_accessor :filters
|
2017-07-12 20:10:42 +00:00
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# The operator for combining multiple dimension filters. If unspecified, it
|
|
|
|
# is treated as an `OR`.
|
|
|
|
# Corresponds to the JSON property `operator`
|
|
|
|
# @return [String]
|
|
|
|
attr_accessor :operator
|
2017-05-04 19:35:56 +00:00
|
|
|
|
|
|
|
def initialize(**args)
|
|
|
|
update!(**args)
|
|
|
|
end
|
|
|
|
|
|
|
|
# Update properties of this object
|
|
|
|
def update!(**args)
|
2017-08-25 19:54:22 +00:00
|
|
|
@filters = args[:filters] if args.key?(:filters)
|
|
|
|
@operator = args[:operator] if args.key?(:operator)
|
2017-07-12 20:10:42 +00:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# Dynamic segment definition for defining the segment within the request.
|
|
|
|
# A segment can select users, sessions or both.
|
|
|
|
class DynamicSegment
|
2017-07-12 20:10:42 +00:00
|
|
|
include Google::Apis::Core::Hashable
|
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# The name of the dynamic segment.
|
|
|
|
# Corresponds to the JSON property `name`
|
2017-07-12 20:10:42 +00:00
|
|
|
# @return [String]
|
2017-08-25 19:54:22 +00:00
|
|
|
attr_accessor :name
|
2017-07-12 20:10:42 +00:00
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# SegmentDefinition defines the segment to be a set of SegmentFilters which
|
|
|
|
# are combined together with a logical `AND` operation.
|
|
|
|
# Corresponds to the JSON property `sessionSegment`
|
|
|
|
# @return [Google::Apis::AnalyticsreportingV4::SegmentDefinition]
|
|
|
|
attr_accessor :session_segment
|
2017-07-12 20:10:42 +00:00
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# SegmentDefinition defines the segment to be a set of SegmentFilters which
|
|
|
|
# are combined together with a logical `AND` operation.
|
|
|
|
# Corresponds to the JSON property `userSegment`
|
|
|
|
# @return [Google::Apis::AnalyticsreportingV4::SegmentDefinition]
|
|
|
|
attr_accessor :user_segment
|
2017-07-12 20:10:42 +00:00
|
|
|
|
|
|
|
def initialize(**args)
|
|
|
|
update!(**args)
|
|
|
|
end
|
|
|
|
|
|
|
|
# Update properties of this object
|
|
|
|
def update!(**args)
|
2017-08-25 19:54:22 +00:00
|
|
|
@name = args[:name] if args.key?(:name)
|
|
|
|
@session_segment = args[:session_segment] if args.key?(:session_segment)
|
|
|
|
@user_segment = args[:user_segment] if args.key?(:user_segment)
|
2017-05-04 19:35:56 +00:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2019-03-20 00:37:12 +00:00
|
|
|
# E-commerce details associated with the user activity.
|
|
|
|
class EcommerceData
|
|
|
|
include Google::Apis::Core::Hashable
|
|
|
|
|
|
|
|
# Action associated with this e-commerce action.
|
|
|
|
# Corresponds to the JSON property `actionType`
|
|
|
|
# @return [String]
|
|
|
|
attr_accessor :action_type
|
|
|
|
|
|
|
|
# The type of this e-commerce activity.
|
|
|
|
# Corresponds to the JSON property `ecommerceType`
|
|
|
|
# @return [String]
|
|
|
|
attr_accessor :ecommerce_type
|
|
|
|
|
|
|
|
# Details of the products in this transaction.
|
|
|
|
# Corresponds to the JSON property `products`
|
|
|
|
# @return [Array<Google::Apis::AnalyticsreportingV4::ProductData>]
|
|
|
|
attr_accessor :products
|
|
|
|
|
|
|
|
# Represents details collected when the visitor performs a transaction on the
|
|
|
|
# page.
|
|
|
|
# Corresponds to the JSON property `transaction`
|
|
|
|
# @return [Google::Apis::AnalyticsreportingV4::TransactionData]
|
|
|
|
attr_accessor :transaction
|
|
|
|
|
|
|
|
def initialize(**args)
|
|
|
|
update!(**args)
|
|
|
|
end
|
|
|
|
|
|
|
|
# Update properties of this object
|
|
|
|
def update!(**args)
|
|
|
|
@action_type = args[:action_type] if args.key?(:action_type)
|
|
|
|
@ecommerce_type = args[:ecommerce_type] if args.key?(:ecommerce_type)
|
|
|
|
@products = args[:products] if args.key?(:products)
|
|
|
|
@transaction = args[:transaction] if args.key?(:transaction)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
# Represents all the details pertaining to an event.
|
|
|
|
class EventData
|
|
|
|
include Google::Apis::Core::Hashable
|
|
|
|
|
|
|
|
# Type of interaction with the object. Eg: 'play'.
|
|
|
|
# Corresponds to the JSON property `eventAction`
|
|
|
|
# @return [String]
|
|
|
|
attr_accessor :event_action
|
|
|
|
|
|
|
|
# The object on the page that was interacted with. Eg: 'Video'.
|
|
|
|
# Corresponds to the JSON property `eventCategory`
|
|
|
|
# @return [String]
|
|
|
|
attr_accessor :event_category
|
|
|
|
|
|
|
|
# Number of such events in this activity.
|
|
|
|
# Corresponds to the JSON property `eventCount`
|
|
|
|
# @return [Fixnum]
|
|
|
|
attr_accessor :event_count
|
|
|
|
|
|
|
|
# Label attached with the event.
|
|
|
|
# Corresponds to the JSON property `eventLabel`
|
|
|
|
# @return [String]
|
|
|
|
attr_accessor :event_label
|
|
|
|
|
|
|
|
# Numeric value associated with the event.
|
|
|
|
# Corresponds to the JSON property `eventValue`
|
|
|
|
# @return [Fixnum]
|
|
|
|
attr_accessor :event_value
|
|
|
|
|
|
|
|
def initialize(**args)
|
|
|
|
update!(**args)
|
|
|
|
end
|
|
|
|
|
|
|
|
# Update properties of this object
|
|
|
|
def update!(**args)
|
|
|
|
@event_action = args[:event_action] if args.key?(:event_action)
|
|
|
|
@event_category = args[:event_category] if args.key?(:event_category)
|
|
|
|
@event_count = args[:event_count] if args.key?(:event_count)
|
|
|
|
@event_label = args[:event_label] if args.key?(:event_label)
|
|
|
|
@event_value = args[:event_value] if args.key?(:event_value)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# The batch request containing multiple report request.
|
|
|
|
class GetReportsRequest
|
|
|
|
include Google::Apis::Core::Hashable
|
2017-06-14 17:02:03 +00:00
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# Requests, each request will have a separate response.
|
|
|
|
# There can be a maximum of 5 requests. All requests should have the same
|
|
|
|
# `dateRanges`, `viewId`, `segments`, `samplingLevel`, and `cohortGroup`.
|
|
|
|
# Corresponds to the JSON property `reportRequests`
|
|
|
|
# @return [Array<Google::Apis::AnalyticsreportingV4::ReportRequest>]
|
|
|
|
attr_accessor :report_requests
|
2017-06-14 17:02:03 +00:00
|
|
|
|
2017-11-10 00:35:09 +00:00
|
|
|
# Enables
|
2019-07-11 00:38:42 +00:00
|
|
|
# [resource based
|
|
|
|
# quotas](/analytics/devguides/reporting/core/v4/limits-quotas#
|
2017-11-10 00:35:09 +00:00
|
|
|
# analytics_reporting_api_v4),
|
|
|
|
# (defaults to `False`). If this field is set to `True` the
|
|
|
|
# per view (profile) quotas are governed by the computational
|
|
|
|
# cost of the request. Note that using cost based quotas will
|
|
|
|
# higher enable sampling rates. (10 Million for `SMALL`,
|
|
|
|
# 100M for `LARGE`. See the
|
2019-07-11 00:38:42 +00:00
|
|
|
# [limits and quotas
|
|
|
|
# documentation](/analytics/devguides/reporting/core/v4/limits-quotas#
|
|
|
|
# analytics_reporting_api_v4)
|
|
|
|
# for details.
|
2017-11-10 00:35:09 +00:00
|
|
|
# Corresponds to the JSON property `useResourceQuotas`
|
|
|
|
# @return [Boolean]
|
|
|
|
attr_accessor :use_resource_quotas
|
|
|
|
alias_method :use_resource_quotas?, :use_resource_quotas
|
|
|
|
|
2017-06-14 17:02:03 +00:00
|
|
|
def initialize(**args)
|
|
|
|
update!(**args)
|
|
|
|
end
|
|
|
|
|
|
|
|
# Update properties of this object
|
|
|
|
def update!(**args)
|
2017-08-25 19:54:22 +00:00
|
|
|
@report_requests = args[:report_requests] if args.key?(:report_requests)
|
2017-11-10 00:35:09 +00:00
|
|
|
@use_resource_quotas = args[:use_resource_quotas] if args.key?(:use_resource_quotas)
|
2017-06-14 17:02:03 +00:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# The main response class which holds the reports from the Reporting API
|
|
|
|
# `batchGet` call.
|
|
|
|
class GetReportsResponse
|
2017-06-14 17:02:03 +00:00
|
|
|
include Google::Apis::Core::Hashable
|
|
|
|
|
2017-11-10 00:35:09 +00:00
|
|
|
# The amount of resource quota tokens deducted to execute the query. Includes
|
|
|
|
# all responses.
|
|
|
|
# Corresponds to the JSON property `queryCost`
|
|
|
|
# @return [Fixnum]
|
|
|
|
attr_accessor :query_cost
|
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# Responses corresponding to each of the request.
|
|
|
|
# Corresponds to the JSON property `reports`
|
|
|
|
# @return [Array<Google::Apis::AnalyticsreportingV4::Report>]
|
|
|
|
attr_accessor :reports
|
2017-06-02 06:11:31 +00:00
|
|
|
|
2017-11-10 00:35:09 +00:00
|
|
|
# The resource quota tokens remaining for the property after the request is
|
|
|
|
# completed.
|
|
|
|
# Corresponds to the JSON property `resourceQuotasRemaining`
|
|
|
|
# @return [Google::Apis::AnalyticsreportingV4::ResourceQuotasRemaining]
|
|
|
|
attr_accessor :resource_quotas_remaining
|
|
|
|
|
2017-05-04 19:35:56 +00:00
|
|
|
def initialize(**args)
|
|
|
|
update!(**args)
|
|
|
|
end
|
2017-04-03 20:18:48 +00:00
|
|
|
|
2017-05-04 19:35:56 +00:00
|
|
|
# Update properties of this object
|
|
|
|
def update!(**args)
|
2017-11-10 00:35:09 +00:00
|
|
|
@query_cost = args[:query_cost] if args.key?(:query_cost)
|
2017-08-25 19:54:22 +00:00
|
|
|
@reports = args[:reports] if args.key?(:reports)
|
2017-11-10 00:35:09 +00:00
|
|
|
@resource_quotas_remaining = args[:resource_quotas_remaining] if args.key?(:resource_quotas_remaining)
|
2017-05-04 19:35:56 +00:00
|
|
|
end
|
|
|
|
end
|
2017-04-03 20:18:48 +00:00
|
|
|
|
2019-03-20 00:37:12 +00:00
|
|
|
# Represents all the details pertaining to a goal.
|
|
|
|
class GoalData
|
|
|
|
include Google::Apis::Core::Hashable
|
|
|
|
|
|
|
|
# URL of the page where this goal was completed.
|
|
|
|
# Corresponds to the JSON property `goalCompletionLocation`
|
|
|
|
# @return [String]
|
|
|
|
attr_accessor :goal_completion_location
|
|
|
|
|
|
|
|
# Total number of goal completions in this activity.
|
|
|
|
# Corresponds to the JSON property `goalCompletions`
|
|
|
|
# @return [Fixnum]
|
|
|
|
attr_accessor :goal_completions
|
|
|
|
|
|
|
|
# This identifies the goal as configured for the profile.
|
|
|
|
# Corresponds to the JSON property `goalIndex`
|
|
|
|
# @return [Fixnum]
|
|
|
|
attr_accessor :goal_index
|
|
|
|
|
|
|
|
# Name of the goal.
|
|
|
|
# Corresponds to the JSON property `goalName`
|
|
|
|
# @return [String]
|
|
|
|
attr_accessor :goal_name
|
|
|
|
|
|
|
|
# URL of the page one step prior to the goal completion.
|
|
|
|
# Corresponds to the JSON property `goalPreviousStep1`
|
|
|
|
# @return [String]
|
|
|
|
attr_accessor :goal_previous_step1
|
|
|
|
|
|
|
|
# URL of the page two steps prior to the goal completion.
|
|
|
|
# Corresponds to the JSON property `goalPreviousStep2`
|
|
|
|
# @return [String]
|
|
|
|
attr_accessor :goal_previous_step2
|
|
|
|
|
|
|
|
# URL of the page three steps prior to the goal completion.
|
|
|
|
# Corresponds to the JSON property `goalPreviousStep3`
|
|
|
|
# @return [String]
|
|
|
|
attr_accessor :goal_previous_step3
|
|
|
|
|
|
|
|
# Value in this goal.
|
|
|
|
# Corresponds to the JSON property `goalValue`
|
|
|
|
# @return [Float]
|
|
|
|
attr_accessor :goal_value
|
|
|
|
|
|
|
|
def initialize(**args)
|
|
|
|
update!(**args)
|
|
|
|
end
|
|
|
|
|
|
|
|
# Update properties of this object
|
|
|
|
def update!(**args)
|
|
|
|
@goal_completion_location = args[:goal_completion_location] if args.key?(:goal_completion_location)
|
|
|
|
@goal_completions = args[:goal_completions] if args.key?(:goal_completions)
|
|
|
|
@goal_index = args[:goal_index] if args.key?(:goal_index)
|
|
|
|
@goal_name = args[:goal_name] if args.key?(:goal_name)
|
|
|
|
@goal_previous_step1 = args[:goal_previous_step1] if args.key?(:goal_previous_step1)
|
|
|
|
@goal_previous_step2 = args[:goal_previous_step2] if args.key?(:goal_previous_step2)
|
|
|
|
@goal_previous_step3 = args[:goal_previous_step3] if args.key?(:goal_previous_step3)
|
|
|
|
@goal_value = args[:goal_value] if args.key?(:goal_value)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
# Represents a set of goals that were reached in an activity.
|
|
|
|
class GoalSetData
|
|
|
|
include Google::Apis::Core::Hashable
|
|
|
|
|
|
|
|
# All the goals that were reached in the current activity.
|
|
|
|
# Corresponds to the JSON property `goals`
|
|
|
|
# @return [Array<Google::Apis::AnalyticsreportingV4::GoalData>]
|
|
|
|
attr_accessor :goals
|
|
|
|
|
|
|
|
def initialize(**args)
|
|
|
|
update!(**args)
|
|
|
|
end
|
|
|
|
|
|
|
|
# Update properties of this object
|
|
|
|
def update!(**args)
|
|
|
|
@goals = args[:goals] if args.key?(:goals)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# [Metrics](https://support.google.com/analytics/answer/1033861)
|
|
|
|
# are the quantitative measurements. For example, the metric `ga:users`
|
|
|
|
# indicates the total number of users for the requested time period.
|
|
|
|
class Metric
|
2017-05-04 19:35:56 +00:00
|
|
|
include Google::Apis::Core::Hashable
|
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# An alias for the metric expression is an alternate name for the
|
|
|
|
# expression. The alias can be used for filtering and sorting. This field
|
|
|
|
# is optional and is useful if the expression is not a single metric but
|
|
|
|
# a complex expression which cannot be used in filtering and sorting.
|
|
|
|
# The alias is also used in the response column header.
|
|
|
|
# Corresponds to the JSON property `alias`
|
|
|
|
# @return [String]
|
|
|
|
attr_accessor :alias
|
2017-07-12 20:10:42 +00:00
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# A metric expression in the request. An expression is constructed from one
|
|
|
|
# or more metrics and numbers. Accepted operators include: Plus (+), Minus
|
|
|
|
# (-), Negation (Unary -), Divided by (/), Multiplied by (*), Parenthesis,
|
|
|
|
# Positive cardinal numbers (0-9), can include decimals and is limited to
|
|
|
|
# 1024 characters. Example `ga:totalRefunds/ga:users`, in most cases the
|
|
|
|
# metric expression is just a single metric name like `ga:users`.
|
|
|
|
# Adding mixed `MetricType` (E.g., `CURRENCY` + `PERCENTAGE`) metrics
|
|
|
|
# will result in unexpected results.
|
|
|
|
# Corresponds to the JSON property `expression`
|
|
|
|
# @return [String]
|
|
|
|
attr_accessor :expression
|
2017-05-26 16:44:32 +00:00
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# Specifies how the metric expression should be formatted, for example
|
|
|
|
# `INTEGER`.
|
|
|
|
# Corresponds to the JSON property `formattingType`
|
2017-06-02 06:11:31 +00:00
|
|
|
# @return [String]
|
2017-08-25 19:54:22 +00:00
|
|
|
attr_accessor :formatting_type
|
2017-05-26 16:44:32 +00:00
|
|
|
|
2017-03-10 21:11:09 +00:00
|
|
|
def initialize(**args)
|
|
|
|
update!(**args)
|
|
|
|
end
|
|
|
|
|
|
|
|
# Update properties of this object
|
|
|
|
def update!(**args)
|
2017-08-25 19:54:22 +00:00
|
|
|
@alias = args[:alias] if args.key?(:alias)
|
|
|
|
@expression = args[:expression] if args.key?(:expression)
|
|
|
|
@formatting_type = args[:formatting_type] if args.key?(:formatting_type)
|
2017-03-10 21:11:09 +00:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# MetricFilter specifies the filter on a metric.
|
|
|
|
class MetricFilter
|
2017-03-10 21:11:09 +00:00
|
|
|
include Google::Apis::Core::Hashable
|
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# The value to compare against.
|
|
|
|
# Corresponds to the JSON property `comparisonValue`
|
|
|
|
# @return [String]
|
|
|
|
attr_accessor :comparison_value
|
2017-03-10 21:11:09 +00:00
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# The metric that will be filtered on. A metricFilter must contain a metric
|
|
|
|
# name. A metric name can be an alias earlier defined as a metric or it can
|
|
|
|
# also be a metric expression.
|
|
|
|
# Corresponds to the JSON property `metricName`
|
|
|
|
# @return [String]
|
|
|
|
attr_accessor :metric_name
|
2017-03-10 21:11:09 +00:00
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# Logical `NOT` operator. If this boolean is set to true, then the matching
|
|
|
|
# metric values will be excluded in the report. The default is false.
|
2017-06-14 17:02:03 +00:00
|
|
|
# Corresponds to the JSON property `not`
|
|
|
|
# @return [Boolean]
|
|
|
|
attr_accessor :not
|
|
|
|
alias_method :not?, :not
|
2017-03-10 21:11:09 +00:00
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# Is the metric `EQUAL`, `LESS_THAN` or `GREATER_THAN` the
|
|
|
|
# comparisonValue, the default is `EQUAL`. If the operator is
|
|
|
|
# `IS_MISSING`, checks if the metric is missing and would ignore the
|
|
|
|
# comparisonValue.
|
|
|
|
# Corresponds to the JSON property `operator`
|
|
|
|
# @return [String]
|
|
|
|
attr_accessor :operator
|
2017-06-14 17:02:03 +00:00
|
|
|
|
|
|
|
def initialize(**args)
|
|
|
|
update!(**args)
|
|
|
|
end
|
|
|
|
|
|
|
|
# Update properties of this object
|
|
|
|
def update!(**args)
|
2017-08-25 19:54:22 +00:00
|
|
|
@comparison_value = args[:comparison_value] if args.key?(:comparison_value)
|
|
|
|
@metric_name = args[:metric_name] if args.key?(:metric_name)
|
2017-06-14 17:02:03 +00:00
|
|
|
@not = args[:not] if args.key?(:not)
|
2017-08-25 19:54:22 +00:00
|
|
|
@operator = args[:operator] if args.key?(:operator)
|
2016-05-16 16:49:15 +00:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2017-06-14 17:02:03 +00:00
|
|
|
# Represents a group of metric filters.
|
|
|
|
# Set the operator value to specify how the filters are logically combined.
|
|
|
|
class MetricFilterClause
|
2016-05-16 16:49:15 +00:00
|
|
|
include Google::Apis::Core::Hashable
|
|
|
|
|
2017-06-14 17:02:03 +00:00
|
|
|
# The repeated set of filters. They are logically combined based on the
|
|
|
|
# operator specified.
|
|
|
|
# Corresponds to the JSON property `filters`
|
|
|
|
# @return [Array<Google::Apis::AnalyticsreportingV4::MetricFilter>]
|
|
|
|
attr_accessor :filters
|
2016-05-16 16:49:15 +00:00
|
|
|
|
2017-07-12 20:10:42 +00:00
|
|
|
# The operator for combining multiple metric filters. If unspecified, it is
|
|
|
|
# treated as an `OR`.
|
|
|
|
# Corresponds to the JSON property `operator`
|
|
|
|
# @return [String]
|
|
|
|
attr_accessor :operator
|
|
|
|
|
2016-05-16 16:49:15 +00:00
|
|
|
def initialize(**args)
|
|
|
|
update!(**args)
|
|
|
|
end
|
|
|
|
|
|
|
|
# Update properties of this object
|
|
|
|
def update!(**args)
|
2017-06-14 17:02:03 +00:00
|
|
|
@filters = args[:filters] if args.key?(:filters)
|
2017-07-12 20:10:42 +00:00
|
|
|
@operator = args[:operator] if args.key?(:operator)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# The headers for the metrics.
|
|
|
|
class MetricHeader
|
2017-07-12 20:10:42 +00:00
|
|
|
include Google::Apis::Core::Hashable
|
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# Headers for the metrics in the response.
|
|
|
|
# Corresponds to the JSON property `metricHeaderEntries`
|
|
|
|
# @return [Array<Google::Apis::AnalyticsreportingV4::MetricHeaderEntry>]
|
|
|
|
attr_accessor :metric_header_entries
|
2017-07-12 20:10:42 +00:00
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# Headers for the pivots in the response.
|
|
|
|
# Corresponds to the JSON property `pivotHeaders`
|
|
|
|
# @return [Array<Google::Apis::AnalyticsreportingV4::PivotHeader>]
|
|
|
|
attr_accessor :pivot_headers
|
|
|
|
|
|
|
|
def initialize(**args)
|
|
|
|
update!(**args)
|
|
|
|
end
|
|
|
|
|
|
|
|
# Update properties of this object
|
|
|
|
def update!(**args)
|
|
|
|
@metric_header_entries = args[:metric_header_entries] if args.key?(:metric_header_entries)
|
|
|
|
@pivot_headers = args[:pivot_headers] if args.key?(:pivot_headers)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
# Header for the metrics.
|
|
|
|
class MetricHeaderEntry
|
|
|
|
include Google::Apis::Core::Hashable
|
|
|
|
|
|
|
|
# The name of the header.
|
2017-07-12 20:10:42 +00:00
|
|
|
# Corresponds to the JSON property `name`
|
|
|
|
# @return [String]
|
|
|
|
attr_accessor :name
|
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# The type of the metric, for example `INTEGER`.
|
2017-07-12 20:10:42 +00:00
|
|
|
# Corresponds to the JSON property `type`
|
|
|
|
# @return [String]
|
|
|
|
attr_accessor :type
|
|
|
|
|
|
|
|
def initialize(**args)
|
|
|
|
update!(**args)
|
|
|
|
end
|
|
|
|
|
|
|
|
# Update properties of this object
|
|
|
|
def update!(**args)
|
|
|
|
@name = args[:name] if args.key?(:name)
|
|
|
|
@type = args[:type] if args.key?(:type)
|
2016-05-16 16:49:15 +00:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2017-06-14 17:02:03 +00:00
|
|
|
# A list of segment filters in the `OR` group are combined with the logical OR
|
|
|
|
# operator.
|
|
|
|
class OrFiltersForSegment
|
2016-05-16 16:49:15 +00:00
|
|
|
include Google::Apis::Core::Hashable
|
|
|
|
|
2017-06-14 17:02:03 +00:00
|
|
|
# List of segment filters to be combined with a `OR` operator.
|
|
|
|
# Corresponds to the JSON property `segmentFilterClauses`
|
|
|
|
# @return [Array<Google::Apis::AnalyticsreportingV4::SegmentFilterClause>]
|
|
|
|
attr_accessor :segment_filter_clauses
|
2017-04-03 20:18:48 +00:00
|
|
|
|
2016-05-16 16:49:15 +00:00
|
|
|
def initialize(**args)
|
|
|
|
update!(**args)
|
|
|
|
end
|
|
|
|
|
|
|
|
# Update properties of this object
|
|
|
|
def update!(**args)
|
2017-06-14 17:02:03 +00:00
|
|
|
@segment_filter_clauses = args[:segment_filter_clauses] if args.key?(:segment_filter_clauses)
|
2016-05-16 16:49:15 +00:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# Specifies the sorting options.
|
|
|
|
class OrderBy
|
2017-02-13 23:28:52 +00:00
|
|
|
include Google::Apis::Core::Hashable
|
2016-05-16 16:49:15 +00:00
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# The field which to sort by. The default sort order is ascending. Example:
|
|
|
|
# `ga:browser`.
|
|
|
|
# Note, that you can only specify one field for sort here. For example,
|
|
|
|
# `ga:browser, ga:city` is not valid.
|
|
|
|
# Corresponds to the JSON property `fieldName`
|
|
|
|
# @return [String]
|
|
|
|
attr_accessor :field_name
|
2017-04-03 20:18:48 +00:00
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# The order type. The default orderType is `VALUE`.
|
|
|
|
# Corresponds to the JSON property `orderType`
|
|
|
|
# @return [String]
|
|
|
|
attr_accessor :order_type
|
2017-03-30 22:30:51 +00:00
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# The sorting order for the field.
|
|
|
|
# Corresponds to the JSON property `sortOrder`
|
2017-07-12 20:10:42 +00:00
|
|
|
# @return [String]
|
2017-08-25 19:54:22 +00:00
|
|
|
attr_accessor :sort_order
|
2017-07-12 20:10:42 +00:00
|
|
|
|
2017-03-27 22:14:47 +00:00
|
|
|
def initialize(**args)
|
|
|
|
update!(**args)
|
|
|
|
end
|
2017-02-13 23:28:52 +00:00
|
|
|
|
2017-03-27 22:14:47 +00:00
|
|
|
# Update properties of this object
|
|
|
|
def update!(**args)
|
2017-08-25 19:54:22 +00:00
|
|
|
@field_name = args[:field_name] if args.key?(:field_name)
|
|
|
|
@order_type = args[:order_type] if args.key?(:order_type)
|
|
|
|
@sort_order = args[:sort_order] if args.key?(:sort_order)
|
2017-03-27 22:14:47 +00:00
|
|
|
end
|
|
|
|
end
|
2017-02-13 23:28:52 +00:00
|
|
|
|
2019-03-20 00:37:12 +00:00
|
|
|
# Represents details collected when the visitor views a page.
|
|
|
|
class PageviewData
|
|
|
|
include Google::Apis::Core::Hashable
|
|
|
|
|
|
|
|
# The URL of the page that the visitor viewed.
|
|
|
|
# Corresponds to the JSON property `pagePath`
|
|
|
|
# @return [String]
|
|
|
|
attr_accessor :page_path
|
|
|
|
|
|
|
|
# The title of the page that the visitor viewed.
|
|
|
|
# Corresponds to the JSON property `pageTitle`
|
|
|
|
# @return [String]
|
|
|
|
attr_accessor :page_title
|
|
|
|
|
|
|
|
def initialize(**args)
|
|
|
|
update!(**args)
|
|
|
|
end
|
|
|
|
|
|
|
|
# Update properties of this object
|
|
|
|
def update!(**args)
|
|
|
|
@page_path = args[:page_path] if args.key?(:page_path)
|
|
|
|
@page_title = args[:page_title] if args.key?(:page_title)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# The Pivot describes the pivot section in the request.
|
|
|
|
# The Pivot helps rearrange the information in the table for certain reports
|
|
|
|
# by pivoting your data on a second dimension.
|
|
|
|
class Pivot
|
2017-03-27 22:14:47 +00:00
|
|
|
include Google::Apis::Core::Hashable
|
2016-05-16 16:49:15 +00:00
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# DimensionFilterClauses are logically combined with an `AND` operator: only
|
|
|
|
# data that is included by all these DimensionFilterClauses contributes to
|
|
|
|
# the values in this pivot region. Dimension filters can be used to restrict
|
|
|
|
# the columns shown in the pivot region. For example if you have
|
|
|
|
# `ga:browser` as the requested dimension in the pivot region, and you
|
|
|
|
# specify key filters to restrict `ga:browser` to only "IE" or "Firefox",
|
|
|
|
# then only those two browsers would show up as columns.
|
|
|
|
# Corresponds to the JSON property `dimensionFilterClauses`
|
|
|
|
# @return [Array<Google::Apis::AnalyticsreportingV4::DimensionFilterClause>]
|
|
|
|
attr_accessor :dimension_filter_clauses
|
|
|
|
|
|
|
|
# A list of dimensions to show as pivot columns. A Pivot can have a maximum
|
|
|
|
# of 4 dimensions. Pivot dimensions are part of the restriction on the
|
|
|
|
# total number of dimensions allowed in the request.
|
|
|
|
# Corresponds to the JSON property `dimensions`
|
|
|
|
# @return [Array<Google::Apis::AnalyticsreportingV4::Dimension>]
|
|
|
|
attr_accessor :dimensions
|
|
|
|
|
|
|
|
# Specifies the maximum number of groups to return.
|
|
|
|
# The default value is 10, also the maximum value is 1,000.
|
|
|
|
# Corresponds to the JSON property `maxGroupCount`
|
|
|
|
# @return [Fixnum]
|
|
|
|
attr_accessor :max_group_count
|
|
|
|
|
|
|
|
# The pivot metrics. Pivot metrics are part of the
|
|
|
|
# restriction on total number of metrics allowed in the request.
|
|
|
|
# Corresponds to the JSON property `metrics`
|
|
|
|
# @return [Array<Google::Apis::AnalyticsreportingV4::Metric>]
|
|
|
|
attr_accessor :metrics
|
|
|
|
|
|
|
|
# If k metrics were requested, then the response will contain some
|
|
|
|
# data-dependent multiple of k columns in the report. E.g., if you pivoted
|
|
|
|
# on the dimension `ga:browser` then you'd get k columns for "Firefox", k
|
|
|
|
# columns for "IE", k columns for "Chrome", etc. The ordering of the groups
|
|
|
|
# of columns is determined by descending order of "total" for the first of
|
|
|
|
# the k values. Ties are broken by lexicographic ordering of the first
|
|
|
|
# pivot dimension, then lexicographic ordering of the second pivot
|
|
|
|
# dimension, and so on. E.g., if the totals for the first value for
|
|
|
|
# Firefox, IE, and Chrome were 8, 2, 8, respectively, the order of columns
|
|
|
|
# would be Chrome, Firefox, IE.
|
|
|
|
# The following let you choose which of the groups of k columns are
|
|
|
|
# included in the response.
|
|
|
|
# Corresponds to the JSON property `startGroup`
|
|
|
|
# @return [Fixnum]
|
|
|
|
attr_accessor :start_group
|
2017-03-27 22:14:47 +00:00
|
|
|
|
|
|
|
def initialize(**args)
|
|
|
|
update!(**args)
|
|
|
|
end
|
|
|
|
|
|
|
|
# Update properties of this object
|
|
|
|
def update!(**args)
|
2017-08-25 19:54:22 +00:00
|
|
|
@dimension_filter_clauses = args[:dimension_filter_clauses] if args.key?(:dimension_filter_clauses)
|
|
|
|
@dimensions = args[:dimensions] if args.key?(:dimensions)
|
|
|
|
@max_group_count = args[:max_group_count] if args.key?(:max_group_count)
|
|
|
|
@metrics = args[:metrics] if args.key?(:metrics)
|
|
|
|
@start_group = args[:start_group] if args.key?(:start_group)
|
2017-03-27 22:14:47 +00:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# The headers for each of the pivot sections defined in the request.
|
|
|
|
class PivotHeader
|
2017-03-27 22:14:47 +00:00
|
|
|
include Google::Apis::Core::Hashable
|
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# A single pivot section header.
|
|
|
|
# Corresponds to the JSON property `pivotHeaderEntries`
|
|
|
|
# @return [Array<Google::Apis::AnalyticsreportingV4::PivotHeaderEntry>]
|
|
|
|
attr_accessor :pivot_header_entries
|
2017-06-14 17:02:03 +00:00
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# The total number of groups for this pivot.
|
|
|
|
# Corresponds to the JSON property `totalPivotGroupsCount`
|
|
|
|
# @return [Fixnum]
|
|
|
|
attr_accessor :total_pivot_groups_count
|
2017-07-12 20:10:42 +00:00
|
|
|
|
2017-06-14 17:02:03 +00:00
|
|
|
def initialize(**args)
|
|
|
|
update!(**args)
|
|
|
|
end
|
|
|
|
|
|
|
|
# Update properties of this object
|
|
|
|
def update!(**args)
|
2017-08-25 19:54:22 +00:00
|
|
|
@pivot_header_entries = args[:pivot_header_entries] if args.key?(:pivot_header_entries)
|
|
|
|
@total_pivot_groups_count = args[:total_pivot_groups_count] if args.key?(:total_pivot_groups_count)
|
2017-06-14 17:02:03 +00:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# The headers for the each of the metric column corresponding to the metrics
|
|
|
|
# requested in the pivots section of the response.
|
|
|
|
class PivotHeaderEntry
|
2017-06-14 17:02:03 +00:00
|
|
|
include Google::Apis::Core::Hashable
|
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# The name of the dimensions in the pivot response.
|
|
|
|
# Corresponds to the JSON property `dimensionNames`
|
|
|
|
# @return [Array<String>]
|
|
|
|
attr_accessor :dimension_names
|
2017-06-14 17:02:03 +00:00
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# The values for the dimensions in the pivot.
|
|
|
|
# Corresponds to the JSON property `dimensionValues`
|
|
|
|
# @return [Array<String>]
|
|
|
|
attr_accessor :dimension_values
|
2017-06-14 17:02:03 +00:00
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# Header for the metrics.
|
|
|
|
# Corresponds to the JSON property `metric`
|
|
|
|
# @return [Google::Apis::AnalyticsreportingV4::MetricHeaderEntry]
|
|
|
|
attr_accessor :metric
|
2017-06-14 17:02:03 +00:00
|
|
|
|
2017-03-27 22:14:47 +00:00
|
|
|
def initialize(**args)
|
|
|
|
update!(**args)
|
|
|
|
end
|
2017-03-10 21:11:09 +00:00
|
|
|
|
2017-03-27 22:14:47 +00:00
|
|
|
# Update properties of this object
|
|
|
|
def update!(**args)
|
2017-08-25 19:54:22 +00:00
|
|
|
@dimension_names = args[:dimension_names] if args.key?(:dimension_names)
|
|
|
|
@dimension_values = args[:dimension_values] if args.key?(:dimension_values)
|
|
|
|
@metric = args[:metric] if args.key?(:metric)
|
2017-03-27 22:14:47 +00:00
|
|
|
end
|
|
|
|
end
|
2017-03-10 21:11:09 +00:00
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# The metric values in the pivot region.
|
|
|
|
class PivotValueRegion
|
2017-03-27 22:14:47 +00:00
|
|
|
include Google::Apis::Core::Hashable
|
2017-03-10 21:11:09 +00:00
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# The values of the metrics in each of the pivot regions.
|
2017-06-14 17:02:03 +00:00
|
|
|
# Corresponds to the JSON property `values`
|
2017-05-26 16:44:32 +00:00
|
|
|
# @return [Array<String>]
|
2017-06-14 17:02:03 +00:00
|
|
|
attr_accessor :values
|
2017-06-02 06:11:31 +00:00
|
|
|
|
2016-05-16 16:49:15 +00:00
|
|
|
def initialize(**args)
|
|
|
|
update!(**args)
|
|
|
|
end
|
|
|
|
|
|
|
|
# Update properties of this object
|
|
|
|
def update!(**args)
|
2017-06-14 17:02:03 +00:00
|
|
|
@values = args[:values] if args.key?(:values)
|
2017-03-10 21:11:09 +00:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2019-03-20 00:37:12 +00:00
|
|
|
# Details of the products in an e-commerce transaction.
|
|
|
|
class ProductData
|
|
|
|
include Google::Apis::Core::Hashable
|
|
|
|
|
|
|
|
# The total revenue from purchased product items.
|
|
|
|
# Corresponds to the JSON property `itemRevenue`
|
|
|
|
# @return [Float]
|
|
|
|
attr_accessor :item_revenue
|
|
|
|
|
|
|
|
# The product name, supplied by the e-commerce tracking application, for
|
|
|
|
# the purchased items.
|
|
|
|
# Corresponds to the JSON property `productName`
|
|
|
|
# @return [String]
|
|
|
|
attr_accessor :product_name
|
|
|
|
|
|
|
|
# Total number of this product units in the transaction.
|
|
|
|
# Corresponds to the JSON property `productQuantity`
|
|
|
|
# @return [Fixnum]
|
|
|
|
attr_accessor :product_quantity
|
|
|
|
|
|
|
|
# Unique code that represents the product.
|
|
|
|
# Corresponds to the JSON property `productSku`
|
|
|
|
# @return [String]
|
|
|
|
attr_accessor :product_sku
|
|
|
|
|
|
|
|
def initialize(**args)
|
|
|
|
update!(**args)
|
|
|
|
end
|
|
|
|
|
|
|
|
# Update properties of this object
|
|
|
|
def update!(**args)
|
|
|
|
@item_revenue = args[:item_revenue] if args.key?(:item_revenue)
|
|
|
|
@product_name = args[:product_name] if args.key?(:product_name)
|
|
|
|
@product_quantity = args[:product_quantity] if args.key?(:product_quantity)
|
|
|
|
@product_sku = args[:product_sku] if args.key?(:product_sku)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# The data response corresponding to the request.
|
|
|
|
class Report
|
2017-03-10 21:11:09 +00:00
|
|
|
include Google::Apis::Core::Hashable
|
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# Column headers.
|
|
|
|
# Corresponds to the JSON property `columnHeader`
|
|
|
|
# @return [Google::Apis::AnalyticsreportingV4::ColumnHeader]
|
|
|
|
attr_accessor :column_header
|
2017-07-12 20:10:42 +00:00
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# The data part of the report.
|
|
|
|
# Corresponds to the JSON property `data`
|
|
|
|
# @return [Google::Apis::AnalyticsreportingV4::ReportData]
|
|
|
|
attr_accessor :data
|
|
|
|
|
|
|
|
# Page token to retrieve the next page of results in the list.
|
|
|
|
# Corresponds to the JSON property `nextPageToken`
|
|
|
|
# @return [String]
|
|
|
|
attr_accessor :next_page_token
|
2017-05-26 16:44:32 +00:00
|
|
|
|
2017-03-10 21:11:09 +00:00
|
|
|
def initialize(**args)
|
|
|
|
update!(**args)
|
|
|
|
end
|
|
|
|
|
|
|
|
# Update properties of this object
|
|
|
|
def update!(**args)
|
2017-08-25 19:54:22 +00:00
|
|
|
@column_header = args[:column_header] if args.key?(:column_header)
|
|
|
|
@data = args[:data] if args.key?(:data)
|
|
|
|
@next_page_token = args[:next_page_token] if args.key?(:next_page_token)
|
2016-05-16 16:49:15 +00:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# The data part of the report.
|
|
|
|
class ReportData
|
2016-05-16 16:49:15 +00:00
|
|
|
include Google::Apis::Core::Hashable
|
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# The last time the data in the report was refreshed. All the hits received
|
|
|
|
# before this timestamp are included in the calculation of the report.
|
|
|
|
# Corresponds to the JSON property `dataLastRefreshed`
|
|
|
|
# @return [String]
|
|
|
|
attr_accessor :data_last_refreshed
|
|
|
|
|
|
|
|
# Indicates if response to this request is golden or not. Data is
|
|
|
|
# golden when the exact same request will not produce any new results if
|
|
|
|
# asked at a later point in time.
|
|
|
|
# Corresponds to the JSON property `isDataGolden`
|
|
|
|
# @return [Boolean]
|
|
|
|
attr_accessor :is_data_golden
|
|
|
|
alias_method :is_data_golden?, :is_data_golden
|
|
|
|
|
|
|
|
# Minimum and maximum values seen over all matching rows. These are both
|
|
|
|
# empty when `hideValueRanges` in the request is false, or when
|
|
|
|
# rowCount is zero.
|
|
|
|
# Corresponds to the JSON property `maximums`
|
|
|
|
# @return [Array<Google::Apis::AnalyticsreportingV4::DateRangeValues>]
|
|
|
|
attr_accessor :maximums
|
|
|
|
|
|
|
|
# Minimum and maximum values seen over all matching rows. These are both
|
|
|
|
# empty when `hideValueRanges` in the request is false, or when
|
|
|
|
# rowCount is zero.
|
|
|
|
# Corresponds to the JSON property `minimums`
|
|
|
|
# @return [Array<Google::Apis::AnalyticsreportingV4::DateRangeValues>]
|
|
|
|
attr_accessor :minimums
|
|
|
|
|
|
|
|
# Total number of matching rows for this query.
|
|
|
|
# Corresponds to the JSON property `rowCount`
|
|
|
|
# @return [Fixnum]
|
|
|
|
attr_accessor :row_count
|
|
|
|
|
|
|
|
# There's one ReportRow for every unique combination of dimensions.
|
|
|
|
# Corresponds to the JSON property `rows`
|
|
|
|
# @return [Array<Google::Apis::AnalyticsreportingV4::ReportRow>]
|
|
|
|
attr_accessor :rows
|
|
|
|
|
|
|
|
# If the results are
|
|
|
|
# [sampled](https://support.google.com/analytics/answer/2637192),
|
|
|
|
# this returns the total number of samples read, one entry per date range.
|
|
|
|
# If the results are not sampled this field will not be defined. See
|
|
|
|
# [developer guide](/analytics/devguides/reporting/core/v4/basics#sampling)
|
|
|
|
# for details.
|
|
|
|
# Corresponds to the JSON property `samplesReadCounts`
|
|
|
|
# @return [Array<Fixnum>]
|
|
|
|
attr_accessor :samples_read_counts
|
|
|
|
|
|
|
|
# If the results are
|
|
|
|
# [sampled](https://support.google.com/analytics/answer/2637192),
|
|
|
|
# this returns the total number of
|
|
|
|
# samples present, one entry per date range. If the results are not sampled
|
|
|
|
# this field will not be defined. See
|
|
|
|
# [developer guide](/analytics/devguides/reporting/core/v4/basics#sampling)
|
|
|
|
# for details.
|
|
|
|
# Corresponds to the JSON property `samplingSpaceSizes`
|
|
|
|
# @return [Array<Fixnum>]
|
|
|
|
attr_accessor :sampling_space_sizes
|
|
|
|
|
|
|
|
# For each requested date range, for the set of all rows that match
|
|
|
|
# the query, every requested value format gets a total. The total
|
|
|
|
# for a value format is computed by first totaling the metrics
|
|
|
|
# mentioned in the value format and then evaluating the value
|
|
|
|
# format as a scalar expression. E.g., The "totals" for
|
|
|
|
# `3 / (ga:sessions + 2)` we compute
|
|
|
|
# `3 / ((sum of all relevant ga:sessions) + 2)`.
|
|
|
|
# Totals are computed before pagination.
|
|
|
|
# Corresponds to the JSON property `totals`
|
|
|
|
# @return [Array<Google::Apis::AnalyticsreportingV4::DateRangeValues>]
|
|
|
|
attr_accessor :totals
|
2017-05-04 19:35:56 +00:00
|
|
|
|
2016-05-16 16:49:15 +00:00
|
|
|
def initialize(**args)
|
|
|
|
update!(**args)
|
|
|
|
end
|
|
|
|
|
|
|
|
# Update properties of this object
|
|
|
|
def update!(**args)
|
2017-08-25 19:54:22 +00:00
|
|
|
@data_last_refreshed = args[:data_last_refreshed] if args.key?(:data_last_refreshed)
|
|
|
|
@is_data_golden = args[:is_data_golden] if args.key?(:is_data_golden)
|
|
|
|
@maximums = args[:maximums] if args.key?(:maximums)
|
|
|
|
@minimums = args[:minimums] if args.key?(:minimums)
|
|
|
|
@row_count = args[:row_count] if args.key?(:row_count)
|
|
|
|
@rows = args[:rows] if args.key?(:rows)
|
|
|
|
@samples_read_counts = args[:samples_read_counts] if args.key?(:samples_read_counts)
|
|
|
|
@sampling_space_sizes = args[:sampling_space_sizes] if args.key?(:sampling_space_sizes)
|
|
|
|
@totals = args[:totals] if args.key?(:totals)
|
2016-05-16 16:49:15 +00:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# The main request class which specifies the Reporting API request.
|
|
|
|
class ReportRequest
|
2016-05-16 16:49:15 +00:00
|
|
|
include Google::Apis::Core::Hashable
|
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# Defines a cohort group.
|
|
|
|
# For example:
|
|
|
|
# "cohortGroup": `
|
|
|
|
# "cohorts": [`
|
|
|
|
# "name": "cohort 1",
|
|
|
|
# "type": "FIRST_VISIT_DATE",
|
|
|
|
# "dateRange": ` "startDate": "2015-08-01", "endDate": "2015-08-01" `
|
|
|
|
# `,`
|
|
|
|
# "name": "cohort 2"
|
|
|
|
# "type": "FIRST_VISIT_DATE"
|
|
|
|
# "dateRange": ` "startDate": "2015-07-01", "endDate": "2015-07-01" `
|
|
|
|
# `]
|
|
|
|
# `
|
|
|
|
# Corresponds to the JSON property `cohortGroup`
|
|
|
|
# @return [Google::Apis::AnalyticsreportingV4::CohortGroup]
|
|
|
|
attr_accessor :cohort_group
|
2017-07-12 20:10:42 +00:00
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# Date ranges in the request. The request can have a maximum of 2 date
|
|
|
|
# ranges. The response will contain a set of metric values for each
|
|
|
|
# combination of the dimensions for each date range in the request. So, if
|
|
|
|
# there are two date ranges, there will be two set of metric values, one for
|
|
|
|
# the original date range and one for the second date range.
|
|
|
|
# The `reportRequest.dateRanges` field should not be specified for cohorts
|
|
|
|
# or Lifetime value requests.
|
|
|
|
# If a date range is not provided, the default date range is (startDate:
|
|
|
|
# current date - 7 days, endDate: current date - 1 day). Every
|
|
|
|
# [ReportRequest](#ReportRequest) within a `batchGet` method must
|
|
|
|
# contain the same `dateRanges` definition.
|
|
|
|
# Corresponds to the JSON property `dateRanges`
|
|
|
|
# @return [Array<Google::Apis::AnalyticsreportingV4::DateRange>]
|
|
|
|
attr_accessor :date_ranges
|
|
|
|
|
|
|
|
# The dimension filter clauses for filtering Dimension Values. They are
|
|
|
|
# logically combined with the `AND` operator. Note that filtering occurs
|
|
|
|
# before any dimensions are aggregated, so that the returned metrics
|
|
|
|
# represent the total for only the relevant dimensions.
|
|
|
|
# Corresponds to the JSON property `dimensionFilterClauses`
|
|
|
|
# @return [Array<Google::Apis::AnalyticsreportingV4::DimensionFilterClause>]
|
|
|
|
attr_accessor :dimension_filter_clauses
|
|
|
|
|
|
|
|
# The dimensions requested.
|
|
|
|
# Requests can have a total of 7 dimensions.
|
|
|
|
# Corresponds to the JSON property `dimensions`
|
|
|
|
# @return [Array<Google::Apis::AnalyticsreportingV4::Dimension>]
|
|
|
|
attr_accessor :dimensions
|
|
|
|
|
|
|
|
# Dimension or metric filters that restrict the data returned for your
|
|
|
|
# request. To use the `filtersExpression`, supply a dimension or metric on
|
|
|
|
# which to filter, followed by the filter expression. For example, the
|
|
|
|
# following expression selects `ga:browser` dimension which starts with
|
|
|
|
# Firefox; `ga:browser=~^Firefox`. For more information on dimensions
|
|
|
|
# and metric filters, see
|
2019-07-11 00:38:42 +00:00
|
|
|
# [Filters
|
|
|
|
# reference](https://developers.google.com/analytics/devguides/reporting/core/v3/
|
|
|
|
# reference#filters).
|
2017-08-25 19:54:22 +00:00
|
|
|
# Corresponds to the JSON property `filtersExpression`
|
|
|
|
# @return [String]
|
|
|
|
attr_accessor :filters_expression
|
|
|
|
|
|
|
|
# If set to true, hides the total of all metrics for all the matching rows,
|
|
|
|
# for every date range. The default false and will return the totals.
|
|
|
|
# Corresponds to the JSON property `hideTotals`
|
|
|
|
# @return [Boolean]
|
|
|
|
attr_accessor :hide_totals
|
|
|
|
alias_method :hide_totals?, :hide_totals
|
|
|
|
|
|
|
|
# If set to true, hides the minimum and maximum across all matching rows.
|
|
|
|
# The default is false and the value ranges are returned.
|
|
|
|
# Corresponds to the JSON property `hideValueRanges`
|
|
|
|
# @return [Boolean]
|
|
|
|
attr_accessor :hide_value_ranges
|
|
|
|
alias_method :hide_value_ranges?, :hide_value_ranges
|
|
|
|
|
|
|
|
# If set to false, the response does not include rows if all the retrieved
|
|
|
|
# metrics are equal to zero. The default is false which will exclude these
|
|
|
|
# rows.
|
|
|
|
# Corresponds to the JSON property `includeEmptyRows`
|
|
|
|
# @return [Boolean]
|
|
|
|
attr_accessor :include_empty_rows
|
|
|
|
alias_method :include_empty_rows?, :include_empty_rows
|
|
|
|
|
|
|
|
# The metric filter clauses. They are logically combined with the `AND`
|
|
|
|
# operator. Metric filters look at only the first date range and not the
|
|
|
|
# comparing date range. Note that filtering on metrics occurs after the
|
|
|
|
# metrics are aggregated.
|
|
|
|
# Corresponds to the JSON property `metricFilterClauses`
|
|
|
|
# @return [Array<Google::Apis::AnalyticsreportingV4::MetricFilterClause>]
|
|
|
|
attr_accessor :metric_filter_clauses
|
|
|
|
|
|
|
|
# The metrics requested.
|
|
|
|
# Requests must specify at least one metric. Requests can have a
|
|
|
|
# total of 10 metrics.
|
|
|
|
# Corresponds to the JSON property `metrics`
|
|
|
|
# @return [Array<Google::Apis::AnalyticsreportingV4::Metric>]
|
|
|
|
attr_accessor :metrics
|
|
|
|
|
|
|
|
# Sort order on output rows. To compare two rows, the elements of the
|
|
|
|
# following are applied in order until a difference is found. All date
|
|
|
|
# ranges in the output get the same row order.
|
|
|
|
# Corresponds to the JSON property `orderBys`
|
|
|
|
# @return [Array<Google::Apis::AnalyticsreportingV4::OrderBy>]
|
|
|
|
attr_accessor :order_bys
|
|
|
|
|
|
|
|
# Page size is for paging and specifies the maximum number of returned rows.
|
|
|
|
# Page size should be >= 0. A query returns the default of 1,000 rows.
|
2018-05-17 00:36:16 +00:00
|
|
|
# The Analytics Core Reporting API returns a maximum of 100,000 rows per
|
2017-08-25 19:54:22 +00:00
|
|
|
# request, no matter how many you ask for. It can also return fewer rows
|
|
|
|
# than requested, if there aren't as many dimension segments as you expect.
|
|
|
|
# For instance, there are fewer than 300 possible values for `ga:country`,
|
|
|
|
# so when segmenting only by country, you can't get more than 300 rows,
|
|
|
|
# even if you set `pageSize` to a higher value.
|
|
|
|
# Corresponds to the JSON property `pageSize`
|
2017-06-14 17:02:03 +00:00
|
|
|
# @return [Fixnum]
|
2017-08-25 19:54:22 +00:00
|
|
|
attr_accessor :page_size
|
|
|
|
|
|
|
|
# A continuation token to get the next page of the results. Adding this to
|
|
|
|
# the request will return the rows after the pageToken. The pageToken should
|
|
|
|
# be the value returned in the nextPageToken parameter in the response to
|
|
|
|
# the GetReports request.
|
|
|
|
# Corresponds to the JSON property `pageToken`
|
|
|
|
# @return [String]
|
|
|
|
attr_accessor :page_token
|
2017-06-14 17:02:03 +00:00
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# The pivot definitions. Requests can have a maximum of 2 pivots.
|
|
|
|
# Corresponds to the JSON property `pivots`
|
|
|
|
# @return [Array<Google::Apis::AnalyticsreportingV4::Pivot>]
|
|
|
|
attr_accessor :pivots
|
2016-05-16 16:49:15 +00:00
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# The desired report
|
|
|
|
# [sample](https://support.google.com/analytics/answer/2637192) size.
|
|
|
|
# If the the `samplingLevel` field is unspecified the `DEFAULT` sampling
|
|
|
|
# level is used. Every [ReportRequest](#ReportRequest) within a
|
|
|
|
# `batchGet` method must contain the same `samplingLevel` definition. See
|
|
|
|
# [developer guide](/analytics/devguides/reporting/core/v4/basics#sampling)
|
|
|
|
# for details.
|
|
|
|
# Corresponds to the JSON property `samplingLevel`
|
|
|
|
# @return [String]
|
|
|
|
attr_accessor :sampling_level
|
2017-06-14 17:02:03 +00:00
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# Segment the data returned for the request. A segment definition helps look
|
|
|
|
# at a subset of the segment request. A request can contain up to four
|
|
|
|
# segments. Every [ReportRequest](#ReportRequest) within a
|
|
|
|
# `batchGet` method must contain the same `segments` definition. Requests
|
|
|
|
# with segments must have the `ga:segment` dimension.
|
|
|
|
# Corresponds to the JSON property `segments`
|
|
|
|
# @return [Array<Google::Apis::AnalyticsreportingV4::Segment>]
|
|
|
|
attr_accessor :segments
|
|
|
|
|
|
|
|
# The Analytics
|
|
|
|
# [view ID](https://support.google.com/analytics/answer/1009618)
|
|
|
|
# from which to retrieve data. Every [ReportRequest](#ReportRequest)
|
|
|
|
# within a `batchGet` method must contain the same `viewId`.
|
|
|
|
# Corresponds to the JSON property `viewId`
|
|
|
|
# @return [String]
|
|
|
|
attr_accessor :view_id
|
2017-06-14 17:02:03 +00:00
|
|
|
|
2016-05-16 16:49:15 +00:00
|
|
|
def initialize(**args)
|
|
|
|
update!(**args)
|
|
|
|
end
|
|
|
|
|
|
|
|
# Update properties of this object
|
|
|
|
def update!(**args)
|
2017-08-25 19:54:22 +00:00
|
|
|
@cohort_group = args[:cohort_group] if args.key?(:cohort_group)
|
|
|
|
@date_ranges = args[:date_ranges] if args.key?(:date_ranges)
|
2017-06-14 17:02:03 +00:00
|
|
|
@dimension_filter_clauses = args[:dimension_filter_clauses] if args.key?(:dimension_filter_clauses)
|
2017-07-12 20:10:42 +00:00
|
|
|
@dimensions = args[:dimensions] if args.key?(:dimensions)
|
2017-08-25 19:54:22 +00:00
|
|
|
@filters_expression = args[:filters_expression] if args.key?(:filters_expression)
|
|
|
|
@hide_totals = args[:hide_totals] if args.key?(:hide_totals)
|
|
|
|
@hide_value_ranges = args[:hide_value_ranges] if args.key?(:hide_value_ranges)
|
|
|
|
@include_empty_rows = args[:include_empty_rows] if args.key?(:include_empty_rows)
|
|
|
|
@metric_filter_clauses = args[:metric_filter_clauses] if args.key?(:metric_filter_clauses)
|
|
|
|
@metrics = args[:metrics] if args.key?(:metrics)
|
|
|
|
@order_bys = args[:order_bys] if args.key?(:order_bys)
|
|
|
|
@page_size = args[:page_size] if args.key?(:page_size)
|
|
|
|
@page_token = args[:page_token] if args.key?(:page_token)
|
|
|
|
@pivots = args[:pivots] if args.key?(:pivots)
|
|
|
|
@sampling_level = args[:sampling_level] if args.key?(:sampling_level)
|
|
|
|
@segments = args[:segments] if args.key?(:segments)
|
|
|
|
@view_id = args[:view_id] if args.key?(:view_id)
|
2016-05-16 16:49:15 +00:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# A row in the report.
|
|
|
|
class ReportRow
|
2016-05-16 16:49:15 +00:00
|
|
|
include Google::Apis::Core::Hashable
|
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# List of requested dimensions.
|
|
|
|
# Corresponds to the JSON property `dimensions`
|
2017-07-12 20:10:42 +00:00
|
|
|
# @return [Array<String>]
|
2017-08-25 19:54:22 +00:00
|
|
|
attr_accessor :dimensions
|
2017-07-12 20:10:42 +00:00
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# List of metrics for each requested DateRange.
|
|
|
|
# Corresponds to the JSON property `metrics`
|
|
|
|
# @return [Array<Google::Apis::AnalyticsreportingV4::DateRangeValues>]
|
|
|
|
attr_accessor :metrics
|
2017-05-26 16:44:32 +00:00
|
|
|
|
2017-06-02 06:11:31 +00:00
|
|
|
def initialize(**args)
|
|
|
|
update!(**args)
|
|
|
|
end
|
2017-05-26 16:44:32 +00:00
|
|
|
|
2017-06-02 06:11:31 +00:00
|
|
|
# Update properties of this object
|
|
|
|
def update!(**args)
|
2017-08-25 19:54:22 +00:00
|
|
|
@dimensions = args[:dimensions] if args.key?(:dimensions)
|
|
|
|
@metrics = args[:metrics] if args.key?(:metrics)
|
2017-06-02 06:11:31 +00:00
|
|
|
end
|
|
|
|
end
|
2017-05-26 16:44:32 +00:00
|
|
|
|
2017-11-10 00:35:09 +00:00
|
|
|
# The resource quota tokens remaining for the property after the request is
|
|
|
|
# completed.
|
|
|
|
class ResourceQuotasRemaining
|
|
|
|
include Google::Apis::Core::Hashable
|
|
|
|
|
|
|
|
# Daily resource quota remaining remaining.
|
|
|
|
# Corresponds to the JSON property `dailyQuotaTokensRemaining`
|
|
|
|
# @return [Fixnum]
|
|
|
|
attr_accessor :daily_quota_tokens_remaining
|
|
|
|
|
|
|
|
# Hourly resource quota tokens remaining.
|
|
|
|
# Corresponds to the JSON property `hourlyQuotaTokensRemaining`
|
|
|
|
# @return [Fixnum]
|
|
|
|
attr_accessor :hourly_quota_tokens_remaining
|
|
|
|
|
|
|
|
def initialize(**args)
|
|
|
|
update!(**args)
|
|
|
|
end
|
|
|
|
|
|
|
|
# Update properties of this object
|
|
|
|
def update!(**args)
|
|
|
|
@daily_quota_tokens_remaining = args[:daily_quota_tokens_remaining] if args.key?(:daily_quota_tokens_remaining)
|
|
|
|
@hourly_quota_tokens_remaining = args[:hourly_quota_tokens_remaining] if args.key?(:hourly_quota_tokens_remaining)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2019-03-20 00:37:12 +00:00
|
|
|
#
|
|
|
|
class ScreenviewData
|
|
|
|
include Google::Apis::Core::Hashable
|
|
|
|
|
|
|
|
# The application name.
|
|
|
|
# Corresponds to the JSON property `appName`
|
|
|
|
# @return [String]
|
|
|
|
attr_accessor :app_name
|
|
|
|
|
|
|
|
# Mobile manufacturer or branded name. Eg: "Google", "Apple" etc.
|
|
|
|
# Corresponds to the JSON property `mobileDeviceBranding`
|
|
|
|
# @return [String]
|
|
|
|
attr_accessor :mobile_device_branding
|
|
|
|
|
|
|
|
# Mobile device model. Eg: "Pixel", "iPhone" etc.
|
|
|
|
# Corresponds to the JSON property `mobileDeviceModel`
|
|
|
|
# @return [String]
|
|
|
|
attr_accessor :mobile_device_model
|
|
|
|
|
|
|
|
# The name of the screen.
|
|
|
|
# Corresponds to the JSON property `screenName`
|
|
|
|
# @return [String]
|
|
|
|
attr_accessor :screen_name
|
|
|
|
|
|
|
|
def initialize(**args)
|
|
|
|
update!(**args)
|
|
|
|
end
|
|
|
|
|
|
|
|
# Update properties of this object
|
|
|
|
def update!(**args)
|
|
|
|
@app_name = args[:app_name] if args.key?(:app_name)
|
|
|
|
@mobile_device_branding = args[:mobile_device_branding] if args.key?(:mobile_device_branding)
|
|
|
|
@mobile_device_model = args[:mobile_device_model] if args.key?(:mobile_device_model)
|
|
|
|
@screen_name = args[:screen_name] if args.key?(:screen_name)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
# The request to fetch User Report from Reporting API `userActivity:get` call.
|
|
|
|
class SearchUserActivityRequest
|
|
|
|
include Google::Apis::Core::Hashable
|
|
|
|
|
|
|
|
# Set of all activity types being requested. Only acvities matching these
|
|
|
|
# types will be returned in the response. If empty, all activies will be
|
|
|
|
# returned.
|
|
|
|
# Corresponds to the JSON property `activityTypes`
|
|
|
|
# @return [Array<String>]
|
|
|
|
attr_accessor :activity_types
|
|
|
|
|
|
|
|
# A contiguous set of days: startDate, startDate + 1 day, ..., endDate.
|
|
|
|
# The start and end dates are specified in
|
|
|
|
# [ISO8601](https://en.wikipedia.org/wiki/ISO_8601) date format `YYYY-MM-DD`.
|
|
|
|
# Corresponds to the JSON property `dateRange`
|
|
|
|
# @return [Google::Apis::AnalyticsreportingV4::DateRange]
|
|
|
|
attr_accessor :date_range
|
|
|
|
|
|
|
|
# Page size is for paging and specifies the maximum number of returned rows.
|
|
|
|
# Page size should be > 0. If the value is 0 or if the field isn't specified,
|
|
|
|
# the request returns the default of 1000 rows per page.
|
|
|
|
# Corresponds to the JSON property `pageSize`
|
|
|
|
# @return [Fixnum]
|
|
|
|
attr_accessor :page_size
|
|
|
|
|
|
|
|
# A continuation token to get the next page of the results. Adding this to
|
|
|
|
# the request will return the rows after the pageToken. The pageToken should
|
|
|
|
# be the value returned in the nextPageToken parameter in the response to
|
|
|
|
# the [SearchUserActivityRequest](#SearchUserActivityRequest) request.
|
|
|
|
# Corresponds to the JSON property `pageToken`
|
|
|
|
# @return [String]
|
|
|
|
attr_accessor :page_token
|
|
|
|
|
|
|
|
# Contains information to identify a particular user uniquely.
|
|
|
|
# Corresponds to the JSON property `user`
|
|
|
|
# @return [Google::Apis::AnalyticsreportingV4::User]
|
|
|
|
attr_accessor :user
|
|
|
|
|
|
|
|
# Required. The Analytics
|
|
|
|
# [view ID](https://support.google.com/analytics/answer/1009618)
|
|
|
|
# from which to retrieve data. Every
|
|
|
|
# [SearchUserActivityRequest](#SearchUserActivityRequest) must contain the
|
|
|
|
# `viewId`.
|
|
|
|
# Corresponds to the JSON property `viewId`
|
|
|
|
# @return [String]
|
|
|
|
attr_accessor :view_id
|
|
|
|
|
|
|
|
def initialize(**args)
|
|
|
|
update!(**args)
|
|
|
|
end
|
|
|
|
|
|
|
|
# Update properties of this object
|
|
|
|
def update!(**args)
|
|
|
|
@activity_types = args[:activity_types] if args.key?(:activity_types)
|
|
|
|
@date_range = args[:date_range] if args.key?(:date_range)
|
|
|
|
@page_size = args[:page_size] if args.key?(:page_size)
|
|
|
|
@page_token = args[:page_token] if args.key?(:page_token)
|
|
|
|
@user = args[:user] if args.key?(:user)
|
|
|
|
@view_id = args[:view_id] if args.key?(:view_id)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
# The response from `userActivity:get` call.
|
|
|
|
class SearchUserActivityResponse
|
|
|
|
include Google::Apis::Core::Hashable
|
|
|
|
|
|
|
|
# This token should be passed to
|
|
|
|
# [SearchUserActivityRequest](#SearchUserActivityRequest) to retrieve the
|
|
|
|
# next page.
|
|
|
|
# Corresponds to the JSON property `nextPageToken`
|
|
|
|
# @return [String]
|
|
|
|
attr_accessor :next_page_token
|
|
|
|
|
|
|
|
# This field represents the
|
|
|
|
# [sampling rate](https://support.google.com/analytics/answer/2637192) for
|
|
|
|
# the given request and is a number between 0.0 to 1.0. See
|
|
|
|
# [developer guide](/analytics/devguides/reporting/core/v4/basics#sampling)
|
|
|
|
# for details.
|
|
|
|
# Corresponds to the JSON property `sampleRate`
|
|
|
|
# @return [Float]
|
|
|
|
attr_accessor :sample_rate
|
|
|
|
|
|
|
|
# Each record represents a session (device details, duration, etc).
|
|
|
|
# Corresponds to the JSON property `sessions`
|
|
|
|
# @return [Array<Google::Apis::AnalyticsreportingV4::UserActivitySession>]
|
|
|
|
attr_accessor :sessions
|
|
|
|
|
|
|
|
# Total rows returned by this query (across different pages).
|
|
|
|
# Corresponds to the JSON property `totalRows`
|
|
|
|
# @return [Fixnum]
|
|
|
|
attr_accessor :total_rows
|
|
|
|
|
|
|
|
def initialize(**args)
|
|
|
|
update!(**args)
|
|
|
|
end
|
|
|
|
|
|
|
|
# Update properties of this object
|
|
|
|
def update!(**args)
|
|
|
|
@next_page_token = args[:next_page_token] if args.key?(:next_page_token)
|
|
|
|
@sample_rate = args[:sample_rate] if args.key?(:sample_rate)
|
|
|
|
@sessions = args[:sessions] if args.key?(:sessions)
|
|
|
|
@total_rows = args[:total_rows] if args.key?(:total_rows)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# The segment definition, if the report needs to be segmented.
|
|
|
|
# A Segment is a subset of the Analytics data. For example, of the entire
|
|
|
|
# set of users, one Segment might be users from a particular country or city.
|
|
|
|
class Segment
|
2017-06-02 06:11:31 +00:00
|
|
|
include Google::Apis::Core::Hashable
|
2017-05-26 16:44:32 +00:00
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# Dynamic segment definition for defining the segment within the request.
|
|
|
|
# A segment can select users, sessions or both.
|
|
|
|
# Corresponds to the JSON property `dynamicSegment`
|
|
|
|
# @return [Google::Apis::AnalyticsreportingV4::DynamicSegment]
|
|
|
|
attr_accessor :dynamic_segment
|
2017-05-26 16:44:32 +00:00
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# The segment ID of a built-in or custom segment, for example `gaid::-3`.
|
|
|
|
# Corresponds to the JSON property `segmentId`
|
|
|
|
# @return [String]
|
|
|
|
attr_accessor :segment_id
|
2017-06-14 17:02:03 +00:00
|
|
|
|
2017-06-02 06:11:31 +00:00
|
|
|
def initialize(**args)
|
|
|
|
update!(**args)
|
|
|
|
end
|
2017-05-26 16:44:32 +00:00
|
|
|
|
2017-06-02 06:11:31 +00:00
|
|
|
# Update properties of this object
|
|
|
|
def update!(**args)
|
2017-08-25 19:54:22 +00:00
|
|
|
@dynamic_segment = args[:dynamic_segment] if args.key?(:dynamic_segment)
|
|
|
|
@segment_id = args[:segment_id] if args.key?(:segment_id)
|
2017-06-02 06:11:31 +00:00
|
|
|
end
|
|
|
|
end
|
2017-05-26 16:44:32 +00:00
|
|
|
|
2017-06-14 17:02:03 +00:00
|
|
|
# SegmentDefinition defines the segment to be a set of SegmentFilters which
|
|
|
|
# are combined together with a logical `AND` operation.
|
|
|
|
class SegmentDefinition
|
2017-06-02 06:11:31 +00:00
|
|
|
include Google::Apis::Core::Hashable
|
2017-05-26 16:44:32 +00:00
|
|
|
|
2017-06-14 17:02:03 +00:00
|
|
|
# A segment is defined by a set of segment filters which are combined
|
|
|
|
# together with a logical `AND` operation.
|
|
|
|
# Corresponds to the JSON property `segmentFilters`
|
|
|
|
# @return [Array<Google::Apis::AnalyticsreportingV4::SegmentFilter>]
|
|
|
|
attr_accessor :segment_filters
|
2016-05-16 16:49:15 +00:00
|
|
|
|
2017-06-02 06:11:31 +00:00
|
|
|
def initialize(**args)
|
|
|
|
update!(**args)
|
|
|
|
end
|
2016-05-16 16:49:15 +00:00
|
|
|
|
2017-06-02 06:11:31 +00:00
|
|
|
# Update properties of this object
|
|
|
|
def update!(**args)
|
2017-06-14 17:02:03 +00:00
|
|
|
@segment_filters = args[:segment_filters] if args.key?(:segment_filters)
|
2017-06-02 06:11:31 +00:00
|
|
|
end
|
|
|
|
end
|
2016-05-16 16:49:15 +00:00
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# Dimension filter specifies the filtering options on a dimension.
|
|
|
|
class SegmentDimensionFilter
|
2017-06-02 06:11:31 +00:00
|
|
|
include Google::Apis::Core::Hashable
|
2016-05-16 16:49:15 +00:00
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# Should the match be case sensitive, ignored for `IN_LIST` operator.
|
|
|
|
# Corresponds to the JSON property `caseSensitive`
|
|
|
|
# @return [Boolean]
|
|
|
|
attr_accessor :case_sensitive
|
|
|
|
alias_method :case_sensitive?, :case_sensitive
|
2017-06-14 17:02:03 +00:00
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# Name of the dimension for which the filter is being applied.
|
|
|
|
# Corresponds to the JSON property `dimensionName`
|
2017-06-14 17:02:03 +00:00
|
|
|
# @return [String]
|
2017-08-25 19:54:22 +00:00
|
|
|
attr_accessor :dimension_name
|
2016-05-16 16:49:15 +00:00
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# The list of expressions, only the first element is used for all operators
|
|
|
|
# Corresponds to the JSON property `expressions`
|
|
|
|
# @return [Array<String>]
|
|
|
|
attr_accessor :expressions
|
2017-07-12 20:10:42 +00:00
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# Maximum comparison values for `BETWEEN` match type.
|
|
|
|
# Corresponds to the JSON property `maxComparisonValue`
|
|
|
|
# @return [String]
|
|
|
|
attr_accessor :max_comparison_value
|
2017-07-12 20:10:42 +00:00
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# Minimum comparison values for `BETWEEN` match type.
|
|
|
|
# Corresponds to the JSON property `minComparisonValue`
|
2017-06-14 17:02:03 +00:00
|
|
|
# @return [String]
|
2017-08-25 19:54:22 +00:00
|
|
|
attr_accessor :min_comparison_value
|
2017-06-14 17:02:03 +00:00
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# The operator to use to match the dimension with the expressions.
|
|
|
|
# Corresponds to the JSON property `operator`
|
|
|
|
# @return [String]
|
|
|
|
attr_accessor :operator
|
2017-03-30 22:30:51 +00:00
|
|
|
|
2016-05-16 16:49:15 +00:00
|
|
|
def initialize(**args)
|
|
|
|
update!(**args)
|
|
|
|
end
|
|
|
|
|
|
|
|
# Update properties of this object
|
|
|
|
def update!(**args)
|
2017-08-25 19:54:22 +00:00
|
|
|
@case_sensitive = args[:case_sensitive] if args.key?(:case_sensitive)
|
|
|
|
@dimension_name = args[:dimension_name] if args.key?(:dimension_name)
|
|
|
|
@expressions = args[:expressions] if args.key?(:expressions)
|
|
|
|
@max_comparison_value = args[:max_comparison_value] if args.key?(:max_comparison_value)
|
|
|
|
@min_comparison_value = args[:min_comparison_value] if args.key?(:min_comparison_value)
|
|
|
|
@operator = args[:operator] if args.key?(:operator)
|
2017-02-13 23:28:52 +00:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# SegmentFilter defines the segment to be either a simple or a sequence
|
|
|
|
# segment. A simple segment condition contains dimension and metric conditions
|
|
|
|
# to select the sessions or users. A sequence segment condition can be used to
|
|
|
|
# select users or sessions based on sequential conditions.
|
|
|
|
class SegmentFilter
|
2017-02-13 23:28:52 +00:00
|
|
|
include Google::Apis::Core::Hashable
|
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# If true, match the complement of simple or sequence segment.
|
|
|
|
# For example, to match all visits not from "New York", we can define the
|
|
|
|
# segment as follows:
|
|
|
|
# "sessionSegment": `
|
|
|
|
# "segmentFilters": [`
|
|
|
|
# "simpleSegment" :`
|
|
|
|
# "orFiltersForSegment": [`
|
|
|
|
# "segmentFilterClauses":[`
|
|
|
|
# "dimensionFilter": `
|
|
|
|
# "dimensionName": "ga:city",
|
|
|
|
# "expressions": ["New York"]
|
|
|
|
# `
|
|
|
|
# `]
|
|
|
|
# `]
|
|
|
|
# `,
|
|
|
|
# "not": "True"
|
|
|
|
# `]
|
|
|
|
# `,
|
|
|
|
# Corresponds to the JSON property `not`
|
2017-07-12 20:10:42 +00:00
|
|
|
# @return [Boolean]
|
2017-08-25 19:54:22 +00:00
|
|
|
attr_accessor :not
|
|
|
|
alias_method :not?, :not
|
2017-06-02 06:11:31 +00:00
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# Sequence conditions consist of one or more steps, where each step is defined
|
|
|
|
# by one or more dimension/metric conditions. Multiple steps can be combined
|
|
|
|
# with special sequence operators.
|
|
|
|
# Corresponds to the JSON property `sequenceSegment`
|
|
|
|
# @return [Google::Apis::AnalyticsreportingV4::SequenceSegment]
|
|
|
|
attr_accessor :sequence_segment
|
2017-06-02 06:11:31 +00:00
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# A Simple segment conditions consist of one or more dimension/metric
|
|
|
|
# conditions that can be combined.
|
|
|
|
# Corresponds to the JSON property `simpleSegment`
|
|
|
|
# @return [Google::Apis::AnalyticsreportingV4::SimpleSegment]
|
|
|
|
attr_accessor :simple_segment
|
2017-06-02 06:11:31 +00:00
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
def initialize(**args)
|
|
|
|
update!(**args)
|
|
|
|
end
|
2017-06-02 06:11:31 +00:00
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# Update properties of this object
|
|
|
|
def update!(**args)
|
|
|
|
@not = args[:not] if args.key?(:not)
|
|
|
|
@sequence_segment = args[:sequence_segment] if args.key?(:sequence_segment)
|
|
|
|
@simple_segment = args[:simple_segment] if args.key?(:simple_segment)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
# Filter Clause to be used in a segment definition, can be wither a metric or
|
|
|
|
# a dimension filter.
|
|
|
|
class SegmentFilterClause
|
|
|
|
include Google::Apis::Core::Hashable
|
|
|
|
|
|
|
|
# Dimension filter specifies the filtering options on a dimension.
|
|
|
|
# Corresponds to the JSON property `dimensionFilter`
|
|
|
|
# @return [Google::Apis::AnalyticsreportingV4::SegmentDimensionFilter]
|
|
|
|
attr_accessor :dimension_filter
|
|
|
|
|
|
|
|
# Metric filter to be used in a segment filter clause.
|
|
|
|
# Corresponds to the JSON property `metricFilter`
|
|
|
|
# @return [Google::Apis::AnalyticsreportingV4::SegmentMetricFilter]
|
|
|
|
attr_accessor :metric_filter
|
|
|
|
|
|
|
|
# Matches the complement (`!`) of the filter.
|
2017-07-12 20:10:42 +00:00
|
|
|
# Corresponds to the JSON property `not`
|
2017-06-14 17:02:03 +00:00
|
|
|
# @return [Boolean]
|
2017-07-12 20:10:42 +00:00
|
|
|
attr_accessor :not
|
|
|
|
alias_method :not?, :not
|
2017-02-13 23:28:52 +00:00
|
|
|
|
|
|
|
def initialize(**args)
|
|
|
|
update!(**args)
|
|
|
|
end
|
|
|
|
|
|
|
|
# Update properties of this object
|
|
|
|
def update!(**args)
|
2017-08-25 19:54:22 +00:00
|
|
|
@dimension_filter = args[:dimension_filter] if args.key?(:dimension_filter)
|
|
|
|
@metric_filter = args[:metric_filter] if args.key?(:metric_filter)
|
2017-07-12 20:10:42 +00:00
|
|
|
@not = args[:not] if args.key?(:not)
|
2016-05-16 16:49:15 +00:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# Metric filter to be used in a segment filter clause.
|
|
|
|
class SegmentMetricFilter
|
2016-05-16 16:49:15 +00:00
|
|
|
include Google::Apis::Core::Hashable
|
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# The value to compare against. If the operator is `BETWEEN`, this value is
|
|
|
|
# treated as minimum comparison value.
|
|
|
|
# Corresponds to the JSON property `comparisonValue`
|
|
|
|
# @return [String]
|
|
|
|
attr_accessor :comparison_value
|
|
|
|
|
|
|
|
# Max comparison value is only used for `BETWEEN` operator.
|
2017-07-12 20:10:42 +00:00
|
|
|
# Corresponds to the JSON property `maxComparisonValue`
|
|
|
|
# @return [String]
|
|
|
|
attr_accessor :max_comparison_value
|
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# The metric that will be filtered on. A `metricFilter` must contain a
|
|
|
|
# metric name.
|
|
|
|
# Corresponds to the JSON property `metricName`
|
2017-06-14 17:02:03 +00:00
|
|
|
# @return [String]
|
2017-08-25 19:54:22 +00:00
|
|
|
attr_accessor :metric_name
|
2016-05-16 16:49:15 +00:00
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# Specifies is the operation to perform to compare the metric. The default
|
|
|
|
# is `EQUAL`.
|
2017-06-14 17:02:03 +00:00
|
|
|
# Corresponds to the JSON property `operator`
|
|
|
|
# @return [String]
|
|
|
|
attr_accessor :operator
|
2016-05-16 16:49:15 +00:00
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# Scope for a metric defines the level at which that metric is defined. The
|
|
|
|
# specified metric scope must be equal to or greater than its primary scope
|
|
|
|
# as defined in the data model. The primary scope is defined by if the
|
|
|
|
# segment is selecting users or sessions.
|
|
|
|
# Corresponds to the JSON property `scope`
|
2017-06-14 17:02:03 +00:00
|
|
|
# @return [String]
|
2017-08-25 19:54:22 +00:00
|
|
|
attr_accessor :scope
|
2017-06-14 17:02:03 +00:00
|
|
|
|
2016-05-16 16:49:15 +00:00
|
|
|
def initialize(**args)
|
|
|
|
update!(**args)
|
|
|
|
end
|
|
|
|
|
|
|
|
# Update properties of this object
|
|
|
|
def update!(**args)
|
2017-08-25 19:54:22 +00:00
|
|
|
@comparison_value = args[:comparison_value] if args.key?(:comparison_value)
|
2017-07-12 20:10:42 +00:00
|
|
|
@max_comparison_value = args[:max_comparison_value] if args.key?(:max_comparison_value)
|
2017-08-25 19:54:22 +00:00
|
|
|
@metric_name = args[:metric_name] if args.key?(:metric_name)
|
2017-06-14 17:02:03 +00:00
|
|
|
@operator = args[:operator] if args.key?(:operator)
|
2017-08-25 19:54:22 +00:00
|
|
|
@scope = args[:scope] if args.key?(:scope)
|
2016-05-16 16:49:15 +00:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# A segment sequence definition.
|
|
|
|
class SegmentSequenceStep
|
2016-05-16 16:49:15 +00:00
|
|
|
include Google::Apis::Core::Hashable
|
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# Specifies if the step immediately precedes or can be any time before the
|
|
|
|
# next step.
|
|
|
|
# Corresponds to the JSON property `matchType`
|
2017-06-14 17:02:03 +00:00
|
|
|
# @return [String]
|
2017-08-25 19:54:22 +00:00
|
|
|
attr_accessor :match_type
|
2017-06-14 17:02:03 +00:00
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# A sequence is specified with a list of Or grouped filters which are
|
|
|
|
# combined with `AND` operator.
|
|
|
|
# Corresponds to the JSON property `orFiltersForSegment`
|
|
|
|
# @return [Array<Google::Apis::AnalyticsreportingV4::OrFiltersForSegment>]
|
|
|
|
attr_accessor :or_filters_for_segment
|
2017-05-04 19:35:56 +00:00
|
|
|
|
2016-05-16 16:49:15 +00:00
|
|
|
def initialize(**args)
|
|
|
|
update!(**args)
|
|
|
|
end
|
|
|
|
|
|
|
|
# Update properties of this object
|
|
|
|
def update!(**args)
|
2017-08-25 19:54:22 +00:00
|
|
|
@match_type = args[:match_type] if args.key?(:match_type)
|
|
|
|
@or_filters_for_segment = args[:or_filters_for_segment] if args.key?(:or_filters_for_segment)
|
2016-05-16 16:49:15 +00:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# Sequence conditions consist of one or more steps, where each step is defined
|
|
|
|
# by one or more dimension/metric conditions. Multiple steps can be combined
|
|
|
|
# with special sequence operators.
|
|
|
|
class SequenceSegment
|
2017-04-03 20:18:48 +00:00
|
|
|
include Google::Apis::Core::Hashable
|
2016-05-16 16:49:15 +00:00
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# If set, first step condition must match the first hit of the visitor (in
|
|
|
|
# the date range).
|
|
|
|
# Corresponds to the JSON property `firstStepShouldMatchFirstHit`
|
|
|
|
# @return [Boolean]
|
|
|
|
attr_accessor :first_step_should_match_first_hit
|
|
|
|
alias_method :first_step_should_match_first_hit?, :first_step_should_match_first_hit
|
2017-06-02 06:11:31 +00:00
|
|
|
|
2017-08-25 19:54:22 +00:00
|
|
|
# The list of steps in the sequence.
|
|
|
|
# Corresponds to the JSON property `segmentSequenceSteps`
|
|
|
|
# @return [Array<Google::Apis::AnalyticsreportingV4::SegmentSequenceStep>]
|
|
|
|
attr_accessor :segment_sequence_steps
|
2017-03-30 22:30:51 +00:00
|
|
|
|
2016-05-16 16:49:15 +00:00
|
|
|
def initialize(**args)
|
|
|
|
update!(**args)
|
|
|
|
end
|
|
|
|
|
|
|
|
# Update properties of this object
|
|
|
|
def update!(**args)
|
2017-08-25 19:54:22 +00:00
|
|
|
@first_step_should_match_first_hit = args[:first_step_should_match_first_hit] if args.key?(:first_step_should_match_first_hit)
|
|
|
|
@segment_sequence_steps = args[:segment_sequence_steps] if args.key?(:segment_sequence_steps)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
# A Simple segment conditions consist of one or more dimension/metric
|
|
|
|
# conditions that can be combined.
|
|
|
|
class SimpleSegment
|
|
|
|
include Google::Apis::Core::Hashable
|
|
|
|
|
|
|
|
# A list of segment filters groups which are combined with logical `AND`
|
|
|
|
# operator.
|
|
|
|
# Corresponds to the JSON property `orFiltersForSegment`
|
|
|
|
# @return [Array<Google::Apis::AnalyticsreportingV4::OrFiltersForSegment>]
|
|
|
|
attr_accessor :or_filters_for_segment
|
|
|
|
|
|
|
|
def initialize(**args)
|
|
|
|
update!(**args)
|
|
|
|
end
|
|
|
|
|
|
|
|
# Update properties of this object
|
|
|
|
def update!(**args)
|
|
|
|
@or_filters_for_segment = args[:or_filters_for_segment] if args.key?(:or_filters_for_segment)
|
2016-05-16 16:49:15 +00:00
|
|
|
end
|
|
|
|
end
|
2019-03-20 00:37:12 +00:00
|
|
|
|
|
|
|
# Represents details collected when the visitor performs a transaction on the
|
|
|
|
# page.
|
|
|
|
class TransactionData
|
|
|
|
include Google::Apis::Core::Hashable
|
|
|
|
|
|
|
|
# The transaction ID, supplied by the e-commerce tracking method, for the
|
|
|
|
# purchase in the shopping cart.
|
|
|
|
# Corresponds to the JSON property `transactionId`
|
|
|
|
# @return [String]
|
|
|
|
attr_accessor :transaction_id
|
|
|
|
|
|
|
|
# The total sale revenue (excluding shipping and tax) of the transaction.
|
|
|
|
# Corresponds to the JSON property `transactionRevenue`
|
|
|
|
# @return [Float]
|
|
|
|
attr_accessor :transaction_revenue
|
|
|
|
|
|
|
|
# Total cost of shipping.
|
|
|
|
# Corresponds to the JSON property `transactionShipping`
|
|
|
|
# @return [Float]
|
|
|
|
attr_accessor :transaction_shipping
|
|
|
|
|
|
|
|
# Total tax for the transaction.
|
|
|
|
# Corresponds to the JSON property `transactionTax`
|
|
|
|
# @return [Float]
|
|
|
|
attr_accessor :transaction_tax
|
|
|
|
|
|
|
|
def initialize(**args)
|
|
|
|
update!(**args)
|
|
|
|
end
|
|
|
|
|
|
|
|
# Update properties of this object
|
|
|
|
def update!(**args)
|
|
|
|
@transaction_id = args[:transaction_id] if args.key?(:transaction_id)
|
|
|
|
@transaction_revenue = args[:transaction_revenue] if args.key?(:transaction_revenue)
|
|
|
|
@transaction_shipping = args[:transaction_shipping] if args.key?(:transaction_shipping)
|
|
|
|
@transaction_tax = args[:transaction_tax] if args.key?(:transaction_tax)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
# Contains information to identify a particular user uniquely.
|
|
|
|
class User
|
|
|
|
include Google::Apis::Core::Hashable
|
|
|
|
|
|
|
|
# Type of the user in the request. The field `userId` is associated with this
|
|
|
|
# type.
|
|
|
|
# Corresponds to the JSON property `type`
|
|
|
|
# @return [String]
|
|
|
|
attr_accessor :type
|
|
|
|
|
|
|
|
# Unique Id of the user for which the data is being requested.
|
|
|
|
# Corresponds to the JSON property `userId`
|
|
|
|
# @return [String]
|
|
|
|
attr_accessor :user_id
|
|
|
|
|
|
|
|
def initialize(**args)
|
|
|
|
update!(**args)
|
|
|
|
end
|
|
|
|
|
|
|
|
# Update properties of this object
|
|
|
|
def update!(**args)
|
|
|
|
@type = args[:type] if args.key?(:type)
|
|
|
|
@user_id = args[:user_id] if args.key?(:user_id)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
# This represents a user session performed on a specific device at a certain
|
|
|
|
# time over a period of time.
|
|
|
|
class UserActivitySession
|
|
|
|
include Google::Apis::Core::Hashable
|
|
|
|
|
|
|
|
# Represents a detailed view into each of the activity in this session.
|
|
|
|
# Corresponds to the JSON property `activities`
|
|
|
|
# @return [Array<Google::Apis::AnalyticsreportingV4::Activity>]
|
|
|
|
attr_accessor :activities
|
|
|
|
|
|
|
|
# The data source of a hit. By default, hits sent from analytics.js are
|
|
|
|
# reported as "web" and hits sent from the mobile SDKs are reported as "app".
|
|
|
|
# These values can be overridden in the Measurement Protocol.
|
|
|
|
# Corresponds to the JSON property `dataSource`
|
|
|
|
# @return [String]
|
|
|
|
attr_accessor :data_source
|
|
|
|
|
|
|
|
# The type of device used: "mobile", "tablet" etc.
|
|
|
|
# Corresponds to the JSON property `deviceCategory`
|
|
|
|
# @return [String]
|
|
|
|
attr_accessor :device_category
|
|
|
|
|
|
|
|
# Platform on which the activity happened: "android", "ios" etc.
|
|
|
|
# Corresponds to the JSON property `platform`
|
|
|
|
# @return [String]
|
|
|
|
attr_accessor :platform
|
|
|
|
|
|
|
|
# Date of this session in ISO-8601 format.
|
|
|
|
# Corresponds to the JSON property `sessionDate`
|
|
|
|
# @return [String]
|
|
|
|
attr_accessor :session_date
|
|
|
|
|
|
|
|
# Unique ID of the session.
|
|
|
|
# Corresponds to the JSON property `sessionId`
|
|
|
|
# @return [String]
|
|
|
|
attr_accessor :session_id
|
|
|
|
|
|
|
|
def initialize(**args)
|
|
|
|
update!(**args)
|
|
|
|
end
|
|
|
|
|
|
|
|
# Update properties of this object
|
|
|
|
def update!(**args)
|
|
|
|
@activities = args[:activities] if args.key?(:activities)
|
|
|
|
@data_source = args[:data_source] if args.key?(:data_source)
|
|
|
|
@device_category = args[:device_category] if args.key?(:device_category)
|
|
|
|
@platform = args[:platform] if args.key?(:platform)
|
|
|
|
@session_date = args[:session_date] if args.key?(:session_date)
|
|
|
|
@session_id = args[:session_id] if args.key?(:session_id)
|
|
|
|
end
|
|
|
|
end
|
2016-05-16 16:49:15 +00:00
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|