yt_data_api 0.0.1 → 0.0.2

data/README.markdown

@@ -1,6 +1,28 @@
 #Yt_Data_Api
 
-Yt_Data_Api adds functionality to access YouTube Data API.
+yt_data_api adds functionality to access elements of the YouTube Data API.  This was created as a learning tool.  Check out youtube_it for more functionality, https://github.com/kylejginavan/youtube_it.
 
-# TODO
-Add more descriptions...
+#Usage
+
+First, create a new client object passing YouTube user credentials.  Note you will have to acquire a developer key from YouTube, http://code.google.com/apis/youtube/2.0/developers_guide_protocol.html#Developer_Key.
+
+`client = YtDataApi::YtDataApiClient.new(YOUTUBE_USER_ID, YOUTUBE_USER_PSWD, YOUTUBE_DEV_KEY)`
+
+Then, call functions on the client object to access the YouTube Data API.
+
+##Create a playlist and get it's id
+`client.create_playlist("test")`
+`playlist_id = client.get_client_playlist_id("test")`
+
+##Delete a playlist
+`client.delete_playlist(playlist_id)`
+
+##Get a video id given a query
+Note spaces were replaced with '+'
+`video_id = client.get_video_id("Otis+Kanye+West")`
+
+##Add video to client playlist
+`client.add_video_to_playlist(video_id, playlist_id)`
+
+#TODO
+- Add more functionality

data/lib/yt_data_api.rb

@@ -7,98 +7,78 @@ require 'xml'
 module YtDataApi
   class YtDataApiClient
     def initialize(user_id, user_pswd, dev_key)
-      self.client_login(user_id, user_pswd, dev_key)
-    end
-
-    def client_login(user_id, user_pswd, dev_key)
-      http = Net::HTTP.new("www.google.com", 443)
-      http.use_ssl = true
-      path = "/accounts/ClientLogin"
-
-      data = "Email=#{user_id}&Passwd=#{user_pswd}&service=youtube&source=Test"
-      headers = {"Content-Type" => "application/x-www-form-urlencoded"}
-
-      response, data = http.post(path, data, headers)
-
-      if(response.code != "200")
-        raise "Error while authenticating YouTube user - #{response.code}"
+      post_response = client_login(user_id, user_pswd, dev_key)
+      
+      if(post_response.code != "200")
+        raise "Error while authenticating #{user_id} - #{post_response.code}: #{post_response.message}"
       end
-
-      @client_user_id = user_id
-      @client_auth_key = data[/Auth=(.*)/, 1]
-      @dev_auth_key = "key=" + dev_key
     end
 
-    def get_video_id(search_query)
-      query_uri = URI.parse("http://gdata.youtube.com/feeds/api/videos?q=#{search_query}&max-results=1")
-      rss_query_result = parse_rss(query_uri)
+    def create_playlist(playlist_name)
+      headers = {"Content-Type" => "application/atom+xml", 
+                 "Authorization" => "GoogleLogin auth=#{@client_auth_key}", 
+                 "X-GData-Key" => @dev_auth_key,
+                 "GData-Version" => "2"}
+		
+      new_row = "<?xml version='1.0' encoding='UTF-8'?>" + 
+                "<entry xmlns='http://www.w3.org/2005/Atom' " + 
+                "xmlns:yt='http://gdata.youtube.com/schemas/2007'>" +
+                "<title type='text'>#{playlist_name}</title><summary></summary></entry>"
 
-      rss_query_result.items.each do |item|
-        return item.id.to_s[/<id>http:\/\/(.*\/)(.*)<\/id>/, 2]
-      end
+      headers["Content-Length"] = new_row.bytesize.to_s
 
-      return nil
+      uri = URI.parse("http://gdata.youtube.com/feeds/api/users/default/playlists")
+      http = Net::HTTP.new(uri.host, uri.port)
+      
+      post_response = http.post(uri.path, new_row, headers)
+      post_response_content = parse_atom_xml(post_response)
+      post_response_entry = post_response_content.root.find_first('yt:playlistId')
+      playlist_id = post_response_entry.content
+      
+      return post_response, playlist_id
     end
