Split tables for the stats (#6)

Reviewed-on: #6
Co-authored-by: sandre <perso@sebastienandre.com>
Co-committed-by: sandre <perso@sebastienandre.com>

Back/.editorconfig

@@ -0,0 +1,13 @@
+# Editor configuration, see http://editorconfig.org
+root = true
+
+[*]
+charset = utf-8
+indent_style = space
+indent_size = 4
+insert_final_newline = true
+trim_trailing_whitespace = true
+
+[*.md]
+max_line_length = off
+trim_trailing_whitespace = false

Back/skydiveLogs-api.Domain/StatsByAircraft.cs

@@ -0,0 +1,13 @@
+namespace skydiveLogs_api.Domain
+{
+    public class StatsByAircraft
+    {
+        public string Aircraft { get; set; }
+
+        public int Nb { get; set; }
+
+        public int Id { get; set; }
+
+        public User User { get; set; }
+    }
+}

Back/skydiveLogs-api.Domain/StatsByDz.cs

@@ -0,0 +1,13 @@
+namespace skydiveLogs_api.Domain
+{
+    public class StatsByDz
+    {
+        public string DropZone { get; set; }
+
+        public int Nb { get; set; }
+
+        public int Id { get; set; }
+
+        public User User { get; set; }
+    }
+}

Back/skydiveLogs-api.Domain/StatsByGear.cs

@@ -0,0 +1,13 @@
+namespace skydiveLogs_api.Domain
+{
+    public class StatsByGear
+    {
+        public string Gear { get; set; }
+
+        public int Nb { get; set; }
+
+        public int Id { get; set; }
+
+        public User User { get; set; }
+    }
+}

Back/skydiveLogs-api.Domain/StatsByJumpType.cs

@@ -0,0 +1,13 @@
+namespace skydiveLogs_api.Domain
+{
+    public class StatsByJumpType
+    {
+        public string JumpType { get; set; }
+
+        public int Nb { get; set; }
+
+        public int Id { get; set; }
+
+        public User User { get; set; }
+    }
+}

Back/skydiveLogs-api.Domain/StatsByYear.cs

@@ -0,0 +1,13 @@
+namespace skydiveLogs_api.Domain
+{
+    public class StatsByYear
+    {
+        public string Year { get; set; }
+
+        public int Nb { get; set; }
+
+        public int Id { get; set; }
+
+        public User User { get; set; }
+    }
+}

Back/skydiveLogs-api.Domain/StatsByYearByJumpType.cs

@@ -0,0 +1,17 @@
+using System.Collections.Generic;
+
+namespace skydiveLogs_api.Domain
+{
+    public class StatsByYearByJumpType
+    {
+        public string Year { get; set; }
+
+        public string JumpType { get; set; }
+
+        public int Nb { get; set; }
+
+        public int Id { get; set; }
+
+        public User User { get; set; }
+    }
+}

Back/skydiveLogs-api.Domain/StatsForLastMonthByDz.cs

@@ -0,0 +1,13 @@
+namespace skydiveLogs_api.Domain
+{
+    public class StatsForLastMonthByDz
+    {
+        public string DropZone { get; set; }
+
+        public int Nb { get; set; }
+
+        public int Id { get; set; }
+
+        public User User { get; set; }
+    }
+}

Back/skydiveLogs-api.Domain/StatsForLastMonthByJumpType.cs

@@ -0,0 +1,13 @@
+namespace skydiveLogs_api.Domain
+{
+    public class StatsForLastMonthByJumpType
+    {
+        public string JumpType { get; set; }
+
+        public int Nb { get; set; }
+
+        public int Id { get; set; }
+
+        public User User { get; set; }
+    }
+}

Back/skydiveLogs-api.Domain/StatsForLastYearByDz.cs

@@ -0,0 +1,13 @@
+namespace skydiveLogs_api.Domain
+{
+    public class StatsForLastYearByDz
+    {
+        public string DropZone { get; set; }
+
+        public int Nb { get; set; }
+
+        public int Id { get; set; }
+
+        public User User { get; set; }
+    }
+}

Back/skydiveLogs-api.Domain/StatsForLastYearByJumpType.cs

@@ -0,0 +1,13 @@
+namespace skydiveLogs_api.Domain
+{
+    public class StatsForLastYearByJumpType
+    {
+        public string JumpType { get; set; }
+
+        public int Nb { get; set; }
+
+        public int Id { get; set; }
+
+        public User User { get; set; }
+    }
+}

Back/skydiveLogs-api.Domain/UserStats.cs

@@ -1,42 +0,0 @@
-using System.Collections.Generic;
-
-namespace skydiveLogs_api.Domain
-{
-    public class UserStats
-    {
-        #region Public Constructors
-
-        public UserStats()
-        {
-            ByAircraft = new List<Statistic>();
-            ByDz = new List<Statistic>();
-            ByGear = new List<Statistic>();
-            ByJumpType = new List<Statistic>();
-            ByYear = new List<Statistic>();
-            ForLastMonthByDz = new List<Statistic>();
-            ForLastMonthByJumpType = new List<Statistic>();
-            ForLastYearByDz = new List<Statistic>();
-            ForLastYearByJumpType = new List<Statistic>();
-            ByYearByJumpType = new List<Statistic>();
-        }
-
-        #endregion Public Constructors
-
-        #region Public Properties
-
-        public IEnumerable<Statistic> ByAircraft { get; set; }
-        public IEnumerable<Statistic> ByDz { get; set; }
-        public IEnumerable<Statistic> ByGear { get; set; }
-        public IEnumerable<Statistic> ByJumpType { get; set; }
-        public IEnumerable<Statistic> ByYear { get; set; }
-        public IEnumerable<Statistic> ForLastMonthByDz { get; set; }
-        public IEnumerable<Statistic> ForLastMonthByJumpType { get; set; }
-        public IEnumerable<Statistic> ForLastYearByDz { get; set; }
-        public IEnumerable<Statistic> ForLastYearByJumpType { get; set; }
-        public IEnumerable<Statistic> ByYearByJumpType { get; set; }
-        public int Id { get; set; }
-        public User User { get; set; }
-
-        #endregion Public Properties
-    }
-}

Back/skydiveLogs-api.DomainBusiness/Interfaces/IStatsByAircraftService.cs

@@ -0,0 +1,16 @@
+using skydiveLogs_api.Domain;
+using System.Collections.Generic;
+
+namespace skydiveLogs_api.DomainBusiness.Interfaces
+{
+    public interface IStatsByAircraftService
+    {
+        #region Public Methods
+
+        IEnumerable<StatsByAircraft> GetStats();
+
+        void Reset();
+
+        #endregion Public Methods
+    }
+}

Back/skydiveLogs-api.DomainBusiness/Interfaces/IStatsByDzService.cs

@@ -0,0 +1,16 @@
+using skydiveLogs_api.Domain;
+using System.Collections.Generic;
+
+namespace skydiveLogs_api.DomainBusiness.Interfaces
+{
+    public interface IStatsByDzService
+    {
+        #region Public Methods
+
+        IEnumerable<StatsByDz> GetStats();
+
+        void Reset();
+
+        #endregion Public Methods
+    }
+}

Back/skydiveLogs-api.DomainBusiness/Interfaces/IStatsByGearService.cs

@@ -0,0 +1,16 @@
+using skydiveLogs_api.Domain;
+using System.Collections.Generic;
+
+namespace skydiveLogs_api.DomainBusiness.Interfaces
+{
+    public interface IStatsByGearService
+    {
+        #region Public Methods
+
+        IEnumerable<StatsByGear> GetStats();
+
+        void Reset();
+
+        #endregion Public Methods
+    }
+}

Back/skydiveLogs-api.DomainBusiness/Interfaces/IStatsByJumpTypeService.cs

@@ -0,0 +1,16 @@
+using skydiveLogs_api.Domain;
+using System.Collections.Generic;
+
+namespace skydiveLogs_api.DomainBusiness.Interfaces
+{
+    public interface IStatsByJumpTypeService
+    {
+        #region Public Methods
+
+        IEnumerable<StatsByJumpType> GetStats();
+
+        void Reset();
+
+        #endregion Public Methods
+    }
+}

Back/skydiveLogs-api.DomainBusiness/Interfaces/IStatsByYearByJumpTypeService.cs

@@ -0,0 +1,16 @@
+using skydiveLogs_api.Domain;
+using System.Collections.Generic;
+
+namespace skydiveLogs_api.DomainBusiness.Interfaces
+{
+    public interface IStatsByYearByJumpTypeService
+    {
+        #region Public Methods
+
+        IEnumerable<StatsByYearByJumpType> GetStats();
+
+        void Reset();
+
+        #endregion Public Methods
+    }
+}

Back/skydiveLogs-api.DomainBusiness/Interfaces/IStatsByYearService.cs

@@ -0,0 +1,15 @@
+using skydiveLogs_api.Domain;
+using System.Collections.Generic;
+
+namespace skydiveLogs_api.DomainBusiness.Interfaces
+{
+    public interface IStatsByYearService
+    {
+        #region Public Methods
+        IEnumerable<StatsByYear> GetStats();
+
+        void Reset();
+
+        #endregion Public Methods
+    }
+}

Back/skydiveLogs-api.DomainBusiness/Interfaces/IStatsForLastMonthByDzService.cs

@@ -0,0 +1,16 @@
+using skydiveLogs_api.Domain;
+using System.Collections.Generic;
+
+namespace skydiveLogs_api.DomainBusiness.Interfaces
+{
+    public interface IStatsForLastMonthByDzService
+    {
+        #region Public Methods
+
+        IEnumerable<StatsForLastMonthByDz> GetStats();
+
+        void Reset();
+
+        #endregion Public Methods
+    }
+}

Back/skydiveLogs-api.DomainBusiness/Interfaces/IStatsForLastMonthByJumpTypeService.cs

@@ -0,0 +1,16 @@
+using skydiveLogs_api.Domain;
+using System.Collections.Generic;
+
+namespace skydiveLogs_api.DomainBusiness.Interfaces
+{
+    public interface IStatsForLastMonthByJumpTypeService
+    {
+        #region Public Methods
+
+        IEnumerable<StatsForLastMonthByJumpType> GetStats();
+
+        void Reset();
+
+        #endregion Public Methods
+    }
+}

Back/skydiveLogs-api.DomainBusiness/Interfaces/IStatsForLastYearByDzService.cs

@@ -0,0 +1,16 @@
+using skydiveLogs_api.Domain;
+using System.Collections.Generic;
+
+namespace skydiveLogs_api.DomainBusiness.Interfaces
+{
+    public interface IStatsForLastYearByDzService
+    {
+        #region Public Methods
+
+        IEnumerable<StatsForLastYearByDz> GetStats();
+
+        void Reset();
+
+        #endregion Public Methods
+    }
+}

Back/skydiveLogs-api.DomainBusiness/Interfaces/IStatsForLastYearByJumpTypeService.cs

@@ -0,0 +1,16 @@
+using skydiveLogs_api.Domain;
+using System.Collections.Generic;
+
+namespace skydiveLogs_api.DomainBusiness.Interfaces
+{
+    public interface IStatsForLastYearByJumpTypeService
+    {
+        #region Public Methods
+
+        IEnumerable<StatsForLastYearByJumpType> GetStats();
+
+        void Reset();
+
+        #endregion Public Methods
+    }
+}

Back/skydiveLogs-api.DomainBusiness/StatsByAircraftService.cs

@@ -0,0 +1,68 @@
+using skydiveLogs_api.Domain;
+using skydiveLogs_api.DomainBusiness.Interfaces;
+using skydiveLogs_api.DomainService.Repositories;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace skydiveLogs_api.DomainBusiness
+{
+    public class StatsByAircraftService : IStatsByAircraftService
+    {
+        #region Public Constructors
+
+        public StatsByAircraftService(IJumpService jumpService,
+                                      IIdentityService identityService,
+                                      IStatsByAircraftRepository statsByAircraftRepository)
+        {
+            _jumpService = jumpService;
+            _identityService = identityService;
+            _statsByAircraftRepository = statsByAircraftRepository;
+        }
+
+        #endregion Public Constructors
+
+        #region Public Methods
+
+        public IEnumerable<StatsByAircraft> GetStats()
+        {
+            var allStats = _statsByAircraftRepository.GetAll(_identityService.ConnectedUser);
+            if (!allStats.Any())
+            {
+                var allJumps = _jumpService.GetAllJumps();
+                var results = new List<StatsByAircraft>();
+
+                if (allJumps.Any())
+                {
+                    results = [.. allJumps.GroupBy(j => j.Aircraft.Name,
+                                                   j => j,
+                                                   (groupby, jumps) => new StatsByAircraft
+                                                   {
+                                                       Aircraft = groupby.ToString(),
+                                                       Nb = jumps.Count(),
+                                                       User = _identityService.ConnectedUser
+                                                   })];
+                }
+
+                _statsByAircraftRepository.Add(results);
+                return results;
+            }
+
+            return allStats;
+        }
+
+        public void Reset()
+        {
+            _statsByAircraftRepository.Delete(_identityService.ConnectedUser);
+        }
+
+        #endregion Public Methods
+
+        #region Private Fields
+
+        private readonly IIdentityService _identityService;
+        private readonly IJumpService _jumpService;
+        private readonly IStatsByAircraftRepository _statsByAircraftRepository;
+
+        #endregion Private Fields
+    }
+}

Back/skydiveLogs-api.DomainBusiness/StatsByDzService.cs

@@ -0,0 +1,68 @@
+using skydiveLogs_api.Domain;
+using skydiveLogs_api.DomainBusiness.Interfaces;
+using skydiveLogs_api.DomainService.Repositories;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace skydiveLogs_api.DomainBusiness
+{
+    public class StatsByDzService : IStatsByDzService
+    {
+        #region Public Constructors
+
+        public StatsByDzService(IJumpService jumpService,
+                                IIdentityService identityService,
+                                IStatsByDzRepository statsByDzRepository)
+        {
+            _jumpService = jumpService;
+            _identityService = identityService;
+            _statsByDzRepository = statsByDzRepository;
+        }
+
+        #endregion Public Constructors
+
+        #region Public Methods
+
+        public IEnumerable<StatsByDz> GetStats()
+        {
+            var allStats = _statsByDzRepository.GetAll(_identityService.ConnectedUser);
+            if (!allStats.Any())
+            {
+                var allJumps = _jumpService.GetAllJumps();
+                var results = new List<StatsByDz>();
+
+                if (allJumps.Any())
+                {
+                    results = [.. allJumps.GroupBy(j => j.DropZone.Name,
+                                                   j => j,
+                                                   (groupby, jumps) => new StatsByDz
+                                                   {
+                                                       DropZone = groupby.ToString(),
+                                                       Nb = jumps.Count(),
+                                                       User = _identityService.ConnectedUser
+                                                   })];
+                }
+
+                _statsByDzRepository.Add(results);
+                return results;
+            }
+
+            return allStats;
+        }
+
+        public void Reset()
+        {
+            _statsByDzRepository.Delete(_identityService.ConnectedUser);
+        }
+
+        #endregion Public Methods
+
+        #region Private Fields
+
+        private readonly IIdentityService _identityService;
+        private readonly IJumpService _jumpService;
+        private readonly IStatsByDzRepository _statsByDzRepository;
+
+        #endregion Private Fields
+    }
+}

Back/skydiveLogs-api.DomainBusiness/StatsByGearService.cs

@@ -0,0 +1,68 @@
+using skydiveLogs_api.Domain;
+using skydiveLogs_api.DomainBusiness.Interfaces;
+using skydiveLogs_api.DomainService.Repositories;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace skydiveLogs_api.DomainBusiness
+{
+    public class StatsByGearService : IStatsByGearService
+    {
+        #region Public Constructors
+
+        public StatsByGearService(IJumpService jumpService,
+                                  IIdentityService identityService,
+                                  IStatsByGearRepository statsByGearRepository)
+        {
+            _jumpService = jumpService;
+            _identityService = identityService;
+            _statsByGearRepository = statsByGearRepository;
+        }
+
+        #endregion Public Constructors
+
+        #region Public Methods
+
+        public IEnumerable<StatsByGear> GetStats()
+        {
+            var allStats = _statsByGearRepository.GetAll(_identityService.ConnectedUser);
+            if (!allStats.Any())
+            {
+                var allJumps = _jumpService.GetAllJumps();
+                var results = new List<StatsByGear>();
+
+                if (allJumps.Any())
+                {
+                    results = [.. allJumps.GroupBy(j => $"{j.Gear.Name} / {j.Gear.MainCanopy}",
+                                                   j => j,
+                                                   (groupby, jumps) => new StatsByGear
+                                                   {
+                                                       Gear = groupby.ToString(),
+                                                       Nb = jumps.Count(),
+                                                       User = _identityService.ConnectedUser
+                                                   })];
+                }
+
+                _statsByGearRepository.Add(results);
+                return results;
+            }
+
+            return allStats;
+        }
+
+        public void Reset()
+        {
+            _statsByGearRepository.Delete(_identityService.ConnectedUser);
+        }
+
+        #endregion Public Methods
+
+        #region Private Fields
+
+        private readonly IIdentityService _identityService;
+        private readonly IJumpService _jumpService;
+        private readonly IStatsByGearRepository _statsByGearRepository;
+
+        #endregion Private Fields
+    }
+}

Back/skydiveLogs-api.DomainBusiness/StatsByJumpTypeService.cs

@@ -0,0 +1,68 @@
+using skydiveLogs_api.Domain;
+using skydiveLogs_api.DomainBusiness.Interfaces;
+using skydiveLogs_api.DomainService.Repositories;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace skydiveLogs_api.DomainBusiness
+{
+    public class StatsByJumpTypeService : IStatsByJumpTypeService
+    {
+        #region Public Constructors
+
+        public StatsByJumpTypeService(IJumpService jumpService,
+                                      IIdentityService identityService,
+                                      IStatsByJumpTypeRepository statsByJumpTypeRepository)
+        {
+            _jumpService = jumpService;
+            _identityService = identityService;
+            _statsByJumpTypeRepository = statsByJumpTypeRepository;
+        }
+
+        #endregion Public Constructors
+
+        #region Public Methods
+
+        public IEnumerable<StatsByJumpType> GetStats()
+        {
+            var allStats = _statsByJumpTypeRepository.GetAll(_identityService.ConnectedUser);
+            if (!allStats.Any())
+            {
+                var allJumps = _jumpService.GetAllJumps();
+                var results = new List<StatsByJumpType>();
+
+                if (allJumps.Any())
+                {
+                    results = [.. allJumps.GroupBy(j => j.JumpType.Name,
+                                                   j => j,
+                                                   (groupby, jumps) => new StatsByJumpType
+                                                   {
+                                                       JumpType = groupby.ToString(),
+                                                       Nb = jumps.Count(),
+                                                       User = _identityService.ConnectedUser
+                                                   })];
+                }
+
+                _statsByJumpTypeRepository.Add(results);
+                return results;
+            }
+
+            return allStats;
+        }
+
+        public void Reset()
+        {
+            _statsByJumpTypeRepository.Delete(_identityService.ConnectedUser);
+        }
+
+        #endregion Public Methods
+
+        #region Private Fields
+
+        private readonly IIdentityService _identityService;
+        private readonly IJumpService _jumpService;
+        private readonly IStatsByJumpTypeRepository _statsByJumpTypeRepository;
+
+        #endregion Private Fields
+    }
+}

Back/skydiveLogs-api.DomainBusiness/StatsByYearByJumpTypeService.cs

@@ -0,0 +1,69 @@
+using skydiveLogs_api.Domain;
+using skydiveLogs_api.DomainBusiness.Interfaces;
+using skydiveLogs_api.DomainService.Repositories;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace skydiveLogs_api.DomainBusiness
+{
+    public class StatsByYearByJumpTypeService : IStatsByYearByJumpTypeService
+    {
+        #region Public Constructors
+
+        public StatsByYearByJumpTypeService(IJumpService jumpService,
+                                            IIdentityService identityService,
+                                            IStatsByYearByJumpTypeRepository statsByYearByJumpTypeRepository)
+        {
+            _jumpService = jumpService;
+            _identityService = identityService;
+            _statsByYearByJumpTypeRepository = statsByYearByJumpTypeRepository;
+        }
+
+        #endregion Public Constructors
+
+        #region Public Methods
+
+        public IEnumerable<StatsByYearByJumpType> GetStats()
+        {
+            var allStats = _statsByYearByJumpTypeRepository.GetAll(_identityService.ConnectedUser);
+            if (!allStats.Any())
+            {
+                var allJumps = _jumpService.GetAllJumps();
+                var results = new List<StatsByYearByJumpType>();
+
+                if (allJumps.Any())
+                {
+                    results = [.. allJumps.GroupBy(j => new { j.JumpType.Name, j.JumpDate.Year },
+                                                   j => j,
+                                                   (groupby, jumps) => new StatsByYearByJumpType
+                                                   {
+                                                       Year = groupby.Year.ToString(),
+                                                       JumpType = groupby.Name.ToString(),
+                                                       Nb = jumps.Count(),
+                                                       User = _identityService.ConnectedUser
+                                                   })];
+                }
+
+                _statsByYearByJumpTypeRepository.Add(results);
+                return results;
+            }
+
+            return allStats;
+        }
+
+        public void Reset()
+        {
+            _statsByYearByJumpTypeRepository.Delete(_identityService.ConnectedUser);
+        }
+
+        #endregion Public Methods
+
+        #region Private Fields
+
+        private readonly IIdentityService _identityService;
+        private readonly IJumpService _jumpService;
+        private readonly IStatsByYearByJumpTypeRepository _statsByYearByJumpTypeRepository;
+
+        #endregion Private Fields
+    }
+}

Back/skydiveLogs-api.DomainBusiness/StatsByYearService.cs

@@ -0,0 +1,68 @@
+using skydiveLogs_api.Domain;
+using skydiveLogs_api.DomainBusiness.Interfaces;
+using skydiveLogs_api.DomainService.Repositories;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace skydiveLogs_api.DomainBusiness
+{
+    public class StatsByYearService : IStatsByYearService
+    {
+        #region Public Constructors
+
+        public StatsByYearService(IJumpService jumpService,
+                                  IIdentityService identityService,
+                                  IStatsByYearRepository statsByYearRepository)
+        {
+            _jumpService = jumpService;
+            _identityService = identityService;
+            _statsByYearRepository = statsByYearRepository;
+        }
+
+        #endregion Public Constructors
+
+        #region Public Methods
+
+        public IEnumerable<StatsByYear> GetStats()
+        {
+            var allStats = _statsByYearRepository.GetAll(_identityService.ConnectedUser);
+            if (!allStats.Any())
+            {
+                var allJumps = _jumpService.GetAllJumps();
+                var results = new List<StatsByYear>();
+
+                if (allJumps.Any())
+                {
+                    results = [.. allJumps.GroupBy(j => j.JumpDate.Year,
+                                                   j => j,
+                                                   (groupby, jumps) => new StatsByYear
+                                                   {
+                                                       Year = groupby.ToString(),
+                                                       Nb = jumps.Count(),
+                                                       User = _identityService.ConnectedUser
+                                                   })];
+                }
+
+                _statsByYearRepository.Add(results);
+                return results;
+            }
+
+            return allStats;
+        }
+
+        public void Reset()
+        {
+            _statsByYearRepository.Delete(_identityService.ConnectedUser);
+        }
+
+        #endregion Public Methods
+
+        #region Private Fields
+
+        private readonly IIdentityService _identityService;
+        private readonly IJumpService _jumpService;
+        private readonly IStatsByYearRepository _statsByYearRepository;
+
+        #endregion Private Fields
+    }
+}

Back/skydiveLogs-api.DomainBusiness/StatsForLastMonthByDzService.cs

@@ -0,0 +1,73 @@
+using skydiveLogs_api.Domain;
+using skydiveLogs_api.DomainBusiness.Interfaces;
+using skydiveLogs_api.DomainService.Repositories;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace skydiveLogs_api.DomainBusiness
+{
+    public class StatsForLastMonthByDzService : IStatsForLastMonthByDzService
+    {
+        #region Public Constructors
+
+        public StatsForLastMonthByDzService(IJumpService jumpService,
+                                            IIdentityService identityService,
+                                            IStatsForLastMonthByDzRepository statsForLastMonthByDzRepository)
+        {
+            _jumpService = jumpService;
+            _identityService = identityService;
+            _statsForLastMonthByDzRepository = statsForLastMonthByDzRepository;
+        }
+
+        #endregion Public Constructors
+
+        #region Public Methods
+
+        public IEnumerable<StatsForLastMonthByDz> GetStats()
+        {
+            var allStats = _statsForLastMonthByDzRepository.GetAll(_identityService.ConnectedUser);
+            if (!allStats.Any())
+            {
+                var allJumps = _jumpService.GetAllJumps();
+                var results = new List<StatsForLastMonthByDz>();
+
+                if (allJumps.Any())
+                {
+                    var lastJump = allJumps.OrderByDescending(j => j.JumpDate).First();
+                    var yearOfLastJump = lastJump.JumpDate.Year;
+                    var monthOfLastJump = lastJump.JumpDate.Month;
+
+                    results = [.. allJumps.Where(j => j.JumpDate.Year == yearOfLastJump && j.JumpDate.Month == monthOfLastJump)
+                                          .GroupBy(j => j.DropZone.Name,
+                                                   j => j,
+                                                   (groupby, jumps) => new StatsForLastMonthByDz
+                                                   {
+                                                       DropZone = groupby.ToString(),
+                                                       Nb = jumps.Count(),
+                                                       User = _identityService.ConnectedUser
+                                                   })];
+                }
+
+                _statsForLastMonthByDzRepository.Add(results);
+                return results;
+            }
+
+            return allStats;
+        }
+
+        public void Reset()
+        {
+            _statsForLastMonthByDzRepository.Delete(_identityService.ConnectedUser);
+        }
+
+        #endregion Public Methods
+
+        #region Private Fields
+
+        private readonly IIdentityService _identityService;
+        private readonly IJumpService _jumpService;
+        private readonly IStatsForLastMonthByDzRepository _statsForLastMonthByDzRepository;
+
+        #endregion Private Fields
+    }
+}

Back/skydiveLogs-api.DomainBusiness/StatsForLastMonthByJumpTypeService.cs

@@ -0,0 +1,73 @@
+using skydiveLogs_api.Domain;
+using skydiveLogs_api.DomainBusiness.Interfaces;
+using skydiveLogs_api.DomainService.Repositories;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace skydiveLogs_api.DomainBusiness
+{
+    public class StatsForLastMonthByJumpTypeService : IStatsForLastMonthByJumpTypeService
+    {
+        #region Public Constructors
+
+        public StatsForLastMonthByJumpTypeService(IJumpService jumpService,
+                                                  IIdentityService identityService,
+                                                  IStatsForLastMonthByJumpTypeRepository statsForLastMonthByJumpTypeRepository)
+        {
+            _jumpService = jumpService;
+            _identityService = identityService;
+            _statsForLastMonthByJumpTypeRepository = statsForLastMonthByJumpTypeRepository;
+        }
+
+        #endregion Public Constructors
+
+        #region Public Methods
+
+        public IEnumerable<StatsForLastMonthByJumpType> GetStats()
+        {
+            var allStats = _statsForLastMonthByJumpTypeRepository.GetAll(_identityService.ConnectedUser);
+            if (!allStats.Any())
+            {
+                var allJumps = _jumpService.GetAllJumps();
+                var results = new List<StatsForLastMonthByJumpType>();
+
+                if (allJumps.Any())
+                {
+                    var lastJump = allJumps.OrderByDescending(j => j.JumpDate).First();
+                    var yearOfLastJump = lastJump.JumpDate.Year;
+                    var monthOfLastJump = lastJump.JumpDate.Month;
+
+                    results = [.. allJumps.Where(j => j.JumpDate.Year == yearOfLastJump && j.JumpDate.Month == monthOfLastJump)
+                                          .GroupBy(j => j.JumpType.Name,
+                                                   j => j,
+                                                   (groupby, jumps) => new StatsForLastMonthByJumpType
+                                                   {
+                                                       JumpType = groupby.ToString(),
+                                                       Nb = jumps.Count(),
+                                                       User = _identityService.ConnectedUser
+                                                   })];
+                }
+
+                _statsForLastMonthByJumpTypeRepository.Add(results);
+                return results;
+            }
+
+            return allStats;
+        }
+
+        public void Reset()
+        {
+            _statsForLastMonthByJumpTypeRepository.Delete(_identityService.ConnectedUser);
+        }
+
+        #endregion Public Methods
+
+        #region Private Fields
+
+        private readonly IIdentityService _identityService;
+        private readonly IJumpService _jumpService;
+        private readonly IStatsForLastMonthByJumpTypeRepository _statsForLastMonthByJumpTypeRepository;
+
+        #endregion Private Fields
+    }
+}

Back/skydiveLogs-api.DomainBusiness/StatsForLastYearByDzService.cs

@@ -0,0 +1,72 @@
+using skydiveLogs_api.Domain;
+using skydiveLogs_api.DomainBusiness.Interfaces;
+using skydiveLogs_api.DomainService.Repositories;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace skydiveLogs_api.DomainBusiness
+{
+    public class StatsForLastYearByDzService : IStatsForLastYearByDzService
+    {
+        #region Public Constructors
+
+        public StatsForLastYearByDzService(IJumpService jumpService,
+                                           IIdentityService identityService,
+                                           IStatsForLastYearByDzRepository statsForLastYearByDzRepository)
+        {
+            _jumpService = jumpService;
+            _identityService = identityService;
+            _statsForLastYearByDzRepository = statsForLastYearByDzRepository;
+        }
+
+        #endregion Public Constructors
+
+        #region Public Methods
+
+        public IEnumerable<StatsForLastYearByDz> GetStats()
+        {
+            var allStats = _statsForLastYearByDzRepository.GetAll(_identityService.ConnectedUser);
+            if (!allStats.Any())
+            {
+                var allJumps = _jumpService.GetAllJumps();
+                var results = new List<StatsForLastYearByDz>();
+
+                if (allJumps.Any())
+                {
+                    var lastJump = allJumps.OrderByDescending(j => j.JumpDate).First();
+                    var yearOfLastJump = lastJump.JumpDate.Year;
+
+                    results = [.. allJumps.Where(j => j.JumpDate.Year == yearOfLastJump)
+                                          .GroupBy(j => j.DropZone.Name,
+                                                   j => j,
+                                                   (groupby, jumps) => new StatsForLastYearByDz
+                                                   {
+                                                       DropZone = groupby.ToString(),
+                                                       Nb = jumps.Count(),
+                                                       User = _identityService.ConnectedUser
+                                                   })];
+                }
+
+                _statsForLastYearByDzRepository.Add(results);
+                return results;
+            }
+
+            return allStats;
+        }
+
+        public void Reset()
+        {
+            _statsForLastYearByDzRepository.Delete(_identityService.ConnectedUser);
+        }
+
+        #endregion Public Methods
+
+        #region Private Fields
+
+        private readonly IIdentityService _identityService;
+        private readonly IJumpService _jumpService;
+        private readonly IStatsForLastYearByDzRepository _statsForLastYearByDzRepository;
+
+        #endregion Private Fields
+    }
+}

Back/skydiveLogs-api.DomainBusiness/StatsForLastYearByJumpTypeService.cs

@@ -0,0 +1,74 @@
+using skydiveLogs_api.Domain;
+using skydiveLogs_api.DomainBusiness.Interfaces;
+using skydiveLogs_api.DomainService.Repositories;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace skydiveLogs_api.DomainBusiness
+{
+    public class StatsForLastYearByJumpTypeService : IStatsForLastYearByJumpTypeService
+    {
+        #region Public Constructors
+
+        public StatsForLastYearByJumpTypeService(IJumpService jumpService,
+                                                 IIdentityService identityService,
+                                                 IStatsForLastYearByJumpTypeRepository statsForLastYearByJumpTypeRepository)
+        {
+            _jumpService = jumpService;
+            _identityService = identityService;
+            _statsForLastYearByJumpTypeRepository = statsForLastYearByJumpTypeRepository;
+        }
+
+        #endregion Public Constructors
+
+        #region Public Methods
+
+        public IEnumerable<StatsForLastYearByJumpType> GetStats()
+        {
+            var allStats = _statsForLastYearByJumpTypeRepository.GetAll(_identityService.ConnectedUser);
+            if (!allStats.Any())
+            {
+                var allJumps = _jumpService.GetAllJumps();
+                var results = new List<StatsForLastYearByJumpType>();
+
+                if (allJumps.Any())
+                {
+                    var lastJump = allJumps.OrderByDescending(j => j.JumpDate).First();
+                    var yearOfLastJump = lastJump.JumpDate.Year;
+
+                    results = [.. allJumps.Where(j => j.JumpDate.Year == yearOfLastJump)
+                                          .GroupBy(j => j.JumpType.Name,
+                                                   j => j,
+                                                   (groupby, jumps) => new StatsForLastYearByJumpType
+                                                   {
+                                                       JumpType = groupby.ToString(),
+                                                       Nb = jumps.Count(),
+                                                       User = _identityService.ConnectedUser
+                                                   })];
+                }
+
+                _statsForLastYearByJumpTypeRepository.Add(results);
+                return results;
+            }
+
+            return allStats;
+        }
+
+
+        public void Reset()
+        {
+            _statsForLastYearByJumpTypeRepository.Delete(_identityService.ConnectedUser);
+        }
+
+        #endregion Public Methods
+
+
+        #region Private Fields
+
+        private readonly IIdentityService _identityService;
+        private readonly IJumpService _jumpService;
+        private readonly IStatsForLastYearByJumpTypeRepository _statsForLastYearByJumpTypeRepository;
+
+        #endregion Private Fields
+    }
+}

Back/skydiveLogs-api.DomainBusiness/StatsService.cs

@@ -1,6 +1,5 @@
 using skydiveLogs_api.Domain;
 using skydiveLogs_api.DomainBusiness.Interfaces;
-using skydiveLogs_api.DomainService.Repositories;
 using System.Collections.Generic;
 using System.Linq;
 
@@ -11,12 +10,28 @@ namespace skydiveLogs_api.DomainBusiness
         #region Public Constructors
 
         public StatsService(IJumpService jumpService,
-                            IUserStatsRepository userStatsRepository,
+                            IStatsByAircraftService statsByAircraftService,
-                            IIdentityService identityService)
+                            IStatsByDzService statsByDzService,
+                            IStatsByGearService statsByGearService,
+                            IStatsByJumpTypeService statsByJumpTypeService,
+                            IStatsByYearByJumpTypeService statsByYearByJumpTypeService,
+                            IStatsByYearService statsByYearService,
+                            IStatsForLastMonthByDzService statsForLastMonthByDzService,
+                            IStatsForLastMonthByJumpTypeService statsForLastMonthByJumpTypeService,
+                            IStatsForLastYearByDzService statsForLastYearByDzService,
+                            IStatsForLastYearByJumpTypeService statsForLastYearByJumpTypeService)
         {
             _jumpService = jumpService;
-            _identityService = identityService;
+            _statsByAircraftService = statsByAircraftService;
-            _userStatsRepository = userStatsRepository;
+            _statsByDzService = statsByDzService;
+            _statsByGearService = statsByGearService;
+            _statsByJumpTypeService = statsByJumpTypeService;
+            _statsByYearByJumpTypeService = statsByYearByJumpTypeService;
+            _statsByYearService = statsByYearService;
+            _statsForLastMonthByDzService = statsForLastMonthByDzService;
+            _statsForLastMonthByJumpTypeService = statsForLastMonthByJumpTypeService;
+            _statsForLastYearByDzService = statsForLastYearByDzService;
+            _statsForLastYearByJumpTypeService = statsForLastYearByJumpTypeService;
         }
 
         #endregion Public Constructors
