Videos: insert

packagemain
import(
"flag"
"fmt"
"log"
"os"
"strings"
"google.golang.org/api/youtube/v3"
)
var(
filename=flag.String("filename","","Name of video file to upload")
title=flag.String("title","Test Title","Video title")
description=flag.String("description","Test Description","Video description")
category=flag.String("category","22","Video category")
keywords=flag.String("keywords","","Comma separated list of video keywords")
privacy=flag.String("privacy","unlisted","Video privacy status")
)
funcmain(){
flag.Parse()
if*filename==""{
log.Fatalf("You must provide a filename of a video file to upload")
}
client:=getClient(youtube.YoutubeUploadScope)
service,err:=youtube.New(client)
iferr!=nil{
log.Fatalf("Error creating YouTube client: %v",err)
}
upload:=&youtube.Video{
Snippet:&youtube.VideoSnippet{
Title:*title,
Description:*description,
CategoryId:*category,
},
Status:&youtube.VideoStatus{PrivacyStatus:*privacy},
}
// The API returns a 400 Bad Request response if tags is an empty string.
ifstrings.Trim(*keywords,"")!=""{
upload.Snippet.Tags=strings.Split(*keywords,",")
}
call:=service.Videos.Insert("snippet,status",upload)
file,err:=os.Open(*filename)
deferfile.Close()
iferr!=nil{
log.Fatalf("Error opening %v: %v",*filename,err)
}
response,err:=call.Media(file).Do()
handleError(err,"")
fmt.Printf("Upload successful! Video ID: %v\n",response.Id)
}
upload_video.go 

usingSystem;
usingSystem.IO;
usingSystem.Reflection;
usingSystem.Threading;
usingSystem.Threading.Tasks;
usingGoogle.Apis.Auth.OAuth2;
usingGoogle.Apis.Services;
usingGoogle.Apis.Upload;
usingGoogle.Apis.Util.Store;
usingGoogle.Apis.YouTube.v3;
usingGoogle.Apis.YouTube.v3.Data;
namespaceGoogle.Apis.YouTube.Samples
{
/// <summary>
/// YouTube Data API v3 sample: upload a video.
/// Relies on the Google APIs Client Library for .NET, v1.7.0 or higher.
/// See https://developers.google.com/api-client-library/dotnet/get_started
/// </summary>
internalclassUploadVideo
{
[STAThread]
staticvoidMain(string[]args)
{
Console.WriteLine("YouTube Data API: Upload Video");
Console.WriteLine("==============================");
try
{
newUploadVideo().Run().Wait();
}
catch(AggregateExceptionex)
{
foreach(vareinex.InnerExceptions)
{
Console.WriteLine("Error: "+e.Message);
}
}
Console.WriteLine("Press any key to continue...");
Console.ReadKey();
}
privateasyncTaskRun()
{
UserCredentialcredential;
using(varstream=newFileStream("client_secrets.json",FileMode.Open,FileAccess.Read))
{
credential=awaitGoogleWebAuthorizationBroker.AuthorizeAsync(
GoogleClientSecrets.Load(stream).Secrets,
// This OAuth 2.0 access scope allows an application to upload files to the
// authenticated user's YouTube channel, but doesn't allow other types of access.
new[]{YouTubeService.Scope.YoutubeUpload},
"user",
CancellationToken.None
);
}
varyoutubeService=newYouTubeService(newBaseClientService.Initializer()
{
HttpClientInitializer=credential,
ApplicationName=Assembly.GetExecutingAssembly().GetName().Name
});
varvideo=newVideo();
video.Snippet=newVideoSnippet();
video.Snippet.Title="Default Video Title";
video.Snippet.Description="Default Video Description";
video.Snippet.Tags=newstring[]{"tag1","tag2"};
video.Snippet.CategoryId="22";// See https://developers.google.com/youtube/v3/docs/videoCategories/list
video.Status=newVideoStatus();
video.Status.PrivacyStatus="unlisted";// or "private" or "public"
varfilePath=@"REPLACE_ME.mp4";// Replace with path to actual movie file.
using(varfileStream=newFileStream(filePath,FileMode.Open))
{
varvideosInsertRequest=youtubeService.Videos.Insert(video,"snippet,status",fileStream,"video/*");
videosInsertRequest.ProgressChanged+=videosInsertRequest_ProgressChanged;
videosInsertRequest.ResponseReceived+=videosInsertRequest_ResponseReceived;
awaitvideosInsertRequest.UploadAsync();
}
}
voidvideosInsertRequest_ProgressChanged(Google.Apis.Upload.IUploadProgressprogress)
{
switch(progress.Status)
{
caseUploadStatus.Uploading:
Console.WriteLine("{0} bytes sent.",progress.BytesSent);
break;
caseUploadStatus.Failed:
Console.WriteLine("An error prevented the upload from completing.\n{0}",progress.Exception);
break;
}
}
voidvideosInsertRequest_ResponseReceived(Videovideo)
{
Console.WriteLine("Video id '{0}' was successfully uploaded.",video.Id);
}
}
}
UploadVideo.cs 

