Class: YouTubeIt::Upload::VideoUpload

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

Overview

Implements video uploads/updates/deletions

require 'youtube_it'

uploader = YouTubeIt::Upload::VideoUpload.new("user", "pass", "dev-key")
uploader.upload File.open("test.m4v"), :title => 'test',
                                     :description => 'cool vid d00d',
                                     :category => 'People',
                                     :keywords => %w[cool blah test]

Instance Method Summary collapse

Methods included from Logging

#logger

Constructor Details

#initialize(*params) ⇒ VideoUpload

Returns a new instance of VideoUpload.



21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
 
# File 'lib/youtube_it/request/video_upload.rb', line 21

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 deprecated, 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

Instance Method Details

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



210
211
212
213
214
215
216
217
218
 
# File 'lib/youtube_it/request/video_upload.rb', line 210

def add_comment(video_id, comment, opts = {})
  reply_to = opts.delete :reply_to
  reply_to = reply_to.unique_id if reply_to.is_a? YouTubeIt::Model::Comment
  comment_body = comment_xml_for(:comment => comment, :reply_to => reply_to_url(video_id, reply_to))
  comment_url  = "/feeds/api/videos/%s/comments" % video_id
  response     = yt_session.post(comment_url, comment_body)
  comment = YouTubeIt::Parser::CommentsFeedParser.new(response.body).parse_single_entry
  return {:code => response.status, :body => response.body, :comment => comment}
end

#add_favorite(video_id) ⇒ Object 



235
236
237
238
239
240
241
 
# File 'lib/youtube_it/request/video_upload.rb', line 235

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, :favorite_entry_id => get_entry_id(response.body)}
end

#add_playlist(options) ⇒ Object 



345
346
347
348
349
350
351
 
# File 'lib/youtube_it/request/video_upload.rb', line 345

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

#add_response(original_video_id, response_video_id) ⇒ Object 



427
428
429
430
431
432
433
 
# File 'lib/youtube_it/request/video_upload.rb', line 427

def add_response(original_video_id, response_video_id)
  response_body   = video_xml_for(:response => response_video_id)
  response_url    = "/feeds/api/videos/%s/responses" % original_video_id
  response        = yt_session.post(response_url, response_body)

  return {:code => response.status, :body => response.body}
end

#add_video_to_playlist(playlist_id, video_id) ⇒ Object 



353
354
355
356
357
358
359
 
# File 'lib/youtube_it/request/video_upload.rb', line 353

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 => get_entry_id(response.body)}
end

#add_video_to_watchlater(video_id) ⇒ Object 



305
306
307
308
309
310
311
 
# File 'lib/youtube_it/request/video_upload.rb', line 305

def add_video_to_watchlater(video_id)
  playlist_body = video_xml_for(:playlist => video_id)
  playlist_url  = "/feeds/api/users/default/watch_later"
  response      = yt_session.post(playlist_url, playlist_body)

  return {:code => response.status, :body => response.body, :watchlater_entry_id => get_entry_id(response.body)}
end

#captions_update(video_id, data, options) ⇒ Object 



119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
 
# File 'lib/youtube_it/request/video_upload.rb', line 119

def captions_update(video_id, data, options)
  @opts = {
      :language => 'en-US',
      :slug => ''
  }.merge(options)

  upload_header = {
      "Slug" => "#{URI.escape(@opts[:slug])}",
      "Content-Language"=>@opts[:language],
      "Content-Type" => "application/vnd.youtube.timedtext; charset=UTF-8",
      "Content-Length" => "#{data.length}",
  }
  upload_url = "/feeds/api/videos/#{video_id}/captions"
  response = yt_session(base_url).post(upload_url, data, upload_header)
  return YouTubeIt::Parser::CaptionFeedParser.new(response.body).parse
end

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



228
229
230
231
232
233
 
# File 'lib/youtube_it/request/video_upload.rb', line 228

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