@@ -43,339 +58,136 @@ namespace skydiveLogs_api.DomainBusiness
             return results;
         }
 
+        public void Reset()
+        {
+            _statsByAircraftService.Reset();
+            _statsByDzService.Reset();
+            _statsByGearService.Reset();
+            _statsByJumpTypeService.Reset();
+            _statsByYearByJumpTypeService.Reset();
+            _statsByYearService.Reset();
+            _statsForLastMonthByDzService.Reset();
+            _statsForLastMonthByJumpTypeService.Reset();
+            _statsForLastYearByDzService.Reset();
+            _statsForLastYearByJumpTypeService.Reset();
+        }
+
         public IEnumerable<Statistic> GetStatsByAircraft()
         {
-            var allStats = GetAllStats();
+            var tmp = _statsByAircraftService.GetStats();
-            if (!allStats.ByAircraft.Any())
+            return [.. tmp.Select(a => new Statistic
             {
-                var allJumps = _jumpService.GetAllJumps();
+                Label = a.Aircraft,
-                var results = new List<Statistic>();
+                Nb = a.Nb
-
+            })];
-                if (allJumps.Any())
-                {
-                    results = allJumps.GroupBy(j => j.Aircraft.Name,
-                                               j => j,
-                                               (groupby, jumps) => new Statistic
-                                               {
-                                                   Label = groupby.ToString(),
-                                                   Nb = jumps.Count()
-                                               })
-                                      .ToList();
-                }
-
-                allStats.ByAircraft = results;
-                _userStatsRepository.Update(allStats);
-            }
-
-            return allStats.ByAircraft;
         }
 
         public IEnumerable<Statistic> GetStatsByDz()
         {
-            var allStats = GetAllStats();
+            var tmp = _statsByDzService.GetStats();
-            if (!allStats.ByDz.Any())
+            return [.. tmp.Select(a => new Statistic
             {
-                var allJumps = _jumpService.GetAllJumps();
+                Label = a.DropZone,
-                var results = new List<Statistic>();
+                Nb = a.Nb
-
+            })];
-                if (allJumps.Any())
-                {
-                    results = allJumps.GroupBy(j => j.DropZone.Name,
-                                               j => j,
-                                               (groupby, jumps) => new Statistic
-                                               {
-                                                   Label = groupby.ToString(),
-                                                   Nb = jumps.Count()
-                                               })
-                                      .ToList();
-                }
-
-                allStats.ByDz = results;
-                _userStatsRepository.Update(allStats);
-            }
-
-            return allStats.ByDz;
         }
 
         public IEnumerable<Statistic> GetStatsByGear()
         {
-            var allStats = GetAllStats();
+            var tmp = _statsByGearService.GetStats();
-            if (!allStats.ByGear.Any())
+            return [.. tmp.Select(a => new Statistic
             {
-                var allJumps = _jumpService.GetAllJumps();
+                Label = a.Gear,
-                var results = new List<Statistic>();
+                Nb = a.Nb
-
+            })];
-                if (allJumps.Any())
-                {
-                    results = allJumps.GroupBy(j => $"{j.Gear.Name} / {j.Gear.MainCanopy}",
-                                               j => j,
-                                               (groupby, jumps) => new Statistic
-                                               {
-                                                   Label = groupby.ToString(),
-                                                   Nb = jumps.Count()
-                                               })
-                                      .ToList();
-                }
-
-                allStats.ByGear = results;
-                _userStatsRepository.Update(allStats);
-            }
-
-            return allStats.ByGear;
         }
 
         public IEnumerable<Statistic> GetStatsByJumpType()
         {
-            var allStats = GetAllStats();
+            var tmp = _statsByJumpTypeService.GetStats();
-            if (!allStats.ByJumpType.Any())
+            return [.. tmp.Select(a => new Statistic
             {
-                var allJumps = _jumpService.GetAllJumps();
+                Label = a.JumpType,
-                var results = new List<Statistic>();
+                Nb = a.Nb
-
+            })];
-                if (allJumps.Any())
-                {
-                    results = allJumps.GroupBy(j => j.JumpType.Name,
-                                               j => j,
-                                               (groupby, jumps) => new Statistic
-                                               {
-                                                   Label = groupby.ToString(),
-                                                   Nb = jumps.Count()
-                                               })
-                                      .ToList();
-                }
-
-                allStats.ByJumpType = results;
-                _userStatsRepository.Update(allStats);
-            }
-
-            return allStats.ByJumpType;
         }
 
         public IEnumerable<Statistic> GetStatsByYear()
         {
-            var allStats = GetAllStats();
+            var tmp = _statsByYearService.GetStats();
-            if (!allStats.ByYear.Any())
+            return [.. tmp.Select(a => new Statistic
             {
-                var allJumps = _jumpService.GetAllJumps();
+                Label = a.Year,
-                var results = new List<Statistic>();
+                Nb = a.Nb
-
+            })];
-                if (allJumps.Any())
-                {
-                    results = allJumps.GroupBy(j => j.JumpDate.Year,
-                                               j => j,
-                                               (groupby, jumps) => new Statistic
-                                               {
-                                                   Label = groupby.ToString(),
-                                                   Nb = jumps.Count()
-                                               })
-                                      .ToList();
-                }
-
-                allStats.ByYear = results;
-                _userStatsRepository.Update(allStats);
-            }
-
-            return allStats.ByYear;
         }
 
         public IEnumerable<Statistic> GetStatsForLastMonthByDz()
         {
-            var allStats = GetAllStats();
+            var tmp = _statsForLastMonthByDzService.GetStats();
-            if (!allStats.ForLastMonthByDz.Any())
+            return [.. tmp.Select(a => new Statistic
             {
-                var allJumps = _jumpService.GetAllJumps();
+                Label = a.DropZone,
-                var results = new List<Statistic>();
+                Nb = a.Nb
-
+            })];
-                if (allJumps.Any())
-                {
-                    var lastJump = allJumps.OrderByDescending(j => j.JumpDate).First();
-                    var yearOfLastJump = lastJump.JumpDate.Year;
-                    var monthOfLastJump = lastJump.JumpDate.Month;
-
-                    results = allJumps.Where(j => j.JumpDate.Year == yearOfLastJump && j.JumpDate.Month == monthOfLastJump)
-                                      .GroupBy(j => j.DropZone.Name,
-                                               j => j,
-                                               (groupby, jumps) => new Statistic
-                                               {
-                                                   Label = groupby.ToString(),
-                                                   Nb = jumps.Count()
-                                               })
-                                      .ToList();
-                }
-
-                allStats.ForLastMonthByDz = results;
-                _userStatsRepository.Update(allStats);
-            }
-
-            return allStats.ForLastMonthByDz;
         }
 
         public IEnumerable<Statistic> GetStatsForLastMonthByJumpType()
         {
-            var allStats = GetAllStats();
+            var tmp = _statsForLastMonthByJumpTypeService.GetStats();
-            if (!allStats.ForLastMonthByJumpType.Any())
+            return [.. tmp.Select(a => new Statistic
             {
-                var allJumps = _jumpService.GetAllJumps();
+                Label = a.JumpType,
-                var results = new List<Statistic>();
+                Nb = a.Nb
-
+            })];
-                if (allJumps.Any())
-                {
-                    var lastJump = allJumps.OrderByDescending(j => j.JumpDate).First();
-                    var yearOfLastJump = lastJump.JumpDate.Year;
-                    var monthOfLastJump = lastJump.JumpDate.Month;
-
-                    results = allJumps.Where(j => j.JumpDate.Year == yearOfLastJump && j.JumpDate.Month == monthOfLastJump)
-                                      .GroupBy(j => j.JumpType.Name,
-                                               j => j,
-                                               (groupby, jumps) => new Statistic
-                                               {
-                                                   Label = groupby.ToString(),
-                                                   Nb = jumps.Count()
-                                               })
-                                      .ToList();
-                }
-
-                allStats.ForLastMonthByJumpType = results;
-                _userStatsRepository.Update(allStats);
-            }
-
-            return allStats.ForLastMonthByJumpType;
         }
 
         public IEnumerable<Statistic> GetStatsForLastYearByDz()
         {
-            var allStats = GetAllStats();
+            var tmp = _statsForLastYearByDzService.GetStats();
-            if (!allStats.ForLastYearByDz.Any())
+            return [.. tmp.Select(a => new Statistic
             {
-                var allJumps = _jumpService.GetAllJumps();
+                Label = a.DropZone,
-                var results = new List<Statistic>();
+                Nb = a.Nb
-
+            })];
-                if (allJumps.Any())
-                {
-                    var lastJump = allJumps.OrderByDescending(j => j.JumpDate).First();
-                    var yearOfLastJump = lastJump.JumpDate.Year;
-
-                    results = allJumps.Where(j => j.JumpDate.Year == yearOfLastJump)
-                                      .GroupBy(j => j.DropZone.Name,
-                                               j => j,
-                                               (groupby, jumps) => new Statistic
-                                               {
-                                                   Label = groupby.ToString(),
-                                                   Nb = jumps.Count()
-                                               })
-                                      .ToList();
-                }
-
-                allStats.ForLastYearByDz = results;
-                _userStatsRepository.Update(allStats);
-            }
-
-            return allStats.ForLastYearByDz;
         }
 
         public IEnumerable<Statistic> GetStatsForLastYearByJumpType()
         {
-            var allStats = GetAllStats();
+            var tmp = _statsForLastYearByJumpTypeService.GetStats();
-            if (!allStats.ForLastYearByJumpType.Any())
+            return [.. tmp.Select(a => new Statistic
             {
-                var allJumps = _jumpService.GetAllJumps();
+                Label = a.JumpType,
-                var results = new List<Statistic>();
+                Nb = a.Nb
-
+            })];
-                if (allJumps.Any())
-                {
-                    var lastJump = allJumps.OrderByDescending(j => j.JumpDate).First();
-                    var yearOfLastJump = lastJump.JumpDate.Year;
-
-                    results = allJumps.Where(j => j.JumpDate.Year == yearOfLastJump)
-                                      .GroupBy(j => j.JumpType.Name,
-                                               j => j,
-                                               (groupby, jumps) => new Statistic
-                                               {
-                                                   Label = groupby.ToString(),
-                                                   Nb = jumps.Count()
-                                               })
-                                      .ToList();
-                }
-
-                allStats.ForLastYearByJumpType = results;
-                _userStatsRepository.Update(allStats);
-            }
-
-            return allStats.ForLastYearByJumpType;
         }
 
         public IEnumerable<Statistic> GetStatsByYearByJumpType()
         {
-            var allStats = GetAllStats();
+            var tmp = _statsByYearByJumpTypeService.GetStats();
-            if (!allStats.ByYearByJumpType.Any())
+            return [.. tmp.Select(a => new Statistic
             {
-                var allJumps = _jumpService.GetAllJumps();
+                Label = a.Year,
-                var results = new List<Statistic>();
+                Label2 = a.JumpType,
-
+                Nb = a.Nb
-                if (allJumps.Any())
+            })];
-                {
-                    results = allJumps.GroupBy(j => new { j.JumpType.Name, j.JumpDate.Year },
-                                               j => j,
-                                               (groupby, jumps) => new Statistic
-                                               {
-                                                   Label = groupby.Year.ToString(),
-                                                   Label2 = groupby.Name.ToString(),
-                                                   Nb = jumps.Count()
-                                               })
-                                      .ToList();
-                }
-
-                allStats.ByYearByJumpType = results;
-                _userStatsRepository.Update(allStats);
-            }
-
-            return allStats.ByYearByJumpType;
-        }
-
-        public void Reset()
-        {
-            var resetStats = new UserStats();
-            var myStats = GetAllStats();
-            myStats.ByAircraft = resetStats.ByAircraft;
-            myStats.ByDz = resetStats.ByDz;
-            myStats.ByGear = resetStats.ByGear;
-            myStats.ByJumpType = resetStats.ByJumpType;
-            myStats.ByYear = resetStats.ByYear;
-            myStats.ForLastMonthByDz = resetStats.ForLastMonthByDz;
-            myStats.ForLastMonthByJumpType = resetStats.ForLastMonthByJumpType;
-            myStats.ForLastYearByDz = resetStats.ForLastYearByDz;
-            myStats.ForLastYearByJumpType = resetStats.ForLastYearByJumpType;
-            myStats.ByYearByJumpType = resetStats.ByYearByJumpType;
-
-            _userStatsRepository.Update(myStats);
         }
 
         #endregion Public Methods
 
