Fix c# version

.semver.txt

@@ -1 +1 @@
-1.0.51
+1.0.66

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)
-Приложение для автоматического добавления Jira Worklog'ов исходя из количества коммитов в ветку.
+# 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'ов исходя из количества коммитов в ветку. Возможна работа по JQL-запросу JIRA.
 
 # Ограничения
  - Предполагается что все Ваши репозитории находятся в одной папке (к которой вы указываете путь в настройках).
@@ -17,7 +17,9 @@
  - JQL (Режим Jira) - можно задать свой JQL для поиска задач. Возможные замены: %USER% - Логин Jira, %DATE% дата на которую формируем список. Значнеие по умолчанию: status changed by '%USER%' during ("%DATE%","%DATE%")
  - Задача "учёта времени" - задача, куда будет списываться по 30 минут в день на "затраты на учет времени". Должна содержать знак '-'.
  - Время запуска - время автоматического запуска бота. Если была установлена галочка "тестовый прогон" - она будет снята.
- - Добавлять описание (Режим Mercurial) - добавлять ли в описание CommitMessage, если не установлено - добавляются стандартные фразы программистов (типа "написание кода").
-
+ - Минут в рабочем дне - количество распределяемых минут (оыбчно 8 * 60).
+ - Рандомных минут - если > 0, то будет прибавлено рандомное количество минут к рабочему времени (но кратное значению округления).
+ - Добавлять описание (Режим Mercurial) - добавлять ли в описание CommitMessage, если не установлено - описание не заполняются.
+ - Автозагрузка - загружать ли программу при старте ОС.
 # Скачать
 Скачать актуальную версию можно тут: https://github.com/monster1025/JiraTimeBot/releases/latest

src/JiraTimeBot/DI/ContainerBuilder.cs

@@ -46,7 +46,8 @@ namespace JiraTimeBot.DI
             _builder.RegisterType<MercurialLog>().As<IMercurialLog>().AsSelf();
             _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>();
@@ -55,6 +56,8 @@ namespace JiraTimeBot.DI
 
             _builder.RegisterType<JiraDescriptionSource>().AsSelf().As<IJiraDescriptionSource>();
             _builder.RegisterType<JiraApi>().AsSelf().AsImplementedInterfaces();
+
+            _builder.RegisterType<JiraHistory>().AsSelf().As<IJiraHistory>();
             
             _builder.Register(c => new Job(c.Resolve<IAllMercurialProviders>(), c.Resolve<ITaskTimeCalculator>(), c.Resolve<ILog>())).AsSelf();
 

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 taskTimeItem.Description;
-            }
-
-            if (settings.WorkType == WorkType.Mercurial)
-            {
-                return _dummyComments.OrderBy(f => Guid.NewGuid()).FirstOrDefault();
-            }
-
-            return "";
+            return addCommentsToWorklog ? taskTimeItem.Description : "";
         }
     }
 }

src/JiraTimeBot/JiraIntegration/JiraApi.cs