#delete(video_id) ⇒ Object

Delete a video on YouTube



185
186
187
188
189
190
 
# File 'lib/youtube_it/request/video_upload.rb', line 185

def delete(video_id)
  delete_url = "/feeds/api/users/default/uploads/%s" % video_id
  response   = yt_session.delete(delete_url)

  return true
end

#delete_comment(video_id, comment_id) ⇒ Object 



220
221
222
223
224
225
226
 
# File 'lib/youtube_it/request/video_upload.rb', line 220

def delete_comment(video_id, comment_id)
  comment_id = comment_id.unique_id if comment_id.is_a? YouTubeIt::Model::Comment
  url  = "/feeds/api/videos/%s/comments/%s" % [video_id, comment_id]
  response     = yt_session.delete(url)

  return response.status == 200
end

#delete_favorite(video_id) ⇒ Object 



243
244
245
246
247
248
 
# File 'lib/youtube_it/request/video_upload.rb', line 243

def delete_favorite(video_id)
  favorite_url = "/feeds/api/users/default/favorites/%s" % video_id
  response     = yt_session.delete(favorite_url)

  return true
end

#delete_message(message_id) ⇒ Object

Delete a video message



193
194
195
196
197
198
 
# File 'lib/youtube_it/request/video_upload.rb', line 193

def delete_message(message_id)
  delete_url = "/feeds/api/users/default/inbox/%s" % message_id
  response   = yt_session.delete(delete_url)

  return true
end

#delete_playlist(playlist_id) ⇒ Object 



376
377
378
379
380
381
 
# File 'lib/youtube_it/request/video_upload.rb', line 376

def delete_playlist(playlist_id)
  playlist_url = "/feeds/api/users/default/playlists/%s" % playlist_id
  response     = yt_session.delete(playlist_url)

  return true
end

#delete_response(original_video_id, response_video_id) ⇒ Object 



435
436
437
438
439
440
 
# File 'lib/youtube_it/request/video_upload.rb', line 435

def delete_response(original_video_id, response_video_id)
  response_url    = "/feeds/api/videos/%s/responses/%s" % [original_video_id, response_video_id]
  response        = yt_session.delete(response_url)

  return {:code => response.status, :body => response.body}
end

#delete_video_from_playlist(playlist_id, playlist_entry_id) ⇒ Object 



369
370
371
372
373
374
 
# File 'lib/youtube_it/request/video_upload.rb', line 369

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

#delete_video_from_watchlater(video_id) ⇒ Object 



313
314
315
316
317
318
 
# File 'lib/youtube_it/request/video_upload.rb', line 313

def delete_video_from_watchlater(video_id)
  playlist_url = "/feeds/api/users/default/watch_later/%s" % video_id
  response     = yt_session.delete(playlist_url)

  return true
end

#enable_http_debugging ⇒ Object 



44
45
46
 
# File 'lib/youtube_it/request/video_upload.rb', line 44

def enable_http_debugging
  @http_debugging = true
end

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



413
414
415
416
417
418
 
# File 'lib/youtube_it/request/video_upload.rb', line 413

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

#get_activity(user, opts) ⇒ Object

Return’s a user’s activity feed.



290
291
292
293
294
295
296
 
# File 'lib/youtube_it/request/video_upload.rb', line 290

def get_activity(user, opts)
  activity_url = "/feeds/api/events?author=%s&v=2&" % (user ? user : "default")
  activity_url << opts.collect { |k,p| [k,p].join '=' }.join('&')
  response = yt_session.get(activity_url)

  return YouTubeIt::Parser::ActivityParser.new(response).parse
end

#get_current_user ⇒ Object 



420
421
422
423
424
425
 
# File 'lib/youtube_it/request/video_upload.rb', line 420

def get_current_user
  current_user_url = "/feeds/api/users/default"
  response         = yt_session.get(current_user_url)

  return Nokogiri::XML(response.body).at("entry/author/name").text
