Class: YouTubeIt::Client

Inherits:
Object
  • Object
show all
Includes:
Logging
Defined in:
lib/youtube_it/client.rb

Direct Known Subclasses

AuthSubClient, OAuthClient

Instance Method Summary collapse

Methods included from Logging

#logger

Constructor Details

#initialize(*params) ⇒ Client

Previously this was a logger instance but we now do it globally



6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
# File 'lib/youtube_it/client.rb', line 6

def initialize *params
  if params.first.is_a?(Hash)
    hash_options = params.first
    @user                  = hash_options[:username]
    @pass                  = hash_options[:password]
    @dev_key               = hash_options[:dev_key]
    @client_id             = hash_options[:client_id] || "youtube_it"
    @legacy_debug_flag     = hash_options[:debug]
  elsif params.first
    puts "* warning: the method YouTubeIt::Client.new(user, passwd, dev_key) is deprecated, use YouTubeIt::Client.new(:username => 'user', :password => 'passwd', :dev_key => 'dev_key')"
    @user               = params.shift
    @pass               = params.shift
    @dev_key            = params.shift
    @client_id          = params.shift || "youtube_it"
    @legacy_debug_flag  = params.shift
  end
end

Instance Method Details

#add_comment(video_id, comment) ⇒ Object 



114
115
116
 
# File 'lib/youtube_it/client.rb', line 114

def add_comment(video_id, comment)
  client.add_comment(video_id, comment)
end

#add_favorite(video_id) ⇒ Object 



125
126
127
 
# File 'lib/youtube_it/client.rb', line 125

def add_favorite(video_id)
  client.add_favorite(video_id)
end

#add_playlist(options) ⇒ Object 



149
150
151
 
# File 'lib/youtube_it/client.rb', line 149

def add_playlist(options)
  client.add_playlist(options)
end

#add_video_to_playlist(playlist_id, video_id) ⇒ Object 



157
158
159
 
# File 'lib/youtube_it/client.rb', line 157

def add_video_to_playlist(playlist_id, video_id)
  client.add_video_to_playlist(playlist_id, video_id)
end

#comments(video_id, opts = {}) ⇒ Object

opts is converted to get params and appended to comments gdata api url eg opts = { 'max-results' => 10, 'start-index' => 20 } hash does not play nice with symbols



121
122
123
 
# File 'lib/youtube_it/client.rb', line 121

def comments(video_id, opts = {})
  client.comments(video_id, opts)
end

#current_user ⇒ Object 



193
194
195
 
# File 'lib/youtube_it/client.rb', line 193

def current_user
  client.get_current_user
end

#delete_favorite(video_id) ⇒ Object 



129
130
131
 
# File 'lib/youtube_it/client.rb', line 129

def delete_favorite(video_id)
  client.delete_favorite(video_id)
end

#delete_playlist(playlist_id) ⇒ Object 



165
166
167
 
# File 'lib/youtube_it/client.rb', line 165

def delete_playlist(playlist_id)
  client.delete_playlist(playlist_id)
end

#delete_video_from_playlist(playlist_id, playlist_entry_id) ⇒ Object 



161
162
163
 
# File 'lib/youtube_it/client.rb', line 161

def delete_video_from_playlist(playlist_id, playlist_entry_id)
  client.delete_video_from_playlist(playlist_id, playlist_entry_id)
end

#dislike_video(video_id) ⇒ Object 



173
174
175
 
# File 'lib/youtube_it/client.rb', line 173

def dislike_video(video_id)
  client.rate_video(video_id, 'dislike')
end

#enable_http_debugging ⇒ Object 



189
190
191
 
# File 'lib/youtube_it/client.rb', line 189

def enable_http_debugging
  client.enable_http_debugging
end

#favorites(user = nil, opts = {}) ⇒ Object 



133
134
135
 
# File 'lib/youtube_it/client.rb', line 133

def favorites(user = nil, opts = {})
  client.favorites(user, opts)
end

#like_video(video_id) ⇒ Object 



169
170
171
 
# File 'lib/youtube_it/client.rb', line 169

def like_video(video_id)
  client.rate_video(video_id, 'like')
end

#my_video(video_id) ⇒ Object

Gets the authenticated users video with the given ID. It may be private.



198
199
200
 
# File 'lib/youtube_it/client.rb', line 198

def my_video(video_id)
  client.get_my_video(video_id)
end

#my_videos(opts = {}) ⇒ Object

Gets all videos



203
204
205
 
# File 'lib/youtube_it/client.rb', line 203

def my_videos(opts = {})
  client.get_my_videos(opts)
end

#playlist(playlist_id) ⇒ Object 



141
142
143
 
# File 'lib/youtube_it/client.rb', line 141

def playlist(playlist_id)
  client.playlist playlist_id
end

#playlists(user = nil) ⇒ Object 



145
146
147
 
# File 'lib/youtube_it/client.rb', line 145

def playlists(user = nil)
  client.playlists(user)
end

#profile(user = nil) ⇒ Object 



137
138
139
 
# File 'lib/youtube_it/client.rb', line 137

def profile(user = nil)
  client.profile(user)
end

