Example #1
0
        public async void ListProjectWorkAsync(bool withFilter)
        {
            var query = new ProjectWorkSearchDto {
                Page = 1, Limit = 1, ProjectId = Guid.NewGuid(), DeveloperId = withFilter ? (Guid?)SessionDeveloper.Id : null
            };
            var project = EntitiesFactory.NewProject(id: query.ProjectId.Value, developerIds: new[] { SessionDeveloper.Id }).Save();

            EntitiesFactory.NewWork(Guid.NewGuid(), project.DeveloperProjects.Single().Id).Save();
            EntitiesFactory.NewWork(Guid.NewGuid(), project.DeveloperProjects.Single().Id).Save();

            var(status, result) = await Request.GetAsync <ResultTest <IEnumerable <ProjectWorkListDto> > >(new Uri($"{Uri}/works"), query);

            var workList = result.Data;

            Assert.Equal(Status.Success, status);
            Assert.NotEmpty(workList);
            Assert.True(result.TotalRows > 0);
            Assert.True(workList.Count() == query.Limit);
            Assert.All(workList, work =>
            {
                Assert.True(work.Hours > 0);
                Assert.Equal(project.Id, work.ProjectId);
                Assert.Equal(project.Title, work.ProjectTitle);
                Assert.NotEmpty(work.Comment);
                Assert.NotEmpty(work.DeveloperName);
                if (withFilter)
                {
                    Assert.Equal(SessionDeveloper.Id, work.DeveloperId);
                    Assert.Equal(SessionDeveloper.Name, work.DeveloperName);
                }
            });
        }
 public async Task <Result <IEnumerable <ProjectWorkListDto> > > ListWorkProjectsAsync([FromQuery] ProjectWorkSearchDto searchDto)
 {
     return(GetResult(await _projectService.ListProjectWorksAsync(searchDto)));
 }
Example #3
0
        public async Task <Result <IEnumerable <ProjectWorkListDto> > > ListProjectWorksAsync(ProjectWorkSearchDto searchDto)
        {
            var query = _workRepository.Query()
                        .Where(w => searchDto.ProjectId == null || w.DeveloperProject.ProjectId == searchDto.ProjectId)
                        .Where(w => searchDto.DeveloperId == null || w.DeveloperProject.DeveloperId == searchDto.DeveloperId);

            var projectWorks = await query
                               .Skip(searchDto.CalculateOffset())
                               .Take(searchDto.Limit)
                               .Select(w => new ProjectWorkListDto
            {
                Id            = w.Id,
                StartTime     = w.StartTime,
                EndTime       = w.EndTime,
                Comment       = w.Comment,
                Hours         = w.Hours,
                ProjectId     = w.DeveloperProject.ProjectId,
                ProjectTitle  = w.DeveloperProject.Project.Title,
                DeveloperId   = w.DeveloperProject.DeveloperId,
                DeveloperName = w.DeveloperProject.Developer.Name
            })
                               .ToArrayAsync();

            return(new Result <IEnumerable <ProjectWorkListDto> >(projectWorks, await query.CountAsync()));
        }