@@ -9,7 +9,15 @@ using JiraTimeBot.TaskTime.Objects;
 
 namespace JiraTimeBot.JiraIntegration
 {
-    public class JiraApi
+    public interface IJiraApi
+    {
+        List<Issue> GetIssuesByJQL(string jql, Settings settings, DateTime? date = null, CancellationToken cancellationToken = default);
+        string GetTaskName(string branch, Settings settings);
+        List<Issue> GetWorkloggedIssuesByDate(Settings settings, DateTime? date = null, CancellationToken cancellationToken = default);
+        void SetTodayWorklog(List<TaskTimeItem> taskTimeItems, Settings settings, DateTime? date = null, bool dummy = false, bool addCommentsToWorklog = false, CancellationToken cancellationToken = default);
+    }
+
+    public class JiraApi : IJiraApi
     {
         private readonly ILog _log;
         private readonly IJiraDescriptionSource _descriptionSource;
@@ -68,7 +76,7 @@ namespace JiraTimeBot.JiraIntegration
             return GetIssuesByJQL(jql, settings, date, cancellationToken);
         }
 
-        private void RemoveWorklogsAddedByUser(List<TaskTimeItem> taskTimeItems, Settings settings, DateTime? date = null,  bool dummy = false, CancellationToken cancellationToken = default(CancellationToken))
+        private void RemoveWorklogsAddedByUser(List<TaskTimeItem> taskTimeItems, Settings settings, DateTime? date = null, bool dummy = false, CancellationToken cancellationToken = default(CancellationToken))
         {
             var alreadyLoggedToday = GetWorkloggedIssuesByDate(settings, date);
             foreach (var issue in alreadyLoggedToday)
@@ -107,9 +115,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 +135,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 +154,7 @@ namespace JiraTimeBot.JiraIntegration
                         {
                             try
                             {
-                                issue.DeleteWorklogAsync(workLog, token: cancellationToken);
+                                issue.DeleteWorklogAsync(workLog, WorklogStrategy.RetainRemainingEstimate, token: cancellationToken);
                             }
                             catch (Exception ex)
                             {
@@ -165,14 +173,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,32 @@ namespace JiraTimeBot.JiraIntegration
 
                 if (userComments.Any())
                 {
-                    foreach (var comment in userComments)
+                    foreach (var comment in userComments.OrderBy(f=>f.CreatedDate))
                     {
-                        workTasks.Add(new MercurialCommitItem
-                        {
-                            Description = issue.Summary,
-                            Time = issue.Updated.GetValueOrDefault(date.Value),
-                            Branch = issue.Key.Value,
-                            FilesAffected = 1
-                        });
+                        var item = new TaskTimeItem(issue.Key.Value,
+                            issue.Summary,
+                            issue.Project,
+                            issue.Updated.GetValueOrDefault(date.Value),
+                            TimeSpan.Zero,
+                            1,
+                            1,
+                            "",
+                            CommitType.Task);
+                        workTasks.Add(item);
                     }
                 }
                 else
                 {
-                    workTasks.Add(new MercurialCommitItem
-                    {
-                        Description = issue.Summary,
-                        Time = issue.Updated.GetValueOrDefault(date.Value),
-                        Branch = issue.Key.Value,
-                        FilesAffected = 1
-                    });
+                    var item = new TaskTimeItem(issue.Key.Value,
+                        issue.Summary,
+                        issue.Project,
+                        issue.Updated.GetValueOrDefault(date.Value),
+                        TimeSpan.Zero,
+                        1,
+                        1,
+                        "",
+                        CommitType.Task);
+                    workTasks.Add(item);
                 }
             }
 

src/JiraTimeBot/JiraIntegration/JiraHistory.cs

@@ -0,0 +1,65 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using JiraTimeBot.Configuration;
+using JiraTimeBot.TaskTime.Objects;
+
+namespace JiraTimeBot.JiraIntegration
+{
+    public interface IJiraHistory
+    {
+        List<TaskTimeItem> GetDayWorklogs(DateTime date,
+                                          Settings settings,
+                                          CancellationToken cancellationToken = default(CancellationToken));
+    }
+
+    public class JiraHistory: IJiraHistory
+    {
+        private readonly IJiraApi _jiraApi;
+
+        public JiraHistory(IJiraApi jiraApi)
+        {
+            _jiraApi = jiraApi;
+        }
+
+        public List<TaskTimeItem> GetDayWorklogs(DateTime date,
+                                                 Settings settings,
+                                                 CancellationToken cancellationToken = default(CancellationToken))
+        {
+            var tasks = _jiraApi.GetIssuesByJQL("status changed by '%USER%' during (\"%DATE%\",\"%DATE%\")", settings, date, cancellationToken);
+            List<TaskTimeItem> resultItems = new List<TaskTimeItem>();
+            foreach (var issue in tasks)
+            {
+                var workLogs = issue.GetWorklogsAsync(cancellationToken).Result;
+                var user = settings.JiraUserName;
+                //user = "Zoya.Aleksandridi";
+                var userWorklogs = workLogs.Where(w =>
+                    w.CreateDate.GetValueOrDefault().Date == date && w.Author.Equals(user,
+                        StringComparison.InvariantCultureIgnoreCase)).ToList();
+                if (!userWorklogs.Any())
+                {
+                    continue;
+                }
+
+                var firstWorklog = userWorklogs.First();
+
+                var description = string.Join("\r\n", userWorklogs.Select(f => f.Comment).Distinct());
+                var totalTime = TimeSpan.FromSeconds(userWorklogs.Sum(f => f.TimeSpentInSeconds));
+                var startDate = firstWorklog?.CreateDate ?? date;
+                var commits = userWorklogs.Sum(f => f.Comment.Count(c => c == '\n'));
+                var taskType = CommitType.Task;
+                if (description.Contains("Подготовка и публикация"))
+                {
+                    taskType = CommitType.Release;
+                }
+
+                resultItems.Add(new TaskTimeItem(issue.Key.Value, description, issue.Project, startDate, totalTime, commits, 1, "", taskType));   
+            }
+
+            return resultItems;
+        }
+    }
+}

src/JiraTimeBot/JiraTimeBot.csproj

@@ -21,6 +21,7 @@
     <DefineConstants>DEBUG;TRACE</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
+    <LangVersion>7.1</LangVersion>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
     <PlatformTarget>AnyCPU</PlatformTarget>
@@ -81,6 +82,7 @@
     <Compile Include="DI\ContainerBuilder.cs" />
     <Compile Include="JiraIntegration\Comments\IJiraDescriptionSource.cs" />
     <Compile Include="JiraIntegration\Comments\JiraDescriptionSource.cs" />
+    <Compile Include="JiraIntegration\JiraHistory.cs" />
     <Compile Include="Job.cs" />
     <Compile Include="Logger.cs" />
     <Compile Include="Configuration\Settings.cs" />
@@ -92,6 +94,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 +103,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,8 +78,18 @@ namespace JiraTimeBot
                 _log.Info("Использую Jira как источник информации.");
                 mercurial = _mercurialProviders.JiraCommitEmulator;
             }
-            List<MercurialCommitItem> commits = mercurial.GetMercurialLog(settings, realDate, cancellationToken);
-            List<TaskTimeItem> taskTimes = _taskTimeDiscoverer.CalculateTaskTime(commits, settings, cancellationToken);
+
+            List<TaskTimeItem> taskTimes = null;
+            if (!(tasksProcessor is MeetingProcessor))
+            {
+                List<TaskTimeItem> commits = mercurial.GetMercurialLog(settings, realDate, cancellationToken);
+                taskTimes = _taskTimeDiscoverer.CalculateTaskTime(commits, settings, cancellationToken);
+            }
+            else
+            {
+                var provider = _mercurialProviders.JiraHistory;
+                taskTimes = provider.GetDayWorklogs(realDate, settings, cancellationToken);
+            }
 
             if (cancellationToken.IsCancellationRequested)
             {

src/JiraTimeBot/Mercurial/IAllMercurialProviders.cs

@@ -6,5 +6,6 @@ namespace JiraTimeBot.Mercurial
     {
         MercurialLog MercurialLog { get; }
         JiraCommitEmulator JiraCommitEmulator { get; }
+        IJiraHistory JiraHistory { get; }
     }
 }

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
@@ -23,23 +23,23 @@ namespace JiraTimeBot.Mercurial
             _commitSkipper = commitSkipper;
             _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,25 +74,47 @@ 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,
-                        Branch = changeset.Branch,
-                        Time = changeset.Timestamp,
-                        FilesAffected = changeset.PathActions.Count
-                    });
+                        var description = task.Description;
+                        if (description.Contains("\n"))
+                        {
+                            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}.";
+                        task.ReleaseVersion = 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)
         {
             //перекодируем сообщение - ибо оно криво забирается в 1252

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) ||
-                commitMessage.StartsWith($"Merge with ", StringComparison.InvariantCultureIgnoreCase))
+            if (commitMessage.StartsWith($"Close {branch}", 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

@@ -1,31 +1,31 @@
-using System.Reflection;                                          
-using System.Runtime.InteropServices;                                          
-// General Information about an assembly is controlled through the following                                          
-// set of attributes. Change these attribute values to modify the information                                          
-// associated with an assembly.                                          
-[assembly: AssemblyTitle("JiraTimeBot")]                                          
-[assembly: AssemblyDescription("")]                                          
-[assembly: AssemblyConfiguration("")]                                          
-[assembly: AssemblyCompany("")]                                          
-[assembly: AssemblyProduct("JiraTimeBot")]                                          
-[assembly: AssemblyCopyright("Copyright © 2019")]                                          
-[assembly: AssemblyTrademark("")]                                          
-[assembly: AssemblyCulture("")]                                          
-// Setting ComVisible to false makes the types in this assembly not visible                                          
-// to COM components.  If you need to access a type in this assembly from                                          
-// COM, set the ComVisible attribute to true on that type.                                          
-[assembly: ComVisible(false)]                                          
-// The following GUID is for the ID of the typelib if this project is exposed to COM                                          
-[assembly: Guid("f3b89316-c38c-4ce6-9d88-0b1373cfba1a")]                                          
-// Version information for an assembly consists of the following four values:                                          
-//                                          
-//      Major Version                                          
-//      Minor Version                                          
-//      Build Number                                          
-//      Revision                                          
-//                                          
-// 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.51")] 
-[assembly: AssemblyFileVersion("1.0.51")] 
-[assembly: AssemblyInformationalVersion("1.0.51")] 
+using System.Reflection;                                                         
+using System.Runtime.InteropServices;                                                         
+// General Information about an assembly is controlled through the following                                                         
+// set of attributes. Change these attribute values to modify the information                                                         
+// associated with an assembly.                                                         
+[assembly: AssemblyTitle("JiraTimeBot")]                                                         
+[assembly: AssemblyDescription("")]                                                         
+[assembly: AssemblyConfiguration("")]                                                         
+[assembly: AssemblyCompany("")]                                                         
+[assembly: AssemblyProduct("JiraTimeBot")]                                                         
+[assembly: AssemblyCopyright("Copyright © 2019")]                                                         
+[assembly: AssemblyTrademark("")]                                                         
+[assembly: AssemblyCulture("")]                                                         
+// Setting ComVisible to false makes the types in this assembly not visible                                                         
+// to COM components.  If you need to access a type in this assembly from                                                         
+// COM, set the ComVisible attribute to true on that type.                                                         
+[assembly: ComVisible(false)]                                                         
+// The following GUID is for the ID of the typelib if this project is exposed to COM                                                         
+[assembly: Guid("f3b89316-c38c-4ce6-9d88-0b1373cfba1a")]                                                         
+// Version information for an assembly consists of the following four values:                                                         
+//                                                         
+//      Major Version                                                         
+//      Minor Version                                                         
+//      Build Number                                                         
+//      Revision                                                         
+//                                                         
+// 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.66")] 
+[assembly: AssemblyFileVersion("1.0.66")] 
+[assembly: AssemblyInformationalVersion("1.0.66")] 

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,10 @@
+using System;
+
+namespace JiraTimeBot.TaskTime.Objects
+{
+    [Flags]
+    public enum CommitType {
+        Task = 1,
+        Release = 2
+    }
+}

src/JiraTimeBot/TaskTime/Objects/TaskTimeItem.cs

@@ -6,10 +6,34 @@ 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 string ReleaseVersion { get; set; }
+
+        public TaskTimeItem(string branch, string description, string project, DateTime startTime, TimeSpan timeSpent, int commits, 
+                            int filesAffected = 1, string releaseVersion = "", CommitType type = CommitType.Task)
+        {
+            Branch = branch;
+            Description = description;
+            Project = project;
+            Commits = commits;
+            TimeSpent = timeSpent;
+            StartTime = startTime;
+            FilesAffected = filesAffected;
+            ReleaseVersion = releaseVersion;
+            Type = type;
+        }
+
+        public void MergeWith(TaskTimeItem toMerge)
+        {
+            Commits += toMerge.Commits;
+            TimeSpent += toMerge.TimeSpent;
+            Description += "\r\n" + toMerge.Description;
+            Type |= toMerge.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)
+            {
+                TaskTimeItem existingItem = workTimeItems.FirstOrDefault(f => f.Branch == workTask.Branch);
+                if (existingItem != null)
+                {
+                    existingItem.MergeWith(workTask);
+                    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);
-                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)
-            {
-                //если переборщили или не достаточно добавили до 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,68 @@
+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>();
+
+            //Нам нужно раскидать 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);
+
+                var orderedTasks = taskGroup.OrderBy(f => f.StartTime).ToArray();
+                StringBuilder sb = new StringBuilder();
+                foreach (var taskDescription in orderedTasks.Select(f=>f.Description).Distinct())
+                {
+                    sb.AppendLine($"- {taskDescription}");
+                }
+
+                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().ReleaseVersion,
+                    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.HasFlag(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.HasFlag(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);