Class: YouTubeIt::Client

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

Direct Known Subclasses

AuthSubClient, OAuth2Client, 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

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

Fetches a user's activity feed.



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

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

#add_comment(video_id, comment, opts = {}) ⇒ Object 



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

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

#add_favorite(video_id) ⇒ Object 



159
160
161
 
# File 'lib/youtube_it/client.rb', line 159

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

#add_playlist(options) ⇒ Object 



224
225
226
 
# File 'lib/youtube_it/client.rb', line 224

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

#add_response(original_video_id, response_video_id) ⇒ Object 



272
273
274
 
# File 'lib/youtube_it/client.rb', line 272

def add_response(original_video_id, response_video_id)
  client.add_response(original_video_id, response_video_id)
end

#add_video_to_playlist(playlist_id, video_id, position = nil) ⇒ Object 



232
233
234
 
# File 'lib/youtube_it/client.rb', line 232

def add_video_to_playlist(playlist_id, video_id, position = nil)
  client.add_video_to_playlist(playlist_id, video_id, position)
end

#add_video_to_watchlater(video_id) ⇒ Object 



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

def add_video_to_watchlater(video_id)
  client.add_video_to_watchlater(video_id)
end

#all_playlists(user = nil) ⇒ Object

Fetches all playlists for a given user by repeatedly making requests for as many pages of playlists as the user has. Note that this can take a long time if the user has many playlists.



211
212
213
214
215
216
217
218
219
220
221
222
 
# File 'lib/youtube_it/client.rb', line 211

def all_playlists(user = nil)
  newest_playlists, all_playlists_for_user = [], []
  start_index, page_size = 1, 25

  begin
    newest_playlists = playlists(user, {'start-index' => start_index, 'max-results' => page_size})
    all_playlists_for_user += newest_playlists
    start_index += page_size
  end while newest_playlists && newest_playlists.size == page_size

  all_playlists_for_user
end

#captions_update(video_id, data, opts = {}) ⇒ Object 



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

def captions_update(video_id, data, opts = {})
  client.captions_update(video_id, data, opts)
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



155
156
157
 
# File 'lib/youtube_it/client.rb', line 155

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

#current_user ⇒ Object 



280
281
282
 
# File 'lib/youtube_it/client.rb', line 280

def current_user
  client.get_current_user
end

#delete_comment(video_id, comment_id) ⇒ Object 



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

def delete_comment(video_id, comment_id)
  client.delete_comment(video_id, comment_id)
end

#delete_favorite(video_id) ⇒ Object 



163
164
165
 
# File 'lib/youtube_it/client.rb', line 163

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

#delete_playlist(playlist_id) ⇒ Object 



244
245
246
 
# File 'lib/youtube_it/client.rb', line 244

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

#delete_response(original_video_id, response_video_id) ⇒ Object 



276
277
278
 
# File 'lib/youtube_it/client.rb', line 276

def delete_response(original_video_id, response_video_id)
  client.delete_response(original_video_id, response_video_id)
end

#delete_video_from_playlist(playlist_id, playlist_entry_id) ⇒ Object 



240
241
242
 
# File 'lib/youtube_it/client.rb', line 240

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

#delete_video_from_watchlater(video_id) ⇒ Object 



196
197
198
 
# File 'lib/youtube_it/client.rb', line 196

def delete_video_from_watchlater(video_id)
  client.delete_video_from_watchlater(video_id)
end

#dislike_video(video_id) ⇒ Object 



252
253
254
 
# File 'lib/youtube_it/client.rb', line 252

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

#enable_http_debugging ⇒ Object 



268
269
270
 
# File 'lib/youtube_it/client.rb', line 268

def enable_http_debugging
  client.enable_http_debugging
end

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



167
168
169
 
# File 'lib/youtube_it/client.rb', line 167

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

#get_all_videos(opts) ⇒ Object 



105
106
107
108
109
110
111
112
113
114
 
# File 'lib/youtube_it/client.rb', line 105

def get_all_videos(opts)
  page = videos_by(opts.merge({:page => 1}))
  videos = page.videos

  while page.next_page && (page = videos_by(opts.merge({:page => page.next_page})) || true)
   videos += page.videos
  end

  videos
end

#like_video(video_id) ⇒ Object 



248
249
250
 
