public async Task <DomainVideo> AddAsync(string projectId, DomainVideo entity)
        {
            ProjectEntity project = await _projectRepository.GetAsync(projectId);

            if (project == null)
            {
                throw new NotFoundException(string.Format("Project {0} was not found", projectId));
            }

            // Check whether project already contains video
            if (project.ProjectType == (int)VideoType.Internal && !string.IsNullOrEmpty(project.OriginalVideoFileId) ||
                project.ProjectType == (int)VideoType.External && !string.IsNullOrEmpty(project.VideoSource))
            {
                throw new ConflictException();
            }

            StorageFile storageFile;

            // adding file to the file system
            using (FileStream stream = File.OpenRead(entity.FileUri))
            {
                storageFile = await _fileSystem.UploadFileFromStreamAsync(
                    new StorageFile(stream, entity.ContentType)
                {
                    UserId   = project.UserId,
                    FileName = entity.FileName,
                    Length   = entity.FileLength
                });
            }

            // updating project
            await _projectRepository.SetVideoAsync(project.Id, (int)VideoType.Internal, storageFile.Id);

            // building result
            DomainVideo result = _mapper.Map <StorageFile, DomainVideo>(storageFile);

            result.FileUri = _uriProvider.CreateUri(result.FileId);

            // adding task to the processing queue
            ProcessedMediaModel processedModel = await _processedEntityManager.GetProcessedMediaModel(entity.FileUri, projectId);

            await _processedVideoHandler.AddVideo(project.Id, project.UserId, result, processedModel);

            return(result);
        }
示例#2
0
        public async Task AddVideo(string projectId, string userId, DomainVideo entity, ProcessedMediaModel processedMediaModel)
        {
            List <DomainProcessedScreenshot> processedScreenshots = processedMediaModel.DomainProcessedScreenshots;
            List <DomainProcessedVideo>      processedVideos      = processedMediaModel.DomainProcessedVideos;

            // Fill entities data
            var entities = new List <IProcessedEntity>(processedScreenshots);

            entities.AddRange(processedVideos);

            foreach (IProcessedEntity processedEntity in entities)
            {
                processedEntity.UserId       = BackendId;
                processedEntity.SourceFileId = entity.FileId;
            }

            // Add video processing entities
            await Task.WhenAll(
                new Task[]
            {
                _processedScreenshotRepository.AddAsync(processedScreenshots.Select(p => _mapper.Map <DomainProcessedScreenshot, ProcessedScreenshotEntity>(p))),
                _processedVideoRepository.AddAsync(processedVideos.Select(p => _mapper.Map <DomainProcessedVideo, ProcessedVideoEntity>(p))),
                _videoQueueRepository.AddAsync(_mapper.Map <DomainVideoQueue, VideoQueueEntity>(
                                                   new DomainVideoQueue
                {
                    ProjectId = projectId,
                    FileId    = entity.FileId,
                    UserId    = userId
                }))
            });
        }