vibedeck-youtube_it 0.0.1

data/lib/youtube_it/request/standard_search.rb

@@ -0,0 +1,43 @@
+class YouTubeIt
+  module Request #:nodoc:
+    class StandardSearch < BaseSearch #:nodoc:
+      attr_reader :max_results                     # max_results
+      attr_reader :order_by                        # orderby, ([relevance], viewCount, published, rating)
+      attr_reader :offset                          # start-index
+      attr_reader :time                            # time
+
+      TYPES = [ :top_rated, :top_favorites, :most_viewed, :most_popular,
+                :most_recent, :most_discussed, :most_linked, :most_responded,
+                :recently_featured, :watch_on_mobile ]
+
+      def initialize(type, options={})
+        @dev_key = options[:dev_key] if options[:dev_key]
+        if TYPES.include?(type)
+          @max_results, @order_by, @offset, @time = nil
+          set_instance_variables(options)
+          @url = base_url + type.to_s << build_query_params(to_youtube_params)
+        else
+          raise "Invalid type, must be one of: #{ TYPES.map { |t| t.to_s }.join(", ") }"
+        end
+      end
+
+      private
+
+      def base_url
+        super << "standardfeeds/"
+      end
+
+      def to_youtube_params
+        {
+          'max-results' => @max_results,
+          'orderby' => @order_by,
+          'start-index' => @offset,
+          'time' => @time,
+          'v' => 2
+        }
+      end
+    end
+
+  end
+end
+

data/lib/youtube_it/request/user_search.rb

@@ -0,0 +1,47 @@
+class YouTubeIt
+  module Request #:nodoc:
+    class UserSearch < BaseSearch #:nodoc:
+      include FieldSearch
+      attr_reader :max_results                     # max_results
+      attr_reader :order_by                        # orderby, ([relevance], viewCount, published, rating)
+      attr_reader :offset                          # start-index
+
+      def initialize(params, options={})
+        @max_results, @order_by, @offset = nil
+        @url = base_url
+        @dev_key = options[:dev_key] if options[:dev_key]
+        if params == :favorites
+          @url << "#{options[:user]}/favorites"
+          set_instance_variables(options)
+        elsif params[:user] && options[:favorites]
+          @url << "#{params[:user]}/favorites"
+          set_instance_variables(params)
+          return
+        elsif params[:user]
+          @url << "#{params[:user]}/uploads"
+          set_instance_variables(params)
+        end
+
+        @url << build_query_params(to_youtube_params)
+        @url << fields_to_params(params.delete(:fields)) if params != :favorites && params[:fields]
+      end
+
+      private
+
+      def base_url
+        super << "users/"
+      end
+
+      def to_youtube_params
+        {
+          'max-results' => @max_results,
+          'orderby' => @order_by,
+          'start-index' => @offset,
+          'v' => 2
+        }
+      end
+    end
+
+  end
+end
+

data/lib/youtube_it/request/video_search.rb

