Еще немного информации в релизах

.semver.txt

@@ -1 +1 @@
-1.0.53
+1.0.61

README.md

@@ -1,5 +1,5 @@
-# JiraTimeBot [![Build status](https://ci.appveyor.com/api/projects/status/anmhfvuj4oq84j1f?svg=true)](https://ci.appveyor.com/project/Monster1025/JiraTimeBot)
+# JiraTimeBot [![Build status](https://ci.appveyor.com/api/projects/status/anmhfvuj4oq84j1f/branch/master?svg=true)](https://ci.appveyor.com/project/monster1025/jiratimebot/branch/master)
-Приложение для автоматического добавления Jira Worklog'ов исходя из количества коммитов в ветку.
+Приложение для автоматического добавления Jira Worklog'ов исходя из количества коммитов в ветку. Возможна работа по JQL-запросу JIRA.
 
 # Ограничения
  - Предполагается что все Ваши репозитории находятся в одной папке (к которой вы указываете путь в настройках).
@@ -19,7 +19,7 @@
  - Время запуска - время автоматического запуска бота. Если была установлена галочка "тестовый прогон" - она будет снята.
  - Минут в рабочем дне - количество распределяемых минут (оыбчно 8 * 60).
  - Рандомных минут - если > 0, то будет прибавлено рандомное количество минут к рабочему времени (но кратное значению округления).
- - Добавлять описание (Режим Mercurial) - добавлять ли в описание CommitMessage, если не установлено - добавляются стандартные фразы программистов (типа "написание кода").
+ - Добавлять описание (Режим Mercurial) - добавлять ли в описание CommitMessage, если не установлено - описание не заполняются.
  - Автозагрузка - загружать ли программу при старте ОС.
 # Скачать
 Скачать актуальную версию можно тут: https://github.com/monster1025/JiraTimeBot/releases/latest

src/JiraTimeBot/DI/ContainerBuilder.cs

@@ -47,6 +47,7 @@ namespace JiraTimeBot.DI
             _builder.RegisterType<JiraCommitEmulator>().As<IMercurialLog>().AsSelf();
             _builder.RegisterAggregateService<IAllMercurialProviders>();
             
+            _builder.RegisterType<TaskTimeSpread>().As<ITaskTimeSpread>().AsSelf();
             _builder.RegisterType<TaskTimeByCommitsCalculator>().As<ITaskTimeCalculator>().AsSelf();
 
             _builder.RegisterType<WorkLogTasksProcessor>().AsSelf().As<ITasksProcessor>();

src/JiraTimeBot/JiraIntegration/Comments/JiraDescriptionSource.cs

@@ -1,32 +1,13 @@
 using JiraTimeBot.Configuration;
 using JiraTimeBot.TaskTime.Objects;
-using System;
-using System.Collections.Generic;
-using System.Linq;
 
 namespace JiraTimeBot.JiraIntegration.Comments
 {
     public class JiraDescriptionSource : IJiraDescriptionSource
     {
-        private readonly List<string> _dummyComments = new List<string>
-        {
-            "Написание кода", "написание кода", "программирование", "реализация задачи", "кодинг", "код + тесты", 
-            "кодинг", "написание кода и тестов"
-        };
-
         public string GetDescription(TaskTimeItem taskTimeItem, bool addCommentsToWorklog, Settings settings)
         {
-            if (addCommentsToWorklog)
+            return addCommentsToWorklog ? taskTimeItem.Description : "";
-            {
-                return taskTimeItem.Description;
-            }
-
-            if (settings.WorkType == WorkType.Mercurial)
-            {
-                return _dummyComments.OrderBy(f => Guid.NewGuid()).FirstOrDefault();
-            }
-
-            return "";
         }
     }
 }

src/JiraTimeBot/JiraIntegration/JiraApi.cs

@@ -107,9 +107,9 @@ namespace JiraTimeBot.JiraIntegration
                 {
                     issue = jira.Issues.Queryable.FirstOrDefault(f => f.Key == taskTimeItem.Branch);
                 }
