Esempio n. 1
0
        public void AddAndGetWorklogs()
        {
            var summaryValue = "Test issue with work logs" + _random.Next(int.MaxValue);

            var issue = new Issue(_jira, "TST")
            {
                Type     = "1",
                Summary  = summaryValue,
                Assignee = "admin"
            };

            issue.SaveChanges();

            issue.AddWorklogAsync("1d").Wait();
            issue.AddWorklogAsync("1h", WorklogStrategy.RetainRemainingEstimate).Wait();
            issue.AddWorklogAsync("1m", WorklogStrategy.NewRemainingEstimate, "2d").Wait();

            issue.AddWorklogAsync(new Worklog("2d", new DateTime(2012, 1, 1), "comment")).Wait();

            var logs = issue.GetWorklogsAsync().Result;

            Assert.Equal(4, logs.Count());
            Assert.Equal("comment", logs.ElementAt(3).Comment);
            Assert.Equal(new DateTime(2012, 1, 1), logs.ElementAt(3).StartDate);
        }
Esempio n. 2
0
        private void LogTime()
        {
            _issue.AddWorklogAsync(SecondsToLoggableTimeString(_notLoggedTimeInSeconds)).GetAwaiter().GetResult();
            _issue.SaveChanges();

            Reset();
        }
Esempio n. 3
0
        public async Task GetIssueThatIncludesOnlyAllNonBasicFields(Jira jira)
        {
            // Arrange
            var issue = new Issue(jira, "TST")
            {
                Type     = "1",
                Summary  = "Test issue",
                Assignee = "admin"
            };

            issue.SaveChanges();

            await issue.AddCommentAsync("My comment");

            await issue.AddWorklogAsync("1d");

            // Act
            var options = new IssueSearchOptions($"key = {issue.Key.Value}")
            {
                FetchBasicFields = false,
                AdditionalFields = new List <string>()
                {
                    "comment", "watches", "worklog"
                }
            };

            var issues = await jira.Issues.GetIssuesFromJqlAsync(options);

            var serverIssue = issues.First();

            // Assert
            Assert.Null(serverIssue.Summary);
            Assert.True(serverIssue.AdditionalFields.ContainsKey("watches"));

            var worklogs = serverIssue.AdditionalFields.Worklogs;

            Assert.Equal(20, worklogs.ItemsPerPage);
            Assert.Equal(0, worklogs.StartAt);
            Assert.Equal(1, worklogs.TotalItems);
            Assert.Equal("1d", worklogs.First().TimeSpent);

            var comments = serverIssue.AdditionalFields.Comments;

            Assert.Equal(1, comments.ItemsPerPage);
            Assert.Equal(0, comments.StartAt);
            Assert.Equal(1, comments.TotalItems);
            Assert.Equal("My comment", comments.First().Body);
        }
Esempio n. 4
0
        public void DeleteWorklog()
        {
            var summary = "Test issue with worklogs" + _random.Next(int.MaxValue);
            var issue   = new Issue(_jira, "TST")
            {
                Type     = "1",
                Summary  = summary,
                Assignee = "admin"
            };

            issue.SaveChanges();

            var worklog = issue.AddWorklogAsync("1h").Result;

            Assert.Single(issue.GetWorklogsAsync().Result);

            issue.DeleteWorklogAsync(worklog).Wait();
            Assert.Empty(issue.GetWorklogsAsync().Result);
        }
