yt-andrewroth 0.25.5.1

data/lib/yt/collections/reports.rb

@@ -0,0 +1,161 @@
+require 'yt/collections/base'
+
+module Yt
+  module Collections
+    # @private
+    class Reports < Base
+      DIMENSIONS = Hash.new({name: 'day', parse: ->(day, *values) { @metrics.keys.zip(values.map{|v| {Date.iso8601(day) => v}}).to_h} }).tap do |hash|
+        hash[:month] = {name: 'month', parse: ->(month, *values) { @metrics.keys.zip(values.map{|v| {Range.new(Date.strptime(month, '%Y-%m').beginning_of_month, Date.strptime(month, '%Y-%m').end_of_month) => v} }).to_h} }
+        hash[:week] = {name: '7DayTotals', parse: ->(last_day_of_week, *values) { @metrics.keys.zip(values.map{|v| {Range.new(Date.strptime(last_day_of_week) - 6, Date.strptime(last_day_of_week)) => v} }).to_h} }
+        hash[:range] = {parse: ->(*values) { @metrics.keys.zip(values.map{|v| {total: v}}).to_h } }
+        hash[:traffic_source] = {name: 'insightTrafficSourceType', parse: ->(source, *values) { @metrics.keys.zip(values.map{|v| {TRAFFIC_SOURCES.key(source) => v}}).to_h} }
+        hash[:playback_location] = {name: 'insightPlaybackLocationType', parse: ->(location, *values) { @metrics.keys.zip(values.map{|v| {PLAYBACK_LOCATIONS.key(location) => v}}).to_h} }
+        hash[:embedded_player_location] = {name: 'insightPlaybackLocationDetail', parse: ->(url, *values) {@metrics.keys.zip(values.map{|v| {url => v}}).to_h} }
+        hash[:related_video] = {name: 'insightTrafficSourceDetail', parse: ->(video_id, *values) { @metrics.keys.zip(values.map{|v| {video_id => v}}).to_h} }
+        hash[:search_term] = {name: 'insightTrafficSourceDetail', parse: ->(search_term, *values) {@metrics.keys.zip(values.map{|v| {search_term => v}}).to_h} }
+        hash[:referrer] = {name: 'insightTrafficSourceDetail', parse: ->(url, *values) {@metrics.keys.zip(values.map{|v| {url => v}}).to_h} }
+        hash[:video] = {name: 'video', parse: ->(video_id, *values) { @metrics.keys.zip(values.map{|v| {video_id => v}}).to_h} }
+        hash[:playlist] = {name: 'playlist', parse: ->(playlist_id, *values) { @metrics.keys.zip(values.map{|v| {playlist_id => v}}).to_h} }
+        hash[:device_type] = {name: 'deviceType', parse: ->(type, *values) {@metrics.keys.zip(values.map{|v| {type.downcase.to_sym => v}}).to_h} }
+        hash[:country] = {name: 'country', parse: ->(country_code, *values) { @metrics.keys.zip(values.map{|v| {country_code => v}}).to_h} }
+        hash[:state] = {name: 'province', parse: ->(country_and_state_code, *values) { @metrics.keys.zip(values.map{|v| {country_and_state_code[3..-1] => v}}).to_h} }
+        hash[:gender_age_group] = {name: 'gender,ageGroup', parse: ->(gender, *values) { [gender.downcase.to_sym, *values] }}
+        hash[:gender] = {name: 'gender', parse: ->(gender, *values) {@metrics.keys.zip(values.map{|v| {gender.downcase.to_sym => v}}).to_h} }
+        hash[:age_group] = {name: 'ageGroup', parse: ->(age_group, *values) {@metrics.keys.zip(values.map{|v| {age_group[3..-1] => v}}).to_h} }
+      end
+
+      # @see https://developers.google.com/youtube/analytics/v1/dimsmets/dims#Traffic_Source_Dimensions
+      # @note EXT_APP is also returned but it’s not in the documentation above!
+      TRAFFIC_SOURCES = {
+        advertising: 'ADVERTISING',
+        annotation: 'ANNOTATION',
+        external_app: 'EXT_APP',
+        external_url: 'EXT_URL',
+        embedded: 'NO_LINK_EMBEDDED',
+        other: 'NO_LINK_OTHER',
+        playlist: 'PLAYLIST',
+        promoted: 'PROMOTED',
+        related_video: 'RELATED_VIDEO',
+        subscriber: 'SUBSCRIBER',
+        channel: 'YT_CHANNEL',
+        other_page: 'YT_OTHER_PAGE',
+        search: 'YT_SEARCH',
+        google: 'GOOGLE_SEARCH',
+        notification: 'NOTIFICATION',
+        info_card: 'INFO_CARD'
+      }
+
+      # @see https://developers.google.com/youtube/analytics/v1/dimsmets/dims#Playback_Location_Dimensions
+      PLAYBACK_LOCATIONS = {
+        channel: 'CHANNEL',
+        watch: 'WATCH',
+        embedded: 'EMBEDDED',
+        other: 'YT_OTHER',
+        external_app: 'EXTERNAL_APP',
+        mobile: 'MOBILE' # only present for data < September 10, 2013
+      }
+
+      attr_writer :metrics
+
+      def within(days_range, country, state, dimension, videos, try_again = true)
+        @days_range = days_range
+        @dimension = dimension
+        @country = country
+        @state = state
+        @videos = videos
+        if dimension == :gender_age_group # array of array
+          Hash.new{|h,k| h[k] = Hash.new 0.0}.tap do |hash|
+            each{|gender, age_group, value| hash[gender][age_group[3..-1]] = value}
+          end
+        else
+          hash = flat_map do |hashes|
+            hashes.map do |metric, values|
+              [metric, values.transform_values{|v| type_cast(v, @metrics[metric])}]
+            end.to_h
+          end
+          hash = hash.inject(@metrics.transform_values{|v| {}}) do |result, hash|
+            result.deep_merge hash
+          end
+          if dimension == :month
+            hash = hash.transform_values{|h| h.sort_by{|range, v| range.first}.to_h}
+          elsif dimension == :week
+            hash = hash.transform_values do |h|
+              h.select{|range, v| range.last.wday == days_range.last.wday}.
+              sort_by{|range, v| range.first}.to_h
+            end
+          elsif dimension == :day
+            hash = hash.transform_values{|h| h.sort_by{|day, v| day}.to_h}
+          elsif dimension.in? [:traffic_source, :country, :state, :playback_location, :device_type]
+            hash = hash.transform_values{|h| h.sort_by{|range, v| -v}.to_h}
+          end
+          (@metrics.one? || @metrics.keys == [:earnings, :estimated_minutes_watched]) ? hash[@metrics.keys.first] : hash
+        end
+      # NOTE: Once in a while, YouTube responds with 400 Error and the message
+      # "Invalid query. Query did not conform to the expectations."; in this
+      # case running the same query after one second fixes the issue. This is
+      # not documented by YouTube and hardly testable, but trying again the
+      # same query is a workaround that works and can hardly cause any damage.
+      # Similarly, once in while YouTube responds with a random 503 error.
+      rescue Yt::Error => e
+        try_again && rescue?(e) ? sleep(3) && within(days_range, country, state, dimension, videos, false) : raise
+      end
+
+    private
+
+      def type_cast(value, type)
+        case [type]
+          when [Integer] then value.to_i if value
+          when [Float] then value.to_f if value
+        end
+      end
+
+      def new_item(data)
+        instance_exec *data, &DIMENSIONS[@dimension][:parse]
+      end
+
+      # @see https://developers.google.com/youtube/analytics/v1/content_owner_reports
+      def list_params
+        super.tap do |params|
+          params[:path] = '/youtube/analytics/v1/reports'
+          params[:params] = reports_params
+          params[:camelize_params] = false
+        end
+      end
+
+      def reports_params
+        @parent.reports_params.tap do |params|
+          params['start-date'] = @days_range.begin
+          params['end-date'] = @days_range.end
+          params['metrics'] = @metrics.keys.join(',').to_s.camelize(:lower)
+          params['dimensions'] = DIMENSIONS[@dimension][:name] unless @dimension == :range
+          params['max-results'] = 50 if @dimension.in? [:playlist, :video]
+          params['max-results'] = 25 if @dimension.in? [:embedded_player_location, :related_video, :search_term, :referrer]
+          if @dimension.in? [:video, :playlist, :embedded_player_location, :related_video, :search_term, :referrer]
+            if @metrics.keys == [:earnings, :estimated_minutes_watched]
+              params['sort'] = '-earnings'
+            else
+              params['sort'] = "-#{@metrics.keys.join(',').to_s.camelize(:lower)}"
+            end
+          end
+          params[:filters] = "video==#{@videos.join ','}" if @videos
+          params[:filters] = ((params[:filters] || '').split(';') + ["country==US"]).compact.uniq.join(';') if @dimension == :state && !@state
+          params[:filters] = ((params[:filters] || '').split(';') + ["country==#{@country}"]).compact.uniq.join(';') if @country && !@state
+          params[:filters] = ((params[:filters] || '').split(';') + ["province==US-#{@state}"]).compact.uniq.join(';') if @state
+          params[:filters] = ((params[:filters] || '').split(';') + ['isCurated==1']).compact.uniq.join(';') if @dimension == :playlist
+          params[:filters] = ((params[:filters] || '').split(';') + ['insightPlaybackLocationType==EMBEDDED']).compact.uniq.join(';') if @dimension == :embedded_player_location
+          params[:filters] = ((params[:filters] || '').split(';') + ['insightTrafficSourceType==RELATED_VIDEO']).compact.uniq.join(';') if @dimension == :related_video
+          params[:filters] = ((params[:filters] || '').split(';') + ['insightTrafficSourceType==YT_SEARCH']).compact.uniq.join(';') if @dimension == :search_term
+          params[:filters] = ((params[:filters] || '').split(';') + ['insightTrafficSourceType==EXT_URL']).compact.uniq.join(';') if @dimension == :referrer
+        end
+      end
+
+      def items_key
+        'rows'
+      end
+
+      def rescue?(error)
+        'badRequest'.in?(error.reasons) && error.to_s =~ /did not conform/
+      end
+    end
+  end
+end

