yt-andrewroth 0.25.5.1

data/lib/yt/models/playlist_item.rb

@@ -0,0 +1,112 @@
+require 'yt/models/resource'
+
+module Yt
+  module Models
+    # Provides methods to interact with YouTube playlist items.
+    # @see https://developers.google.com/youtube/v3/docs/playlistItems
+    class PlaylistItem < Resource
+
+    ### SNIPPET ###
+
+      # @!attribute [r] title
+      #   @return [String] the item’s title.
+      delegate :title, to: :snippet
+
+      # @!attribute [r] description
+      #   @return [String] the item’s description.
+      delegate :description, to: :snippet
+
+      # @!method thumbnail_url(size = :default)
+      #   Returns the URL of the item’s thumbnail.
+      #   @param [Symbol, String] size The size of the item’s thumbnail.
+      #   @return [String] if +size+ is +default+, the URL of a 120x90px image.
+      #   @return [String] if +size+ is +medium+, the URL of a 320x180px image.
+      #   @return [String] if +size+ is +high+, the URL of a 480x360px image.
+      #   @return [nil] if the +size+ is not +default+, +medium+ or +high+.
+      delegate :thumbnail_url, to: :snippet
+
+      # @!attribute [r] published_at
+      #   @return [Time] the time that the item was added to the playlist.
+      delegate :published_at, to: :snippet
+
+      # @!attribute [r] channel_id
+      #   @return [String] the ID of the channel that the item belongs to.
+      delegate :channel_id, to: :snippet
+
+      # @!attribute [r] channel_title
+      #   @return [String] the title of the channel that the item belongs to.
+      delegate :channel_title, to: :snippet
+
+      # @!attribute [r] playlist_id
+      #   @return [String] the ID of the playlist that the item is in.
+      delegate :playlist_id, to: :snippet
+
+      # @return [String] the ID of the video referred by the item.
+      def video_id
+        snippet.resource_id['videoId']
+      end
+
+      # @return [Integer] the order in which the item appears in a playlist.
+      #   The value is zero-based, so the first item has a position of 0.
+      def position
+        ensure_complete_snippet :position
+      end
+
+    ### ACTIONS (UPLOAD, UPDATE, DELETE) ###
+
+      # Deletes the playlist item.
+      # @return [Boolean] whether the playlist item does not exist anymore.
+      # @raise [Yt::Errors::Unauthorized] if {Resource#auth auth} is not an
+      #   authenticated Yt::Account with permissions to delete the item.
+      def delete(options = {})
+        do_delete {@id = nil}
+        !exists?
+      end
+
+      # Updates the attributes of a playlist item.
+      # @return [Boolean] whether the item was successfully updated.
+      # @raise [Yt::Errors::Unauthorized] if {Resource#auth auth} is not an
+      #   authenticated Yt::Account with permissions to update the item.
+      # @param [Hash] attributes the attributes to update.
+      # @option attributes [Integer] the order in which the item should appear
+      #   in a playlist. The value is zero-based, so the first position of 0.
+      def update(attributes = {})
+        super
+      end
+
+    ### ASSOCIATIONS ###
+
+      # @return [Yt::Models::Video] the video referred by the item.
+      def video
+        @video ||= Video.new id: video_id, auth: @auth if video_id
+      end
+
+    ### PRIVATE API ###
+
+      # @private
+      def exists?
+        !@id.nil?
+      end
+
+      # @private
+      # Override Resource's new to set video if the response includes it
+      def initialize(options = {})
+        super options
+        @video = options[:video] if options[:video]
+      end
+
+    private
+
+      def resource_id
+        {kind: 'youtube#video', videoId: video_id}
+      end
+
+      # @see https://developers.google.com/youtube/v3/docs/playlistItems/update
+      def update_parts
+        keys = [:position, :playlist_id, :resource_id]
+        snippet = {keys: keys, required: true}
+        {snippet: snippet}
+      end
+    end
+  end
+end

data/lib/yt/models/policy.rb

