Example #1
0
        public void GetDetailedReport()
        {
            for (int i = 0; i < 6; i++)
            {
                var expTimeEntry = TimeEntryService.Add(new TimeEntry()
                {
                    IsBillable  = true,
                    CreatedWith = "TimeEntryTestAdd",
                    Duration    = 900,
                    Start       = DateTime.Now.AddDays(-i).ToIsoDateStr(),
                    Stop        = DateTime.Now.AddDays(-i).AddMinutes(20).ToIsoDateStr(),
                    ProjectId   = DefaultProjectId,
                    WorkspaceId = DefaultWorkspaceId
                });
                Assert.IsNotNull(expTimeEntry);
            }

            var standardParams = new DetailedReportParams()
            {
                UserAgent   = "TogglAPI.Net",
                WorkspaceId = DefaultWorkspaceId,
                Since       = DateTime.Now.AddYears(-1).ToIsoDateStr()
            };

            var result = ReportService.Detailed(standardParams);

            Assert.AreEqual(result.Data.Count, 6);
            Assert.AreEqual(result.TotalCount, 6);
        }
Example #2
0
        public async System.Threading.Tasks.Task <DetailedReport> FullDetailedReport(DetailedReportParams requestParameters)
        {
            var report = await Detailed(requestParameters);

            if (report.TotalCount < report.PerPage)
            {
                return(report);
            }

            var pageCount = (report.TotalCount + report.PerPage - 1) / report.PerPage;

            DetailedReport resultReport = null;

            for (var page = 1; page <= pageCount; page++)
            {
                requestParameters.Page = page;
                var pagedReport = await Detailed(requestParameters);

                if (resultReport == null)
                {
                    resultReport = pagedReport;
                }
                else
                {
                    resultReport.Data.AddRange(pagedReport.Data);
                }
            }
            return(resultReport);
        }
        public async Task <DetailedReport> GetFullDetailedReportAsync(DetailedReportParams requestParameters)
        {
            var report = await Detailed(requestParameters).ConfigureAwait(false);

            if (report.TotalCount < report.PerPage)
            {
                return(report);
            }

            var pageCount = (report.TotalCount + report.PerPage - 1) / report.PerPage;

            var resultReport = default(DetailedReport?);

            for (var page = 1; page <= pageCount; page++)
            {
                requestParameters.Page = page;
                var pagedReport = await Detailed(requestParameters).ConfigureAwait(false);

                if (resultReport?.Data == null)
                {
                    resultReport = pagedReport;
                }
                else
                {
                    resultReport.Data.AddRange(pagedReport.Data);
                }
            }

            return(resultReport !);
        }