data/lib/yt/collections/resources.rb

@@ -0,0 +1,57 @@
+# encoding: UTF-8
+require 'yt/collections/base'
+
+module Yt
+  module Collections
+    # @private
+    class Resources < Base
+      def delete_all(params = {})
+        do_delete_all params
+      end
+
+      def insert(attributes = {}, options = {}) #
+        underscore_keys! attributes
+        body = build_insert_body attributes
+        params = {part: body.keys.join(',')}
+        do_insert(params: params, body: body)
+      end
+
+    private
+
+      def attributes_for_new_item(data)
+        {id: data['id'], snippet: data['snippet'], status: data['status'], auth: @auth}
+      end
+
+      def resources_params
+        {max_results: 50, part: 'snippet,status'}
+      end
+
+      def build_insert_body(attributes = {})
+        {}.tap do |body|
+          insert_parts.each do |name, part|
+            if should_include_part_in_insert? part, attributes
+              body[name] = build_insert_body_part part, attributes
+              sanitize_brackets! body[name] if part[:sanitize_brackets]
+            end
+          end
+        end
+      end
+
+      def build_insert_body_part(part, attributes = {})
+        {}.tap do |body_part|
+          part[:keys].map do |key|
+            body_part[camelize key] = attributes[key] if attributes[key]
+          end
+        end
+      end
+
+      def should_include_part_in_insert?(part, attributes = {})
+        (part[:keys] & attributes.keys).any?
+      end
+
+      def camelize(value)
+        value.to_s.camelize(:lower).to_sym
+      end
+    end
+  end
+end