end

#get_my_contacts(opts) ⇒ Object

Fetches the currently authenticated user’s contacts (i.e. friends). When the authentication credentials are incorrect, an AuthenticationError will be raised.



138
139
140
141
142
143
144
 
# File 'lib/youtube_it/request/video_upload.rb', line 138

def get_my_contacts(opts)
  contacts_url = "/feeds/api/users/default/contacts?v=2"
  contacts_url << opts.collect { |k,p| [k,p].join '=' }.join('&')
  response = yt_session.get(contacts_url)

  return YouTubeIt::Parser::ContactsParser.new(response).parse
end

#get_my_messages(opts) ⇒ Object

Fetches the currently authenticated user’s messages (i.e. inbox). When the authentication credentials are incorrect, an AuthenticationError will be raised.



156
157
158
159
160
161
162
 
# File 'lib/youtube_it/request/video_upload.rb', line 156

def get_my_messages(opts)
  messages_url = "/feeds/api/users/default/inbox"
  messages_url << opts.collect { |k,p| [k,p].join '=' }.join('&')
  response = yt_session.get(messages_url)

  return YouTubeIt::Parser::MessagesParser.new(response).parse
end

#get_my_video(video_id) ⇒ Object

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.



166
167
168
169
170
171
 
# File 'lib/youtube_it/request/video_upload.rb', line 166

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 rescue nil
end

#get_my_videos(opts) ⇒ Object

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.



175
176
177
178
179
180
181
182
 
# File 'lib/youtube_it/request/video_upload.rb', line 175

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

#get_upload_token(options, nexturl) ⇒ Object 



200
201
202
203
204
205
206
207
208
 
# File 'lib/youtube_it/request/video_upload.rb', line 200

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

#get_watch_history ⇒ Object 



442
443
444
445
446
447
 
# File 'lib/youtube_it/request/video_upload.rb', line 442

def get_watch_history
  watch_history_url = "/feeds/api/users/default/watch_history?v=2"
  response = yt_session.get(watch_history_url)

  return YouTubeIt::Parser::VideosFeedParser.new(response.body).parse
end

#new_subscription_videos(user) ⇒ Object 



449
450
451
452
453
454
 
# File 'lib/youtube_it/request/video_upload.rb', line 449

def new_subscription_videos(user)
  subscription_url = "/feeds/api/users/%s/newsubscriptionvideos?v=2" % (user ? user : "default")
  response         = yt_session.get(subscription_url)

  return YouTubeIt::Parser::VideosFeedParser.new(response.body).parse
end

#playlist(playlist_id, order_by = :position) ⇒ Object 



320
321
322
323
324
325
 
# File 'lib/youtube_it/request/video_upload.rb', line 320

def playlist(playlist_id, order_by = :position)
  playlist_url = "/feeds/api/playlists/%s?v=2&orderby=%s" % [playlist_id, order_by]
  response     = yt_session.get(playlist_url)

  return YouTubeIt::Parser::PlaylistFeedParser.new(response).parse
end

#playlists(user, opts = {}) ⇒ Object

Fetches playlists for the given user. An optional hash of parameters can be given and will be appended to the request. Paging parameters will need to be used to access playlists beyond the most recent 25 (page size default for YouTube API at the time of this writing) if a user has more than 25 playlists.

Paging parameters include the following start-index - 1-based index of which playlist to start from (default is 1) max-results - maximum number of playlists to fetch, up to 25 (default is 25)



335
336
337
338
339
340
341
342
343
 
# File 'lib/youtube_it/request/video_upload.rb', line 335

def playlists(user, opts={})
  playlist_url = "/feeds/api/users/%s/playlists" % (user ? user : "default")
  params = {'v' => 2}
  params.merge!(opts) if opts
  playlist_url << "?#{params.collect { |k,v| [k,v].join '=' }.join('&')}"
  response = yt_session.get(playlist_url)

  return YouTubeIt::Parser::PlaylistsFeedParser.new(response).parse