-                catch (Exception)
+                catch (Exception ex)
                 {
-
+                    _log.Error($"Ошибка получения задачи из JIRA: {ex.Message} - {ex.InnerException?.Message}");
                 }
                 if (issue == null)
                 {
@@ -127,7 +127,7 @@ namespace JiraTimeBot.JiraIntegration
                 foreach (var workLog in userWorklogs)
                 {
                     var timeSpent = TimeSpan.FromSeconds(workLog.TimeSpentInSeconds);
-                    var timeDiff = Math.Abs((timeSpent - taskTimeItem.Time).TotalMinutes);
+                    var timeDiff = Math.Abs((timeSpent - taskTimeItem.TimeSpent).TotalMinutes);
                     if (timeDiff > 1 || userWorklogs.Count > 1 || userWorklogs.First().Comment != comment)
                     {
                         if (timeDiff > 1)
@@ -146,7 +146,7 @@ namespace JiraTimeBot.JiraIntegration
                         {
                             try
                             {
-                                issue.DeleteWorklogAsync(workLog, token: cancellationToken);
+                                issue.DeleteWorklogAsync(workLog, WorklogStrategy.RetainRemainingEstimate, token: cancellationToken);
                             }
                             catch (Exception ex)
                             {
@@ -165,14 +165,14 @@ namespace JiraTimeBot.JiraIntegration
 
                 if (!hasTodayWorklog)
                 {
-                    var timeSpentJira = $"{taskTimeItem.Time.TotalMinutes}m";
+                    var timeSpentJira = $"{taskTimeItem.TimeSpent.TotalMinutes}m";
 
                     Worklog workLogToAdd = new Worklog(timeSpentJira, date.Value, comment);
                     if (!dummy)
                     {
                         try
                         {
-                            workLogToAdd = issue.AddWorklogAsync(workLogToAdd, token: cancellationToken).Result;
+                            workLogToAdd = issue.AddWorklogAsync(workLogToAdd, WorklogStrategy.RetainRemainingEstimate, token: cancellationToken).Result;
                         }
                         catch (Exception ex)
                         {

src/JiraTimeBot/JiraIntegration/JiraCommitEmulator.cs

@@ -5,7 +5,8 @@ using System.Threading;
 using Atlassian.Jira;
 using JiraTimeBot.Configuration;
 using JiraTimeBot.Mercurial;
-using JiraTimeBot.Mercurial.Objects;
+using JiraTimeBot.TaskTime.Objects;
+
 
 namespace JiraTimeBot.JiraIntegration
 {
@@ -20,19 +21,19 @@ namespace JiraTimeBot.JiraIntegration
             _jiraApi = jiraApi;
         }
 
-        public List<MercurialCommitItem> GetMercurialLog(Settings settings,
+        public List<TaskTimeItem> GetMercurialLog(Settings settings,
                                     DateTime? date = null,
                                     CancellationToken cancellationToken = default(CancellationToken))
         {
             date = date.GetValueOrDefault(DateTime.Now.Date);
-            var workTasks = new List<MercurialCommitItem>();
+            var workTasks = new List<TaskTimeItem>();
             var issues = _jiraApi.GetIssuesByJQL(settings.JiraQuery, settings, date, cancellationToken);
 
             foreach (var issue in issues)
             {
                 if (cancellationToken.IsCancellationRequested)
                 {
-                    return new List<MercurialCommitItem>();
+                    return new List<TaskTimeItem>();
                 }
                 var comments = issue.GetCommentsAsync(cancellationToken).Result?.ToList() ?? new List<Comment>();
 
@@ -43,26 +44,30 @@ namespace JiraTimeBot.JiraIntegration
 
                 if (userComments.Any())
                 {
-                    foreach (var comment in userComments)
+                    foreach (var comment in userComments.OrderBy(f=>f.CreatedDate))
                     {
-                        workTasks.Add(new MercurialCommitItem
+                        var item = new TaskTimeItem(issue.Key.Value,
-                        {
+                            issue.Summary,
-                            Description = issue.Summary,
+                            issue.Project,
-                            Time = issue.Updated.GetValueOrDefault(date.Value),
+                            issue.Updated.GetValueOrDefault(date.Value),
-                            Branch = issue.Key.Value,
+                            TimeSpan.Zero,
-                            FilesAffected = 1
+                            1,
-                        });
+                            1,
+                            CommitType.Task);
+                        workTasks.Add(item);
                     }
                 }
                 else
                 {
-                    workTasks.Add(new MercurialCommitItem
+                    var item = new TaskTimeItem(issue.Key.Value,
-                    {
+                        issue.Summary,
-                        Description = issue.Summary,
+                        issue.Project,
-                        Time = issue.Updated.GetValueOrDefault(date.Value),
+                        issue.Updated.GetValueOrDefault(date.Value),
-                        Branch = issue.Key.Value,
+                        TimeSpan.Zero,
-                        FilesAffected = 1
+                        1,
-                    });
+                        1,
+                        CommitType.Task);
+                    workTasks.Add(item);
                 }
             }
 

src/JiraTimeBot/JiraTimeBot.csproj

@@ -92,6 +92,8 @@
     <Compile Include="Mercurial\IMercurialLog.cs" />
     <Compile Include="Mercurial\Modifiers\TechnicalInfoSkipper.cs" />
     <Compile Include="TasksProcessors\IAllTasksProcessors.cs" />
+    <Compile Include="TaskTime\Objects\CommitType.cs" />
+    <Compile Include="TaskTime\TaskTimeSpread.cs" />
     <Compile Include="UI\frmMain.cs">
       <SubType>Form</SubType>
     </Compile>
@@ -99,7 +101,6 @@
       <DependentUpon>frmMain.cs</DependentUpon>
     </Compile>
     <Compile Include="JiraIntegration\JiraApi.cs" />
-    <Compile Include="Mercurial\Objects\MercurialCommitItem.cs" />
     <Compile Include="Mercurial\MercurialLog.cs" />
     <Compile Include="Configuration\PasswordEncryptionClass.cs" />
     <Compile Include="Program.cs" />

src/JiraTimeBot/Job.cs

@@ -5,7 +5,6 @@ using System.Threading;
 using System.Threading.Tasks;
 using JiraTimeBot.Configuration;
 using JiraTimeBot.Mercurial;
-using JiraTimeBot.Mercurial.Objects;
 using JiraTimeBot.TasksProcessors;
 using JiraTimeBot.TaskTime;
 using JiraTimeBot.TaskTime.Objects;
@@ -79,7 +78,7 @@ namespace JiraTimeBot
                 _log.Info("Использую Jira как источник информации.");
                 mercurial = _mercurialProviders.JiraCommitEmulator;
             }
-            List<MercurialCommitItem> commits = mercurial.GetMercurialLog(settings, realDate, cancellationToken);
+            List<TaskTimeItem> commits = mercurial.GetMercurialLog(settings, realDate, cancellationToken);
             List<TaskTimeItem> taskTimes = _taskTimeDiscoverer.CalculateTaskTime(commits, settings, cancellationToken);
 
             if (cancellationToken.IsCancellationRequested)

src/JiraTimeBot/Mercurial/IMercurialLog.cs

@@ -2,12 +2,12 @@
 using System.Collections.Generic;
 using System.Threading;
 using JiraTimeBot.Configuration;
-using JiraTimeBot.Mercurial.Objects;
+using JiraTimeBot.TaskTime.Objects;
 
 namespace JiraTimeBot.Mercurial
 {
     public interface IMercurialLog
     {
-        List<MercurialCommitItem> GetMercurialLog(Settings settings, DateTime? date = null, CancellationToken cancellationToken = default(CancellationToken));
+        List<TaskTimeItem> GetMercurialLog(Settings settings, DateTime? date = null, CancellationToken cancellationToken = default(CancellationToken));
     }
 }

src/JiraTimeBot/Mercurial/MercurialLog.cs

@@ -6,7 +6,7 @@ using System.Text;
 using System.Threading;
 using JiraTimeBot.Configuration;
 using JiraTimeBot.Mercurial.Modifiers;
-using JiraTimeBot.Mercurial.Objects;
+using JiraTimeBot.TaskTime.Objects;
 using Mercurial;
 
 namespace JiraTimeBot.Mercurial
@@ -24,22 +24,22 @@ namespace JiraTimeBot.Mercurial
             _technicalInfoSkipper = technicalInfoSkipper;
         }
         
-        public List<MercurialCommitItem> GetMercurialLog(Settings settings, DateTime? date = null, CancellationToken cancellationToken = default(CancellationToken))
+        public List<TaskTimeItem> GetMercurialLog(Settings settings, DateTime? date = null, CancellationToken cancellationToken = default(CancellationToken))
         {
             if (string.IsNullOrEmpty(settings.RepositoryPath) || !Directory.Exists(settings.RepositoryPath))
             {
                 _log.Error("Папка с репо не сушествует.");
-                return new List<MercurialCommitItem>();
+                return new List<TaskTimeItem>();
             }
 
             date = date.GetValueOrDefault(DateTime.Now.Date);
 
-            var workTasks = new List<MercurialCommitItem>();
+            var workTasks = new List<TaskTimeItem>();
             foreach (var repoDirectory in Directory.GetDirectories(settings.RepositoryPath))
             {
                 if (cancellationToken.IsCancellationRequested)
                 {
-                    return new List<MercurialCommitItem>();
+                    return new List<TaskTimeItem>();
                 }
 
                 //var project = new DirectoryInfo(repoDirectory).Name;
@@ -48,6 +48,8 @@ namespace JiraTimeBot.Mercurial
                     continue;
                 }
 
+                var directoryInfo = new DirectoryInfo(repoDirectory);
+
                 var repo = new Repository(repoDirectory);
                 var logCommand = new LogCommand
                 {
@@ -62,7 +64,7 @@ namespace JiraTimeBot.Mercurial
                 {
                     if (cancellationToken.IsCancellationRequested)
                     {
-                        return new List<MercurialCommitItem>();
+                        return new List<TaskTimeItem>();
                     }
 
                     var commitMessage = FixEncoding(changeset.CommitMessage);
@@ -72,24 +74,44 @@ namespace JiraTimeBot.Mercurial
                     }
                     commitMessage = _technicalInfoSkipper.StripTechnicalInfo(commitMessage);
 
-                    workTasks.Add(new MercurialCommitItem
+                    var task = new TaskTimeItem(changeset.Branch,
+                        commitMessage,
+                        directoryInfo.Name,
+                        changeset.Timestamp,
+                        TimeSpan.Zero,
+                        1,
+                        changeset.PathActions.Count,
+                        GetCommitType(changeset.Branch));
+
+                    if (task.Type == CommitType.Release && task.Description.StartsWith("Merge with", StringComparison.CurrentCultureIgnoreCase))
                     {
-                        Description = commitMessage,
+                        var description = task.Description;
-                        Branch = changeset.Branch,
+                        if (description.Contains("\n"))
-                        Time = changeset.Timestamp,
+                        {
-                        FilesAffected = changeset.PathActions.Count
+                            description = description.Split('\n')[0];
-                    });
+                        }
+                        var branch = description.Replace("Merge with", "").Replace(" ", "");
+                        var release = task.Branch.Replace("release", "");
+
+                        task.Branch = branch;
+                        task.Description = $"Подготовка и публикация версии {task.Project} {release}.";
+                    }
+                    workTasks.Add(task);
                     _log?.Trace($" - Найден changeset: {changeset.Timestamp} - {changeset.Branch} - {changeset.AuthorEmailAddress} - {commitMessage}");
                 }
             }
             if (!workTasks.Any())
             {
-                return new List<MercurialCommitItem>();
+                return new List<TaskTimeItem>();
             }
 
             return workTasks;
         }
 
+        private CommitType GetCommitType(string branch)
+        {
+            return branch.StartsWith("release") ? CommitType.Release : CommitType.Task;
+        }
 
         private string FixEncoding(string source)
         {

src/JiraTimeBot/Mercurial/Modifiers/CommitSkipper.cs

@@ -6,14 +6,18 @@ namespace JiraTimeBot.Mercurial.Modifiers
     {
         public bool IsNeedToSkip(string branch, string commitMessage)
         {
+            if (branch.StartsWith("release") && commitMessage.StartsWith("Merge with", StringComparison.InvariantCultureIgnoreCase))
+            {
+                return false;
+            }
             if (!branch.Contains("-"))
             {
                 return true;
             }
 
             //Пропускаем Close и Merge коммиты
-            if (commitMessage.StartsWith($"Close {branch} ", StringComparison.InvariantCultureIgnoreCase) ||
+            if (commitMessage.StartsWith($"Close {branch}", StringComparison.InvariantCultureIgnoreCase) ||
-                commitMessage.StartsWith($"Merge with ", StringComparison.InvariantCultureIgnoreCase))
+                commitMessage.StartsWith($"Merge with", StringComparison.InvariantCultureIgnoreCase))
             {
                 return true;
             }

src/JiraTimeBot/Mercurial/Objects/MercurialCommitItem.cs

@@ -1,12 +0,0 @@
-using System;
-
-namespace JiraTimeBot.Mercurial.Objects
-{
-    public class MercurialCommitItem
-    {
-        public string Description { get; set; }
-        public string Branch { get; set; }
-        public DateTime Time { get; set; }
-        public int FilesAffected { get; set; }
-    }
-}

src/JiraTimeBot/Properties/AssemblyInfo.cs

@@ -26,6 +26,6 @@ using System.Runtime.InteropServices;
 //                                                    
 // You can specify all the values or you can default the Build and Revision Numbers                                                    
 // by using the '*' as shown below:                                                    
-[assembly: AssemblyVersion("1.0.53")] 
+[assembly: AssemblyVersion("1.0.61")] 
-[assembly: AssemblyFileVersion("1.0.53")] 
+[assembly: AssemblyFileVersion("1.0.61")] 
-[assembly: AssemblyInformationalVersion("1.0.53")] 
+[assembly: AssemblyInformationalVersion("1.0.61")] 

src/JiraTimeBot/TaskTime/ITaskTimeCalculator.cs

@@ -1,13 +1,13 @@
 using System.Collections.Generic;
 using System.Threading;
 using JiraTimeBot.Configuration;
-using JiraTimeBot.Mercurial.Objects;
+
 using JiraTimeBot.TaskTime.Objects;
 
 namespace JiraTimeBot.TaskTime
 {
     public interface ITaskTimeCalculator
     {
-        List<TaskTimeItem> CalculateTaskTime(List<MercurialCommitItem> commitItems, Settings settings, CancellationToken cancellationToken = default(CancellationToken));
+        List<TaskTimeItem> CalculateTaskTime(List<TaskTimeItem> commitItems, Settings settings, CancellationToken cancellationToken = default(CancellationToken));
     }
 }

src/JiraTimeBot/TaskTime/Objects/CommitType.cs

@@ -0,0 +1,7 @@
+namespace JiraTimeBot.TaskTime.Objects
+{
+    public enum CommitType {
+        Task = 0,
+        Release = 1
+    }
+}

src/JiraTimeBot/TaskTime/Objects/TaskTimeItem.cs

@@ -6,10 +6,24 @@ namespace JiraTimeBot.TaskTime.Objects
     {
         public string Description { get; set; }
         public string Branch { get; set; }
-        public TimeSpan Time { get; set; }
-        public int Commits { get; set; }
-
         public DateTime StartTime { get; set; }
-        public DateTime EndTime { get; set; }
+        public TimeSpan TimeSpent { get; set; }
+        public int Commits { get; set; }
+        public int FilesAffected { get; set; }
+        public CommitType Type { get; set; }
+        public string Project { get; set; }
+
+        public TaskTimeItem(string branch, string description, string project, DateTime startTime, TimeSpan timeSpent, int commits, 
+                            int filesAffected = 1, CommitType type = CommitType.Task)
+        {
+            Branch = branch;
+            Description = description;
+            Project = project;
+            Commits = commits;
+            TimeSpent = timeSpent;
+            StartTime = startTime;
+            FilesAffected = filesAffected;
+            Type = type;
+        }
     }
 }

src/JiraTimeBot/TaskTime/TaskTimeByCommitsCalculator.cs

@@ -4,7 +4,7 @@ using System.Linq;
 using System.Text;
 using System.Threading;
 using JiraTimeBot.Configuration;
-using JiraTimeBot.Mercurial.Objects;
+
 using JiraTimeBot.TaskTime.Objects;
 
 namespace JiraTimeBot.TaskTime
@@ -12,102 +12,112 @@ namespace JiraTimeBot.TaskTime
     public class TaskTimeByCommitsCalculator: ITaskTimeCalculator
     {
         private readonly ILog _log;
+        private readonly ITaskTimeSpread _spreadHelper;
 
-        public TaskTimeByCommitsCalculator(ILog log)
+        public TaskTimeByCommitsCalculator(ILog log, ITaskTimeSpread spreadHelper)
         {
             _log = log;
+            _spreadHelper = spreadHelper;
         }
 
-        public List<TaskTimeItem> CalculateTaskTime(List<MercurialCommitItem> commits, Settings settings, CancellationToken cancellationToken = default(CancellationToken))
+        public List<TaskTimeItem> CalculateTaskTime(List<TaskTimeItem> commits, Settings settings, CancellationToken cancellationToken = default(CancellationToken))
         {
             int minutesPerWorkDay = settings.MinuterPerWorkDay + GetRandomMinutes(settings);
             int workHours = (settings.MinuterPerWorkDay / 60);
             int totalCommitsCount = commits.Count;
+            var taskCommits = commits.Where(f => f.Type == CommitType.Task).ToList();
+            var releaseCommits = commits.Where(f => f.Type == CommitType.Release).ToList();
 
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return new List<TaskTimeItem>();
+            }
             if (!commits.Any())
             {
                 return new List<TaskTimeItem>();
             }
 
+            FixTooBigInterval(settings, workHours, totalCommitsCount);
+
+            int remainMinutes = minutesPerWorkDay;
+
+            var workTimeItems = new List<TaskTimeItem>();
+            var timeControlTask = GetTimeControlTask(settings.TimeControlTask);
+            if (timeControlTask != null)
+            {
+                workTimeItems.Add(timeControlTask);
+                remainMinutes -= (int)timeControlTask.TimeSpent.TotalMinutes;
+            }
+
+            if (releaseCommits.Any())
+            {
+                var releaseTasks = _spreadHelper.SpreadTime(releaseCommits, 30, 1);
+                workTimeItems.AddRange(releaseTasks);
+                remainMinutes -= releaseTasks.Sum(f=>(int)f.TimeSpent.TotalMinutes);
+            }
+
+            var workTasks = _spreadHelper.SpreadTime(taskCommits, remainMinutes, settings.RoundToMinutes);
+            foreach (var workTask in workTasks)
+            {
+                var existingItem = workTimeItems.FirstOrDefault(f => f.Branch == workTask.Branch);
+                if (existingItem != null)
+                {
+                    existingItem.TimeSpent += workTask.TimeSpent;
+                    existingItem.Description += "\r\n" + workTask.Description;
+                    continue;
+                }
+
+                workTimeItems.Add(workTask);
+            }
+            workTimeItems = workTimeItems.OrderByDescending(f => f.TimeSpent).ToList();
+
+            remainMinutes = minutesPerWorkDay - (int) workTimeItems.Sum(f => f.TimeSpent.TotalMinutes);
+            if (remainMinutes != 0)
+            {
+                _log.Trace($"Погрешность распределения времени: {remainMinutes}. Добавляю к первой задаче.");
+            }
+            if ((workTimeItems.First().TimeSpent.TotalMinutes > Math.Abs(remainMinutes) && remainMinutes < 0) || remainMinutes > 0)
+            {
+                //если переборщили или не достаточно добавили до 8 часов - скореектируем остаток в первой задаче (она самая трудозатратная).
+                workTimeItems.First().TimeSpent += TimeSpan.FromMinutes(remainMinutes);
+            }
+
+            PrintTotal(workTimeItems);
+
+            return workTimeItems.OrderByDescending(f=>f.TimeSpent).ToList();
+        }
+
+
+        private TaskTimeItem GetTimeControlTask(string timeControlTask, int minutes = 30)
+        {
+            //Если указана задача контроля времени - то спишем туда 30 минут и вычеркнем их из общего рабочего времени.
+            if (!string.IsNullOrEmpty(timeControlTask))
+            {
+                return new TaskTimeItem(timeControlTask,
+                    "Ведение учета времени",
+                    "Service",
+                    DateTime.Now,
+                    TimeSpan.FromMinutes(minutes),
+                    1,
+                    1,
+                    CommitType.Task);
+            }
+
+            return null;
+        }
+
+        private void FixTooBigInterval(Settings settings, int workHours, int totalCommitsCount)
+        {
             //если кол-во коммитов более чем кол-во интервалов - то уменьшим интервал вдвое.
             while (totalCommitsCount > (workHours * (60.0 / settings.RoundToMinutes)))
             {
-                settings.RoundToMinutes = (int)RoundTo((decimal)(settings.RoundToMinutes / 2.0), 5);
+                settings.RoundToMinutes = (int) RoundTo((decimal) (settings.RoundToMinutes / 2.0), 5);
                 _log.Info($"Слишком много задач - уменьшаю интервал до {settings.RoundToMinutes}.");
                 if (settings.RoundToMinutes == 5)
                 {
                     break;
                 }
             }
-
-            List<TaskTimeItem> workTimeItems = new List<TaskTimeItem>();
-            //Если указана задача контроля времени - то спишем туда 30 минут и вычеркнем их из общего рабочего времени.
-            if (!string.IsNullOrEmpty(settings.TimeControlTask))
-            {
-                minutesPerWorkDay = minutesPerWorkDay - 30;
-                workTimeItems.Add(new TaskTimeItem
-                {
-                    Time = TimeSpan.FromMinutes(30),
-                    Branch = settings.TimeControlTask,
-                    Commits = 1,
-                    Description = "Ведение учета времени",
-                    StartTime = DateTime.Now.Date
-                });
-            }
-
-            int remainMinutes = minutesPerWorkDay;
-            //Нам нужно раскидать 480 минут в день.
-            foreach (var taskGroup in commits.GroupBy(f => f.Branch).OrderByDescending(f=>f.Count()))
-            {
-                if (cancellationToken.IsCancellationRequested)
-                {
-                    return new List<TaskTimeItem>();
-                }
-
-                int currentTaskCommits = taskGroup.Count();
-                int currentTaskTime = (int)RoundTo(minutesPerWorkDay / totalCommitsCount * currentTaskCommits, settings.RoundToMinutes, false);
-                remainMinutes = remainMinutes - currentTaskTime;
-
-                var orderedTasks = taskGroup.OrderBy(f => f.Time).ToArray();
-                StringBuilder sb = new StringBuilder();
-                foreach (var task in orderedTasks)
-                {
-                    sb.AppendLine($"- {task.Description}");
-                }
-
-                var taskTimeItem = new TaskTimeItem
-                {
-                    Branch = taskGroup.Key,
-                    Time = TimeSpan.FromMinutes(currentTaskTime),
-                    Commits = taskGroup.Count(),
-                    Description = sb.ToString(),
-
-                    StartTime = orderedTasks.First().Time,
-                    EndTime = orderedTasks.Last().Time
-                };
-
-                workTimeItems.Add(taskTimeItem);
-            }
-            if (!workTimeItems.Any())
-            {
-                return new List<TaskTimeItem>();
-            }
-            workTimeItems = workTimeItems.OrderByDescending(f => f.Time).ToList();
-
-            if (remainMinutes != 0)
-            {
-                _log.Trace($"Погрешность распределения времени: {remainMinutes}. Добавляю к первой задаче.");
-            }
-
-            if ((workTimeItems.First().Time.TotalMinutes > Math.Abs(remainMinutes) && remainMinutes < 0) || remainMinutes > 0)
-            {
-                //если переборщили или не достаточно добавили до 8 часов - скореектируем остаток в первой задаче (она самая трудозатратная).
-                workTimeItems.First().Time += TimeSpan.FromMinutes(remainMinutes);
-            }
-
-            PrintTotal(workTimeItems);
-
-            return workTimeItems;
         }
 
         private int GetRandomMinutes(Settings settings)
@@ -123,7 +133,7 @@ namespace JiraTimeBot.TaskTime
             var totalTime = TimeSpan.Zero;
             foreach (var workTimeItem in workTimeItems)
             {
-                totalTime += workTimeItem.Time;
+                totalTime += workTimeItem.TimeSpent;
             }
 
             _log.Trace($"Итоговое реально проставляемое время: {totalTime}");

src/JiraTimeBot/TaskTime/TaskTimeSpread.cs

@@ -0,0 +1,69 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using JiraTimeBot.TaskTime.Objects;
+
+namespace JiraTimeBot.TaskTime
+{
+    public interface ITaskTimeSpread
+    {
+        List<TaskTimeItem> SpreadTime(List<TaskTimeItem> source,
+                                      int minutes,
+                                      int roundToMinutes,
+                                      bool roundUp = false,
+                                      bool appendTime = true);
+    }
+    public class TaskTimeSpread: ITaskTimeSpread
+    {
+        public List<TaskTimeItem> SpreadTime(List<TaskTimeItem> source, int minutes, int roundToMinutes, bool roundUp = false, bool appendTime = true)
+        {
+            List<TaskTimeItem> newList = new List<TaskTimeItem>();
+            int remainMinutes = minutes;
+
+            //Нам нужно раскидать 480 минут в день.
+            foreach (var taskGroup in source.GroupBy(f => f.Branch).OrderByDescending(f => f.Count()))
+            {
+                int currentTaskCommits = taskGroup.Count();
+                int currentTaskTime = (int)RoundTo(minutes / source.Count * currentTaskCommits, roundToMinutes, roundUp);
+                remainMinutes = remainMinutes - currentTaskTime;
+
+                var orderedTasks = taskGroup.OrderBy(f => f.StartTime).ToArray();
+                StringBuilder sb = new StringBuilder();
+                foreach (var task in orderedTasks)
+                {
+                    sb.AppendLine($"- {task.Description}");
+                }
+
+                var timeSpent = appendTime
+                    ? TimeSpan.FromMinutes(taskGroup.Sum(f => f.TimeSpent.TotalMinutes)) +
+                      TimeSpan.FromMinutes(currentTaskTime)
+                    : TimeSpan.FromMinutes(currentTaskTime);
+
+                var taskTimeItem = new TaskTimeItem(
+                    taskGroup.Key,
+                    sb.ToString(),
+                    taskGroup.First().Project,
+                    taskGroup.Min(f => f.StartTime),
+                    timeSpent,
+                    taskGroup.Sum(f => f.Commits),
+                    taskGroup.Sum(f => f.FilesAffected),
+                    taskGroup.First().Type);
+
+                newList.Add(taskTimeItem);
+            }
+
+            return newList;
+        }
+
+        private decimal RoundTo(decimal value, decimal to = 15, bool up = true)
+        {
+            if ((value % to) == 0)
+                return value;
+            if (up)
+                return (value - (value % to) + to);
+
+            return (value - (value % to));
+        }
+    }
+}

src/JiraTimeBot/TasksProcessors/MeetingProcessor.cs

@@ -23,10 +23,18 @@ namespace JiraTimeBot.TasksProcessors
         {
             _log.Trace($"На реальную дату {realDate:dd.MM.yyyy} распределение по задачам:");
 
-            foreach (var taskTime in taskTimes.OrderByDescending(f => f.Time))
+            foreach (var taskTime in taskTimes.Where(f=>f.Type == CommitType.Task).OrderByDescending(f => f.TimeSpent))
             {
                 var taskName = _jiraApi.GetTaskName(taskTime.Branch, settings);
-                _log.Trace($" - [{taskTime.Branch}, коммитов {taskTime.Commits}]: {taskName} - {taskTime.Time}");
+                _log.Trace($" - [{taskTime.Branch}, коммитов {taskTime.Commits}]: {taskName} - {taskTime.TimeSpent}");
+            }
+
+            var releases = taskTimes.Where(f => f.Type == CommitType.Release).GroupBy(f=>f.Description);
+            foreach (var release in releases)
+            {
+                var sum = release.Sum(f => (int) f.TimeSpent.TotalMinutes);
+                var description = release.First().Description.Replace(Environment.NewLine, "");
+                _log.Trace($" - [Release, задач {release.Count()}]: {description} - {TimeSpan.FromMinutes(sum)}");
             }
         }
     }

src/JiraTimeBot/TasksProcessors/WorkLogTasksProcessor.cs

@@ -23,7 +23,7 @@ namespace JiraTimeBot.TasksProcessors
             _log.Trace($"На реальную дату {realDate:dd.MM.yyyy} распределение по задачам:");
             foreach (var taskTime in taskTimes)
             {
-                _log.Trace($"- {taskTime.Branch} (коммитов {taskTime.Commits}): {taskTime.Time}");
+                _log.Trace($"- {taskTime.Branch} (коммитов {taskTime.Commits}): {taskTime.TimeSpent}");
             }
 
             _jiraApi.SetTodayWorklog(taskTimes, settings, date: setForDate, dummy: dummyMode, addCommentsToWorklog: settings.AddCommentsToWorklog, cancellationToken: cancellationToken);