-        #region Private Methods
-
-        private UserStats GetAllStats()
-        {
-            var allStats = _userStatsRepository.GetAll(_identityService.ConnectedUser);
-            if (allStats == null)
-            {
-                allStats = new UserStats
-                {
-                    User = _identityService.ConnectedUser
-                };
-                _userStatsRepository.Add(allStats);
-            }
-
-            return allStats;
-        }
-
-        #endregion Private Methods
-
         #region Private Fields
 
-        private readonly IIdentityService _identityService;
         private readonly IJumpService _jumpService;
-        private readonly IUserStatsRepository _userStatsRepository;
+        private readonly IStatsByAircraftService _statsByAircraftService;
+        private readonly IStatsByDzService _statsByDzService;
+        private readonly IStatsByGearService _statsByGearService;
+        private readonly IStatsByJumpTypeService _statsByJumpTypeService;
+        private readonly IStatsByYearByJumpTypeService _statsByYearByJumpTypeService;
+        private readonly IStatsByYearService _statsByYearService;
+        private readonly IStatsForLastMonthByDzService _statsForLastMonthByDzService;
+        private readonly IStatsForLastMonthByJumpTypeService _statsForLastMonthByJumpTypeService;
+        private readonly IStatsForLastYearByDzService _statsForLastYearByDzService;
+        private readonly IStatsForLastYearByJumpTypeService _statsForLastYearByJumpTypeService;
 
         #endregion Private Fields
     }