@@ -0,0 +1,36 @@
+require 'yt/models/base'
+require 'yt/models/policy_rule'
+
+module Yt
+  module Models
+    # Provides methods to interact with YouTube ContentID policies.
+    # A policy resource specifies rules that define a particular usage or
+    # match policy that a partner can associate with an asset or claim.
+    # @see https://developers.google.com/youtube/partner/docs/v1/policies
+    class Policy < Base
+      def initialize(options = {})
+        @data = options[:data]
+      end
+
+      # @return [String] the ID that YouTube assigns and uses to uniquely
+      #   identify the policy.
+      has_attribute :id
+
+      # @return [String] the policy’s name.
+      has_attribute :name
+
+      # @return [String] the policy’s description.
+      has_attribute :description
+
+      # @return [String] the time the policy was updated.
+      has_attribute :updated_at, type: Time, from: :time_updated
+
+      # @return [Array<PolicyRule>] a list of rules that specify the action
+      #   that YouTube should take and may optionally specify the conditions
+      #   under which that action is enforced.
+      has_attribute :rules do |rules|
+        rules.map{|rule| PolicyRule.new data: rule}
+      end
+    end
+  end
+end

data/lib/yt/models/policy_rule.rb

@@ -0,0 +1,124 @@
+require 'yt/models/base'
+
+module Yt
+  module Models
+    # Provides methods to interact with YouTube ContentID policy rules.
+    # Rules that specify the action that YouTube should take and may optionally
+    # specify the conditions under which that action is enforced.
+    # @see https://developers.google.com/youtube/partner/docs/v1/policies
+    class PolicyRule < Base
+      def initialize(options = {})
+        @data = options[:data]
+      end
+
+      # Return the policy that YouTube should enforce if the rule’s conditions
+      # are all valid for an asset or for an attempt to view that asset on
+      # YouTube. Possible values are: +'block'+, +'monetize'+, +'takedown'+,
+      # +'track'+.
+      # @return [String] the policy that YouTube should enforce.
+      has_attribute :action
+
+      # @return [Array] A list of additional actions that YouTube should take if
+      #   the conditions in the rule are met. Possible values are: +'review'+.
+      has_attribute :subaction
+
+      # Return the list of territories where the policy applies.
+      # Each territory is an ISO 3166 two-letter country code.
+      # YouTube determines whether the condition is satisfied based on the
+      # user’s location.
+      # @return [Array<String>] the territories where the policy applies.
+      # @example (with 'block' action) only block a video for U.S. users:
+      #   included_territories #=> ['us']
+      def included_territories
+        territories_type == 'include' ? territories : []
+      end
+
+      # Return the list of territories where the policy does not apply.
+      # Each territory is an ISO 3166 two-letter country code.
+      # YouTube determines whether the condition is satisfied based on the
+      # user’s location.
+      # @return [Array<String>] the territories where the policy does not apply.
+      # @example (with 'block' action) only allow U.S. users to view a video:
+      #   excluded_territories #=> ['us']
+      def excluded_territories
+        territories_type == 'exclude' ? territories : []
+      end
+
+      # @return [Array<Hash<Symbol, Float>>] the intervals of time the user-
+      #   or partner-uploaded content needs to match a reference file for the
+      #   rule to apply. :low is the minimum (inclusive) allowed value and
+      #   :high is the maximum (inclusive) allowed value for the rule to apply.
+      # @example videos that match the reference for 20 to 30 seconds:
+      #   match_duration #= [{low: 20.0, high: 30.0}]
+      def match_duration
+        match_duration_list.map{|r| low_and_high r}
+      end
+
+      # @return [Array<Hash<Symbol, Float>>] the intervals of percentages the
+      #   user- or partner-uploaded content needs to match a reference file for
+      #   the rule to apply. :low is the minimum (inclusive) allowed value and
+      #   :high is the maximum (inclusive) allowed value for the rule to apply.
+      # @example videos that match the reference for 40%~50% of their duration:
+      #   match_percent #= [{low: 40.0, high: 50.0}]
+      def match_percent
+        match_percent_list.map{|r| low_and_high r}
+      end
+
+      # @return [Array<Hash<Symbol, Float>>] the intervals of duration that the
+      #   reference must have for the rule to apply. :low is the minimum
+      #   (inclusive) allowed value, :high is the maximum (inclusive) allowed
+      #   value for the rule to apply.
+      # @example references that are between 20 and 30 seconds:
+      #   reference_duration #= [{low: 20.0, high: 30.0}]
+      def reference_duration
+        reference_duration_list.map{|r| low_and_high r}
+      end
+
+      # @return [Array<Hash<Symbol, Float>>] the intervals of percentages the
+      #   reference file needs to match the user- or partner-uploaded content
+      #   for the rule to apply. :low is the minimum (inclusive) allowed value,
+      #   :high is the maximum (inclusive) allowed value for the rule to apply.
+      # @example videos that match either 0%~10% or 40%~50% of a reference:
+      #   reference_percent #= [{low: 0.0, high: 10.0}, {low: 40.0, high: 50.0}]
+      def reference_percent
+        reference_percent_list.map{|r| low_and_high r}
+      end
+
+    private
+
+      has_attribute :conditions, default: {}
+
+      def territories_object
+        conditions.fetch 'requiredTerritories', {}
+      end
+
+      def territories_type
+        territories_object['type']
+      end
+
+      def territories
+        territories_object['territories']
+      end
+
+      def match_duration_list
+        conditions.fetch 'matchDuration', []
+      end
+
+      def match_percent_list
+        conditions.fetch 'matchPercent', []
+      end
+
+      def reference_duration_list
+        conditions.fetch 'referenceDuration', []
+      end
+
+      def reference_percent_list
+        conditions.fetch 'referencePercent', []
+      end
+
+      def low_and_high(range)
+        {low: range['low'], high: range['high']}
+      end
+    end
+  end
+end

