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

Instance Method Details

#add_comment(video_id, comment) ⇒ Object 



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

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

#add_favorite(video_id) ⇒ Object 



207
208
209
210
211
212
213
 
# File 'lib/youtube_it/request/video_upload.rb', line 207

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

#add_playlist(options) ⇒ Object 



255
256
257
258
259
260
261
 
# File 'lib/youtube_it/request/video_upload.rb', line 255

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 



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

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 



263
264
265
266
267
268
269
 
# File 'lib/youtube_it/request/video_upload.rb', line 263

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

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



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

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



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

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

  return true
end

#delete_favorite(video_id) ⇒ Object 



215
216
217
218
219
220
221
222
223
 
# File 'lib/youtube_it/request/video_upload.rb', line 215

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

#delete_message(message_id) ⇒ Object

Delete a video message



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

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 



286
287
288
289
290
291
 
# File 'lib/youtube_it/request/video_upload.rb', line 286

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 



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

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 



279
280
281
282
283
284
 
# File 'lib/youtube_it/request/video_upload.rb', line 279

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

#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 



323
324
325
326
327
328
 
# File 'lib/youtube_it/request/video_upload.rb', line 323

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.



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

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 



330
331
332
333
334
335
 
# File 'lib/youtube_it/request/video_upload.rb', line 330

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

  return REXML::Document.new(response.body).elements["entry"].elements['author'].elements['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.



120
121
122
123
124
125
126
 
# File 'lib/youtube_it/request/video_upload.rb', line 120

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.



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

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.



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

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

#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.



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

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 



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

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 



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

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 



359
360
361
362
363
364
 
# File 'lib/youtube_it/request/video_upload.rb', line 359

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) ⇒ Object 



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

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

#playlists(user) ⇒ Object 



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

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

#profile(user) ⇒ Object 



225
226
227
228
229
230
 
# File 'lib/youtube_it/request/video_upload.rb', line 225

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

#rate_video(video_id, rating) ⇒ Object 



293
294
295
296
297
298
299
 
# File 'lib/youtube_it/request/video_upload.rb', line 293

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 



128
129
130
131
132
133
134
 
# File 'lib/youtube_it/request/video_upload.rb', line 128

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 



308
309
310
311
312
313
314
 
# File 'lib/youtube_it/request/video_upload.rb', line 308

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 



301
302
303
304
305
306
 
# File 'lib/youtube_it/request/video_upload.rb', line 301

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 



316
317
318
319
320
321
 
# File 'lib/youtube_it/request/video_upload.rb', line 316

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
end

#update_playlist(playlist_id, options) ⇒ Object 



271
272
273
274
275
276
277
 
# File 'lib/youtube_it/request/video_upload.rb', line 271

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
end