@@ -0,0 +1,102 @@
+class YouTubeIt
+  module Request #:nodoc:
+    class VideoSearch < BaseSearch #:nodoc:
+      include FieldSearch
+
+      # From here: http://code.google.com/apis/youtube/reference.html#yt_format
+      ONLY_EMBEDDABLE = 5
+
+      attr_reader :max_results                     # max_results
+      attr_reader :order_by                        # orderby, ([relevance], viewCount, published, rating)
+      attr_reader :offset                          # start-index
+      attr_reader :query                           # vq
+      attr_reader :response_format                 # alt, ([atom], rss, json)
+      attr_reader :tags                            # /-/tag1/tag2
+      attr_reader :categories                      # /-/Category1/Category2
+      attr_reader :video_format                    # format (1=mobile devices)
+      attr_reader :racy                            # racy ([exclude], include)
+      attr_reader :author
+      attr_reader :lang                            # lt
+
+      def initialize(params={})
+        # Initialize our various member data to avoid warnings and so we'll
+        # automatically fall back to the youtube api defaults
+        @max_results, @order_by,
+        @offset, @query,
+        @response_format, @video_format,
+        @racy, @author, @lang = nil
+        @url = base_url
+        @dev_key = params[:dev_key] if params[:dev_key]
+
+        # Return a single video (base_url + /T7YazwP8GtY)
+        return @url << "/" << params[:video_id] << "?v=2" if params[:video_id]
+
+        @url << "/-/" if (params[:categories] || params[:tags])
+        @url << categories_to_params(params.delete(:categories)) if params[:categories]
+        @url << tags_to_params(params.delete(:tags)) if params[:tags]
+
+        set_instance_variables(params)
+
+        if( params[ :only_embeddable ] )
+          @video_format = ONLY_EMBEDDABLE
+        end
+
+        @url << build_query_params(to_youtube_params)
+        @url << fields_to_params(params.delete(:fields)) if params[:fields]
+      end
+
+      private
+
+      def base_url
+        super << "videos"
+      end
+
+      def to_youtube_params
+        {
+          'max-results' => @max_results,
+          'orderby' => @order_by,
+          'start-index' => @offset,
+          'v' => 2,
+          'q' => @query,
+          'alt' => @response_format,
+          'format' => @video_format,
+          'racy' => @racy,
+          'author' => @author,
+          'lr' => @lang
+        }
+      end
+
+
+      # Convert category symbols into strings and build the URL. GData requires categories to be capitalized.
+      # Categories defined like: categories => { :include => [:news], :exclude => [:sports], :either => [..] }
+      # or like: categories => [:news, :sports]
+      def categories_to_params(categories)
+        if categories.respond_to?(:keys) and categories.respond_to?(:[])
+          s = ""
+          s << categories[:either].map { |c| c.to_s.capitalize }.join("%7C") << '/' if categories[:either]
+          s << categories[:include].map { |c| c.to_s.capitalize }.join("/") << '/' if categories[:include]
+          s << ("-" << categories[:exclude].map { |c| c.to_s.capitalize }.join("/-")) << '/' if categories[:exclude]
+          s
+        else
+          categories.map { |c| c.to_s.capitalize }.join("/") << '/'
+        end
+      end
+
+      # Tags defined like: tags => { :include => [:football], :exclude => [:soccer], :either => [:polo, :tennis] }
+      # or tags => [:football, :soccer]
+      def tags_to_params(tags)
+        if tags.respond_to?(:keys) and tags.respond_to?(:[])
+          s = ""
+          s << tags[:either].map { |t| YouTubeIt.esc(t.to_s) }.join("%7C") << '/' if tags[:either]
+          s << tags[:include].map { |t| YouTubeIt.esc(t.to_s) }.join("/") << '/' if tags[:include]
+          s << ("-" << tags[:exclude].map { |t| YouTubeIt.esc(t.to_s) }.join("/-")) << '/' if tags[:exclude]
+          s
+        else
+          tags.map { |t| YouTubeIt.esc(t.to_s) }.join("/") << '/'
+        end
+      end
+
+    end
+  end
+end
+

data/lib/youtube_it/request/video_upload.rb