data/lib/yt/collections/resumable_sessions.rb

@@ -0,0 +1,51 @@
+require 'yt/collections/base'
+require 'yt/models/resumable_session'
+
+module Yt
+  module Collections
+    # @private
+    # Provides methods to upload videos with the resumable upload protocol.
+    #
+    # Resources with resumable sessions are: {Yt::Models::Account accounts}.
+    #
+    # @see https://developers.google.com/youtube/v3/guides/using_resumable_upload_protocol
+    class ResumableSessions < Base
+
+      # Starts a resumable session by sending to YouTube the metadata of the
+      # object to upload. If the request succeeds, YouTube returns a unique
+      # URL to upload the object file (and eventually resume the upload).
+      # @param [Integer] content_length the size (bytes) of the object to upload.
+      # @param [Hash] body the metadata to add to the uploaded object.
+      def insert(content_length, body = {})
+        @headers = headers_for content_length
+        do_insert body: body, headers: @headers
+      end
+
+    private
+
+      def attributes_for_new_item(data)
+        {url: data['Location'], headers: @headers, auth: @auth}
+      end
+
+      def insert_params
+        super.tap do |params|
+          params[:response_format] = nil
+          params[:path] = @parent.upload_path
+          params[:params] = @parent.upload_params.merge uploadType: 'resumable'
+        end
+      end
+
+      def headers_for(content_length)
+        {}.tap do |headers|
+          headers['x-upload-content-length'] = content_length
+          headers['X-Upload-Content-Type'] = @parent.upload_content_type
+        end
+      end
+
+      # The result is not in the body but in the headers
+      def extract_data_from(response)
+        response.header
+      end
+    end
+  end
+end