Esempio n. 5
0
        public void SetTodayWorklog(List <TaskTimeItem> taskTimeItems, Settings settings, DateTime?date = null, bool dummy = false, bool addCommentsToWorklog = false, CancellationToken cancellationToken = default)
        {
            date = date.GetValueOrDefault(DateTime.Now.Date).Date;
            var jira = GetClient(settings);

            if (settings.RemoveManuallyAddedWorklogs)
            {
                //Удаляем добавленные вручную пользователем данные.
                RemoveWorklogsAddedByUser(taskTimeItems, settings, date, dummy, cancellationToken);
            }

            foreach (TaskTimeItem taskTimeItem in taskTimeItems)
            {
                Issue issue = null;
                try
                {
                    issue = jira.Issues.Queryable.FirstOrDefault(f => f.Key == taskTimeItem.Branch);
                }
                catch (Exception ex)
                {
                    _log.Error($"Ошибка получения задачи из JIRA: {ex.Message} - {ex.InnerException?.Message}");
                }
                if (issue == null)
                {
                    _log.Error($"[!] Не могу найти ветку {taskTimeItem.Branch} в JIRA, пропускаю!");
                    continue;
                }

                var hasTodayWorklog = false;
                var workLogs        = issue.GetWorklogsAsync(cancellationToken).Result;
                var userWorklogs    = workLogs.Where(w =>
                                                     w.StartDate.GetValueOrDefault().Date == date && w.Author.Equals(settings.JiraUserName,
                                                                                                                     StringComparison.InvariantCultureIgnoreCase)).ToList();
                var comment = _descriptionSource.GetDescription(taskTimeItem, addCommentsToWorklog, settings);

                foreach (var workLog in userWorklogs)
                {
                    var timeSpent = TimeSpan.FromSeconds(workLog.TimeSpentInSeconds);
                    var timeDiff  = Math.Abs((timeSpent - taskTimeItem.TimeSpent).TotalMinutes);
                    if (timeDiff > 1 || userWorklogs.Count > 1 || userWorklogs.First().Comment != comment)
                    {
                        if (timeDiff > 1)
                        {
                            _log.Trace($"Время отличается на {timeDiff} минут, удаляю worklog: {taskTimeItem.Branch} {workLog.Author} {workLog.CreateDate}: {workLog.TimeSpent}");
                        }
                        else if (userWorklogs.Count > 1)
                        {
                            _log.Trace($"Найдено более одного ворклога на задачу, удаляю worklog: {taskTimeItem.Branch} {workLog.Author} {workLog.CreateDate}: {workLog.TimeSpent}");
                        }
                        else
                        {
                            _log.Trace($"Описание отличается, удаляю worklog: {taskTimeItem.Branch} {workLog.Author} {workLog.CreateDate}: {workLog.TimeSpent}");
                        }
                        if (!dummy)
                        {
                            try
                            {
                                issue.DeleteWorklogAsync(workLog, WorklogStrategy.AutoAdjustRemainingEstimate, token: cancellationToken);
                            }
                            catch (Exception ex)
                            {
                                _log.Error($"Не могу удалить Worklog по задаче {taskTimeItem.Branch}: {ex.Message}.");
                                continue;
                            }
                        }
                        hasTodayWorklog = false;
                    }
                    else
                    {
                        _log.Trace($"По задаче {taskTimeItem.Branch} уже есть аналогичный worklog. Пропускаю.");
                        hasTodayWorklog = true;
                    }
                }

                if (!hasTodayWorklog)
                {
                    var timeSpentJira = $"{taskTimeItem.TimeSpent.TotalMinutes}m";

                    Worklog workLogToAdd = new Worklog(timeSpentJira, date.Value, comment);
                    if (!dummy)
                    {
                        try
                        {
                            workLogToAdd = issue.AddWorklogAsync(workLogToAdd, WorklogStrategy.AutoAdjustRemainingEstimate, token: cancellationToken).Result;
                        }
                        catch (Exception ex)
                        {
                            _log.Error($"Не могу добавить Worklog по задаче {taskTimeItem.Branch}: {ex.Message} ({ex.InnerException?.Message}).");
                            continue;
                        }
                    }
                    _log.Trace($"Добавили Worklog для {taskTimeItem.Branch}: {workLogToAdd.Author} {workLogToAdd.CreateDate}: {workLogToAdd.TimeSpent}");
                }
            }
        }