Back/skydiveLogs-api.DomainService/Repositories/IStatsByAircraftRepository.cs

@@ -0,0 +1,8 @@
+using skydiveLogs_api.Domain;
+
+namespace skydiveLogs_api.DomainService.Repositories
+{
+    public interface IStatsByAircraftRepository : IStatsRepository<StatsByAircraft>
+    {
+    }
+}

Back/skydiveLogs-api.DomainService/Repositories/IStatsByDzRepository.cs

@@ -0,0 +1,8 @@
+using skydiveLogs_api.Domain;
+
+namespace skydiveLogs_api.DomainService.Repositories
+{
+    public interface IStatsByDzRepository : IStatsRepository<StatsByDz>
+    {
+    }
+}

Back/skydiveLogs-api.DomainService/Repositories/IStatsByGearRepository.cs

@@ -0,0 +1,8 @@
+using skydiveLogs_api.Domain;
+
+namespace skydiveLogs_api.DomainService.Repositories
+{
+    public interface IStatsByGearRepository : IStatsRepository<StatsByGear>
+    {
+    }
+}

Back/skydiveLogs-api.DomainService/Repositories/IStatsByJumpTypeRepository.cs

@@ -0,0 +1,8 @@
+using skydiveLogs_api.Domain;
+
+namespace skydiveLogs_api.DomainService.Repositories
+{
+    public interface IStatsByJumpTypeRepository : IStatsRepository<StatsByJumpType>
+    {
+    }
+}