Example #4
0
        public void GetDetailedReportSince()
        {
            var timeEntryService = new TimeEntryService(Constants.ApiToken);

            for (int i = 0; i < 6; i++)
            {
                var timeEntry = new TimeEntry()
                {
                    IsBillable  = true,
                    CreatedWith = "TimeEntryTestAdd",
                    Description = "Test Desc" + DateTime.Now.Ticks,
                    Duration    = 900,
                    Start       = DateTime.Now.AddDays(-i).ToIsoDateStr(),
                    Stop        = DateTime.Now.AddDays(-i).AddMinutes(20).ToIsoDateStr(),
                    ProjectId   = DefaultProjectId,
                    WorkspaceId = DefaultWorkspaceId
                };
                var expTimeEntry = timeEntryService.Add(timeEntry);
                Assert.IsNotNull(expTimeEntry);
            }

            var standardParams = new DetailedReportParams()
            {
                UserAgent   = "TogglAPI.Net",
                WorkspaceId = DefaultWorkspaceId
            };

            var result = ReportService.Detailed(standardParams);

            Assert.AreEqual(result.Data.Count, 6);
            Assert.AreEqual(result.TotalCount, 6);

            var te = new TimeEntry()
            {
                IsBillable  = true,
                CreatedWith = "TimeEntryTestAdd",
                Description = "Test Desc" + DateTime.Now.Ticks,
                Duration    = 900,
                Start       = DateTime.Now.AddDays(-7).ToIsoDateStr(),
                Stop        = DateTime.Now.AddDays(-7).AddMinutes(20).ToIsoDateStr(),
                ProjectId   = DefaultProjectId,
                WorkspaceId = DefaultWorkspaceId
            };
            var expTe = timeEntryService.Add(te);

            Assert.IsNotNull(expTe);

            result = ReportService.Detailed(standardParams);
            Assert.AreEqual(result.Data.Count, 6);
            Assert.AreEqual(result.TotalCount, 6);

            result = ReportService.Detailed(new DetailedReportParams()
            {
                UserAgent   = "test_api",
                WorkspaceId = DefaultWorkspaceId,
                Since       = DateTime.Now.AddDays(-7).ToIsoDateStr()
            });
            Assert.AreEqual(result.Data.Count, 7);
            Assert.AreEqual(result.TotalCount, 7);
        }
        public void Merge(int masterTaskId, int[] slaveTasksIds, int workspaceId, string userAgent = "TogglAPI.Net")
        {
            var reportService = new ReportService(this.ToggleSrv);
            var timeEntryService = new TimeEntryService(this.ToggleSrv);

            var reportParams = new DetailedReportParams()
            {
                UserAgent = userAgent,
                WorkspaceId = workspaceId,
                TaskIds = string.Join(",", slaveTasksIds.Select(id => id.ToString())),
                Since = DateTime.Now.AddYears(-1).ToIsoDateStr()
            };

            var result = reportService.Detailed(reportParams);

            if (result.TotalCount > result.PerPage)
                result = reportService.FullDetailedReport(reportParams);

            foreach (var reportTimeEntry in result.Data)
            {
                var timeEntry = timeEntryService.Get(reportTimeEntry.Id.Value);
                timeEntry.TaskId = masterTaskId;
                var editedTimeEntry = timeEntryService.Edit(timeEntry);
                if (editedTimeEntry == null)
                    throw new ArgumentNullException(string.Format("Can't edit timeEntry #{0}", reportTimeEntry.Id));
            }

            foreach (var slaveTaskId in slaveTasksIds)
            {
                if (!Delete(slaveTaskId))
                    throw new InvalidOperationException(string.Format("Can't delte task #{0}", slaveTaskId));
            }
        }
        public void Merge(int masterTaskId, int slaveTaskId, int workspaceId, string userAgent = "TogglAPI.Net")
        {
            var reportService = new ReportService(this.ToggleSrv);
            var timeEntryService = new TimeEntryService(this.ToggleSrv);

            var reportParams = new DetailedReportParams()
            {
                UserAgent = userAgent,
                WorkspaceId = workspaceId,
                TaskIds = slaveTaskId.ToString(),
                Since = DateTime.Now.AddYears(-1).ToIsoDateStr()
            };

            var result = reportService.Detailed(reportParams);

            if (result.TotalCount > result.PerPage)
                result = reportService.FullDetailedReport(reportParams);

            foreach (var reportTimeEntry in result.Data)
            {
                var timeEntry = timeEntryService.Get(reportTimeEntry.Id.Value);
                timeEntry.TaskId = masterTaskId;
                try
                {
                    var editedTimeEntry = timeEntryService.Edit(timeEntry);
                }
                catch (Exception ex)
                {
                    var res = ex.Data;
                }
            }

            if (!Delete(slaveTaskId))
                throw new InvalidOperationException(string.Format("Can't delte task #{0}", slaveTaskId));
        }
        public DetailedReport FullDetailedReport(DetailedReportParams requestParameters)
        {
            var report = this.Detailed(requestParameters);

            if (report.TotalCount < report.PerPage)
            {
                return(report);
            }

            var pageCount = (report.TotalCount + report.PerPage - 1) / report.PerPage;

            DetailedReport resultReport = null;

            for (var page = 1; page <= pageCount; page++)
            {
                requestParameters.Page = page;
                var pagedReport = Detailed(requestParameters);

                if (resultReport == null)
                {
                    resultReport = pagedReport;
                }
                else
                {
                    resultReport.Data.AddRange(pagedReport.Data);
                }
            }

            return(resultReport);
        }
        public async void MergeAsync(int masterTaskId, int[] slaveTasksIds, int workspaceId, string userAgent = TogglClient.UserAgent)
        {
            var reportService    = new ReportServiceAsync(TogglSrv);
            var timeEntryService = new TimeEntryServiceAsync(TogglSrv);

            var reportParams = new DetailedReportParams
            {
                UserAgent   = userAgent,
                WorkspaceId = workspaceId,
                TaskIds     = string.Join(",", slaveTasksIds.Select(id => id.ToString())),
                Since       = DateTime.Now.AddYears(-1).ToIsoDateStr()
            };

            var result = await reportService.Detailed(reportParams).ConfigureAwait(false);

            if (result.TotalCount > result.PerPage)
            {
                result = await reportService.GetFullDetailedReportAsync(reportParams).ConfigureAwait(false);
            }

            foreach (var reportTimeEntry in result.Data ?? throw new FormatException("Data was unexpectedly null"))
            {
                if (reportTimeEntry.Id == null)
                {
                    continue;
                }
                var timeEntry = await timeEntryService
                                .GetAsync(reportTimeEntry.Id.Value)
                                .ConfigureAwait(false);

                timeEntry.TaskId = masterTaskId;
                var editedTimeEntry = await timeEntryService
                                      .UpdateAsync(timeEntry)
                                      .ConfigureAwait(false);

                if (editedTimeEntry == null)
                {
                    throw new ArgumentNullException(string.Format("Can't edit timeEntry #{0}", reportTimeEntry.Id));
                }
            }

            foreach (var slaveTaskId in slaveTasksIds)
            {
                if (!await DeleteAsync(slaveTaskId).ConfigureAwait(false))
                {
                    throw new InvalidOperationException(string.Format("Can't delete task #{0}", slaveTaskId));
                }
            }
        }