data/lib/yt/models/rating.rb

@@ -0,0 +1,37 @@
+require 'yt/models/base'
+
+module Yt
+  module Models
+    # @private
+    # Provides methods to modify the rating of a video on YouTube.
+    # @see https://developers.google.com/youtube/v3/docs/videos/rate
+    # @see https://developers.google.com/youtube/v3/docs/videos/getRating
+    class Rating < Base
+      # @return [Symbol, nil] the rating of a video (if present).
+      #  Possible values are: +:dislike+, +:like+, +:none+, +:unspecified+.
+      attr_reader :rating
+
+      def initialize(options = {})
+        @rating = options[:rating].to_sym if options[:rating]
+        @video_id = options[:video_id]
+        @auth = options[:auth]
+      end
+
+      def set(new_rating)
+        do_update(params: {rating: new_rating}) {@rating = new_rating}
+      end
+
+    private
+
+      # @return [Hash] the parameters to submit to YouTube to update a rating.
+      # @see https://developers.google.com/youtube/v3/docs/videos/rate
+      def update_params
+        super.tap do |params|
+          params[:method] = :post
+          params[:path] = '/youtube/v3/videos/rate'
+          params[:params] = {id: @video_id}
+        end
+      end
+    end
+  end
+end

data/lib/yt/models/reference.rb