Back/skydiveLogs-api.DomainService/Repositories/IStatsByYearByJumpTypeRepository.cs

@@ -0,0 +1,8 @@
+using skydiveLogs_api.Domain;
+
+namespace skydiveLogs_api.DomainService.Repositories
+{
+    public interface IStatsByYearByJumpTypeRepository : IStatsRepository<StatsByYearByJumpType>
+    {
+    }
+}

Back/skydiveLogs-api.DomainService/Repositories/IStatsByYearRepository.cs

@@ -0,0 +1,8 @@
+using skydiveLogs_api.Domain;
+
+namespace skydiveLogs_api.DomainService.Repositories
+{
+    public interface IStatsByYearRepository : IStatsRepository<StatsByYear>
+    {
+    }
+}

Back/skydiveLogs-api.DomainService/Repositories/IStatsForLastMonthByDzRepository.cs

@@ -0,0 +1,8 @@
+using skydiveLogs_api.Domain;
+
+namespace skydiveLogs_api.DomainService.Repositories
+{
+    public interface IStatsForLastMonthByDzRepository : IStatsRepository<StatsForLastMonthByDz>
+    {
+    }
+}

Back/skydiveLogs-api.DomainService/Repositories/IStatsForLastMonthByJumpTypeRepository.cs

@@ -0,0 +1,8 @@
+using skydiveLogs_api.Domain;
+
+namespace skydiveLogs_api.DomainService.Repositories
+{
+    public interface IStatsForLastMonthByJumpTypeRepository : IStatsRepository<StatsForLastMonthByJumpType>
+    {
+    }
+}

Back/skydiveLogs-api.DomainService/Repositories/IStatsForLastYearByDzRepository.cs

@@ -0,0 +1,8 @@
+using skydiveLogs_api.Domain;
+
+namespace skydiveLogs_api.DomainService.Repositories
+{
+    public interface IStatsForLastYearByDzRepository : IStatsRepository<StatsForLastYearByDz>
+    {
+    }
+}

