コード例 #1
0
ファイル: ProjectService.cs プロジェクト: GusLab/video-portal
        public async Task<List<DomainProject>> GetListAsync(DomainProject entity)
        {
            List<ProjectEntity> projects = await _projectRepository.GetUserProjectsAsync(entity.UserId);
            if (!projects.Any())
            {
                return new List<DomainProject>();
            }

            return projects.Select(p => _mapper.Map<ProjectEntity, DomainProject>(p)).ToList();
        }
コード例 #2
0
ファイル: ProjectService.cs プロジェクト: GusLab/video-portal
        public async Task<DomainProject> AddAsync(DomainProject entity)
        {
            entity.Created = DateTime.UtcNow;
            entity.Modified = DateTime.UtcNow;
            entity.HitsCount = 0;

            ProjectEntity projectEntity = _mapper.Map<DomainProject, ProjectEntity>(entity);
            ProjectEntity project = await _projectRepository.AddAsync(projectEntity);

            return _mapper.Map<ProjectEntity, DomainProject>(project);
        }
コード例 #3
0
ファイル: ProjectService.cs プロジェクト: GusLab/video-portal
        public async Task<DomainProject> GetAsync(DomainProject entity)
        {
            ProjectEntity project = await _projectRepository.GetAsync(entity.Id);
            if (project == null)
            {
                throw new NotFoundException(string.Format("Project with id '{0}' was not found.", entity.Id));
            }

            if (project.UserId != entity.UserId)
            {
                throw new ForbiddenException();
            }

            return _mapper.Map<ProjectEntity, DomainProject>(project);
        }
コード例 #4
0
        private async Task<ExampleProject> GetProjectAsync(DomainProject project)
        {
            if (project == null)
            {
                throw new ArgumentNullException("project");
            }

            // Avsx
            Task<StorageFile> avsxTask = Task.FromResult<StorageFile>(null);
            if (!string.IsNullOrEmpty(project.AvsxFileId))
            {
                avsxTask = _fileSystem.GetFilePropertiesSlimAsync(new StorageFile { Id = project.AvsxFileId });
            }

            // Screenshot
            Task<StorageFile> screenshotTask = Task.FromResult<StorageFile>(null);
            if (!string.IsNullOrEmpty(project.ScreenshotFileId))
            {
                screenshotTask = _fileSystem.GetFilePropertiesSlimAsync(new StorageFile { Id = project.ScreenshotFileId });
            }

            // Original video
            Task<StorageFile> videoTask = Task.FromResult<StorageFile>(null);
            if (!string.IsNullOrEmpty(project.OriginalVideoFileId))
            {
                videoTask = _fileSystem.GetFilePropertiesSlimAsync(new StorageFile { Id = project.OriginalVideoFileId });
            }

            await Task.WhenAll(new[]
            {
                avsxTask,
                screenshotTask,
                videoTask
            });


            var result = new ExampleProject
            {
                Id = project.Id,
                Name = project.Name,
                Description = project.Description,
                Created = project.Created,
                Views = project.HitsCount,
                Likes = project.LikesCount,
                Dislikes = project.DislikesCount,
                ProjectType = (int)project.ProjectType,
                ProjectSubtype = (int)project.ProjectSubtype
            };


            if (avsxTask.Result != null)
            {
                result.AvsxUri = _uriProvider.CreateUri(avsxTask.Result.Id);
                result.TotalSize += avsxTask.Result.Length;
            }

            if (screenshotTask.Result != null)
            {
                result.ScreenshotUri = _uriProvider.CreateUri(screenshotTask.Result.Id);
                result.TotalSize += screenshotTask.Result.Length;
            }

            if (videoTask.Result != null)
            {
                result.VideoUri = _uriProvider.CreateUri(videoTask.Result.Id);
                result.VideoHash = videoTask.Result.Id;
                result.TotalSize += videoTask.Result.Length;
            }

            return result;
        }
コード例 #5
0
        public Task SendVideoCommentNotificationAsync(DomainUser user, DomainProject project, DomainComment domainComment)
        {
            var email = new SendEmailDomain
            {
                Address = _settings.EmailAddressInfo,
                DisplayName = Emails.SenderDisplayName,
                Emails = new List<string> { user.Email },
                Subject = Emails.SubjectVideoComment,
                UserId = user.Id,
                Body = string.Format(PortalResources.VideoCommentNotification,
                    user.Name,
                    _userUriProvider.GetUri(domainComment.UserId),
                    domainComment.UserName,
                    _projectUriProvider.GetUri(project.Id),
                    project.Name,
                    domainComment.Body,
                    _settings.PortalUri)
            };

            // Send email on user registration
            return _emailSenderService.SendEmailAsync(email);
        }