@@ -0,0 +1,415 @@
+class YouTubeIt
+  module Upload
+    class VideoUpload
+      include YouTubeIt::Logging
+
+      def initialize *params
+        if params.first.is_a?(Hash)
+          hash_options = params.first
+          @user                          = hash_options[:username]
+          @password                      = hash_options[:password]
+          @dev_key                       = hash_options[:dev_key]
+          @access_token                  = hash_options[:access_token]
+          @authsub_token                 = hash_options[:authsub_token]
+          @client_id                     = hash_options[:client_id] || "youtube_it"
+          @config_token                  = hash_options[:config_token]
+        else
+          puts "* warning: the method YouTubeIt::Upload::VideoUpload.new(username, password, dev_key) is depricated, use YouTubeIt::Upload::VideoUpload.new(:username => 'user', :password => 'passwd', :dev_key => 'dev_key')"
+          @user                          = params.shift
+          @password                      = params.shift
+          @dev_key                       = params.shift
+          @access_token                  = params.shift
+          @authsub_token                 = params.shift
+          @client_id                     = params.shift || "youtube_it"
+          @config_token                  = params.shift
+        end
+      end
+
+
+      def enable_http_debugging
+        @http_debugging = true
+      end
+
+      #
+      # Upload "data" to youtube, where data is either an IO object or
+      # raw file data.
+      # The hash keys for opts (which specify video info) are as follows:
+      #   :mime_type
+      #   :filename
+      #   :title
+      #   :description
+      #   :category
+      #   :keywords
+      #   :private
+      # New V2 api hash keys for accessControl:
+      #   :rate
+      #   :comment
+      #   :commentVote
+      #   :videoRespond
+      #   :list
+      #   :embed
+      #   :syndicate
+      # Specifying :private will make the video private, otherwise it will be public.
+      #
+      # When one of the fields is invalid according to YouTube,
+      # an UploadError will be raised. Its message contains a list of newline separated
+      # errors, containing the key and its error code.
+      #
+      # When the authentication credentials are incorrect, an AuthenticationError will be raised.
+      def upload(data, opts = {})
+        @opts    = { :mime_type => 'video/mp4',
+                     :title => '',
+                     :description => '',
+                     :category => '',
+                     :keywords => [] }.merge(opts)
+
+        @opts[:filename] ||= generate_uniq_filename_from(data)
+
+        post_body_io = generate_upload_io(video_xml, data)
+
+        upload_header = {
+            "Slug"           => "#{@opts[:filename]}",
+            "Content-Type"   => "multipart/related; boundary=#{boundary}",
+            "Content-Length" => "#{post_body_io.expected_length}",
+        }
+
+        upload_url = "/feeds/api/users/default/uploads"
+        response = yt_session(uploads_url).post(upload_url, post_body_io, upload_header)
+
+        return YouTubeIt::Parser::VideoFeedParser.new(response.body).parse
+      end
+
+      # Updates a video in YouTube.  Requires:
+      #   :title
+      #   :description
+      #   :category
+      #   :keywords
+      # The following are optional attributes:
+      #   :private
+      # When the authentication credentials are incorrect, an AuthenticationError will be raised.
+      def update(video_id, options)
+        @opts       = options
+        update_body = video_xml
+        update_url  = "/feeds/api/users/default/uploads/%s" % video_id
+        response    = yt_session.put(update_url, update_body)
+        
+        return YouTubeIt::Parser::VideoFeedParser.new(response.body).parse
+      end
+
+      # Fetches the data of a video, which may be private. The video must be owned by this user.
+      # When the authentication credentials are incorrect, an AuthenticationError will be raised.
+      def get_my_video(video_id)
+        get_url  = "/feeds/api/users/default/uploads/%s" % video_id
+        response = yt_session.get(get_url)
+        
+        return YouTubeIt::Parser::VideoFeedParser.new(response.body).parse
+      end
+
+      # Fetches the data of the videos of the current user, which may be private. 
+      # When the authentication credentials are incorrect, an AuthenticationError will be raised.
+      def get_my_videos(opts)
+        max_results = opts[:per_page] || 50
+        start_index = ((opts[:page] || 1) -1) * max_results +1
+        get_url     = "/feeds/api/users/default/uploads?max-results=#{max_results}&start-index=#{start_index}"
+        response    = yt_session.get(get_url)
+
+        return YouTubeIt::Parser::VideosFeedParser.new(response.body).parse
+      end
+
+      # Delete a video on YouTube
+      def delete(video_id)
+        delete_url = "/feeds/api/users/default/uploads/%s" % video_id
+        response   = yt_session.delete(delete_url)
+
+        return true
+      end
+
+      def get_upload_token(options, nexturl)
+        @opts      = options
+        token_body = video_xml
+        token_url  = "/action/GetUploadToken"
+        response   = yt_session.post(token_url, token_body)
+        
+        return {:url    => "#{response.body[/<url>(.+)<\/url>/, 1]}?nexturl=#{nexturl}",
+                :token  => response.body[/<token>(.+)<\/token>/, 1]}
+      end
+
+      def add_comment(video_id, comment)
+        comment_body = video_xml_for(:comment => comment)
+        comment_url  = "/feeds/api/videos/%s/comments" % video_id
+        response     = yt_session.post(comment_url, comment_body)
+        
+        return {:code => response.status, :body => response.body}
+      end
+
+      def comments(video_id, opts = {})
+        comment_url = "/feeds/api/videos/%s/comments?" % video_id
+        comment_url << opts.collect { |k,p| [k,p].join '=' }.join('&')
+        response    = yt_session.get(comment_url)
+        
+        return YouTubeIt::Parser::CommentsFeedParser.new(response).parse
+      end
+
+      def add_favorite(video_id)
+        favorite_body = video_xml_for(:favorite => video_id)
+        favorite_url  = "/feeds/api/users/default/favorites"
+        response      = yt_session.post(favorite_url, favorite_body)
+        
+        return {:code => response.status, :body => response.body}
+      end
+
+      def delete_favorite(video_id)
+        favorite_header = {
+          "GData-Version"  => "1",
+        }
+        favorite_url = "/feeds/api/users/default/favorites/%s" % video_id
+        response     = yt_session.delete(favorite_url, favorite_header)
+        
+        return true
+      end
+
+      def profile(user)
+        profile_url = "/feeds/api/users/%s?v=2" % (user ? user : "default")
+        response    = yt_session.get(profile_url)
+
+        return YouTubeIt::Parser::ProfileFeedParser.new(response).parse
+      end
+
+      def playlist(playlist_id)
+        playlist_url = "/feeds/api/playlists/%s?v=2" % playlist_id
+        response     = yt_session.get(playlist_url)
+        
+        return YouTubeIt::Parser::PlaylistFeedParser.new(response).parse
+      end
+
+      def playlists(user)
+        playlist_url = "/feeds/api/users/%s/playlists?v=2" % (user ? user : "default")
+        response     = yt_session.get(playlist_url)
+        
+        return YouTubeIt::Parser::PlaylistsFeedParser.new(response).parse
+      end
+      
+      def add_playlist(options)
+        playlist_body = video_xml_for_playlist(options)
+        playlist_url  = "/feeds/api/users/default/playlists"
+        response      = yt_session.post(playlist_url, playlist_body)
+        
+        return YouTubeIt::Parser::PlaylistFeedParser.new(response).parse
+      end
+
+      def add_video_to_playlist(playlist_id, video_id)
+        playlist_body = video_xml_for(:playlist => video_id)
+        playlist_url  = "/feeds/api/playlists/%s" % playlist_id
+        response      = yt_session.post(playlist_url, playlist_body)
+        
+        return {:code => response.status, :body => response.body, :playlist_entry_id => playlist_entry_id_from_playlist(response.body)}
+      end
+
+      def update_playlist(playlist_id, options)
+        playlist_body = video_xml_for_playlist(options)
+        playlist_url  = "/feeds/api/users/default/playlists/%s" % playlist_id
+        response      = yt_session.put(playlist_url, playlist_body)
+        
+        return YouTubeIt::Parser::PlaylistFeedParser.new(response).parse
+      end
+
+      def delete_video_from_playlist(playlist_id, playlist_entry_id)
+        playlist_url = "/feeds/api/playlists/%s/%s" % [playlist_id, playlist_entry_id]
+        response     = yt_session.delete(playlist_url)
+        
+        return true
+      end
+
+      def delete_playlist(playlist_id)
+        playlist_url = "/feeds/api/users/default/playlists/%s" % playlist_id
+        response     = yt_session.delete(playlist_url)
+        
+        return true
+      end
+
+      def rate_video(video_id, rating)
+        rating_body = video_xml_for(:rating => rating)
+        rating_url  = "/feeds/api/videos/#{video_id}/ratings"
+        response    = yt_session.post(rating_url, rating_body)
+        
+        return {:code => response.status, :body => response.body}
+      end
+      
+      def subscriptions(user)
+        subscription_url = "/feeds/api/users/%s/subscriptions?v=2" % (user ? user : "default")
+        response         = yt_session.get(subscription_url)
+        
+        return YouTubeIt::Parser::SubscriptionFeedParser.new(response).parse
+      end
+            
+      def subscribe_channel(channel_name)
+        subscribe_body = video_xml_for(:subscribe => channel_name)
+        subscribe_url  = "/feeds/api/users/default/subscriptions"
+        response       = yt_session.post(subscribe_url, subscribe_body)
+         
+        return {:code => response.status, :body => response.body}
+      end
+      
+      def unsubscribe_channel(subscription_id)
+        unsubscribe_url = "/feeds/api/users/default/subscriptions/%s" % subscription_id
+        response        = yt_session.delete(unsubscribe_url)
+           
+        return {:code => response.status, :body => response.body}
+      end
+      
+      def favorites(user, opts = {})
+        favorite_url = "/feeds/api/users/%s/favorites#{opts.empty? ? '' : '?#{opts.to_param}'}" % (user ? user : "default")
+        response     = yt_session.get(favorite_url)
+
+        return YouTubeIt::Parser::VideosFeedParser.new(response.body).parse
+      end
+
+      def get_current_user
+        current_user_url = "/feeds/api/users/default"
+        response         = yt_session.get(current_user_url, authorization_headers)
+
+        return REXML::Document.new(response.body).elements["entry"].elements['author'].elements['name'].text
+      end
+
+      private
+
+      def uploads_url
+        ["http://uploads", base_url.sub("http://","")].join('.')
+      end
+
+      def base_url
+        "http://gdata.youtube.com"
+      end
+
+      def boundary
+        "An43094fu"
+      end
+
+      def authorization_headers
+        header = {
+                  "X-GData-Client" => "#{@client_id}",
+                  "X-GData-Key"    => "key=#{@dev_key}",
+                }
+        if @authsub_token
+          header.merge!("Authorization"  => "AuthSub token=#{@authsub_token}")
+        elsif @access_token.nil? && @authsub_token.nil?
+          header.merge!("Authorization"  => "GoogleLogin auth=#{auth_token}")
+        end
+        header
+      end
+
+      def uploaded_video_id_from(string)
+        xml = REXML::Document.new(string)
+        xml.elements["//id"].text[/videos\/(.+)/, 1]
+      end
+
+      def playlist_id_from(string)
+        xml = REXML::Document.new(string)
+        entry = xml.elements["entry"]
+        entry.elements["id"].text[/playlist([^<]+)/, 1].sub(':','')
+      end
+
+      # If data can be read, use the first 1024 bytes as filename. If data
+      # is a file, use path. If data is a string, checksum it
+      def generate_uniq_filename_from(data)
+        if data.respond_to?(:path)
+          Digest::MD5.hexdigest(data.path)
+        elsif data.respond_to?(:read)
+          chunk = data.read(1024)
+          data.rewind
+          Digest::MD5.hexdigest(chunk)
+        else
+          Digest::MD5.hexdigest(data)
+        end
+      end
+
+      def auth_token
+        @auth_token ||= begin
+          http  = Faraday.new("https://www.google.com")
+          body = "Email=#{YouTubeIt.esc @user}&Passwd=#{YouTubeIt.esc @password}&service=youtube&source=#{YouTubeIt.esc @client_id}"
+          response = http.post("/youtube/accounts/ClientLogin", body, "Content-Type" => "application/x-www-form-urlencoded")
+          raise ::AuthenticationError.new(response.body[/Error=(.+)/,1], response.status.to_i) if response.status.to_i != 200
+          @auth_token = response.body[/Auth=(.+)/, 1]
+        end
+      end
+
+      # TODO: isn't there a cleaner way to output top-notch XML without requiring stuff all over the place?
+      def video_xml
+        b = Builder::XmlMarkup.new
+        b.instruct!
+        b.entry(:xmlns => "http://www.w3.org/2005/Atom", 'xmlns:media' => "http://search.yahoo.com/mrss/", 'xmlns:yt' => "http://gdata.youtube.com/schemas/2007") do | m |
+          m.tag!("media:group") do | mg |
+            mg.tag!("media:title", @opts[:title], :type => "plain")
+            mg.tag!("media:description", @opts[:description], :type => "plain")
+            mg.tag!("media:keywords", @opts[:keywords].join(","))
+            mg.tag!('media:category', @opts[:category], :scheme => "http://gdata.youtube.com/schemas/2007/categories.cat")
+            mg.tag!('yt:private') if @opts[:private]
+            mg.tag!('media:category', @opts[:dev_tag], :scheme => "http://gdata.youtube.com/schemas/2007/developertags.cat") if @opts[:dev_tag]
+          end
+          m.tag!("yt:accessControl", :action => "rate", :permission => @opts[:rate]) if @opts[:rate]
+          m.tag!("yt:accessControl", :action => "comment", :permission => @opts[:comment]) if @opts[:comment]
+          m.tag!("yt:accessControl", :action => "commentVote", :permission => @opts[:commentVote]) if @opts[:commentVote]
+          m.tag!("yt:accessControl", :action => "videoRespond", :permission => @opts[:videoRespond]) if @opts[:videoRespond]
+          m.tag!("yt:accessControl", :action => "list", :permission => @opts[:list]) if @opts[:list]
+          m.tag!("yt:accessControl", :action => "embed", :permission => @opts[:embed]) if @opts[:embed]
+          m.tag!("yt:accessControl", :action => "syndicate", :permission => @opts[:syndicate]) if @opts[:syndicate]
+        end.to_s
+      end
+
+      def video_xml_for(data)
+        b = Builder::XmlMarkup.new
+        b.instruct!
+        b.entry(:xmlns => "http://www.w3.org/2005/Atom", 'xmlns:yt' => "http://gdata.youtube.com/schemas/2007") do | m |
+          m.content(data[:comment]) if data[:comment]
+          m.id(data[:favorite] || data[:playlist]) if data[:favorite] || data[:playlist]
+          m.tag!("yt:rating", :value => data[:rating]) if data[:rating]
+          if(data[:subscribe])
+            m.category(:scheme => "http://gdata.youtube.com/schemas/2007/subscriptiontypes.cat", :term => "channel")
+            m.tag!("yt:username", data[:subscribe])
+          end
+        end.to_s
+      end
+
+      def video_xml_for_playlist(data)
+        b = Builder::XmlMarkup.new
+        b.instruct!
+        b.entry(:xmlns => "http://www.w3.org/2005/Atom", 'xmlns:yt' => "http://gdata.youtube.com/schemas/2007") do | m |
+          m.title(data[:title]) if data[:title]
+          m.summary(data[:description] || data[:summary]) if data[:description] || data[:summary]
+          m.tag!('yt:private') if data[:private]
+        end.to_s
+      end
+
+      def generate_upload_io(video_xml, data)
+        post_body = [
+          "--#{boundary}\r\n",
+          "Content-Type: application/atom+xml; charset=UTF-8\r\n\r\n",
+          video_xml,
+          "\r\n--#{boundary}\r\n",
+          "Content-Type: #{@opts[:mime_type]}\r\nContent-Transfer-Encoding: binary\r\n\r\n",
+          data,
+          "\r\n--#{boundary}--\r\n",
+        ]
+
+        # Use Greedy IO to not be limited by 1K chunks
+        YouTubeIt::GreedyChainIO.new(post_body)
+      end
+
+      def playlist_entry_id_from_playlist(string)
+        playlist_xml = REXML::Document.new(string)
+        playlist_xml.elements.each("/entry") do |item|
+          return item.elements["id"].text[/^.*:([^:]+)$/,1]
+        end
+      end
+
+      def yt_session(url = nil)
+        Faraday.new(:url => url ? url : base_url) do |builder|
+          builder.use Faraday::Request::OAuth, @config_token if @config_token
+          builder.use Faraday::Request::AuthHeader, authorization_headers
+          builder.use Faraday::Response::YouTubeIt 
+          builder.adapter Faraday.default_adapter          
+        end
+      end
+    end
+  end
+end