#!/usr/bin/ruby
require'rubygems'
gem'google-api-client','>0.7'
require'google/api_client'
require'google/api_client/client_secrets'
require'google/api_client/auth/file_storage'
require'google/api_client/auth/installed_app'
require'trollop'
# A limited OAuth 2 access scope that allows for uploading files, but not other
# types of account access.
YOUTUBE_UPLOAD_SCOPE='https://www.googleapis.com/auth/youtube.upload'
YOUTUBE_API_SERVICE_NAME='youtube'
YOUTUBE_API_VERSION='v3'
defget_authenticated_service
client=Google::APIClient.new(
:application_name=>$PROGRAM_NAME,
:application_version=>'1.0.0'
)
youtube=client.discovered_api(YOUTUBE_API_SERVICE_NAME,YOUTUBE_API_VERSION)
file_storage=Google::APIClient::FileStorage.new("#{$PROGRAM_NAME}-oauth2.json")
iffile_storage.authorization.nil?
client_secrets=Google::APIClient::ClientSecrets.load
flow=Google::APIClient::InstalledAppFlow.new(
:client_id=>client_secrets.client_id,
:client_secret=>client_secrets.client_secret,
:scope=>[YOUTUBE_UPLOAD_SCOPE]
)
client.authorization=flow.authorize(file_storage)
else
client.authorization=file_storage.authorization
end
returnclient,youtube
end
defmain
opts=Trollop::optionsdo
opt:file,'Video file to upload',:type=>String
opt:title,'Video title',:default=>'Test Title',:type=>String
opt:description,'Video description',
:default=>'Test Description',:type=>String
opt:category_id,'Numeric video category. See https://developers.google.com/youtube/v3/docs/videoCategories/list',
:default=>22,:type=>:int
opt:keywords,'Video keywords, comma-separated',
:default=>'',:type=>String
opt:privacy_status,'Video privacy status: public, private, or unlisted',
:default=>'public',:type=>String
end
ifopts[:file].nil?ornotFile.file?(opts[:file])
Trollop::die:file,'does not exist'
end
client,youtube=get_authenticated_service
begin
body={
:snippet=>{
:title=>opts[:title],
:description=>opts[:description],
:tags=>opts[:keywords].split(','),
:categoryId=>opts[:category_id],
},
:status=>{
:privacyStatus=>opts[:privacy_status]
}
}
videos_insert_response=client.execute!(
:api_method=>youtube.videos.insert,
:body_object=>body,
:media=>Google::APIClient::UploadIO.new(opts[:file],'video/*'),
:parameters=>{
:uploadType=>'resumable',
:part=>body.keys.join(',')
}
)
videos_insert_response.resumable_upload.send_all(client)
puts"Video id '#{videos_insert_response.data.id}' was successfully uploaded."
rescueGoogle::APIClient::TransmissionError=>e
putse.result.body
end
end
main
upload_video.rb