data/lib/yt/collections/snippets.rb

@@ -0,0 +1,27 @@
+require 'yt/collections/base'
+require 'yt/models/snippet'
+
+module Yt
+  module Collections
+    # @private
+    class Snippets < Base
+
+    private
+
+      def attributes_for_new_item(data)
+        {data: data['snippet'], auth: @auth}
+      end
+
+      # @return [Hash] the parameters to submit to YouTube to get the
+      #   snippet of a resource, for instance a channel.
+      # @see https://developers.google.com/youtube/v3/docs/channels#resource
+      def list_params
+        endpoint = @parent.kind.pluralize.camelize :lower
+        super.tap do |params|
+          params[:path] = "/youtube/v3/#{endpoint}"
+          params[:params] = {id: @parent.id, part: 'snippet'}
+        end
+      end
+    end
+  end
+end

data/lib/yt/collections/statistics_sets.rb

@@ -0,0 +1,30 @@
+require 'yt/collections/base'
+require 'yt/models/statistics_set'
+
+module Yt
+  module Collections
+    # @private
+    class StatisticsSets < Base
+
+    private
+
+      def attributes_for_new_item(data)
+        {data: data['statistics']}
+      end
+
+      # @return [Hash] the parameters to submit to YouTube to get the
+      #   statistics of a resource, for instance a video.
+      # @see https://developers.google.com/youtube/v3/docs/videos#resource
+      def list_params
+        super.tap do |params|
+          params[:path] = "/youtube/v3/#{@parent.kind.pluralize}"
+          params[:params] = statistics_sets_params
+        end
+      end
+
+      def statistics_sets_params
+        {max_results: 50, part: 'statistics', id: @parent.id}
+      end
+    end
+  end
+end

data/lib/yt/collections/statuses.rb

@@ -0,0 +1,27 @@
+require 'yt/collections/base'
+require 'yt/models/status'
+
+module Yt
+  module Collections
+    # @private
+    class Statuses < Base
+
+    private
+
+      def attributes_for_new_item(data)
+        {data: data['status']}
+      end
+
+      # @return [Hash] the parameters to submit to YouTube to get the status
+      #   of a resource, for instance a channel.
+      # @see https://developers.google.com/youtube/v3/docs/channels/list
+      def list_params
+        endpoint = @parent.kind.pluralize.camelize :lower
+        super.tap do |params|
+          params[:path] = "/youtube/v3/#{endpoint}"
+          params[:params] = {id: @parent.id, part: 'status'}
+        end
+      end
+    end
+  end
+end

data/lib/yt/collections/subscribed_channels.rb

