public async Task <ActionResult <VideoMediaModelOutput> > Update([FromRoute] int id, [FromBody] VideoMediaModelInput videoMediaInput)
{
VideoMedia videoMediaDB = await _videoMediaData.GetByID(id : id);
if (videoMediaDB == null)
{
return(new NotFoundObjectResult("This video does not exist."));
}
VideoMedia videoMediaDBDuplicated = await _videoMediaData.GetByHashedID(hashedId : videoMediaInput.HashedID);
if (videoMediaDBDuplicated != null && videoMediaDBDuplicated.ID != videoMediaDB.ID)
{
return(new ConflictObjectResult("A video with same hashedId already exists"));
}
VideoMedia videoMedia = _mapper.Map <VideoMedia>(videoMediaInput);
videoMedia.ID = videoMediaDB.ID;
VideoMedia videoMediaUpdated = await _videoMediaData.Update(videoMedia : videoMedia);
VideoMediaModelOutput videoMediaUpdatedOutput = _mapper.Map <VideoMediaModelOutput>(videoMediaUpdated);
return(new CreatedAtRouteResult("GetVideoMediaByID", new { id = videoMediaUpdatedOutput.ID }, videoMediaUpdatedOutput));
}
public IVideoMedia CreateVideo(IInfoMedia infoMedia = null)
{
IVideoMedia media = new VideoMedia();
if (infoMedia != null)
infoMedia.SetInfo(media);
return media;
}
public void startTransmit(VideoMedia sink, VideoMediaTransmitParam param)
{
pjsua2PINVOKE.VideoMedia_startTransmit(swigCPtr, VideoMedia.getCPtr(sink), VideoMediaTransmitParam.getCPtr(param));
if (pjsua2PINVOKE.SWIGPendingException.Pending)
{
throw pjsua2PINVOKE.SWIGPendingException.Retrieve();
}
}
public void stopTransmit(VideoMedia sink)
{
pjsua2PINVOKE.VideoMedia_stopTransmit(swigCPtr, VideoMedia.getCPtr(sink));
if (pjsua2PINVOKE.SWIGPendingException.Pending)
{
throw pjsua2PINVOKE.SWIGPendingException.Retrieve();
}
}
public void FillModel(VideoMedia media)
{
Title = media.Title;
Year = media.Year;
Bitrate = media.Bitrate;
Width = media.Width;
Height = media.Height;
}
public VideoMedia getVideoMedia()
{
VideoMedia ret = new VideoMedia(pjsua2PINVOKE.VideoWindow_getVideoMedia(swigCPtr), true);
if (pjsua2PINVOKE.SWIGPendingException.Pending)
{
throw pjsua2PINVOKE.SWIGPendingException.Retrieve();
}
return(ret);
}
public VideoMedia getDecodingVideoMedia(int med_idx)
{
VideoMedia ret = new VideoMedia(pjsua2PINVOKE.Call_getDecodingVideoMedia(swigCPtr, med_idx), true);
if (pjsua2PINVOKE.SWIGPendingException.Pending)
{
throw pjsua2PINVOKE.SWIGPendingException.Retrieve();
}
return(ret);
}
public async Task <ActionResult> Delete([FromRoute] int id)
{
VideoMedia videoMediaDB = await _videoMediaData.GetByID(id : id);
if (videoMediaDB == null)
{
return(new NotFoundObjectResult("This video does not exist."));
}
await _videoMediaData.Delete(id : id);
return(NoContent());
}
public async Task <ActionResult <VideoMediaModelOutput> > Insert([FromBody] VideoMediaModelInput videoMediaInput)
{
VideoMedia videoMediaDBDuplicated = await _videoMediaData.GetByHashedID(hashedId : videoMediaInput.HashedID);
if (videoMediaDBDuplicated != null)
{
return(new ConflictObjectResult("A video with same hashedId already exists"));
}
VideoMedia videoMedia = _mapper.Map <VideoMedia>(videoMediaInput);
VideoMedia videoMediaInserted = await _videoMediaData.Insert(videoMedia : videoMedia);
VideoMediaModelOutput videoMediaInsertedOutput = _mapper.Map <VideoMediaModelOutput>(videoMediaInserted);
return(new CreatedAtRouteResult("GetVideoMediaByID", new { id = videoMediaInsertedOutput.ID }, videoMediaInsertedOutput));
}
public async Task <ActionResult <VideoMediaModelOutput> > GetByID([FromRoute] int id)
{
VideoMedia videoMedia = await _videoMediaData.GetByID(id : id);
if (videoMedia == null)
{
return(new NotFoundObjectResult("This video does not exist."));
}
IEnumerable <VideoComment> videoComments = await _videoCommentData.GetAllByVideoMedia(videoMediaID : videoMedia.ID.Value);
VideoMediaModelOutput videoMediaOutput = _mapper.Map <VideoMediaModelOutput>(videoMedia);
videoMediaOutput.Comments = _mapper.Map <IEnumerable <VideoCommentModelOutput> >(videoComments);
return(Ok(videoMediaOutput));
}
public async Task <VideoMedia> Update(VideoMedia videoMedia)
{
#region Generate SqlParameters
List <SqlParameter> sqlParameters = new List <SqlParameter>();
sqlParameters.Add(_dbManager.CreateInputParameter("@ID", videoMedia.ID));
sqlParameters.Add(_dbManager.CreateInputParameter("@HashedID", videoMedia.HashedID));
sqlParameters.Add(_dbManager.CreateInputParameter("@Title", videoMedia.Title));
sqlParameters.Add(_dbManager.CreateInputParameter("@Color", videoMedia.Color));
sqlParameters.Add(_dbManager.CreateInputParameter("@ThumbnailUrl", videoMedia.ThumbnailUrl));
#endregion
await _dbManager.Update(storedProcedure : "usp_VideoMedias_UpdateByID", sqlParameters : sqlParameters);
return(videoMedia);
}
public async Task <ActionResult <VideoMediaModelOutput> > GetByID([FromRoute] int videoMediaId, [FromRoute] int id)
{
VideoMedia videoMediaDB = await _videoMediaData.GetByID(id : videoMediaId);
if (videoMediaDB == null)
{
return(new NotFoundObjectResult("This video does not exist."));
}
VideoComment videoComment = await _videoCommentData.GetByID(id : id);
if (videoComment == null || videoComment.VideoMedia?.ID != videoMediaDB.ID)
{
return(new NotFoundObjectResult("This comment does not exist."));
}
VideoCommentModelOutput videoCommentOutput = _mapper.Map <VideoCommentModelOutput>(videoComment);
return(Ok(videoCommentOutput));
}
public async Task <VideoMedia> Insert(VideoMedia videoMedia)
{
#region Generate SqlParameters
List <SqlParameter> sqlParameters = new List <SqlParameter>();
sqlParameters.Add(_dbManager.CreateInputParameter("@HashedID", videoMedia.HashedID));
sqlParameters.Add(_dbManager.CreateInputParameter("@Title", videoMedia.Title));
sqlParameters.Add(_dbManager.CreateInputParameter("@Color", videoMedia.Color));
sqlParameters.Add(_dbManager.CreateInputParameter("@ThumbnailUrl", videoMedia.ThumbnailUrl));
SqlParameter ouputParameterId = _dbManager.CreateOutputParameter("@ID", SqlDbType.Int);
sqlParameters.Add(ouputParameterId);
#endregion
await _dbManager.Insert(storedProcedure : "usp_VideoMedias_Insert", sqlParameters : sqlParameters);
videoMedia.ID = (int)ouputParameterId.Value;
return(videoMedia);
}
public User GetWithEmotions(User user, VideoMedia videoMedia)
{
var emotionAverage = EmotionAverage.GetAverage(videoMedia.Frames);
user.Emotion = new Emotion
{
Anger = emotionAverage.Anger,
Disgust = emotionAverage.Disgust,
Fear = emotionAverage.Fear,
Sadness = emotionAverage.Sadness,
Joy = emotionAverage.Joy,
Surprise = emotionAverage.Surprise
};
_emotionRater = new EmotionRater(emotionAverage);
user.BestEmotion = _emotionRater.GetBestEmotion();
user.Gender = CharacteristicsRetriever.GetGender(videoMedia.Frames);
user.AgeGroup = CharacteristicsRetriever.GetAgeGroup(videoMedia.Frames);
return(user);
}
private void addVideoCmd()
{
OpenFileDialog dialog = new OpenFileDialog();
bool? res;
dialog.Multiselect = true;
dialog.Filter = "Video files|*.wmv;*.avi;*.mpg;*.mov;*.asf;*.mkv";
res = dialog.ShowDialog();
if (res == true)
{
foreach (string file in dialog.FileNames)
{
VideoMedia tmp = Media.CreateMedia(false, file, false, ExtensionStatic.GetIconsFromExtension(Path.GetExtension(file))) as VideoMedia;
if (tmp != null)
{
ListVideos.Add(tmp);
}
}
}
saveVideos();
}
public async Task <ActionResult <VideoCommentModelOutput> > Insert([FromRoute] int videoMediaId, [FromBody] VideoCommentModelInput videoCommentInput)
{
VideoMedia videoMediaDB = await _videoMediaData.GetByID(id : videoMediaId);
if (videoMediaDB == null)
{
return(new NotFoundObjectResult("This video does not exist."));
}
VideoComment videoComment = _mapper.Map <VideoComment>(videoCommentInput);
videoComment.VideoMedia = videoMediaDB;
videoComment.UploadDate = DateTime.Now;
VideoComment videoCommentInserted = await _videoCommentData.Insert(videoComment : videoComment);
VideoCommentModelOutput videoCommentInsertedOutput = _mapper.Map <VideoCommentModelOutput>(videoCommentInserted);
return(new CreatedAtRouteResult(
"GetVideoCommentByID",
new { videoMediaId = videoCommentInsertedOutput.VideoMediaID, id = videoCommentInsertedOutput.ID },
videoCommentInsertedOutput
));
}
// Post different type of medias
public IHttpActionResult PostMediaObject(int id, string modifier)
{
ClaimsIdentity claimsIdentity = (ClaimsIdentity)User.Identity;
Claim userClaim = claimsIdentity.FindFirst(ClaimTypes.Name);
string myUsername = userClaim.Value;
var dbb = new MyDbContext();
User u = dbb.Users.FirstOrDefault(i => i.username == myUsername);
Memory m = dbb.Memories.Include("vacation").FirstOrDefault(i => i.id == id);
if (m.vacation.user.id == u.id)
{
if (modifier == "pictures")
{
var uploadedFile = HttpContext.Current.Request.Files["picture-file"];
if (uploadedFile != null && uploadedFile.ContentLength > 0)
{
byte[] data = new byte[uploadedFile.ContentLength];
uploadedFile.InputStream.Read(data, 0, uploadedFile.ContentLength);
Stream stream = new MemoryStream(data);
var filename = Convert.ToString(DateTime.Now.ToFileTime());
string file = uploadedFile.FileName;
string filetype = file.Substring(file.IndexOf('.') + 1);
var picture = new PictureMedia
{
fileurl = "http://mediamedia.s3.amazonaws.com/" + filename + "." + filetype,
container = uploadedFile.ContentType,
width = Convert.ToInt32(HttpContext.Current.Request.QueryString["width"]),
height = Convert.ToInt32(HttpContext.Current.Request.QueryString["height"])
};
string bucketName = "mediamedia";
string awsAccessKeyId = "AKIAJPF4ZQUNSJSIICFA";
string awsSecretAccessKey = "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";
using (var client = new AmazonS3Client(
awsAccessKeyId,
awsSecretAccessKey,
Amazon.RegionEndpoint.EUCentral1))
{
client.PutObject(new PutObjectRequest()
{
InputStream = stream,
BucketName = bucketName,
Key = filename + "." + filetype
});
}
//adds info of file in database
using (var db = new MyDbContext())
{
var currentMemory = db.Memories.Include("mediaList").FirstOrDefault(v => v.id == id);
currentMemory.mediaList.Add(picture);
db.SaveChanges();
return(Ok("The swag file has been uploaded"));
}
}
}
if (modifier == "sounds")
{
var uploadedFile = HttpContext.Current.Request.Files["sound-file"];
if (uploadedFile != null && uploadedFile.ContentLength > 0)
{
byte[] data = new byte[uploadedFile.ContentLength];
uploadedFile.InputStream.Read(data, 0, uploadedFile.ContentLength);
Stream stream = new MemoryStream(data);
var filename = Convert.ToString(DateTime.Now.ToFileTime());
string file = uploadedFile.FileName;
string filetype = file.Substring(file.IndexOf('.') + 1);
var sound = new SoundMedia
{
fileurl = "http://mediamedia.s3.amazonaws.com/" + filename + "." + filetype,
container = uploadedFile.ContentType,
duration = Convert.ToInt32(HttpContext.Current.Request.QueryString["duration"]),
codec = Convert.ToString(HttpContext.Current.Request.QueryString["codec"]),
bitrate = Convert.ToInt32(HttpContext.Current.Request.QueryString["bitrate"]),
channels = Convert.ToInt32(HttpContext.Current.Request.QueryString["channels"]),
samplingrate = Convert.ToInt32(HttpContext.Current.Request.QueryString["samplingrate"]),
};
string bucketName = "mediamedia";
string awsAccessKeyId = "AKIAJPF4ZQUNSJSIICFA";
string awsSecretAccessKey = "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";
using (var client = new AmazonS3Client(
awsAccessKeyId,
awsSecretAccessKey,
Amazon.RegionEndpoint.EUCentral1))
{
client.PutObject(new PutObjectRequest()
{
InputStream = stream,
BucketName = bucketName,
Key = filename + "." + filetype
});
}
//adds info of file in database
using (var db = new MyDbContext())
{
var currentMemory = db.Memories.Include("mediaList").FirstOrDefault(v => v.id == id);
currentMemory.mediaList.Add(sound);
db.SaveChanges();
return(Ok("The swag file has been uploaded"));
}
}
}
if (modifier == "videos")
{
var uploadedFile = HttpContext.Current.Request.Files["video-file"];
if (uploadedFile != null && uploadedFile.ContentLength > 0)
{
byte[] data = new byte[uploadedFile.ContentLength];
uploadedFile.InputStream.Read(data, 0, uploadedFile.ContentLength);
Stream stream = new MemoryStream(data);
var filename = Convert.ToString(DateTime.Now.ToFileTime());
string file = uploadedFile.FileName;
string filetype = file.Substring(file.IndexOf('.') + 1);
var video = new VideoMedia
{
fileurl = "http://mediamedia.s3.amazonaws.com/" + filename + "." + filetype,
container = uploadedFile.ContentType,
width = Convert.ToInt32(HttpContext.Current.Request.QueryString["width"]),
height = Convert.ToInt32(HttpContext.Current.Request.QueryString["height"]),
videocodec = Convert.ToString(HttpContext.Current.Request.QueryString["ideocodec"]),
videobitrate = Convert.ToInt32(HttpContext.Current.Request.QueryString["videobitrate"]),
framerate = Convert.ToInt32(HttpContext.Current.Request.QueryString["framerate"]),
audiocodec = Convert.ToString(HttpContext.Current.Request.QueryString["audiocodec"]),
audiobitrate = Convert.ToInt32(HttpContext.Current.Request.QueryString["audiobitrate"]),
samplingrate = Convert.ToInt32(HttpContext.Current.Request.QueryString["samplingrate"])
};
string bucketName = "mediamedia";
string awsAccessKeyId = "AKIAJPF4ZQUNSJSIICFA";
string awsSecretAccessKey = "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";
using (var client = new AmazonS3Client(
awsAccessKeyId,
awsSecretAccessKey,
Amazon.RegionEndpoint.EUCentral1))
{
client.PutObject(new PutObjectRequest()
{
InputStream = stream,
BucketName = bucketName,
Key = filename + "." + filetype
});
}
//adds info of file in database
using (var db = new MyDbContext())
{
var currentMemory = db.Memories.Include("mediaList").FirstOrDefault(v => v.id == id);
currentMemory.mediaList.Add(video);
db.SaveChanges();
return(Ok("The swag file has been uploaded"));
}
}
}
}
return(InternalServerError(new Exception("could not upload")));
}
internal static global::System.Runtime.InteropServices.HandleRef getCPtr(VideoMedia obj)
{
return((obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr);
}