Back/skydiveLogs-api.DomainService/Repositories/IStatsForLastYearByJumpTypeRepository.cs

@@ -0,0 +1,8 @@
+using skydiveLogs_api.Domain;
+
+namespace skydiveLogs_api.DomainService.Repositories
+{
+    public interface IStatsForLastYearByJumpTypeRepository : IStatsRepository<StatsForLastYearByJumpType>
+    {
+    }
+}

Back/skydiveLogs-api.DomainService/Repositories/IStatsRepository.cs

@@ -0,0 +1,20 @@
+using skydiveLogs_api.Domain;
+using System.Collections.Generic;
+
+namespace skydiveLogs_api.DomainService.Repositories
+{
+    public interface IStatsRepository<T>
+    {
+        #region Public Methods
+
+        IEnumerable<T> GetAll(User user);
+
+        int Add(IEnumerable<T> newEntity);
+
+        bool Update(IEnumerable<T> updatedEntity, User user);
+
+        bool Delete(User user);
+
+        #endregion Public Methods
+    }
+}

Back/skydiveLogs-api.DomainService/Repositories/IUserStatsRepository.cs

@@ -1,13 +0,0 @@
-using skydiveLogs_api.Domain;
-
-namespace skydiveLogs_api.DomainService.Repositories
-{
-    public interface IUserStatsRepository : IRepository<UserStats>
-    {
-        #region Public Methods
-
-        UserStats GetAll(User user);
-
-        #endregion Public Methods
-    }
-}

Back/skydiveLogs-api.Infrastructure/Interfaces/IDataProvider.cs

@@ -30,12 +30,30 @@ namespace skydiveLogs_api.Infrastructure.Interfaces
 
         ILiteCollection<JumpType> CollOfJumpType { get; }
 
-        ILiteCollection<UserStats> CollOfStats { get; }
-
         ILiteCollection<User> CollOfUser { get; }
-        
+
         ILiteCollection<TunnelFlight> CollOfTunnelFlight { get; }
 
+        ILiteCollection<StatsByAircraft> CollOfStatsByAircraft { get; }
+
+        ILiteCollection<StatsByDz> CollOfStatsByDz { get; }
+
+        ILiteCollection<StatsByGear> CollOfStatsByGear { get; }
+
+        ILiteCollection<StatsByJumpType> CollOfStatsByJumpType { get; }
+
+        ILiteCollection<StatsByYear> CollOfStatsByYear { get; }
+
+        ILiteCollection<StatsForLastMonthByDz> CollOfStatsForLastMonthByDz { get; }
+
+        ILiteCollection<StatsForLastMonthByJumpType> CollOfStatsForLastMonthByJumpType { get; }
+
+        ILiteCollection<StatsForLastYearByDz> CollOfStatsForLastYearByDz { get; }
+
+        ILiteCollection<StatsForLastYearByJumpType> CollOfStatsForLastYearByJumpType { get; }
+
+        ILiteCollection<StatsByYearByJumpType> CollOfStatsByYearByJumpType { get; }
+
         #endregion Public Properties
     }
 }

Back/skydiveLogs-api.Infrastructure/LiteDbProvider.cs

@@ -21,8 +21,6 @@ namespace skydiveLogs_api.Infrastructure
 
             BsonMapper.Global.Entity<UserImage>().DbRef(x => x.User, "User");
 
-            BsonMapper.Global.Entity<UserStats>().DbRef(x => x.User, "User");
-
             BsonMapper.Global.Entity<Gear>().DbRef(x => x.User, "User");
 
             BsonMapper.Global.Entity<FavoriteDropZone>().DbRef(x => x.User, "User");
@@ -31,6 +29,17 @@ namespace skydiveLogs_api.Infrastructure
             BsonMapper.Global.Entity<TunnelFlight>().DbRef(x => x.Tunnel, "DropZone");
             BsonMapper.Global.Entity<TunnelFlight>().DbRef(x => x.JumpType, "JumpType");
             BsonMapper.Global.Entity<TunnelFlight>().DbRef(x => x.User, "User");
+
+            BsonMapper.Global.Entity<StatsByAircraft>().DbRef(x => x.User, "User");
+            BsonMapper.Global.Entity<StatsByDz>().DbRef(x => x.User, "User");
+            BsonMapper.Global.Entity<StatsByGear>().DbRef(x => x.User, "User");
+            BsonMapper.Global.Entity<StatsByJumpType>().DbRef(x => x.User, "User");
+            BsonMapper.Global.Entity<StatsByYear>().DbRef(x => x.User, "User");
+            BsonMapper.Global.Entity<StatsForLastMonthByDz>().DbRef(x => x.User, "User");
+            BsonMapper.Global.Entity<StatsForLastMonthByJumpType>().DbRef(x => x.User, "User");
+            BsonMapper.Global.Entity<StatsForLastYearByDz>().DbRef(x => x.User, "User");
+            BsonMapper.Global.Entity<StatsForLastYearByJumpType>().DbRef(x => x.User, "User");
+            BsonMapper.Global.Entity<StatsByYearByJumpType>().DbRef(x => x.User, "User");
         }
 
         #endregion Public Constructors
@@ -58,10 +67,18 @@ namespace skydiveLogs_api.Infrastructure
         public ILiteCollection<UserImage> CollOfImage => _db.GetCollection<UserImage>();
         public ILiteCollection<Jump> CollOfJump => _db.GetCollection<Jump>();
         public ILiteCollection<JumpType> CollOfJumpType => _db.GetCollection<JumpType>();
-        public ILiteCollection<UserStats> CollOfStats => _db.GetCollection<UserStats>();
         public ILiteCollection<User> CollOfUser => _db.GetCollection<User>();
         public ILiteCollection<TunnelFlight> CollOfTunnelFlight => _db.GetCollection<TunnelFlight>();
-
+        public ILiteCollection<StatsByAircraft> CollOfStatsByAircraft => _db.GetCollection<StatsByAircraft>();
+        public ILiteCollection<StatsByDz> CollOfStatsByDz => _db.GetCollection<StatsByDz>();
+        public ILiteCollection<StatsByGear> CollOfStatsByGear => _db.GetCollection<StatsByGear>();
+        public ILiteCollection<StatsByJumpType> CollOfStatsByJumpType => _db.GetCollection<StatsByJumpType>();
+        public ILiteCollection<StatsByYear> CollOfStatsByYear => _db.GetCollection<StatsByYear>();
+        public ILiteCollection<StatsForLastMonthByDz> CollOfStatsForLastMonthByDz => _db.GetCollection<StatsForLastMonthByDz>();
+        public ILiteCollection<StatsForLastMonthByJumpType> CollOfStatsForLastMonthByJumpType => _db.GetCollection<StatsForLastMonthByJumpType>();
+        public ILiteCollection<StatsForLastYearByDz> CollOfStatsForLastYearByDz => _db.GetCollection<StatsForLastYearByDz>();
+        public ILiteCollection<StatsForLastYearByJumpType> CollOfStatsForLastYearByJumpType => _db.GetCollection<StatsForLastYearByJumpType>();
+        public ILiteCollection<StatsByYearByJumpType> CollOfStatsByYearByJumpType => _db.GetCollection<StatsByYearByJumpType>();
         #endregion Public Properties
 
         #region Private Fields

Back/skydiveLogs-api.Infrastructure/StatsByAircraftRepository.cs

@@ -0,0 +1,74 @@
+using LiteDB;
+using skydiveLogs_api.Domain;
+using skydiveLogs_api.DomainService.Repositories;
+using skydiveLogs_api.Infrastructure.Interfaces;
+using System.Collections.Generic;
+
+namespace skydiveLogs_api.Infrastructure
+{
+    public class StatsByAircraftRepository : IStatsByAircraftRepository
+    {
+        #region Public Constructors
+
+        public StatsByAircraftRepository(IDataProvider dataProvider)
+        {
+            _dataProvider = dataProvider;
+            _col = _dataProvider.CollOfStatsByAircraft;
+        }
+
+        #endregion Public Constructors
+
+        #region Public Methods
+
+        public int Add(IEnumerable<StatsByAircraft> newStats)
+        {
+            int result = 0;
+
+            try
+            {
+                foreach (var newStat in newStats)
+                {
+                    var tmp = _col.Insert(newStats);
+                    result = tmp;
+                }
+            }
+            catch
+            {
+                result = 0;
+            }
+
+            return result;
+        }
+
+        public IEnumerable<StatsByAircraft> GetAll(User user)
+        {
+            return _col.Include(x => x.User)
+                       .Query()
+                       .Where(j => j.User.Id == user.Id)
+                       .ToList();
+        }
+
+        public bool Update(IEnumerable<StatsByAircraft> updatedStats, User user)
+        {
+            Delete(user);
+            var tmp = Add(updatedStats);
+
+            return tmp != 0;
+        }
+
+        public bool Delete(User user)
+        {
+            var tmp = _col.DeleteMany(s => s.User.Id == user.Id);
+            return tmp != 0;
+        }
+
+        #endregion Public Methods
+
+        #region Private Fields
+
+        private readonly ILiteCollection<StatsByAircraft> _col;
+        private readonly IDataProvider _dataProvider;
+
+        #endregion Private Fields
+    }
+}

Back/skydiveLogs-api.Infrastructure/StatsByDzRepository.cs

@@ -1,4 +1,4 @@
-using LiteDB;
+using LiteDB;
 using skydiveLogs_api.Domain;
 using skydiveLogs_api.DomainService.Repositories;
 using skydiveLogs_api.Infrastructure.Interfaces;