#subscribe_channel(channel_name) ⇒ Object 



177
178
179
 
# File 'lib/youtube_it/client.rb', line 177

def subscribe_channel(channel_name)
  client.subscribe_channel(channel_name)
end

#subscriptions(user_id = nil) ⇒ Object 



185
186
187
 
# File 'lib/youtube_it/client.rb', line 185

def subscriptions(user_id = nil)
  client.subscriptions(user_id)
end

#unsubscribe_channel(subscription_id) ⇒ Object 



181
182
183
 
# File 'lib/youtube_it/client.rb', line 181

def unsubscribe_channel(subscription_id)
  client.unsubscribe_channel(subscription_id)
end

#update_playlist(playlist_id, options) ⇒ Object 



153
154
155
 
# File 'lib/youtube_it/client.rb', line 153

def update_playlist(playlist_id, options)
  client.update_playlist(playlist_id, options)
end

#upload_token(options, nexturl = "http://www.youtube.com/my_videos") ⇒ Object 



110
111
112
 
# File 'lib/youtube_it/client.rb', line 110

def upload_token(options, nexturl = "http://www.youtube.com/my_videos")
  client.get_upload_token(options, nexturl)
end

#video_by(vid) ⇒ Object

Retrieves a single YouTube video.

Parameters

vid

The ID or URL of the video that you'd like to retrieve.

user

The user that uploaded the video that you'd like to retrieve.

Returns

YouTubeIt::Model::Video



86
87
88
89
90
 
# File 'lib/youtube_it/client.rb', line 86

def video_by(vid)
  video_id = vid =~ /^http/ ? vid : "http://gdata.youtube.com/feeds/api/videos/#{vid}?v=2#{@dev_key ? '&key='+@dev_key : ''}"
  parser = YouTubeIt::Parser::VideoFeedParser.new(video_id)
  parser.parse
end

#video_by_user(user, vid) ⇒ Object 



92
93
94
95
96
 
# File 'lib/youtube_it/client.rb', line 92

def video_by_user(user, vid)
  video_id = "http://gdata.youtube.com/feeds/api/users/#{user}/uploads/#{vid}?v=2#{@dev_key ? '&key='+@dev_key : ''}"
  parser = YouTubeIt::Parser::VideoFeedParser.new(video_id)
  parser.parse
end

#video_delete(video_id) ⇒ Object 



106
107
108
 
# File 'lib/youtube_it/client.rb', line 106

def video_delete(video_id)
  client.delete(video_id)
end

#video_update(video_id, opts = {}) ⇒ Object 



102
103
104
 
# File 'lib/youtube_it/client.rb', line 102

def video_update(video_id, opts = {})
  client.update(video_id, opts)
end

#video_upload(data, opts = {}) ⇒ Object 



98
99
100
 
# File 'lib/youtube_it/client.rb', line 98

def video_upload(data, opts = {})
  client.upload(data, opts)
end

#videos_by(params, options = {}) ⇒ Object

Retrieves an array of standard feed, custom query, or user videos.

Parameters

If fetching videos for a standard feed:

params<Symbol>:: Accepts a symbol of :top_rated, :top_favorites, :most_viewed,
               :most_popular, :most_recent, :most_discussed, :most_linked,
               :most_responded, :recently_featured, and :watch_on_mobile.

You can find out more specific information about what each standard feed provides
by visiting: http://code.google.com/apis/youtube/reference.html#Standard_feeds

options<Hash> (optional)::  Accepts the options of :time, :page (default is 1),
                          and :per_page (default is 25). :offset and :max_results
                          can also be passed for a custom offset.

If fetching videos by tags, categories, query:

params<Hash>:: Accepts the keys :tags, :categories, :query, :order_by,
             :author, :racy, :response_format, :video_format, :page (default is 1),
             and :per_page(default is 25)

options<Hash>:: Not used. (Optional)

If fetching videos for a particular user:

params<Hash>:: Key of :user with a value of the username.
options<Hash>:: Not used. (Optional)

Returns

YouTubeIt::Response::VideoSearch



51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
 
# File 'lib/youtube_it/client.rb', line 51

def videos_by(params, options={})
  request_params = params.respond_to?(:to_hash) ? params : options
  request_params[:page] = integer_or_default(request_params[:page], 1)

  request_params[:dev_key] = @dev_key if @dev_key

  unless request_params[:max_results]
    request_params[:max_results] = integer_or_default(request_params[:per_page], 25)
  end

  unless request_params[:offset]
    request_params[:offset] = calculate_offset(request_params[:page], request_params[:max_results] )
  end

  if params.respond_to?(:to_hash) and not params[:user]
    request = YouTubeIt::Request::VideoSearch.new(request_params)
  elsif (params.respond_to?(:to_hash) && params[:user]) || (params == :favorites)
    request = YouTubeIt::Request::UserSearch.new(params, request_params)
  else
    request = YouTubeIt::Request::StandardSearch.new(params, request_params)
  end

  logger.debug "Submitting request [url=#{request.url}]." if @legacy_debug_flag
  parser = YouTubeIt::Parser::VideosFeedParser.new(request.url)
  parser.parse
end