public async Task <Video> Add(Video entity)
{
await ReferencialIntegrityCheckUser(entity);
await ReferencialIntegrityCheckMap(entity);
return(await _videoRepository.Add(entity));
}
public async Task <ActionResult <VideoModel> > Post(VideoModel model)
{
try
{
var evideo = await repository.GetByVideoName(model.VideoName);
if (evideo != null)
{
return(BadRequest("This video already exists"));
}
var newvideo = mapper.Map <Video>(model);
repository.Add(newvideo);
if (await repository.SaveChangesAsync())
{
var url = linkGenerator.GetPathByAction(HttpContext,
"Get",
values: new { VideoId = newvideo.VideoId });
return(Created(url, mapper.Map <VideoModel>(newvideo)));
}
}
catch (Exception)
{
return(this.StatusCode(StatusCodes.Status500InternalServerError, "Database Failure"));
}
return(BadRequest());
}
public ActionResult Add(Video obj)
{
try
{
var video = _videoRepository.GetAll().FirstOrDefault(x => x.Name == obj.Name.Trim());
if (video != null)
{
return(Json(new
{
IsSuccess = false,
Messenger = "Tên video đã tồn tại",
}, JsonRequestBehavior.AllowGet));
}
obj.CreatedBy = User.ID;
_videoRepository.Add(obj);
return(Json(new
{
IsSuccess = true,
Messenger = "Thêm mới video thành công",
}, JsonRequestBehavior.AllowGet));
}
catch (Exception)
{
return(Json(new
{
IsSuccess = false,
Messenger = string.Format("Thêm mới video thất bại")
}, JsonRequestBehavior.AllowGet));
}
}
public async Task <VideoResponse> AddVideoAsync(AddVideoRequest request)
{
Video video = await _mapper.From(request).AdaptToTypeAsync <Video>();
Video result = _videoRepository.Add(video);
int affected = await _videoRepository.UnitOfWork.SaveChangesAsync();
return(_mapper.Map <VideoResponse>(result));
}
public async Task <bool> Insert(Video video)
{
try
{
var status = await _repository.Add(video);
return(status);
}
catch (OzoneException ex)
{
throw new OzoneException(ex.Message, ex.InnerException);
}
}
//TODO: Refactor !
public async Task UploadVideo(VideoUploadDto videoDto, string path)
{
string fullPath = path + '\\' + videoDto.VideoName + ".mp4";
Video newVideo = CreateNewVideo(videoDto, fullPath);
await _videoRepository.Add(newVideo);
var result = _videoRepository.Save();
using (var stream = new FileStream(fullPath, FileMode.Create))
{
await videoDto.VideoFile.CopyToAsync(stream);
}
}
public async Task RunAsync()
{
List <Video> result;
if (_repository.GetAllVideos().Count > 0)
{
result = await ContinueAsync().ConfigureAwait(false);
result.ForEach(v => _repository.Add(v));
}
else
{
var tasks = ParseAll();
Debug.WriteLine("All threads started...");
await Task.WhenAll(tasks.ToArray()).ConfigureAwait(false);
foreach (var task in tasks)
{
task.Result.ForEach(v => _repository.Add(v));
}
}
_repository.SaveChanges();
}
public async Task <IActionResult> CreateVideo([FromBody] SaveVideoResource saveVideoResource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var video = _mapper.Map <SaveVideoResource, Video>(saveVideoResource);
_repository.Add(video);
await _unitOfWork.CompleteAsync();
await _unitOfWork.ChangeVideo(video.Id);
var result = _mapper.Map <Video, VideoResource>(video);
return(Ok(result));
}
public async Task <IActionResult> AddFile(CancellationToken token)
{
try
{
// Read from data
var formData = await Request.ReadFormAsync(token);
// Save video metadata
StringValues values;
formData.TryGetValue("metadata", out values);
var video = JsonConvert.DeserializeObject <Video>(values[0]);
// Save splash screen
video.ScreenPath = string.Empty;
// Save video to file system
var path = "./microtube/videos/"; //TODO: Move to config.json
Directory.CreateDirectory(path);
foreach (var file in formData.Files)
{
if (file.Length > 0)
{
var uniqueName = $"{Guid.NewGuid()}{Path.GetExtension(file.FileName)}";
video.Path = Path.Combine(path, uniqueName);
using (var fileStream = new FileStream(video.Path, FileMode.Create))
{
await file.CopyToAsync(fileStream, token);
}
break;
}
}
// Save video in DB
_repository.Add(token, video);
_repository.Save(token);
return(Ok(video));
}
catch (Exception ex)
{
return(BadRequest(ex));
}
}
public ICommandResult Execute(CreateOrUpdateVideoCommand command)
{
Video _Video = AutoMapper.Mapper.Map <CreateOrUpdateVideoCommand, Video>(command);
if (command.Id == 0)
{
VideoRepository.Add(_Video);
}
else
{
VideoRepository.Update(_Video);
}
unitOfWork.Commit();
AutoMapper.Mapper.Map <Video, CreateOrUpdateVideoCommand>(_Video, command);
return(new CommandResult(true));
}
//consider changing the out parameter to a validation type object
public void Save(IVideo video, out bool success)
{
Checks.Argument.IsNotNull(video, "video");
success = false;
if (null == _repo.FindByVideoId(video.VideoId))
{
try
{
_repo.Add(video);
success = true;
}
catch (Exception ex)
{
success = false;
}
}
}
private IVideo SaveVideoData(SyndicationItem item, string mediaType, string eventName, string year)
{
IVideo video = null;
try
{
string sessionCode = string.Empty;
string hostedPageLink = string.Empty;
if (item.Links != null && item.Links.Count > 0)
{
var link = item.Links.Where(l => l.RelationshipType != null && l.RelationshipType == "alternate").FirstOrDefault();
if (link != null && link.Uri != null)
{
hostedPageLink = link.Uri.AbsoluteUri;
sessionCode = link.Uri.Segments[link.Uri.Segments.Count() - 1].ToString();
}
}
var parsedDuration = int.TryParse(GetExtensionElementValue(item, "duration"), out int durationSeconds);
var summary = HttpUtility.HtmlDecode(GetExtensionElementValue(item, "summary"));
video = new Video()
{
Title = CleanVideoTitle(item.Title.Text),
SummaryHtml = item.Summary.Text,
Summary = summary,
PublishDate = item.PublishDate.LocalDateTime,
HostedPageLink = hostedPageLink,
SessionCode = sessionCode,
DurationSeconds = durationSeconds,
IsVideoViewingComplete = false,
EventYear = year,
EventName = eventName
};
video = _videoRepository.Add(video);
}
catch (Exception ex)
{
Debug.WriteLine(ex.ToString());
}
return(video);
}
/// <summary>
/// Create a new video.
/// </summary>
/// <param name="video"></param>
/// <returns></returns>
public void Add(VideoMaterialInfo video)
{
var videoDb = _mapper.Map <VideoMaterialInfo, VideoMaterialDb>(video);
_videoRepository.Add(videoDb);
}
public async Task <VideoDTO> Add(VideoDTO video)
{
var result = await _repository.Add(_mapper.Map <Video>(video)).ConfigureAwait(false);
return(_mapper.Map <VideoDTO>(result));
}
public void AddVideo(Video video)
{
_videoRepository.Add(video);
}
public Video Add(Video model)
{
return(_videoRepository.Add(model));
}
public void AddVideo(VideoDto videoDto)
{
videoDto.CreateTime = DateTime.Now;
_videoRepository.Add(QsMapper.CreateMap <VideoDto, Video>(videoDto));
_videoRepository.UnitOfWork.Commit();
}