@@ -0,0 +1,172 @@
+require 'yt/models/base'
+
+module Yt
+  module Models
+    # Provides methods to interact with YouTube ContentID references.
+    # @see https://developers.google.com/youtube/partner/docs/v1/references
+    class Reference < Base
+      def initialize(options = {})
+        @data = options[:data]
+        @id = options[:id]
+        @auth = options[:auth]
+      end
+
+      # Soft-deletes the reference.
+      #
+      # @note YouTube API does not provide a +delete+ method for the Reference
+      #   resource, but only an +update+ method. Updating the +status+ of a
+      #   Reference to "inactive" can be considered a soft-deletion, since it
+      #   allows to successively create new references for the same claim.
+      # @return [Boolean] whether the reference is inactive.
+      def delete
+        body = {id: id, status: :inactive}
+        do_update(body: body) {|data| @data = data}
+        inactive?
+      end
+
+      # @return [String] the ID that YouTube assigns and uses to uniquely
+      #   identify the reference.
+      has_attribute :id
+
+      # @return [String] the ID that uniquely identifies the asset that the
+      #   reference is associated with.
+      has_attribute :asset_id
+
+      # @return [Float] The length of the reference in seconds
+      has_attribute :length
+
+      # @return [String] the ID of the source video. This field is only present
+      #   if the reference was created by associating an asset with an existing
+      #   YouTube video that was uploaded to a YouTube channel linked to your
+      #   CMS account.
+      has_attribute :video_id
+
+      # @return [String] the claim ID that represents the resulting association
+      #   between the asset and the video. This field is only present if the
+      #   reference was created by associating an asset with an existing
+      #   YouTube video that was uploaded to a YouTube channel linked to your
+      #   CMS account.
+      has_attribute :claim_id
+
+      # @return [boolean] whether or not the reference content is included in
+      #   YouTube's AudioSwap program. Set this field's value to true to
+      #   indicate that  the reference content should be included in YouTube's
+      #   AudioSwap program.
+      has_attribute :audioswap_enabled?, from: :audioswap_enabled
+
+      # @return [boolean] should the reference be used to generate claims. Set
+      #   this value to true to indicate that the reference should not be used
+      #   to generate claims. This field is only used on AudioSwap references.
+      has_attribute :ignore_fp_match?, from: :ignore_fp_match
+
+      # @return [Boolean] the urgent status of the reference file.
+      #   Set this value to true to indicate that YouTube should prioritize
+      #   Content ID processing for a video file. YouTube processes urgent
+      #   video files before other files that are not marked as urgent.
+      #   This setting is primarily used for videos of live events or other
+      #   videos that require time-sensitive processing.
+      #   The sooner YouTube completes Content ID processing for a video, the
+      #   sooner YouTube can match user-uploaded videos to that video.
+      has_attribute :urgent?, from: :urgent
+
+      # @return [String] An explanation of how a reference entered its current
+      #   state. This value is only present if the reference’s status is either
+      #   inactive or deleted.
+      has_attribute :status_reason
+
+      # @return [String] The ID that uniquely identifies the reference that
+      #   this reference duplicates. This field is only present if the
+      #   reference’s status is duplicate_on_hold.
+      has_attribute :duplicate_leader
+
+# Status
+
+      # @return [String] the reference’s status. Possible values are:
+      #   +'activating'+, +'active'+, +'checking'+, +'computing_fingerprint'+,
+      #   +'deleted'+, +'duplicate_on_hold'+, +'inactive'+,
+      #   +'live_streaming_processing'+, +'urgent_reference_processing'+.
+      has_attribute :status
+
+      # @return [Boolean] whether the reference is pending.
+      def activating?
+        status == 'activating'
+      end
+
+      # @return [Boolean] whether the reference is active.
+      def active?
+        status == 'active'
+      end
+
+      # @return [Boolean] whether the reference is being compared to existing
+      #   references to identify any reference conflicts that might exist.
+      def checking?
+        status == 'checking'
+      end
+
+      # @return [Boolean] whether the reference’s fingerprint is being
+      #   computed.
+      def computing_fingerprint?
+        status == 'computing_fingerprint'
+      end
+
+      # @return [Boolean] whether the reference is deleted.
+      def deleted?
+        status == 'deleted'
+      end
+
+      # @return [Boolean] whether the reference iis a duplicate and is on hold.
+      def duplicate_on_hold?
+        status == 'duplicate_on_hold'
+      end
+
+      # @return [Boolean] whether the reference is inactive.
+      def inactive?
+        status == 'inactive'
+      end
+
+      # @return [Boolean] whether the reference is being processed from a live
+      #   video stream.
+      def live_streaming_processing?
+        status == 'live_streaming_processing'
+      end
+
+      # @return [Boolean] whether the reference is urgent_reference_processing.
+      def urgent_reference_processing?
+        status == 'urgent_reference_processing'
+      end
+
+# Content Type
+
+      # Returns the audiovisual portion of the referenced content.
+      # @return [String] the audiovisual portion of the referenced content.
+      #   Possible values are: +'audio'+, +'audiovisual'+, +'video'+.
+      has_attribute :content_type
+
+      # @return [Boolean] whether the reference covers only the audio.
+      def audio?
+        content_type == 'audio'
+      end
+
+      # @return [Boolean] whether the reference covers only the video.
+      def video?
+        content_type == 'video'
+      end
+
+      # @return [Boolean] whether the reference covers both audio and video.
+      def audiovisual?
+        content_type == 'audiovisual'
+      end
+
+    private
+
+      # @see https://developers.google.com/youtube/partner/docs/v1/references/update
+      def update_params
+        super.tap do |params|
+          params[:expected_response] = Net::HTTPOK
+          params[:path] = "/youtube/partner/v1/references/#{id}"
+          params[:params] = {on_behalf_of_content_owner: @auth.owner_name}
+        end
+      end
+    end
+  end
+end