コード例 #6
0
        public async Task<HttpResponseMessage> Post(ProjectModel model)
        {
            try
            {
                await CongratUserIfNeeded();
            }
            catch (Exception e)
            {
                Trace.TraceError("Failed to notify user by email: {0}", e);
            }

            ProductType product = _productIdExtractor.Get(UserAgent);

            var project = new DomainProject
            {
                UserId = UserId,
                Name = model.Name,
                Description = model.Description,
                Access = model.Access,
                ProductType = product,
                ProjectType = model.ProjectType,
                ProjectSubtype = model.ProjectSubtype,
                EnableComments = model.EnableComments
            };

            project = await _projectService.AddAsync(project);

            var responseProject = new Project
            {
                Id = project.Id,
                Description = project.Description,
                Access = project.Access,
                Name = project.Name,
                Created = project.Created,
                PublicUrl = _projectUriProvider.GetUri(project.Id),
                ProjectType = project.ProjectType,
                ProjectSubtype = project.ProjectSubtype,
                EnableComments = project.EnableComments
            };

            HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.Created, responseProject);
            response.SetLastModifiedDate(project.Modified);

            return response;
        }
コード例 #7
0
        public async Task<HttpResponseMessage> Delete(string id)
        {
            var projectQuery = new DomainProject
            {
                UserId = UserId,
                Id = id
            };

            await _projectService.DeleteAsync(projectQuery);

            return Request.CreateResponse(HttpStatusCode.OK);
        }
コード例 #8
0
        public async Task<HttpResponseMessage> Put(string id, ProjectModel model)
        {
            var project = new DomainProject { Id = id, UserId = UserId };
            DomainProject originalProject = await _projectService.GetAsync(project);

            // updating original project
            originalProject.Name = model.Name;
            originalProject.Description = model.Description;
            originalProject.Access = model.Access;
            originalProject.EnableComments = model.EnableComments;
            project = await _projectService.EditAsync(originalProject);

            var responseProjects = new Project
            {
                Created = project.Created,
                Description = project.Description,
                Id = project.Id,
                Access = project.Access,
                Name = project.Name,
                PublicUrl = _projectUriProvider.GetUri(project.Id),
                ProjectType = project.ProjectType,
                ProjectSubtype = project.ProjectSubtype,
                EnableComments = project.EnableComments
            };

            HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.OK, responseProjects);
            response.SetLastModifiedDate(project.Modified);

            return response;
        }
コード例 #9
0
        public async Task<HttpResponseMessage> Get(string id)
        {
            if (string.IsNullOrEmpty(id))
            {
                return Request.CreateResponse(HttpStatusCode.BadRequest, ResponseMessages.ProjectInvalidId);
            }

            var project = new DomainProject
            {
                UserId = UserId,
                Id = id
            };

            project = await _projectService.GetAsync(project);

            var responseProject = new Project
            {
                Id = project.Id,
                Description = project.Description,
                Name = project.Name,
                Access = project.Access,
                Created = project.Created,
                PublicUrl = _projectUriProvider.GetUri(project.Id),
                ProjectType = project.ProjectType,
                ProjectSubtype = project.ProjectSubtype,
                EnableComments = project.EnableComments
            };

            HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.OK, responseProject);
            response.SetLastModifiedDate(project.Modified);

            return response;
        }
