public void TestUploadLocalVideo()
{
var uploadParams = new VideoUploadParams()
{
File = new FileDescription(m_testVideoPath),
Tags = m_apiTag
};
var uploadResult = m_cloudinary.Upload(uploadParams);
Assert.AreEqual(640, uploadResult.Width);
Assert.AreEqual(320, uploadResult.Height);
Assert.AreEqual(FILE_FORMAT_MP4, uploadResult.Format);
Assert.NotNull(uploadResult.Audio);
Assert.AreEqual("aac", uploadResult.Audio.Codec);
Assert.NotNull(uploadResult.Video);
Assert.AreEqual("h264", uploadResult.Video.Codec);
var getResource = new GetResourceParams(uploadResult.PublicId)
{
ResourceType = ResourceType.Video
};
var info = m_cloudinary.GetResource(getResource);
Assert.AreEqual(FILE_FORMAT_MP4, info.Format);
}
public void TestExplicitVideo()
{
var uploadParams = new VideoUploadParams()
{
File = new FileDescription(m_testVideoPath),
Tags = m_apiTag
};
var uploadResult = m_cloudinary.Upload(uploadParams);
var exp = new ExplicitParams(uploadResult.PublicId)
{
Type = "upload",
ResourceType = ResourceType.Video,
Context = new StringDictionary("context1=254")
};
var expResult = m_cloudinary.Explicit(exp);
Assert.IsNotNull(expResult);
var getResult = m_cloudinary.GetResource(new GetResourceParams(expResult.PublicId)
{
ResourceType = ResourceType.Video
});
Assert.IsNotNull(getResult);
Assert.AreEqual("254", getResult.Context["custom"]["context1"].ToString());
}
public PhotoUploadResult AddVideo(IFormFile file)
{
var uploadResult = new VideoUploadResult();
if (file.Length > 0)
{
using (var stream = file.OpenReadStream())
{
var uploadParams = new VideoUploadParams
{
File = new FileDescription(file.FileName, stream)
};
uploadResult = _cloudinary.Upload(uploadParams);
}
}
if (uploadResult.Error != null)
{
throw new Exception(uploadResult.Error.Message);
}
return(new PhotoUploadResult
{
PublicId = uploadResult.PublicId,
Url = uploadResult.SecureUri.AbsoluteUri
});
}
public async Task <UploadResult> UploadVideoAsync(IFormFile file, string folder = "")
{
if (file.Length <= 0)
{
throw new Exception(ExceptionMessages.VideoUploadError);
}
await using var stream = file.OpenReadStream();
var uploadParams = new VideoUploadParams
{
File = new FileDescription(file.FileName, stream),
Folder = folder
};
var uploadResult = await _cloudinary.UploadAsync(uploadParams);
if (uploadResult.Error != null)
{
throw new Exception(uploadResult.Error.Message);
}
return(new UploadResult
{
Url = uploadResult.SecureUrl.AbsoluteUri,
PublicId = uploadResult.PublicId,
CreatedAt = uploadResult.CreatedAt
});
}
public async Task <FileUploadResult> AddVideo(IFormFile file)
{
var uploadResult = new VideoUploadResult();
if (file.Length > 0)
{
using (var stream = file.OpenReadStream())
{
var uploadParams = new VideoUploadParams
{
File = new FileDescription(file.FileName, stream),
Transformation = new Transformation().Quality("auto"),
};
uploadResult = await _cloudinary.UploadLargeAsync(uploadParams);
}
}
if (uploadResult.Error != null)
{
return new FileUploadResult
{
PublicId = "",
Url = "",
Message = uploadResult.Error.Message
}
}
;
return(new FileUploadResult
{
PublicId = uploadResult.PublicId,
Url = uploadResult.SecureUrl.AbsoluteUri,
Message = ""
});
}
public VideoUploadResult UploadVideo(IFormFile file)
{
try {
if (file.Length > 0)
{
var fileStream = file.OpenReadStream();
var uploadParams = new VideoUploadParams()
{
File = new FileDescription(file.FileName, fileStream),
Overwrite = true,
PublicId = "ElearningWebsiteVideos/" + file.FileName.Replace(" ", ""),
};
var uploadResult = _cloudinary.UploadLarge(uploadParams);
return(uploadResult);
}
else
{
throw new Exception("Video upload failed");
}
} catch (Exception e) {
throw e;
}
}
public VideoUploadResult PostVideoToServer([FromBody] VideoDataRequest req)
{
var cloudinary = GetCloudinaryAccountInfo();
var video = req.Url;
var vidPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, @"videos/" + video);
var tranform = new Transformation().Crop("pad").Width(200).Height(200).
Duration(10).Quality(120).Radius(20).Effect("reverse").Flags("splice").AudioCodec("none");
var eagerTransform = new List <Transformation>()
{
new Transformation().Width(250).Height(250).Crop("crop").Radius(20),
new Transformation().Width(100).Height(150).Crop("fit").Effect("brightness:20").AudioCodec("none")
};
var vidId = video.Substring(0, 10);
var uploadParams = new VideoUploadParams
{
File = new FileDescription(vidPath),
PublicId = vidId,
Transformation = tranform,
EagerTransforms = eagerTransform,
Tags = "Khophi_" + vidId,
Folder = "/videos",
Overwrite = true,
Colors = true,
};
var uploadResult = cloudinary.Upload(uploadParams);
HackContext context = HttpContext.RequestServices.GetService(typeof(HackContext)) as HackContext;
context.FillVideoInfo(uploadResult, req.Name);
return(uploadResult);
}
private ResourceUploadResult UploadResource(IResourceFile file, ResourceType resourceType)
{
if (file == null || file.Length == 0)
{
throw new UploadResourceException("null file");
}
RawUploadResult uploadResult;
var uploadParams = new RawUploadParams();
switch (resourceType)
{
case ResourceType.Image:
uploadParams = new ImageUploadParams();
break;
case ResourceType.Video:
uploadParams = new VideoUploadParams();
break;
}
using (var stream = file.OpenReadStream())
{
uploadParams.File = new FileDescription(file.FileName, stream);
uploadResult = _cloudinary.Upload(uploadParams);
}
if (uploadResult.Error != null)
{
throw new UploadResourceException(uploadResult.Error.Message);
}
return(new ResourceUploadResult(uploadResult.PublicId, uploadResult.SecureUrl.AbsoluteUri));
}
public static async Task <VideoUploadResult> UploadVideoAsync(Cloudinary cloudinary, IFormFile videoFile)
{
var result = "";
byte[] destinationImage;
using (var memoryStream = new MemoryStream())
{
await videoFile.CopyToAsync(memoryStream);
destinationImage = memoryStream.ToArray();
}
using (var destinationStream = new MemoryStream(destinationImage))
{
var uploadParams = new VideoUploadParams()
{
File = new FileDescription(videoFile.FileName, destinationStream),
};
var uploadResult = await cloudinary.UploadAsync(uploadParams);
return(uploadResult);
}
}
public string UploadVideo(IFormFile videoFile, string fileName)
{
byte[] destinationData;
using (var ms = new MemoryStream())
{
videoFile.CopyTo(ms);
destinationData = ms.ToArray();
}
UploadResult uploadResult = null;
using (var ms = new MemoryStream(destinationData))
{
VideoUploadParams uploadParams = new VideoUploadParams
{
Folder = GlobalConstants.tubeVideosFolder,
File = new FileDescription(fileName, ms)
};
uploadResult = this.cloudinaryUtility.Upload(uploadParams);
}
return(uploadResult?.SecureUri.AbsoluteUri);
}
public async Task <IActionResult> AddVideoForUser(int businessId,
[FromForm] VideoForCreationDto videoForCreationDto)
{
var businessFromRepo = await _repo.GetBusiness(businessId);
if (businessFromRepo.UserId != int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value))
{
return(Unauthorized());
}
var file = videoForCreationDto.File;
var uploadResult = new VideoUploadResult();
if (file.Length > 0)
{
using (var stream = file.OpenReadStream())
{
var uploadParams = new VideoUploadParams
{
File = new FileDescription(file.Name, stream)
};
uploadResult = _cloudinary.Upload(uploadParams);
}
}
if (businessFromRepo.Video != null && businessFromRepo.Video.PublicId != null)
{
var deleteParams = new DeletionParams(businessFromRepo.Video.PublicId)
{
ResourceType = ResourceType.Video
};
var result = _cloudinary.Destroy(deleteParams);
if (result.Result == "ok")
{
_repo.Delete(businessFromRepo.Video);
}
}
videoForCreationDto.Url = uploadResult.Uri.ToString();
videoForCreationDto.PublicId = uploadResult.PublicId;
var video = _mapper.Map <VideoModel>(videoForCreationDto);
businessFromRepo.Video = video;
if (await _repo.SaveAll())
{
var videoToReturn = _mapper.Map <VideoForReturnDto>(video);
return(CreatedAtRoute("GetVideo", new { id = video.Id }, videoToReturn));
}
return(BadRequest("Cloud not add the video"));
}
public async Task <ActionResult <MediaFile> > PostMediaFile([FromForm] UploadFile model)
{
IFormFile file = model.File;
Account account = new Account(
"dn2pht7no",
"763416155661231",
"Y8_D6HDCOUNJAUoPvi8wtVWhkmE");
Cloudinary cloudinary = new Cloudinary(account);
var fs = file.OpenReadStream();
var uploadParams = new VideoUploadParams()
{
File = new FileDescription(file.FileName, fs)
};
var uploadResult = cloudinary.Upload(uploadParams);
string full_filename = Path.GetFileName(file.FileName);
string[] file_parts = full_filename.Split(".");
string file_name = file_parts[0];
string file_extension = file_parts[1];
MediaFile mediaFile = new MediaFile();
mediaFile.MediaName = file_name;
mediaFile.MediaDate = DateTime.Now;
mediaFile.FileName = full_filename;
mediaFile.FileType = file_extension;
if (file_extension == "mp4")
{
mediaFile.MediaType = "video";
}
else if (file_extension == "mp3")
{
mediaFile.MediaType = "video";
}
else
{
mediaFile.MediaType = "other";
}
if (model.Desctiption != null)
{
mediaFile.MediaDescription = model.Desctiption;
}
else
{
mediaFile.MediaDescription = "...";
}
mediaFile.FileLink = uploadResult.Uri.ToString();
var u = await _context.User.SingleOrDefaultAsync(u => u.UserName == "admin");
mediaFile.Uploader = u;
_context.MediaFile.Add(mediaFile);
await _context.SaveChangesAsync();
System.Console.WriteLine(mediaFile.FileId);
return(CreatedAtAction("GetMediaFile", new { id = mediaFile.FileId }, mediaFile));
}
public async Task <IActionResult> AddVideo([FromForm] VideoForCreationDto videoForCreationDto)
{
if (!await _repo.IsExistTopic(videoForCreationDto.TopicId))
{
return(BadRequest("Topic doesn't Exist"));
}
var topic = await _repo.GetTopicsById(videoForCreationDto.TopicId);
var file = videoForCreationDto.File;
var uploadResult = new VideoUploadResult();
if (file.Length > 0)
{
using (var stream = file.OpenReadStream())
{
var uploadParams = new VideoUploadParams()
{
File = new FileDescription(file.FileName, stream),
/* Transformation = new Transformation()
* .Width(500).Height(500).Crop("fill").Gravity("face"), */
/* EagerTransforms = new List<Transformation>()
* {
* new EagerTransformation().Width(300).Height(300).Crop("pad").AudioCodec("none"),
* new EagerTransformation().Width(160).Height(100).Crop("crop").Gravity("south").AudioCodec("none")},
* EagerAsync = true */
};
uploadResult = _cloudinary.UploadLarge(uploadParams);
}
}
var videoToCreate = _mapper.Map <Videos>(videoForCreationDto);
videoToCreate.Url = uploadResult.Uri.ToString();
videoToCreate.PublicId = uploadResult.PublicId;
videoToCreate.ChapterName = topic.ChapterName;
videoToCreate.ClassName = topic.ClassName;
videoToCreate.CreatedDate = DateTime.Now;
videoToCreate.SubjectName = topic.SubjctName;
videoToCreate.TopicName = topic.Name;
videoToCreate.ClassId = topic.ClassId;
videoToCreate.SubjectForClassId = topic.SubjectIdInClass;
videoToCreate.ChapterId = topic.ChapterId;
_repo.Add <Videos>(videoToCreate);
if (await _repo.SaveAll())
{
return(Ok());
}
return(BadRequest("Failed to add Video"));
}
public async Task <VideoUploadResult> UploadAsync(VideoUploadParams parameters)
{
var url = Api.ApiUrlVideoUpV.BuildUrl();
ResetInternalFileDescription(parameters.File, int.MaxValue);
using (var response = await Api.CallAsync(HttpMethod.Post, url, parameters.ToParamsDictionary(), parameters.File, null))
{
return(await VideoUploadResult.Parse(response));
}
}
/// <summary>
/// Uploads a video file to cloudinary.
/// </summary>
/// <param name="parameters">Parameters of video uploading .</param>
/// <returns>Results of video uploading.</returns>
public VideoUploadResult Upload(VideoUploadParams parameters)
{
string uri = m_api.ApiUrlVideoUpV.BuildUrl();
ResetInternalFileDescription(parameters.File);
using (HttpWebResponse response = m_api.Call(HttpMethod.POST, uri, parameters.ToParamsDictionary(), parameters.File))
{
return(VideoUploadResult.Parse(response));
}
}
public string LocalPathToVideoUrl(string localPath)
{
var uploadParams = new VideoUploadParams()
{
File = new FileDescription(localPath)
};
var uploadResult = _cloudinary.Upload(uploadParams);
var videoUrl = uploadResult.SecureUri.OriginalString;
return(videoUrl);
}
public string VideoUpload(IFormFile file)
{
using (Stream stream = file.OpenReadStream())
{
VideoUploadParams uploadParams = new VideoUploadParams()
{
File = new FileDescription(file.Name, stream),
};
return(cloudinary.Upload(uploadParams).SecureUri.ToString());
}
}
/// <summary>
/// A convenient method for uploading a video before testing.
/// </summary>
/// <param name="setParamsAction">Action to set custom upload parameters.</param>
/// <returns>The upload result.</returns>
protected VideoUploadResult UploadTestVideoResource(
Action <VideoUploadParams> setParamsAction = null,
StorageType storageType = StorageType.upload)
{
var uploadParams = new VideoUploadParams();
setParamsAction?.Invoke(uploadParams);
uploadParams.File = uploadParams.File ?? new FileDescription(m_testVideoPath);
PopulateMissingRawUploadParams(uploadParams, false, storageType);
return(m_cloudinary.Upload(uploadParams));
}
public void FileUpload()
{
VideoUploadParams uploadParams = new VideoUploadParams
{
File = new FileDescription(@"D:\Git\Ggg.Github\Ggg.Csharp\apps\app-cloudinary\videos\dog.mp4"),
PublicId = "my_folder/my_sub_folder/my_dog",
Overwrite = true,
NotificationUrl = "http://mysite/my_notification_endpoint"
};
VideoUploadResult uploadResult = Cloudinary.Upload(uploadParams);
TestUtilities.LogAndWrite(uploadResult, "FileUpload.txt");
}
public static string UploadVideo(HttpPostedFileBase video)
{
var uploadParams = new VideoUploadParams()
{
File = new FileDescription(video.FileName, video.InputStream)
};
var uploadResult = cloudinary.Upload(uploadParams);
if ((int)uploadResult.StatusCode >= 200 && (int)uploadResult.StatusCode <= 299)
{
string path = uploadResult.Uri.ToString();
return(path);
}
return("Not Found");
}
public async Task <CloudinaryDotNet.Actions.VideoUploadResult> AddAudioAsync(IFormFile file)
{
var uploadResult = new VideoUploadResult();
if (file.Length > 0)
{
using var stream = file.OpenReadStream();
var upladParams = new VideoUploadParams
{
File = new FileDescription(file.FileName, stream),
};
uploadResult = await _cloudinary.UploadAsync(upladParams);
}
return(uploadResult);
}
public async Task <VideoUploadResult> UploadFormFileAsync(IFormFile file)
{
using (var memoryStream = file.OpenReadStream())
{
var uploadParams = new VideoUploadParams
{
File = new FileDescription(Guid.NewGuid().ToString(), memoryStream),
PublicId = $"{GlobalConstants.PublicAuIdPrefix}{Guid.NewGuid()}",
};
var uploadResult = await this.cloudinary.UploadAsync(uploadParams);
return(uploadResult);
}
}
public async Task <CloudinaryAsset> AddCloudAssetAsync(CloudinaryAsset cloudinaryAsset, int id, int lessonId)
{
var file = cloudinaryAsset.File;
var uploadResult = new VideoUploadResult();
try
{
if (file.Length > 0)
{
using (var stream = file.OpenReadStream())
{
var uploadParams = new VideoUploadParams()
{
File = new FileDescription(file.Name, stream)
};
uploadResult = _cloudinary.Upload(uploadParams);
}
}
}
catch (Exception e)
{
string errorMessage = $"Exception - MESSAGE: {e.Message} STACK TRACE: {e.StackTrace}";
// Exception logging code here
}
cloudinaryAsset.Url = uploadResult.Uri.ToString();
cloudinaryAsset.PublicId = uploadResult.PublicId;
cloudinaryAsset.AssetName = cloudinaryAsset.File.FileName;
cloudinaryAsset.Type = cloudinaryAsset.File.ContentType;
cloudinaryAsset.UserId = id;
cloudinaryAsset.LessonId = lessonId;
var assetForReturn = cloudinaryAsset;
CloudAsset asset = new CloudAsset()
{
AssetName = cloudinaryAsset.AssetName,
Type = cloudinaryAsset.Type,
Url = cloudinaryAsset.Url,
PublicId = cloudinaryAsset.PublicId,
UserId = cloudinaryAsset.UserId,
LessonId = cloudinaryAsset.LessonId
};
await _repository.AddCloudAssetAsync(asset);
return(assetForReturn);
}
public string Upload(IFormFile file)
{
Account account = new Account(
"dm7lepkwv",
"453935962484596",
"h68wAGIHesHWZKhQB5huALUPdW0");
Cloudinary cloudinary = new Cloudinary(account);
var uploadParams = new VideoUploadParams()
{
File = new FileDescription("test", file.OpenReadStream()),
};
var uploadResult = cloudinary.Upload(uploadParams, "raw");
return(uploadResult.Uri.ToString());
}
public async Task <IActionResult> AddVideo(int propertyId, [FromForm] VideoCreateDto videoCreateDto)
{
int userId = Convert.ToInt32(_userManager.GetUserId(User));
if (userId != _context.Properties.FindAsync(propertyId).Result.UserId)
{
return(Unauthorized());
}
var propertyFromRepo = await _repo.GetProperty(propertyId);
var file = videoCreateDto.VideoFile;
var uploadResult = new VideoUploadResult();
if (file.Length > 0)
{
using (var stream = file.OpenReadStream())
{
var uploadParams = new VideoUploadParams()
{
File = new FileDescription(file.Name, stream),
Transformation = new Transformation().Width(500)
.Height(500)
};
uploadResult = _cloudinary.Upload(uploadParams);
}
}
videoCreateDto.VideoUrl = uploadResult.Uri.ToString();
videoCreateDto.VideoPublicId = uploadResult.PublicId;
var video = _mapper.Map <Video>(videoCreateDto);
propertyFromRepo.Videos.Add(video);
if (await _repo.SaveAll())
{
var videoToReturn = _mapper.Map <VideoReturnDto>(video);
return(CreatedAtRoute("GetVideo", new { id = propertyId }, videoToReturn));
}
return(BadRequest("Failed to add video"));
}
public static VideoUploadResult UploadVideo()
{
Cloudinary cloudinary = GetCloudinary();
VideoUploadParams uploadParams = new VideoUploadParams()
{
File = new FileDescription(GetVideosFolder() + @"\dog.mp4"),
PublicId = "dog",
EagerTransforms = new List <Transformation>()
{
new Transformation().Width(300).Height(300).Crop("pad").AudioCodec("none"),
new Transformation().Width(160).Height(100).Crop("crop").Gravity("south").AudioCodec("none"),
},
EagerAsync = true,
EagerNotificationUrl = "https://requestbin.fullcontact.com/1964k7d1"
};
VideoUploadResult uploadResult = cloudinary.Upload(uploadParams);
return(uploadResult);
}
public void ServerSideUpload()
{
Cloudinary cloudinary = TestUtilities.GetCloudinary();
VideoUploadParams uploadParams = new VideoUploadParams()
{
File = new FileDescription(TestUtilities.GetVideosFolder() + @"\dog.mp4"),
PublicId = "my_folder/my_sub_folder/dog_closeup",
EagerTransforms = new List <Transformation>()
{
new Transformation().Width(300).Height(300).Crop("pad").AudioCodec("none"),
new Transformation().Width(160).Height(100).Crop("crop").Gravity("south").AudioCodec("none"),
},
EagerAsync = true,
EagerNotificationUrl = "https://requestbin.fullcontact.com/1964k7d1"
};
VideoUploadResult uploadResult = cloudinary.Upload(uploadParams);
TestUtilities.LogAndWrite(uploadResult, "ServerSideUpload.txt");
}
public async Task <IActionResult> Addvideo(int userId, int id, [FromForm] VideoForCreationDto videoForCreationDto)
{
if (userId != int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value))
{
return(Unauthorized());
}
videoForCreationDto.UserId = userId;
// var userFromRepo = await _repository.GetUser(userId, true);
var file = videoForCreationDto.File;
var uploadResult = new VideoUploadResult();
if (file != null && file.Length > 0)
{
using (var stream = file.OpenReadStream())
{
var uploadParams = new VideoUploadParams()
{
File = new FileDescription(file.Name, stream),
Transformation = new Transformation()
.Width(900).Height(800).Crop("crop")
};
uploadResult = _cloudinary.Upload(uploadParams);
}
}
videoForCreationDto.Url = uploadResult.Uri.ToString();
videoForCreationDto.publicId = uploadResult.PublicId;
videoForCreationDto.PlaylistId = id;
var Video = _mapper.Map <video>(videoForCreationDto);
_repository.Add(Video);
// userFromRepo.videos.Add(Video);
if (await _repository.SaveAll())
{
var VideosToReturn = _mapper.Map <VideoForReturnDto>(Video);
return(CreatedAtRoute("GetVideo", new { id = Video.Id }, VideosToReturn));
}
return(BadRequest("خطأ في إضافة الفيديو"));
}
/// <summary>
/// It is used to Upload Video into the Cloudinary
/// </summary>
/// <param name="video">Video Path</param>
/// <returns>If Video Uploaded Successfully return Video Link else Exception</returns>
private string UploadVideoToCloudinary(IFormFile video)
{
try
{
var myAccount = new Account(_configuration["Cloudinary:CloudName"], _configuration["Cloudinary:ApiKey"], _configuration["Cloudinary:ApiSecret"]);
Cloudinary _cloudinary = new Cloudinary(myAccount);
var videoUpload = new VideoUploadParams()
{
File = new FileDescription(video.FileName, video.OpenReadStream()),
};
var uploadResult = _cloudinary.Upload(videoUpload);
return(uploadResult.SecureUri.AbsoluteUri);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public async Task <IActionResult> AddVideoForUser(int userId, [FromForm] VideoForCreationDto videoForCreationDto)
{
if (userId != int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value))
{
return(Unauthorized());
}
var userFromRepo = await _repo.GetUser(userId);
var file = videoForCreationDto.File;
var uploadResults = new VideoUploadResult();
if (file.Length > 0)
{
using (var stream = file.OpenReadStream()){
var uploadParams = new VideoUploadParams()
{
File = new FileDescription(file.Name, stream),
Transformation = new Transformation().Width(500).Height(500).Crop("fill")
};
uploadResults = _cloudinary.Upload(uploadParams);
}
}
videoForCreationDto.VideoUrl = uploadResults.Uri.ToString();
videoForCreationDto.PublicId = uploadResults.PublicId;
var video = _mapper.Map <Models.Video>(videoForCreationDto);
userFromRepo.Videos.Add(video);
if (await _repo.SaveAll())
{
var videoToReturn = _mapper.Map <VideoForReturnDto>(video);
return(CreatedAtRoute("GetVideo", new VideoForReturnDto {
Id = video.Id
}, videoToReturn));
}
return(BadRequest("Could not add the video!"));
}