# File 'lib/youtube_it/client.rb', line 248

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

#message_delete(message_id) ⇒ Object 



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

def message_delete(message_id)
  client.delete_message(message_id)
end

#my_contacts(opts = {}) ⇒ Object

Gets all of the user's contacts/friends.



295
296
297
 
# File 'lib/youtube_it/client.rb', line 295

def my_contacts(opts = {})
  client.get_my_contacts(opts)
end

#my_messages(opts = {}) ⇒ Object

Gets all of the user's messages/inbox.



305
306
307
 
# File 'lib/youtube_it/client.rb', line 305

def my_messages(opts = {})
  client.get_my_messages(opts)
end

#my_video(video_id) ⇒ Object

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



285
286
287
 
# File 'lib/youtube_it/client.rb', line 285

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

#my_videos(opts = {}) ⇒ Object

Gets all videos



290
291
292
 
# File 'lib/youtube_it/client.rb', line 290

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

#new_subscription_videos(user_id = nil) ⇒ Object

Gets new subscription videos



315
316
317
 
# File 'lib/youtube_it/client.rb', line 315

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

#playlist(playlist_id, opts = {}) ⇒ Object 



200
201
202
 
# File 'lib/youtube_it/client.rb', line 200

def playlist(playlist_id, opts = {})
  client.playlist(playlist_id, opts)
end

#playlists(user = nil, opts = nil) ⇒ Object 



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

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

#profile(user = nil) ⇒ Object 



171
172
173
 
# File 'lib/youtube_it/client.rb', line 171

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

#profiles(*users) ⇒ Object 



175
176
177
 
# File 'lib/youtube_it/client.rb', line 175

def profiles(*users)
  client.profiles(*users)
end

#send_message(opts = {}) ⇒ Object

Send video message



300
301
302
 
# File 'lib/youtube_it/client.rb', line 300

def send_message(opts = {})
  client.send_message(opts)
end

#subscribe_channel(channel_name) ⇒ Object 



256
257
258
 
# File 'lib/youtube_it/client.rb', line 256

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

#subscriptions(user_id = nil) ⇒ Object 



264
265
266
 
# File 'lib/youtube_it/client.rb', line 264

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

#unsubscribe_channel(subscription_id) ⇒ Object 



260
261
262
 
# File 'lib/youtube_it/client.rb', line 260

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

#update_playlist(playlist_id, options) ⇒ Object 



228
229
230
 
# File 'lib/youtube_it/client.rb', line 228

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

#update_position_video_from_playlist(playlist_id, playlist_entry_id, position = nil) ⇒ Object 



236
237
238
 
# File 'lib/youtube_it/client.rb', line 236

def update_position_video_from_playlist(playlist_id, playlist_entry_id, position = nil)
  client.update_position_video_from_playlist(playlist_id, playlist_entry_id, position)
end

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



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

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

#video_by(video) ⇒ 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
91
92
93
94
95
96
97
 
# File 'lib/youtube_it/client.rb', line 86

def video_by(video)
  vid = nil
  vid_regex = /(?:youtube.com|youtu.be).*(?:\/|v=)([a-zA-Z0-9_-]+)/
  if video =~ vid_regex
    vid = $1
  else
    vid = video
  end
  video_id ="http://gdata.youtube.com/feeds/api/videos/#{vid}?v=#{YouTubeIt::API_VERSION}#{@dev_key ? '&key='+@dev_key : ''}"
  parser = YouTubeIt::Parser::VideoFeedParser.new(video_id)
  parser.parse
end

#video_by_user(user, vid) ⇒ Object 



99
100
101
102
103
 
# File 'lib/youtube_it/client.rb', line 99

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

#video_delete(video_id) ⇒ Object 



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

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

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



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

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

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



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

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

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



116
117
118
 
# File 'lib/youtube_it/client.rb', line 116

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

#videos(*idxes) ⇒ Object 



179
180
181
 
# File 'lib/youtube_it/client.rb', line 179

def videos(*idxes)
  client.videos(*idxes)
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, :safe_search, :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

#watch_history ⇒ Object

Gets the user's watch history



310
311
312
 
# File 'lib/youtube_it/client.rb', line 310

def watch_history
  client.get_watch_history
end

#watchlater(user = nil) ⇒ Object 



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

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