@@ -0,0 +1,46 @@
+require 'yt/collections/channels'
+
+module Yt
+  module Collections
+    # Provides methods to interact with the list of channels a resource is
+    # subscribed to.
+    #
+    # Resources with subscribed channels are: {Yt::Models::Channel channels}.
+    #
+    class SubscribedChannels < Channels
+
+    private
+
+      def attributes_for_new_item(data)
+        snippet = data.fetch 'snippet', {}
+        resource = snippet.fetch 'resourceId', {}
+        {id: resource['channelId'], snippet: snippet, auth: @auth}
+      end
+
+      # @return [Hash] the parameters to submit to YouTube to list subscribers.
+      # @see https://developers.google.com/youtube/v3/docs/subscriptions/list
+      def list_params
+        super.tap{|params| params[:path] = '/youtube/v3/subscriptions'}
+      end
+
+      # @private
+      # @note Subscribers overwrites +channel_params+ since the query
+      #   is slightly different.
+      def channels_params
+        {}.tap do |params|
+          params[:max_results] = 50
+          params[:part] = 'snippet'
+          params[:channel_id] = @parent.id
+          apply_where_params! params
+        end
+      end
+
+      # @private
+      # @note Subscribers overwrites +list_resources+ since the objects to
+      #   instatiate belongs to Channel class not Subscriber.
+      def resource_class
+        Yt::Models::Channel
+      end
+    end
+  end
+end

data/lib/yt/collections/subscribers.rb

@@ -0,0 +1,33 @@
+require 'yt/collections/subscribed_channels'
+
+module Yt
+  module Collections
+    # Provides methods to interact with subscribers of a YouTube resource.
+    #
+    # Resources with subscribers are: {Yt::Models::Account accounts}.
+    #
+    # Confusingly, YouTube API provides the +same+ endpoint to either
+    # retrieve the channels that you are subscribed to or the channels
+    # that are subscribed to you. The difference relies in the setting the
+    # +mySubscribers+ parameter to true and in reading the information
+    # from the +subscriberSnippet+ part, not the +snippet+ part.
+    # @see https://developers.google.com/youtube/v3/docs/subscriptions/list
+    class Subscribers < SubscribedChannels
+
+    private
+
+      def attributes_for_new_item(data)
+        snippet = data.fetch 'subscriberSnippet', {}
+        {id: snippet['channelId'], snippet: snippet, auth: @auth}
+      end
+
+      def channels_params
+        {}.tap do |params|
+          params[:max_results] = 50
+          params[:part] = 'subscriberSnippet'
+          params[:my_subscribers] = true
+        end
+      end
+    end
+  end
+end

data/lib/yt/collections/subscriptions.rb

@@ -0,0 +1,50 @@
+require 'yt/collections/base'
+require 'yt/models/subscription'
+
+module Yt
+  module Collections
+    # @private
+    class Subscriptions < Base
+
+      def insert(options = {})
+        do_insert
+      rescue Yt::Error => error
+        ignorable_error = error.reasons.include? 'subscriptionDuplicate'
+        ignorable_error ||= (@parent.id == @auth.channel.id) if @auth
+        raise error unless options[:ignore_errors] && ignorable_error
+      end
+
+    private
+
+      def attributes_for_new_item(data)
+        {id: data['id'], auth: @auth}
+      end
+
+      # @return [Hash] the parameters to submit to YouTube to list subscriptions.
+      # @see https://developers.google.com/youtube/v3/docs/subscriptions/list
+      def list_params
+        super.tap do |params|
+          params[:params] = subscriptions_params
+        end
+      end
+
+      def subscriptions_params
+        {}.tap do |params|
+          params[:max_results] = 50
+          params[:for_channel_id] = @parent.id
+          params[:mine] = true
+          params[:part] = 'snippet'
+        end
+      end
+
+      # @return [Hash] the parameters to submit to YouTube to add a subscriptions.
+      # @see https://developers.google.com/youtube/v3/docs/subscriptions/insert
+      def insert_params
+        super.tap do |params|
+          params[:params] = {part: 'snippet'}
+          params[:body] = {snippet: {resourceId: {channelId: @parent.id}}}
+        end
+      end
+    end
+  end
+end