コード例 #10
0
        public async Task<HttpResponseMessage> Post(ExternalProjectModel model)
        {
            try
            {
                await CongratUserIfNeeded();
            }
            catch (Exception e)
            {
                Trace.TraceError("Failed to notify user by email: {0}", e);
            }

            // Add project
            ProductType product = _productIdExtractor.Get(UserAgent);

            var project = new DomainProject
            {
                UserId = UserId,
                Name = model.Name,
                Description = model.Description,
                Access = model.Access,
                ProductType = product,
                ProjectType = model.ProjectType,
                ProjectSubtype = model.ProjectSubtype,
                EnableComments = model.EnableComments
            };

            project = await _projectService.AddAsync(project);

            // Add external video
            await _externalVideoService.AddAsync(project.Id, new DomainExternalVideo
            {
                ProductName = model.ProductName,
                VideoUri = model.VideoUri
            });

            // Add avsx file if exists
            if (model.Avsx != null)
            {
                var avsx = new DomainAvsx
                {
                    ContentType = model.Avsx.ContentType,
                    FileName = model.Avsx.Name,
                    FileUri = model.Avsx.Uri,
                    FileLength = model.Avsx.Length
                };

                await _projectAvsxService.AddAsync(project.Id, avsx);
                // For statistics
                Request.Properties.Add("isAvsx", true);
            }

            // Add screenshot file if exists
            if (model.Screenshot != null)
            {
                var screenshot = new DomainScreenshot
                {
                    FileName = model.Screenshot.Name,
                    FileUri = model.Screenshot.Uri,
                    FileId = Guid.NewGuid().ToString(),
                    FileLength = model.Screenshot.Length,
                    ContentType = model.Screenshot.ContentType,
                    Created = DateTime.UtcNow,
                    Modified = DateTime.UtcNow
                };

                await _projectScreenshotService.AddAsync(project.Id, screenshot);
                // For statistics
                Request.Properties.Add("isScreenshot", true);
            }

            var responseProject = new Project
            {
                Id = project.Id,
                Description = project.Description,
                Access = project.Access,
                Name = project.Name,
                Created = project.Created,
                PublicUrl = _projectUriProvider.GetUri(project.Id),
                ProjectType = project.ProjectType,
                ProjectSubtype = project.ProjectSubtype,
                EnableComments = project.EnableComments
            };

            HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.Created, responseProject);
            response.SetLastModifiedDate(project.Modified);

            return response;
        }
コード例 #11
0
ファイル: ProjectService.cs プロジェクト: GusLab/video-portal
        public async Task<DomainProject> EditAsync(DomainProject entity)
        {
            ProjectEntity project = await _projectRepository.GetAsync(entity.Id);
            if (project.UserId != entity.UserId)
            {
                throw new ForbiddenException();
            }

            ProjectEntity updatedProject = _mapper.Map<DomainProject, ProjectEntity>(entity);

            // Overwriting not-modified fields
            updatedProject.Created = project.Created;
            updatedProject.Modified = DateTime.UtcNow;
            updatedProject.ProjectType = project.ProjectType;
            updatedProject.ProjectSubtype = project.ProjectSubtype;
            updatedProject.ProductId = project.ProductId;
            updatedProject.HitsCount = project.HitsCount;

            updatedProject = await _projectRepository.UpdateAsync(updatedProject);

            return _mapper.Map<ProjectEntity, DomainProject>(updatedProject);
        }
コード例 #12
0
ファイル: ProjectService.cs プロジェクト: GusLab/video-portal
        public async Task DeleteAsync(DomainProject entity)
        {
            ProjectEntity project = await _projectRepository.GetAsync(entity.Id);
            if (project == null)
            {
                throw new NotFoundException();
            }

            if (project.UserId != entity.UserId)
            {
                throw new ForbiddenException();
            }


            var tasks = new List<Task>();

            // removing avsx
            if (!string.IsNullOrEmpty(project.AvsxFileId))
            {
                tasks.Add(_fileSystem.DeleteFileAsync(new StorageFile { Id = project.AvsxFileId, UserId = project.UserId }));
            }

            // removing video
            if (!string.IsNullOrEmpty(project.OriginalVideoFileId))
            {
                tasks.Add(_fileSystem.DeleteFileAsync(new StorageFile { Id = project.OriginalVideoFileId, UserId = project.UserId }));
            }

            // removing screenshot
            if (!string.IsNullOrEmpty(project.ScreenshotFileId))
            {
                tasks.Add(_fileSystem.DeleteFileAsync(new StorageFile { Id = project.ScreenshotFileId, UserId = project.UserId }));
            }

            // removing encoded screenshots
            tasks.AddRange(project.EncodedScreenshots.Select(s => _fileSystem.DeleteFileAsync(new StorageFile { Id = s.FileId, UserId = project.UserId })));

            // removing encoded videos
            tasks.AddRange(project.EncodedVideos.Select(s => _fileSystem.DeleteFileAsync(new StorageFile { Id = s.FileId, UserId = project.UserId })));

            try
            {
                await Task.WhenAll(tasks);
            }
            catch (Exception e)
            {
                // could not delete all related files
                Trace.TraceError("Could not delete all related files for project {0}: {1}", project.Id, e);
            }

            // removing project with all embedded data: avsx, video, screenshot
            await _projectRepository.DeleteAsync(project.Id);
        }