Example #9
0
        static void Main(string[] args)
        {
            var apiKey = "";
            var usrSrv = new UserService(apiKey);
            var c      = usrSrv.GetCurrent();
            //usrSrv.

            var workspaceId    = c.DefaultWorkspaceId ?? 0;
            var standardParams = new DetailedReportParams()
            {
                UserAgent   = "",
                WorkspaceId = workspaceId,
                Since       = DateTime.Now.AddDays(-10).ToIsoDateTimeStr()
            };

            var reportService = new ReportService(apiKey);
            var res           = reportService.Detailed(standardParams);
        }
        public async System.Threading.Tasks.Task MergeAsync(long masterTaskId, long slaveTaskId, long workspaceId, string userAgent = TogglClient.UserAgent)
        {
            var reportService    = new ReportServiceAsync(TogglSrv);
            var timeEntryService = new TimeEntryServiceAsync(TogglSrv);

            var reportParams = new DetailedReportParams
            {
                UserAgent   = userAgent,
                WorkspaceId = workspaceId,
                TaskIds     = slaveTaskId.ToString(),
                Since       = DateTime.Now.AddYears(-1).ToIsoDateStr()
            };

            var result = await reportService.Detailed(reportParams).ConfigureAwait(false);

            if (result.TotalCount > result.PerPage)
            {
                result = await reportService.GetFullDetailedReportAsync(reportParams).ConfigureAwait(false);
            }

            foreach (var reportTimeEntry in result.Data ?? throw new FormatException("Data was unexpectedly null"))
            {
                if (reportTimeEntry.Id == null)
                {
                    continue;
                }
                var timeEntry = await timeEntryService.GetAsync(reportTimeEntry.Id.Value).ConfigureAwait(false);

                timeEntry.TaskId = masterTaskId;
                try
                {
                    var _ = await timeEntryService.UpdateAsync(timeEntry).ConfigureAwait(false);
                }
                catch (Exception ex)
                {
                    var _ = ex.Data;
                }
            }

            if (!await DeleteAsync(slaveTaskId).ConfigureAwait(false))
            {
                throw new InvalidOperationException(string.Format("Can't delete task #{0}", slaveTaskId));
            }
        }