data/lib/youtube_it/response/video_search.rb

@@ -0,0 +1,41 @@
+class YouTubeIt
+  module Response
+    class VideoSearch < YouTubeIt::Record
+      # *String*:: Unique feed identifying url.
+      attr_reader :feed_id 
+      
+      # *Fixnum*:: Number of results per page.
+      attr_reader :max_result_count
+      
+      # *Fixnum*:: 1-based offset index into the full result set.
+      attr_reader :offset
+      
+      # *Fixnum*:: Total number of results available for the original request.
+      attr_reader :total_result_count
+
+      # *Time*:: Date and time at which the feed was last updated
+      attr_reader :updated_at
+
+      # *Array*:: Array of YouTubeIt::Model::Video records
+      attr_reader :videos
+
+      def current_page
+        ((offset - 1) / max_result_count) + 1
+      end
+      
+      # current_page + 1 or nil if there is no next page
+      def next_page
+        current_page < total_pages ? (current_page + 1) : nil
+      end
+
+      # current_page - 1 or nil if there is no previous page
+      def previous_page
+        current_page > 1 ? (current_page - 1) : nil
+      end
+
+      def total_pages
+        (total_result_count / max_result_count.to_f).ceil
+      end
+    end
+  end
+end

data/lib/youtube_it/version.rb

@@ -0,0 +1,4 @@
+class YouTubeIt
+  VERSION = '2.0.0.vbdk'
+end
+