@@ -6,28 +6,31 @@ using System.Collections.Generic;
 
 namespace skydiveLogs_api.Infrastructure
 {
-    public class UserStatsRepository : IUserStatsRepository
+    public class StatsByDzRepository : IStatsByDzRepository
     {
         #region Public Constructors
 
-        public UserStatsRepository(IDataProvider dataProvider)
+        public StatsByDzRepository(IDataProvider dataProvider)
         {
             _dataProvider = dataProvider;
-            _col = _dataProvider.CollOfStats;
+            _col = _dataProvider.CollOfStatsByDz;
         }
 
         #endregion Public Constructors
 
         #region Public Methods
 
-        public int Add(UserStats newStats)
+        public int Add(IEnumerable<StatsByDz> newStats)
         {
-            int result;
+            int result = 0;
 
             try
             {
-                var tmp = _col.Insert(newStats);
+                foreach (var newStat in newStats)
-                result = tmp.AsInt32;
+                {
+                    var tmp = _col.Insert(newStats);
+                    result = tmp;
+                }
             }
             catch
             {
@@ -37,39 +40,33 @@ namespace skydiveLogs_api.Infrastructure
             return result;
         }
 
-        public IEnumerable<UserStats> GetAll()
+        public IEnumerable<StatsByDz> GetAll(User user)
-        {
-            throw new System.NotImplementedException();
-        }
-
-        public UserStats GetAll(User user)
         {
             return _col.Include(x => x.User)
                        .Query()
                        .Where(j => j.User.Id == user.Id)
-                       .SingleOrDefault();
+                       .ToList();
         }
 
-        public UserStats GetById(int id)
+        public bool Update(IEnumerable<StatsByDz> updatedStats, User user)
         {
-            throw new System.NotImplementedException();
+            Delete(user);
+            var tmp = Add(updatedStats);
+
+            return tmp != 0;
         }
 
-        public int GetCount()
+        public bool Delete(User user)
         {
-            throw new System.NotImplementedException();
+            var tmp = _col.DeleteMany(s => s.User.Id == user.Id);
-        }
+            return tmp != 0;
-
-        public bool Update(UserStats stats)
-        {
-            return _col.Update(stats);
         }
 
         #endregion Public Methods
 
         #region Private Fields
 
-        private readonly ILiteCollection<UserStats> _col;
+        private readonly ILiteCollection<StatsByDz> _col;
         private readonly IDataProvider _dataProvider;
 
         #endregion Private Fields

Back/skydiveLogs-api.Infrastructure/StatsByGearRepository.cs

@@ -0,0 +1,74 @@
+using LiteDB;
+using skydiveLogs_api.Domain;
+using skydiveLogs_api.DomainService.Repositories;
+using skydiveLogs_api.Infrastructure.Interfaces;
+using System.Collections.Generic;
+
+namespace skydiveLogs_api.Infrastructure
+{
+    public class StatsByGearRepository : IStatsByGearRepository
+    {
+        #region Public Constructors
+
+        public StatsByGearRepository(IDataProvider dataProvider)
+        {
+            _dataProvider = dataProvider;
+            _col = _dataProvider.CollOfStatsByGear;
+        }
+
+        #endregion Public Constructors
+
+        #region Public Methods
+
+        public int Add(IEnumerable<StatsByGear> newStats)
+        {
+            int result = 0;
+
+            try
+            {
+                foreach (var newStat in newStats)
+                {
+                    var tmp = _col.Insert(newStats);
+                    result = tmp;
+                }
+            }
+            catch
+            {
+                result = 0;
+            }
+
+            return result;
+        }
+
+        public IEnumerable<StatsByGear> GetAll(User user)
+        {
+            return _col.Include(x => x.User)
+                       .Query()
+                       .Where(j => j.User.Id == user.Id)
+                       .ToList();
+        }
+
+        public bool Update(IEnumerable<StatsByGear> updatedStats, User user)
+        {
+            Delete(user);
+            var tmp = Add(updatedStats);
+
+            return tmp != 0;
+        }
+
+        public bool Delete(User user)
+        {
+            var tmp = _col.DeleteMany(s => s.User.Id == user.Id);
+            return tmp != 0;
+        }
+
+        #endregion Public Methods
+
+        #region Private Fields
+
+        private readonly ILiteCollection<StatsByGear> _col;
+        private readonly IDataProvider _dataProvider;
+
+        #endregion Private Fields
+    }
+}

Back/skydiveLogs-api.Infrastructure/StatsByJumpTypeRepository.cs

@@ -0,0 +1,74 @@
+using LiteDB;
+using skydiveLogs_api.Domain;
+using skydiveLogs_api.DomainService.Repositories;
+using skydiveLogs_api.Infrastructure.Interfaces;
+using System.Collections.Generic;
+
+namespace skydiveLogs_api.Infrastructure
+{
+    public class StatsByJumpTypeRepository : IStatsByJumpTypeRepository
+    {
+        #region Public Constructors
+
+        public StatsByJumpTypeRepository(IDataProvider dataProvider)
+        {
+            _dataProvider = dataProvider;
+            _col = _dataProvider.CollOfStatsByJumpType;
+        }
+
+        #endregion Public Constructors
+
+        #region Public Methods
+
+        public int Add(IEnumerable<StatsByJumpType> newStats)
+        {
+            int result = 0;
+
+            try
+            {
+                foreach (var newStat in newStats)
+                {
+                    var tmp = _col.Insert(newStats);
+                    result = tmp;
+                }
+            }
+            catch
+            {
+                result = 0;
+            }
+
+            return result;
+        }
+
+        public IEnumerable<StatsByJumpType> GetAll(User user)
+        {
+            return _col.Include(x => x.User)
+                       .Query()
+                       .Where(j => j.User.Id == user.Id)
+                       .ToList();
+        }
+
+        public bool Update(IEnumerable<StatsByJumpType> updatedStats, User user)
+        {
+            Delete(user);
+            var tmp = Add(updatedStats);
+
+            return tmp != 0;
+        }
+
+        public bool Delete(User user)
+        {
+            var tmp = _col.DeleteMany(s => s.User.Id == user.Id);
+            return tmp != 0;
+        }
+
+        #endregion Public Methods
+
+        #region Private Fields
+
+        private readonly ILiteCollection<StatsByJumpType> _col;
+        private readonly IDataProvider _dataProvider;
+
+        #endregion Private Fields
+    }
+}

Back/skydiveLogs-api.Infrastructure/StatsByYearByJumpTypeRepository.cs

@@ -0,0 +1,74 @@
+using LiteDB;
+using skydiveLogs_api.Domain;
+using skydiveLogs_api.DomainService.Repositories;
+using skydiveLogs_api.Infrastructure.Interfaces;
+using System.Collections.Generic;
+
+namespace skydiveLogs_api.Infrastructure
+{
+    public class StatsByYearByJumpTypeRepository : IStatsByYearByJumpTypeRepository
+    {
+        #region Public Constructors
+
+        public StatsByYearByJumpTypeRepository(IDataProvider dataProvider)
+        {
+            _dataProvider = dataProvider;
+            _col = _dataProvider.CollOfStatsByYearByJumpType;
+        }
+
+        #endregion Public Constructors
+
+        #region Public Methods
+
+        public int Add(IEnumerable<StatsByYearByJumpType> newStats)
+        {
+            int result = 0;
+
+            try
+            {
+                foreach (var newStat in newStats)
+                {
+                    var tmp = _col.Insert(newStats);
+                    result = tmp;
+                }
+            }
+            catch
+            {
+                result = 0;
+            }
+
+            return result;
+        }
+
+        public IEnumerable<StatsByYearByJumpType> GetAll(User user)
+        {
+            return _col.Include(x => x.User)
+                       .Query()
+                       .Where(j => j.User.Id == user.Id)
+                       .ToList();
+        }
+
+        public bool Update(IEnumerable<StatsByYearByJumpType> updatedStats, User user)
+        {
+            Delete(user);
+            var tmp = Add(updatedStats);
+
+            return tmp != 0;
+        }
+
+        public bool Delete(User user)
+        {
+            var tmp = _col.DeleteMany(s => s.User.Id == user.Id);
+            return tmp != 0;
+        }
+
+        #endregion Public Methods
+
+        #region Private Fields
+
+        private readonly ILiteCollection<StatsByYearByJumpType> _col;
+        private readonly IDataProvider _dataProvider;
+
+        #endregion Private Fields
+    }
+}

Back/skydiveLogs-api.Infrastructure/StatsByYearRepository.cs

@@ -0,0 +1,74 @@
+using System.Collections.Generic;
+using LiteDB;
+using skydiveLogs_api.Domain;
+using skydiveLogs_api.DomainService.Repositories;
+using skydiveLogs_api.Infrastructure.Interfaces;
+
+namespace skydiveLogs_api.Infrastructure
+{
+    public class StatsByYearRepository : IStatsByYearRepository
+    {
+        #region Public Constructors
+
+        public StatsByYearRepository(IDataProvider dataProvider)
+        {
+            _dataProvider = dataProvider;
+            _col = _dataProvider.CollOfStatsByYear;
+        }
+
+        #endregion Public Constructors
+
+        #region Public Methods
+
+        public int Add(IEnumerable<StatsByYear> newStats)
+        {
+            int result = 0;
+
+            try
+            {
+                foreach (var newStat in newStats)
+                {
+                    var tmp = _col.Insert(newStats);
+                    result = tmp;
+                }
+            }
+            catch
+            {
+                result = 0;
+            }
+
+            return result;
+        }
+
+        public IEnumerable<StatsByYear> GetAll(User user)
+        {
+            return _col.Include(x => x.User)
+                       .Query()
+                       .Where(j => j.User.Id == user.Id)
+                       .ToList();
+        }
+
+        public bool Update(IEnumerable<StatsByYear> updatedStats, User user)
+        {
+            Delete(user);
+            var tmp = Add(updatedStats);
+
+            return tmp != 0;
+        }
+
+        public bool Delete(User user)
+        {
+            var tmp = _col.DeleteMany(s => s.User.Id == user.Id);
+            return tmp != 0;
+        }
+
+        #endregion Public Methods
+
+        #region Private Fields
+
+        private readonly ILiteCollection<StatsByYear> _col;
+        private readonly IDataProvider _dataProvider;
+
+        #endregion Private Fields
+    }
+}

Back/skydiveLogs-api.Infrastructure/StatsForLastMonthByDzRepository.cs

@@ -0,0 +1,74 @@
+using LiteDB;
+using skydiveLogs_api.Domain;
+using skydiveLogs_api.DomainService.Repositories;
+using skydiveLogs_api.Infrastructure.Interfaces;
+using System.Collections.Generic;
+
+namespace skydiveLogs_api.Infrastructure
+{
+    public class StatsForLastMonthByDzRepository : IStatsForLastMonthByDzRepository
+    {
+        #region Public Constructors
+
+        public StatsForLastMonthByDzRepository(IDataProvider dataProvider)
+        {
+            _dataProvider = dataProvider;
+            _col = _dataProvider.CollOfStatsForLastMonthByDz;
+        }
+
+        #endregion Public Constructors
+
+        #region Public Methods
+
+        public int Add(IEnumerable<StatsForLastMonthByDz> newStats)
+        {
+            int result = 0;
+
+            try
+            {
+                foreach (var newStat in newStats)
+                {
+                    var tmp = _col.Insert(newStats);
+                    result = tmp;
+                }
+            }
+            catch
+            {
+                result = 0;
+            }
+
+            return result;
+        }
+
+        public IEnumerable<StatsForLastMonthByDz> GetAll(User user)
+        {
+            return _col.Include(x => x.User)
+                       .Query()
+                       .Where(j => j.User.Id == user.Id)
+                       .ToList();
+        }
+
+        public bool Update(IEnumerable<StatsForLastMonthByDz> updatedStats, User user)
+        {
+            Delete(user);
+            var tmp = Add(updatedStats);
+
+            return tmp != 0;
+        }
+
+        public bool Delete(User user)
+        {
+            var tmp = _col.DeleteMany(s => s.User.Id == user.Id);
+            return tmp != 0;
+        }
+
+        #endregion Public Methods
+
+        #region Private Fields
+
+        private readonly ILiteCollection<StatsForLastMonthByDz> _col;
+        private readonly IDataProvider _dataProvider;
+
+        #endregion Private Fields
+    }
+}

Back/skydiveLogs-api.Infrastructure/StatsForLastMonthByJumpTypeRepository.cs

@@ -0,0 +1,74 @@
+using LiteDB;
+using skydiveLogs_api.Domain;
+using skydiveLogs_api.DomainService.Repositories;
+using skydiveLogs_api.Infrastructure.Interfaces;
+using System.Collections.Generic;
+
+namespace skydiveLogs_api.Infrastructure
+{
+    public class StatsForLastMonthByJumpTypeRepository : IStatsForLastMonthByJumpTypeRepository
+    {
+        #region Public Constructors
+
+        public StatsForLastMonthByJumpTypeRepository(IDataProvider dataProvider)
+        {
+            _dataProvider = dataProvider;
+            _col = _dataProvider.CollOfStatsForLastMonthByJumpType;
+        }
+
+        #endregion Public Constructors
+
+        #region Public Methods
+
+        public int Add(IEnumerable<StatsForLastMonthByJumpType> newStats)
+        {
+            int result = 0;
+
+            try
+            {
+                foreach (var newStat in newStats)
+                {
+                    var tmp = _col.Insert(newStats);
+                    result = tmp;
+                }
+            }
+            catch
+            {
+                result = 0;
+            }
+
+            return result;
+        }
+
+        public IEnumerable<StatsForLastMonthByJumpType> GetAll(User user)
+        {
+            return _col.Include(x => x.User)
+                       .Query()
+                       .Where(j => j.User.Id == user.Id)
+                       .ToList();
+        }
+
+        public bool Update(IEnumerable<StatsForLastMonthByJumpType> updatedStats, User user)
+        {
+            Delete(user);
+            var tmp = Add(updatedStats);
+
+            return tmp != 0;
+        }
+
+        public bool Delete(User user)
+        {
+            var tmp = _col.DeleteMany(s => s.User.Id == user.Id);
+            return tmp != 0;
+        }
+
+        #endregion Public Methods
+
+        #region Private Fields
+
+        private readonly ILiteCollection<StatsForLastMonthByJumpType> _col;
+        private readonly IDataProvider _dataProvider;
+
+        #endregion Private Fields
+    }
+}

Back/skydiveLogs-api.Infrastructure/StatsForLastYearByDzRepository.cs

@@ -0,0 +1,74 @@
+using LiteDB;
+using skydiveLogs_api.Domain;
+using skydiveLogs_api.DomainService.Repositories;
+using skydiveLogs_api.Infrastructure.Interfaces;
+using System.Collections.Generic;
+
+namespace skydiveLogs_api.Infrastructure
+{
+    public class StatsForLastYearByDzRepository : IStatsForLastYearByDzRepository
+    {
+        #region Public Constructors
+
+        public StatsForLastYearByDzRepository(IDataProvider dataProvider)
+        {
+            _dataProvider = dataProvider;
+            _col = _dataProvider.CollOfStatsForLastYearByDz;
+        }
+
+        #endregion Public Constructors
+
+        #region Public Methods
+
+        public int Add(IEnumerable<StatsForLastYearByDz> newStats)
+        {
+            int result = 0;
+
+            try
+            {
+                foreach (var newStat in newStats)
+                {
+                    var tmp = _col.Insert(newStats);
+                    result = tmp;
+                }
+            }
+            catch
+            {
+                result = 0;
+            }
+
+            return result;
+        }
+
+        public IEnumerable<StatsForLastYearByDz> GetAll(User user)
+        {
+            return _col.Include(x => x.User)
+                       .Query()
+                       .Where(j => j.User.Id == user.Id)
+                       .ToList();
+        }
+
+        public bool Update(IEnumerable<StatsForLastYearByDz> updatedStats, User user)
+        {
+            Delete(user);
+            var tmp = Add(updatedStats);
+
+            return tmp != 0;
+        }
+
+        public bool Delete(User user)
+        {
+            var tmp = _col.DeleteMany(s => s.User.Id == user.Id);
+            return tmp != 0;
+        }
+
+        #endregion Public Methods
+
+        #region Private Fields
+
+        private readonly ILiteCollection<StatsForLastYearByDz> _col;
+        private readonly IDataProvider _dataProvider;
+
+        #endregion Private Fields
+    }
+}

Back/skydiveLogs-api.Infrastructure/StatsForLastYearByJumpTypeRepository.cs

@@ -0,0 +1,74 @@
+using LiteDB;
+using skydiveLogs_api.Domain;
+using skydiveLogs_api.DomainService.Repositories;
+using skydiveLogs_api.Infrastructure.Interfaces;
+using System.Collections.Generic;
+
+namespace skydiveLogs_api.Infrastructure
+{
+    public class StatsForLastYearByJumpTypeRepository : IStatsForLastYearByJumpTypeRepository
+    {
+        #region Public Constructors
+
+        public StatsForLastYearByJumpTypeRepository(IDataProvider dataProvider)
+        {
+            _dataProvider = dataProvider;
+            _col = _dataProvider.CollOfStatsForLastYearByJumpType;
+        }
+
+        #endregion Public Constructors
+
+        #region Public Methods
+
+        public int Add(IEnumerable<StatsForLastYearByJumpType> newStats)
+        {
+            int result = 0;
+
+            try
+            {
+                foreach (var newStat in newStats)
+                {
+                    var tmp = _col.Insert(newStats);
+                    result = tmp;
+                }
+            }
+            catch
+            {
+                result = 0;
+            }
+
+            return result;
+        }
+
+        public IEnumerable<StatsForLastYearByJumpType> GetAll(User user)
+        {
+            return _col.Include(x => x.User)
+                       .Query()
+                       .Where(j => j.User.Id == user.Id)
+                       .ToList();
+        }
+
+        public bool Update(IEnumerable<StatsForLastYearByJumpType> updatedStats, User user)
+        {
+            Delete(user);
+            var tmp = Add(updatedStats);
+
+            return tmp != 0;
+        }
+
+        public bool Delete(User user)
+        {
+            var tmp = _col.DeleteMany(s => s.User.Id == user.Id);
+            return tmp != 0;
+        }
+
+        #endregion Public Methods
+
+        #region Private Fields
+
+        private readonly ILiteCollection<StatsForLastYearByJumpType> _col;
+        private readonly IDataProvider _dataProvider;
+
+        #endregion Private Fields
+    }
+}

Back/skydiveLogs-api.Ioc/IocService.cs

@@ -32,13 +32,24 @@ namespace skydiveLogs_api.Ioc
             _services.AddScoped<IDropZoneService, DropZoneService>();
             _services.AddScoped<IJumpService, JumpService>();
             _services.AddScoped<IJumpTypeService, JumpTypeService>();
-            _services.AddScoped<IStatsService, StatsService>();
             _services.AddScoped<IUserService, UserService>();
             _services.AddScoped<IUserImageService, UserImageService>();
             _services.AddScoped<IInitDbService, InitDbService>();
             _services.AddScoped<ITunnelService, TunnelService>();
             _services.AddScoped<ITunnelFlightService, TunnelFlightService>();
 
+            _services.AddScoped<IStatsService, StatsService>();
+            _services.AddScoped<IStatsByAircraftService, StatsByAircraftService>();
+            _services.AddScoped<IStatsByDzService, StatsByDzService>();
+            _services.AddScoped<IStatsByGearService, StatsByGearService>();
+            _services.AddScoped<IStatsByJumpTypeService, StatsByJumpTypeService>();
+            _services.AddScoped<IStatsByYearByJumpTypeService, StatsByYearByJumpTypeService>();
+            _services.AddScoped<IStatsByYearService, StatsByYearService>();
+            _services.AddScoped<IStatsForLastMonthByDzService, StatsForLastMonthByDzService>();
+            _services.AddScoped<IStatsForLastMonthByJumpTypeService, StatsForLastMonthByJumpTypeService>();
+            _services.AddScoped<IStatsForLastYearByDzService, StatsForLastYearByDzService>();
+            _services.AddScoped<IStatsForLastYearByJumpTypeService, StatsForLastYearByJumpTypeService>();
+
             _services.AddSingleton<ICacheService, CacheService>();
             _services.AddScoped<IIdentityService, IdentityService>();
 
@@ -52,9 +63,19 @@ namespace skydiveLogs_api.Ioc
             _services.AddScoped<IUserRepository, UserRepository>();
             _services.AddScoped<IUserImageRepository, UserImageRepository>();
             _services.AddScoped<IFavoriteDropZoneRepository, FavoriteDropZoneRepository>();
-            _services.AddScoped<IUserStatsRepository, UserStatsRepository>();
             _services.AddScoped<ITunnelFlightRepository, TunnelFlightRepository>();
 
+            _services.AddScoped<IStatsByAircraftRepository, StatsByAircraftRepository>();
+            _services.AddScoped<IStatsByDzRepository, StatsByDzRepository>();
+            _services.AddScoped<IStatsByGearRepository, StatsByGearRepository>();
+            _services.AddScoped<IStatsByJumpTypeRepository, StatsByJumpTypeRepository>();
+            _services.AddScoped<IStatsByYearByJumpTypeRepository, StatsByYearByJumpTypeRepository>();
+            _services.AddScoped<IStatsByYearRepository, StatsByYearRepository>();
+            _services.AddScoped<IStatsForLastMonthByDzRepository, StatsForLastMonthByDzRepository>();
+            _services.AddScoped<IStatsForLastMonthByJumpTypeRepository, StatsForLastMonthByJumpTypeRepository>();
+            _services.AddScoped<IStatsForLastYearByDzRepository, StatsForLastYearByDzRepository>();
+            _services.AddScoped<IStatsForLastYearByJumpTypeRepository, StatsForLastYearByJumpTypeRepository>();
+
             string connectionString = _configuration.GetConnectionString("DefaultConnection");
             _services.AddSingleton<IDataProvider>(c => new LiteDbProvider(connectionString));
         }

Front/skydivelogs-app/src/app/summary/summary.component.ts

@@ -193,7 +193,7 @@ export class SummaryComponent implements OnInit {
             let firstYear: number = Number(data[0].label);
             const now = new Date();
             const currentYear = now.getFullYear();
-            const nbYears = currentYear - firstYear;
+            const nbYears = currentYear - firstYear + 1;
             let listOfYears = new Array(nbYears)
                 .fill(null)
                 .map(() => firstYear++);