Example #11
0
        public IEnumerable <TogglWorklog> GetTimeSheet(DateTime start, DateTime end)
        {
            var token     = _applicationUserService.GetTogglTokenForCurrentUser();
            var togglUser = GetTogglUser();

            var reportService = new ReportService(token);

            int pageNumber = 1;

            List <TogglWorklog> _worklogs = new List <TogglWorklog>();

            while (true)
            {
                var reportParams = new DetailedReportParams
                {
                    Since = start.Date.ToIsoDateTimeStrWithoutTimeZone(),
                    Until = end.Date.ToIsoDateTimeStrWithoutTimeZone(),
                    Page  = pageNumber,

                    UserAgent   = togglUser.Email,
                    WorkspaceId = togglUser.DefaultWorkspaceId ?? 0, // TODO: FIX
                };

                var detailedReport = reportService.Detailed(reportParams);

                var worklogsonPage = detailedReport.Data.Select(MapTogglWorklog);
                _worklogs.AddRange(worklogsonPage);

                var totalCount = detailedReport.TotalCount;
                var perPage    = detailedReport.PerPage;

                if ((perPage * pageNumber) >= totalCount)
                {
                    break;
                }

                pageNumber++;
            }

            return(_worklogs);
        }
Example #12
0
        public async System.Threading.Tasks.Task <DetailedReport> Detailed(DetailedReportParams requestParameters)
        {
            var report = await TogglSrv.Get <DetailedReport>(ApiRoutes.Reports.Detailed, requestParameters.ToKeyValuePair());

            return(report);
        }
        public DetailedReport Detailed(DetailedReportParams requestParameters)
        {
            var report = TogglSrv.Get <DetailedReport>(ApiRoutes.Reports.Detailed, requestParameters.ToKeyValuePair());

            return(report);
        }
Example #14
0
        public void GetTimeEntriesByTaskId()
        {
            var task1 = TaskService.Add(new Task
            {
                IsActive         = true,
                Name             = "task1",
                EstimatedSeconds = 3600,
                WorkspaceId      = DefaultWorkspaceId,
                ProjectId        = DefaultProjectId
            });

            Assert.IsNotNull(task1);

            var task2 = TaskService.Add(new Task
            {
                IsActive         = true,
                Name             = "task2",
                EstimatedSeconds = 3600,
                WorkspaceId      = DefaultWorkspaceId,
                ProjectId        = DefaultProjectId
            });

            Assert.IsNotNull(task2);

            var timeEntryService = new TimeEntryService(Constants.ApiToken);

            for (int i = 0; i < 3; i++)
            {
                var timeEntry = new TimeEntry()
                {
                    IsBillable  = true,
                    CreatedWith = "TimeEntryTestAdd",
                    Description = "Test Desc" + DateTime.Now.Ticks,
                    Duration    = 900,
                    Start       = DateTime.Now.AddDays(-i).ToIsoDateStr(),
                    Stop        = DateTime.Now.AddDays(-i).AddMinutes(20).ToIsoDateStr(),
                    WorkspaceId = DefaultWorkspaceId,
                    TaskId      = task1.Id
                };
                var expTimeEntry = timeEntryService.Add(timeEntry);
                Assert.IsNotNull(expTimeEntry);
            }

            for (int i = 0; i < 3; i++)
            {
                var timeEntry = new TimeEntry()
                {
                    IsBillable  = true,
                    CreatedWith = "TimeEntryTestAdd",
                    Description = "Test Desc" + DateTime.Now.Ticks,
                    Duration    = 900,
                    Start       = DateTime.Now.AddDays(-i).ToIsoDateStr(),
                    Stop        = DateTime.Now.AddDays(-i).AddMinutes(20).ToIsoDateStr(),
                    WorkspaceId = DefaultWorkspaceId,
                    TaskId      = task2.Id
                };
                var expTimeEntry = timeEntryService.Add(timeEntry);
                Assert.IsNotNull(expTimeEntry);
            }

            var standardParams = new DetailedReportParams()
            {
                UserAgent   = "TogglAPI.Net",
                WorkspaceId = DefaultWorkspaceId,
                Since       = DateTime.Now.AddYears(-1).ToIsoDateStr(),
                TaskIds     = string.Format("{0},{1}", task1.Id.Value, task2.Id.Value)
            };

            var result = ReportService.Detailed(standardParams);

            Assert.AreEqual(result.Data.Count, 6);
            Assert.AreEqual(result.TotalCount, 6);

            standardParams.TaskIds = task1.Id.Value.ToString();

            result = ReportService.Detailed(standardParams);
            Assert.AreEqual(result.Data.Count, 3);
            Assert.AreEqual(result.TotalCount, 3);
        }