-
-    def get_client_playlist_id(playlist_name)
+    
+    def get_playlist_id(playlist_name)
       headers = {"Content-Type" => "application/x-www-form-urlencoded", 
                  "Authorization" => "GoogleLogin auth=#{@client_auth_key}", 
                  "X-GData-Key" => @dev_auth_key}	
 		
       uri = URI.parse("http://gdata.youtube.com/feeds/api/users/default/playlists?v=2")
 
-      xml_client_playlists = Net::HTTP.start(uri.host, uri.port){|http|
+      playlists_feed = Net::HTTP.start(uri.host, uri.port){|http|
         http.get(uri.path, headers)
       }
+      
+      playlists_content = parse_atom_xml(playlists_feed)
+      playlists_entries = playlists_content.root.find('atom:entry')
 
-      #Parse xml of client's playlists
-      source = XML::Parser.string(xml_client_playlists.body)
-      content = source.parse
-      content.root.namespaces.default_prefix = 'atom'
-
-      entries = content.root.find('atom:entry')
-		
-      #Get playlist id
-      entries.each do |entry|
+      playlists_entries.each do |entry|
         if(entry.find_first('atom:title').content.eql?(playlist_name))
-          feedlink = entry.find_first('gd:feedLink').attributes["href"]
-          return feedlink[/http:\/\/gdata.youtube.com\/feeds\/api\/playlists\/(.+)/, 1]
+          return entry.find_first('yt:playlistId').content
         end
       end
 		
       return nil
     end
-
-    def get_client_playlist_entries(playlist_id)
-      headers = {"Content-Type" => "application/x-www-form-urlencoded", 
-                 "Authorization" => "GoogleLogin auth=#{@client_auth_key}", 
-                 "X-GData-Key" => @dev_auth_key}	
-		
-      uri = URI.parse("http://gdata.youtube.com/feeds/api/playlists/#{playlist_id}?v=2")
-
-      xml_client_playlist_videos = Net::HTTP.start(uri.host, uri.port){|http|
-        http.get(uri.path, headers)
-      }
-
-      source = XML::Parser.string(xml_client_playlist_videos.body)
-      content = source.parse
-      content.root.namespaces.default_prefix = 'atom'
-
-      entries = content.root.find('atom:entry')
-
-      playlist_entries = []
-
-      entries.each do |entry|
-        entry_id = entry.find_first('atom:id')
-        playlist_entry = 
-          entry_id.content[/http:\/\/.*\/(.+)/, 1]
-        playlist_entries << playlist_entry
+    
+    def get_video_ids(search_query, count = 1)
+      query_uri = URI.parse("http://gdata.youtube.com/feeds/api/videos?q=#{search_query}&max-results=#{count}")
+      rss_query_result = parse_rss(query_uri)
+      video_ids = []
+      
+      rss_query_result.items.each do |item|
+        video_id = item.id.to_s[/<id>http:\/\/(.*\/)(.*)<\/id>/, 2]
+        return video_id if count == 1
+        video_ids << video_id
       end
-		
-      playlist_entries
 
+      if(video_ids.empty?)
+        nil
+      else
+        video_ids
+      end
     end
-
+    
     def add_video_to_playlist(video_id, playlist_id)
       headers = {"Content-Type" => "application/atom+xml", 
                  "Authorization" => "GoogleLogin auth=#{@client_auth_key}", 
@@ -116,37 +96,56 @@ module YtDataApi
       http = Net::HTTP.new(uri.host, uri.port)
 
       post_response = http.post(uri.path, new_row, headers)
-
-      if(post_response.code != "201")
-        raise "Error while adding #{video_id} to #{playlist_id} - #{post_response.code}"
+    end
+    
+    def add_videos_to_playlist(video_ids, playlist_id)
+      failed_to_add = []
+      
+      video_ids.each_with_index do |video_id, index|
+        post_response = add_video_to_playlist(video_id, playlist_id)
+        
+        if(post_response.code == "403")
+          sleep(30)
+          post_repsonse = add_video_to_playlist(video_id, playlist_id)
+        end
+        
+        if(post_response.code != "201")
+          failed_to_add << "#{index + 1},#{video_id},#{post_response.code}"
+        end
+      end
+      
+      if(failed_to_add.empty?)
+        "201"
+      else
+        failed_to_add
       end
-
-      post_response.code
     end
 
-    def create_playlist(playlist_name)
-      headers = {"Content-Type" => "application/atom+xml", 
+    def get_client_playlist_entries(playlist_id)
+      headers = {"Content-Type" => "application/x-www-form-urlencoded", 
                  "Authorization" => "GoogleLogin auth=#{@client_auth_key}", 
-                 "X-GData-Key" => @dev_auth_key,
-                 "GData-Version" => "2"}
+                 "X-GData-Key" => @dev_auth_key}	
 		
-      new_row = "<?xml version='1.0' encoding='UTF-8'?>" + 
-                "<entry xmlns='http://www.w3.org/2005/Atom' " + 
-                "xmlns:yt='http://gdata.youtube.com/schemas/2007'>" +
-                "<title type='text'>#{playlist_name}</title><summary></summary></entry>"
+      uri = URI.parse("http://gdata.youtube.com/feeds/api/playlists/#{playlist_id}?v=2")
 
-      headers["Content-Length"] = new_row.bytesize.to_s
+      playlist_entries_feed = Net::HTTP.start(uri.host, uri.port){|http|
+        http.get(uri.path, headers)
+      }
 
-      uri = URI.parse("http://gdata.youtube.com/feeds/api/users/default/playlists")
-      http = Net::HTTP.new(uri.host, uri.port)
+      playlist_entries_content = parse_atom_xml(playlist_entries_feed)
+      playlist_entries = playlist_entries_content.root.find('atom:entry')
 
-      post_response = http.post(uri.path, new_row, headers)
+      playlist_entries_ids = []
 
-      if(post_response.code != "201")
-        raise "Error while creating #{playlist_name} - #{post_response.code}"
+      playlist_entries.each do |entry|
+        entry_id = entry.find_first('atom:id')
+        playlist_entry = 
+          entry_id.content[/http:\/\/.*\/(.+)/, 1]
+        playlist_entries_ids << playlist_entry
       end
+		
+      playlist_entries_ids
 
-      post_response.code
     end
 
     def empty_playlist(playlist_id)
@@ -188,7 +187,7 @@ module YtDataApi
 
       delete_response.code
     end
-
+    
     private
       #Use Ruby RSS Parser to return parseable info from RSS feed
       def parse_rss(rss_feed)
@@ -200,6 +199,38 @@ module YtDataApi
         end
 
         RSS::Parser.parse(rss_content, false)
-    end
+      end
+      
+      def parse_atom_xml(xml)
+        source = XML::Parser.string(xml.body)
+        content = source.parse
+        content.root.namespaces.default_prefix = 'atom'
+        content
+      end
+      
+      def http_post_ssl(url, data, headers)
+        uri = URI.parse(url)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = true
+        
+        http.post(uri.path, data, headers)
+      end
+      
+      def client_login(user_id, user_pswd, dev_key)      
+        post_url = "https://www.google.com/accounts/ClientLogin"
+        data = "Email=#{user_id}&Passwd=#{user_pswd}&service=youtube&source=YtDataApi"
+        headers = {"Content-Type" => "application/x-www-form-urlencoded"}
+
+        post_response, data = http_post_ssl(post_url, data, headers)
+
+        if(post_response.code != "200")
+          post_response
+        else
+          @client_user_id = user_id
+          @client_auth_key = data[/Auth=(.*)/, 1]
+          @dev_auth_key = "key=" + dev_key
+          post_response
+        end
+      end
   end
 end

data/lib/yt_data_api/version.rb

@@ -1,3 +1,3 @@
 module YtDataApi
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/spec/yt_data_api_spec.rb

@@ -5,10 +5,6 @@ describe "YtDataApi::YtDataApiClient" do
     YtDataApi::YtDataApiClient.new(ENV['YT_USER'], ENV['YT_USER_PSWD'], ENV['YT_DEV_AUTH_KEY'])
   end
 
-  it "should not create a new instance without credentials for ClientLogin Authentication" do
-    lambda{ YtDataApi::YtDataApiClient.new }.should raise_error ArgumentError
-  end
-
   it "should not create a new instance without valid credentials for ClientLogin Authentication" do
     lambda{ YtDataApi::YtDataApiClient.new("trash", "trash", "trash") }.should raise_error
   end 
@@ -16,27 +12,72 @@ describe "YtDataApi::YtDataApiClient" do
   describe "authenticated" do
     before(:each) do
       @client = YtDataApi::YtDataApiClient.new(ENV['YT_USER'], ENV['YT_USER_PSWD'], ENV['YT_DEV_AUTH_KEY'])
-      @create_response = @client.create_playlist("test_one")
-      @playlist_id = @client.get_client_playlist_id("test_one")
+      @create_response, @playlist_id = @client.create_playlist("test_one")
     end
 
     it "should create a client's playlist" do
-      @create_response.should == "201"
+      @create_response.code.should == "201"
     end
 
     it "should get a client's playlist id given the playlist's name" do
-     @playlist_id.should_not be nil
+      playlist_id = @client.get_playlist_id("test_one")
+      playlist_id.should == @playlist_id
+    end
+    
+    it "should return nil if the playlist id cannot be found given playlist name" do
+      playlist_id = @client.get_playlist_id("trash")
+      playlist_id.should == nil
     end
 
-    it "should get a video id given a query string" do
+    it "should get one video id given a query string" do
       query = "vampire-weekend-giving-up-the-gun"
-      video_id = @client.get_video_id(query)
+      video_id = @client.get_video_ids(query)
       video_id.should == "bccKotFwzoY"
     end
+    
+    it "should get multiple video ids given a query string and count" do
+      query = "vampire-weekend-giving-up-the-gun"
+      video_ids = @client.get_video_ids(query, 10)
+      video_ids.size.should == 10
+    end
+    
+    it "should return nil if no videos are found for given query" do
+      query = ","
+      video_id = @client.get_video_ids(query)
+      video_id.should == nil
+    end
 
     it "should add a video to a client's playlist" do
       video_id = "bccKotFwzoY"
       post_response = @client.add_video_to_playlist(video_id, @playlist_id)
+      post_response.code.should == "201"
+    end
+    
+    it "should add multiple videos (less than 50) to a client's playlist" do
+      video_ids = []
+      5.times do
+        video_ids << "bccKotFwzoY"
+      end
+      
+      post_response = @client.add_videos_to_playlist(video_ids, @playlist_id)
+      post_response.should == "201"
+    end
+    
+    it "should return an array of videos that could not be added to the client's playlist" do
+      video_ids = %w{ bccKotFwzoY trash trash bccKotFwzoY trash }
+      
+      post_response = @client.add_videos_to_playlist(video_ids, @playlist_id)
+      array = post_response.map{|entry| entry.split(",")[1] }
+      array.should == %w{ trash trash trash }
+    end
+    
+    it "should add multiple videos (more than 50) to a playlist" do
+      video_ids = []
+      100.times do
+        video_ids << "bccKotFwzoY"
+      end
+      
+      post_response = @client.add_videos_to_playlist(video_ids, @playlist_id)
       post_response.should == "201"
     end
 
@@ -55,7 +96,7 @@ describe "YtDataApi::YtDataApiClient" do
     end
 
     after(:each) do
-      playlist = @client.get_client_playlist_id("test_one")
+      playlist = @client.get_playlist_id("test_one")
       @client.delete_playlist(@playlist_id) unless playlist.nil?
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: yt_data_api
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-08-24 00:00:00.000000000Z
+date: 2011-11-15 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: libxml-ruby
-  requirement: &70195100472000 !ruby/object:Gem::Requirement
+  requirement: &70157707836100 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,10 +21,10 @@ dependencies:
         version: 1.1.3
   type: :runtime
   prerelease: false
-  version_requirements: *70195100472000
+  version_requirements: *70157707836100
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70195100474040 !ruby/object:Gem::Requirement
+  requirement: &70157707835600 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -32,7 +32,7 @@ dependencies:
         version: 2.4.0
   type: :development
   prerelease: false
-  version_requirements: *70195100474040
+  version_requirements: *70157707835600
 description: ! "Create a new instance of YtDataApi::YtDataApiClient passing \n                     user
   credentials (username, password) and YouTube developer key\n                     to
   access YouTube Data API using ClientLogin authentication."