Пример #1
0
        public async Task GetDetailedReportAsync_ShouldReturnDetailedReportDto()
        {
            var now    = DateTimeOffset.UtcNow;
            var client = await SetupHelper.CreateTestClientAsync(_client, _workspaceId);

            var project = await SetupHelper.CreateTestProjectAsync(_client, _workspaceId, client.Id);

            await SetupHelper.CreateTestTimeEntryAsync(_client, _workspaceId, now, project.Id);

            var userResponse = await _client.GetCurrentUserAsync();

            userResponse.IsSuccessful.Should().BeTrue();

            var nowWithTimeZone = DateTimeHelper.ConvertToTimeZone(userResponse.Data.Settings.TimeZone, now);

            var detailedReportRequest = new DetailedReportRequest {
                ExportType         = ExportType.JSON,
                DateRangeStart     = nowWithTimeZone.AddMinutes(-2),
                DateRangeEnd       = nowWithTimeZone.AddMinutes(2),
                SortOrder          = SortOrderType.DESCENDING,
                Description        = String.Empty,
                Rounding           = false,
                WithoutDescription = false,
                AmountShown        = AmountShownType.EARNED,
                Clients            = new ClientsFilterDto {
                    Contains = ContainsType.CONTAINS,
                    Ids      = new List <string> {
                        client.Id
                    },
                    Status = StatusType.ACTIVE
                },
                DetailedFilter = new DetailedFilterDto {
                    SortColumn = SortColumnType.DATE,
                    Page       = 1,
                    PageSize   = 50
                },
                TimeZone = userResponse.Data.Settings.TimeZone
            };

            var getDetailedReportResult = await _client.GetDetailedReportAsync(_workspaceId, detailedReportRequest);

            getDetailedReportResult.IsSuccessful.Should().BeTrue();
            getDetailedReportResult.Data.Should().NotBeNull();
            getDetailedReportResult.Data.TimeEntries.Should().HaveCountGreaterOrEqualTo(1);

            // Cleanup
            var deleteProject = await _client.ArchiveAndDeleteProject(_workspaceId, project.Id);

            deleteProject.IsSuccessful.Should().BeTrue();
        }
Пример #2
0
        public async Task FindAllHydratedTimeEntriesForUserAsync_ShouldReturnHydratedTimeEntryDtoImplList()
        {
            const int hourlyRateAmount = 1234;

            // Create project
            var projectRequest = new ProjectRequest
            {
                Name       = "FindAllHydratedTimeEntriesForProjectAsync " + Guid.NewGuid(),
                Color      = "#FF00FF",
                HourlyRate = new HourlyRateRequest {
                    Amount = hourlyRateAmount
                }
            };

            var createProject = await _client.CreateProjectAsync(_workspaceId, projectRequest);

            createProject.IsSuccessful.Should().BeTrue();
            createProject.Data.Should().NotBeNull();

            ProjectDtoImpl project = createProject.Data;

            var now = DateTimeOffset.UtcNow;
            var timeEntryRequest = new TimeEntryRequest
            {
                Start     = now,
                End       = now.AddSeconds(1),
                ProjectId = project.Id
            };

            var createResult = await _client.CreateTimeEntryAsync(_workspaceId, timeEntryRequest);

            createResult.IsSuccessful.Should().BeTrue();

            var userResponse = await _client.GetCurrentUserAsync();

            userResponse.IsSuccessful.Should().BeTrue();

            var response = await _client.FindAllHydratedTimeEntriesForUserAsync(_workspaceId, userResponse.Data.Id,
                                                                                start : DateTimeOffset.Now.AddDays(-1),
                                                                                end : DateTimeOffset.Now.AddDays(1));

            response.IsSuccessful.Should().BeTrue();
            response.Data.Should().Contain(timeEntry => timeEntry.Id.Equals(createResult.Data.Id));
            response.Data.Should().Contain(timeEntry => timeEntry.HourlyRate.Amount.Equals(hourlyRateAmount));

            var deleteProject = await _client.ArchiveAndDeleteProject(_workspaceId, project.Id);

            deleteProject.IsSuccessful.Should().BeTrue();
        }
Пример #3
0
        public async Task FindAllTasksAsync_ShouldReturnTaskList()
        {
            // Prepare some project
            var projectRequest = new ProjectRequest {
                Name = "Task find project " + Guid.NewGuid(), Color = "#FF00FF"
            };
            var createResult = await _client.CreateProjectAsync(_workspaceId, projectRequest);

            createResult.IsSuccessful.Should().BeTrue();
            var projectId = createResult.Data.Id;

            var response = await _client.FindAllTasksAsync(_workspaceId, projectId);

            response.IsSuccessful.Should().BeTrue();

            var deleteProject = await _client.ArchiveAndDeleteProject(_workspaceId, projectId);

            deleteProject.IsSuccessful.Should().BeTrue();
        }
Пример #4
0
        public async Task CreateTemplatesAsync_ShouldCreteTemplateAndReturnTemplateDto()
        {
            // Create project for test
            var projectRequest = new ProjectRequest {
                Name = "Create Template test project " + Guid.NewGuid(), Color = "#FFFFFF"
            };
            var projectResponse = await _client.CreateProjectAsync(_workspaceId, projectRequest);

            projectResponse.IsSuccessful.Should().BeTrue();
            var projectId = projectResponse.Data.Id;
            // Create task
            var taskRequest = new TaskRequest {
                Name = "Template create task " + Guid.NewGuid()
            };
            var taskResponse = await _client.CreateTaskAsync(_workspaceId, projectId, taskRequest);

            taskResponse.IsSuccessful.Should().BeTrue();
            var taskId = taskResponse.Data.Id;

            var templatePatchRequest = new TemplateRequest()
            {
                Name             = "Create Test template " + Guid.NewGuid(),
                ProjectsAndTasks = new List <ProjectsTaskTupleRequest>()
                {
                    new ProjectsTaskTupleRequest
                    {
                        ProjectId = projectId,
                        TaskId    = taskId
                    }
                }
            };

            var createResult = await _client.CreateTemplatesAsync(_workspaceId, templatePatchRequest);

            createResult.IsSuccessful.Should().BeTrue();
            createResult.Data.Should().NotBeNull();

            var deleteProject = await _client.ArchiveAndDeleteProject(_workspaceId, projectId);

            deleteProject.IsSuccessful.Should().BeTrue();
        }
Пример #5
0
        public async Task CreateProjectAsync_ShouldCreateProjectAndReturnProjectImplDto()
        {
            var projectRequest = new ProjectRequest
            {
                Name  = "Test project " + Guid.NewGuid(),
                Color = "#FF00FF"
            };
            var createResult = await _client.CreateProjectAsync(_workspaceId, projectRequest);

            createResult.IsSuccessful.Should().BeTrue();
            createResult.Data.Should().NotBeNull();

            var findResult = await _client.FindAllProjectsOnWorkspaceAsync(_workspaceId);

            findResult.IsSuccessful.Should().BeTrue();
            findResult.Data.Should().ContainEquivalentOf(createResult.Data);

            var deleteProject = await _client.ArchiveAndDeleteProject(_workspaceId, createResult.Data.Id);

            deleteProject.IsSuccessful.Should().BeTrue();
        }