Example #15
0
		public void Merge(int masterTaskId, int slaveTaskId, int workspaceId, string userAgent = "TogglAPI.Net")
	    {
		    var reportService = new ReportService(this.ToggleSrv);
		    var timeEntryService = new TimeEntryService(this.ToggleSrv);

			var reportParams = new DetailedReportParams()
								{
									UserAgent = userAgent,
									WorkspaceId = workspaceId,
									TaskIds = slaveTaskId.ToString(),
									Since = DateTime.Now.AddYears(-1).ToIsoDateStr()
								};

		    var result = reportService.Detailed(reportParams);

			if (result.TotalCount > result.PerPage)
				result = reportService.FullDetailedReport(reportParams);

		    foreach (var reportTimeEntry in result.Data)
		    {
			    var timeEntry = timeEntryService.Get(reportTimeEntry.Id.Value);
				timeEntry.TaskId = masterTaskId;
			    try
			    {
				    var editedTimeEntry = timeEntryService.Edit(timeEntry);
			    }
			    catch (Exception ex)
			    {
				    var res = ex.Data;
			    }			    
		    }

		    if (!Delete(slaveTaskId))
				throw new InvalidOperationException(string.Format("Can't delte task #{0}", slaveTaskId));
	    }
Example #16
0
		public void Merge(int masterTaskId, int[] slaveTasksIds, int workspaceId, string userAgent = "TogglAPI.Net")
		{
			var reportService = new ReportService(this.ToggleSrv);
			var timeEntryService = new TimeEntryService(this.ToggleSrv);

			var reportParams = new DetailedReportParams()
			{
				UserAgent = userAgent,
				WorkspaceId = workspaceId,
				TaskIds = string.Join(",", slaveTasksIds.Select(id => id.ToString())),
				Since = DateTime.Now.AddYears(-1).ToIsoDateStr()
			};

			var result = reportService.Detailed(reportParams);

			if (result.TotalCount > result.PerPage)
				result = reportService.FullDetailedReport(reportParams);

			foreach (var reportTimeEntry in result.Data)
			{
				var timeEntry = timeEntryService.Get(reportTimeEntry.Id.Value);
				timeEntry.TaskId = masterTaskId;
				var editedTimeEntry = timeEntryService.Edit(timeEntry);
				if (editedTimeEntry == null)
					throw new ArgumentNullException(string.Format("Can't edit timeEntry #{0}", reportTimeEntry.Id));
			}

			foreach (var slaveTaskId in slaveTasksIds)
			{
				if (!Delete(slaveTaskId))
					throw new InvalidOperationException(string.Format("Can't delte task #{0}", slaveTaskId));	
			}			
		}
 public Task <DetailedReport> Detailed(DetailedReportParams requestParameters)
 => TogglSrv.GetAsync <DetailedReport>(ApiRoutes.Reports.Detailed, requestParameters.ToKeyValuePair());