end

#profile(user = nil) ⇒ Object 



250
251
252
253
254
 
# File 'lib/youtube_it/request/video_upload.rb', line 250

def profile(user=nil)
  response    = yt_session.get(profile_url(user))

  return YouTubeIt::Parser::ProfileFeedParser.new(response).parse
end

#profile_url(user = nil) ⇒ Object 



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

def profile_url(user=nil)
  "/feeds/api/users/%s?v=2" % (user || "default")
end

#profiles(usernames_to_fetch) ⇒ Object 



256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
 
# File 'lib/youtube_it/request/video_upload.rb', line 256

def profiles(usernames_to_fetch)
  usernames_to_fetch.each_slice(50).map do |usernames|
    post = Nokogiri::XML <<-BATCH
        <feed 
          xmlns='http://www.w3.org/2005/Atom'
          xmlns:media='http://search.yahoo.com/mrss/'
          xmlns:batch='http://schemas.google.com/gdata/batch'
          xmlns:yt='http://gdata.youtube.com/schemas/2007'>
        </feed>
      BATCH
    usernames.each do |username|
      post.at('feed').add_child <<-ENTRY
        <entry>
          <batch:operation type="query" />
          <id>#{profile_url(username)}</id>
          <batch:id>#{username}</batch:id>
        </entry>
      ENTRY
    end

    post_body = StringIO.new('')
    post.write_to( post_body, :indent => 2 )
    post_body_io = StringIO.new(post_body.string)

    response = yt_session.post('feeds/api/users/batch', post_body_io )
    YouTubeIt::Parser::BatchProfileFeedParser.new(response).parse
  end.reduce({},:merge)
end

#rate_video(video_id, rating) ⇒ Object 



383
384
385
386
387
388
389
 
# File 'lib/youtube_it/request/video_upload.rb', line 383

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

#send_message(opts) ⇒ Object 



146
147
148
149
150
151
152
 
# File 'lib/youtube_it/request/video_upload.rb', line 146

def send_message(opts)
  message_body = message_xml_for(opts)
  message_url  = "/feeds/api/users/%s/inbox" % opts[:recipient_id]
  response     = yt_session.post(message_url, message_body)

  return {:code => response.status, :body => response.body}
end

#subscribe_channel(channel_name) ⇒ Object 



398
399
400
401
402
403
404
 
# File 'lib/youtube_it/request/video_upload.rb', line 398

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

#subscriptions(user) ⇒ Object 



391
392
393
394
395
396
 
# File 'lib/youtube_it/request/video_upload.rb', line 391

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

#unsubscribe_channel(subscription_id) ⇒ Object 



406
407
408
409
410
411
 
# File 'lib/youtube_it/request/video_upload.rb', line 406

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

#update(video_id, options) ⇒ Object

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.



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

def update(video_id, options)
  @opts = { :title => '',
            :description => '',
            :category => 'People',
            :keywords => [] }.merge(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 rescue nil
end

#update_playlist(playlist_id, options) ⇒ Object 



361
362
363
364
365
366
367
 
# File 'lib/youtube_it/request/video_upload.rb', line 361

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

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

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.



74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
 
# File 'lib/youtube_it/request/video_upload.rb', line 74

def upload(data, opts = {})
  @opts    = { :mime_type => 'video/mp4',
               :title => '',
               :description => '',
               :category => 'People',
               :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 rescue nil
end

#watchlater(user) ⇒ Object 



298
299
300
301
302
303
 
# File 'lib/youtube_it/request/video_upload.rb', line 298

def watchlater(user)
  watchlater_url = "/feeds/api/users/%s/watch_later?v=2" % (user ? user : "default")
  response = yt_session.get(watchlater_url)

  return YouTubeIt::Parser::PlaylistFeedParser.new(response).parse
end