CS2-91: Moved TelemetryTracker from WellService to TelemetryService

AsbCloudApp/Services/ITelemetryService.cs

@@ -1,6 +1,7 @@
 using AsbCloudApp.Data;
 using System.Collections.Generic;
-using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
 
 namespace AsbCloudApp.Services
 {
@@ -13,5 +14,8 @@ namespace AsbCloudApp.Services
         int? GetIdTelemetryByIdWell(int idWell);
         int Merge(IEnumerable<int> telemetryIds);
         IEnumerable<(string Key, int[] Ids)> GetRedundentRemoteUids();
+        Task<IEnumerable<WellDto>> GetTransmittingWellsAsync(int idCompany, 
+            CancellationToken token);
+        void SaveRequestDate(string uid);
     }
 }

AsbCloudApp/Services/ITelemetryTracker.cs

@@ -1,10 +1,12 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 
 namespace AsbCloudApp.Services
 {
     public interface ITelemetryTracker
     {
         void SaveRequestDate(string uid);
+        DateTime GetLastTelemetryDateByUid(string uid);
         IEnumerable<string> GetTransmittingTelemetryUids();
     }
 }

AsbCloudInfrastructure/Services/Analysis/TelemetryAnalyticsBackgroundService.cs

@@ -5,6 +5,7 @@ using System.Diagnostics;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Hosting;
 using AsbCloudInfrastructure.Services.Cache;
+using AsbCloudApp.Services;
 using AsbCloudDb.Model;
 
 namespace AsbCloudInfrastructure.Services.Analysis
@@ -12,11 +13,13 @@ namespace AsbCloudInfrastructure.Services.Analysis
     public class TelemetryAnalyticsBackgroundService : BackgroundService
     {
         private readonly CacheDb cacheDb;
+        private readonly ITelemetryTracker telemetryTracker;
         private readonly TimeSpan period = TimeSpan.FromHours(1);
 
-        public TelemetryAnalyticsBackgroundService(CacheDb cacheDb)
+        public TelemetryAnalyticsBackgroundService(CacheDb cacheDb, ITelemetryTracker telemetryTracker)
         {
             this.cacheDb = cacheDb;
+            this.telemetryTracker = telemetryTracker;
         }
 
         protected override async Task ExecuteAsync(CancellationToken token = default)
@@ -34,7 +37,7 @@ namespace AsbCloudInfrastructure.Services.Analysis
                     try
                     {
                         using var context = new AsbCloudDbContext(options);
-                        var telemetryService = new TelemetryService(context, cacheDb);
+                        var telemetryService = new TelemetryService(context, telemetryTracker, cacheDb);
                         var analyticsService = new TelemetryAnalyticsService(context,
                             telemetryService, cacheDb);
 

AsbCloudInfrastructure/Services/TelemetryService.cs

@@ -5,10 +5,10 @@ using AsbCloudInfrastructure.Services.Cache;
 using Mapster;
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
 using System;
 using Microsoft.EntityFrameworkCore;
-using System.Threading.Tasks;
-using System.Threading;
 
 namespace AsbCloudInfrastructure.Services
 {
@@ -17,16 +17,43 @@ namespace AsbCloudInfrastructure.Services
         private readonly CacheTable<Telemetry> cacheTelemetry;
         private readonly CacheTable<Well> cacheWells;
         private readonly IAsbCloudDbContext db;
+        private readonly ITelemetryTracker telemetryTracker;
 
-        public TelemetryService(IAsbCloudDbContext db, CacheDb cacheDb)
+        public TelemetryService(IAsbCloudDbContext db, ITelemetryTracker telemetryTracker, 
+            CacheDb cacheDb)
         {
             cacheTelemetry = cacheDb.GetCachedTable<Telemetry>((AsbCloudDbContext)db);
             cacheWells = cacheDb.GetCachedTable<Well>((AsbCloudDbContext)db);
             this.db = db;
+            this.telemetryTracker = telemetryTracker;
+        }
+        
+        public async Task<IEnumerable<WellDto>> GetTransmittingWellsAsync(int idCompany, CancellationToken token)
+        {
+            var wells = new List<Well>();
+            IEnumerable<string> activeTelemetriesUids = telemetryTracker.GetTransmittingTelemetryUids();
+            if (activeTelemetriesUids.Any())
+            {
+                wells = await db.GetWellsForCompany(idCompany)
+                    .Where(w => activeTelemetriesUids.Contains(w.Telemetry.RemoteUid))
+                    .AsNoTracking()
+                    .ToListAsync(token)
+                    .ConfigureAwait(false);
+            }
+            return wells.Select(w => new WellDto
+            {
+                Id = w.Id,
+                Caption = w.Caption,
+                Cluster = w.Cluster.Caption,
+                Deposit = w.Cluster.Deposit.Caption,
+            });
         }
 
+        public void SaveRequestDate(string uid) =>
+            telemetryTracker.SaveRequestDate(uid);
+
         public int GetOrCreateTemetryIdByUid(string uid)
-            => GetOrCreateTelemetryByUid(uid).Id;
+        => GetOrCreateTelemetryByUid(uid).Id;
 
         public int? GetidWellByTelemetryUid(string uid)
             => GetWellByTelemetryUid(uid)?.Id;

AsbCloudInfrastructure/Services/TelemetryTracker.cs

@@ -10,21 +10,25 @@ namespace AsbCloudInfrastructure.Services
         private IDictionary<string, DateTime> requests = new Dictionary<string, DateTime>();
         private readonly TimeSpan timeout = TimeSpan.FromMinutes(6);
 
-        private void DeleteOldRequestDates()
-        {
-            requests = requests.Where(dValue => (DateTime.Now - dValue.Value) < timeout).ToDictionary(dValue => dValue.Key, dValue => dValue.Value);
-        }
-
         public void SaveRequestDate(string uid)
         {
             requests[uid] = DateTime.Now;
             DeleteOldRequestDates();
         }
 
+        public DateTime GetLastTelemetryDateByUid(string uid) =>
+            requests[uid];
+
         public IEnumerable<string> GetTransmittingTelemetryUids()
         {
             DeleteOldRequestDates();
             return requests.Keys;
         }
+        
+        private void DeleteOldRequestDates()
+        {
+            requests = requests.Where(dValue => (DateTime.Now - dValue.Value) < timeout)
+                .ToDictionary(dValue => dValue.Key, dValue => dValue.Value);
+        }
     }
 }

AsbCloudInfrastructure/Services/WellService.cs

@@ -15,37 +15,32 @@ namespace AsbCloudInfrastructure.Services
     public class WellService : IWellService
     {
         private readonly IAsbCloudDbContext db;
-        private readonly ITelemetryTracker telemetryTracker;
+        private readonly ITelemetryService telemetryService;
         private readonly CacheTable<RelationCompanyWell> cacheRelationCompaniesWells;
         private readonly CacheTable<Well> cacheWells;
 
-        public WellService(IAsbCloudDbContext db, ITelemetryTracker telemetryTracker, CacheDb cacheDb)
+        public WellService(IAsbCloudDbContext db, ITelemetryService telemetryService, CacheDb cacheDb)
         {
             this.db = db;
-            this.telemetryTracker = telemetryTracker;
+            this.telemetryService = telemetryService;
             cacheRelationCompaniesWells = cacheDb.GetCachedTable<RelationCompanyWell>((AsbCloudDbContext)db);
             cacheWells = cacheDb.GetCachedTable<Well>((AsbCloudDbContext)db);
         }
-
+        
-        public async Task<IEnumerable<WellDto>> GetTransmittingWellsAsync(int idCompany, CancellationToken token)
+        public async Task<IEnumerable<WellDto>> GetTransmittingWellsAsync(int idCompany, 
-        {
+            CancellationToken token) =>
-            var wells = new List<Well>();
+            await telemetryService.GetTransmittingWellsAsync(idCompany, token);
-            IEnumerable<string> activeTelemetriesUids = telemetryTracker.GetTransmittingTelemetryUids();
-            if (activeTelemetriesUids.Any())
-            {
-                wells = await db.GetWellsForCompany(idCompany)
-                    .Where(w => activeTelemetriesUids.Contains(w.Telemetry.RemoteUid))
-                    .AsNoTracking()
-                    .ToListAsync(token)
-                    .ConfigureAwait(false);
-            }
-            return wells.Select(w => From(w));
-        }
 
         public async Task<IEnumerable<WellDto>> GetWellsByCompanyAsync(int idCompany, CancellationToken token)
         {
             var wells = await db.GetWellsForCompany(idCompany).ToListAsync(token);
-            return wells.Select(w => From(w));
+            return wells.Select(w => new WellDto
+            {
+                Id = w.Id,
+                Caption = w.Caption,
+                Cluster = w.Cluster.Caption,
+                Deposit = w.Cluster.Deposit.Caption,
+            });
         }
 
         public bool IsCompanyInvolvedInWell(int idCompany, int idWell)
@@ -55,19 +50,6 @@ namespace AsbCloudInfrastructure.Services
          => await cacheRelationCompaniesWells.ContainsAsync(r => r.IdWell == idWell &&
                 r.IdCompany == idCompany, token).ConfigureAwait(false);
 
-        private static WellDto From(Well well)
-        {
-            var wellDto = new WellDto
-            {
-                Id = well.Id,
-                Caption = well.Caption,
-                Cluster = well.Cluster.Caption,
-                Deposit = well.Cluster.Deposit.Caption,
-            };
-
-            return wellDto;
-        }
-
         public async Task<WellDto> GetAsync(int idWell, CancellationToken token)
         {
             var entity = await db.Wells

AsbCloudWebApi/Controllers/TelemetryController.cs

@@ -23,22 +23,19 @@ namespace AsbCloudWebApi.Controllers
         private readonly IEventService eventService;
         private readonly ITelemetryUserService telemetryUserService;
         private readonly IHubContext<TelemetryHub> telemetryHubContext;
-        private readonly ITelemetryTracker telemetryTracker;
 
         public TelemetryController(
             ITelemetryService telemetryService,
             IMessageService messageService,
             IEventService eventService,
             ITelemetryUserService telemetryUserService,
-            IHubContext<TelemetryHub> telemetryHubContext,
+            IHubContext<TelemetryHub> telemetryHubContext)
-            ITelemetryTracker telemetryTracker)
         {
             this.telemetryService = telemetryService;
             this.messageService = messageService;
             this.eventService = eventService;
             this.telemetryUserService = telemetryUserService;
             this.telemetryHubContext = telemetryHubContext;
-            this.telemetryTracker = telemetryTracker;
         }
 
         /// <summary>
@@ -52,7 +49,7 @@ namespace AsbCloudWebApi.Controllers
         public IActionResult PostInfo(string uid, [FromBody] TelemetryInfoDto info)
         {
             telemetryService.UpdateInfo(uid, info);
-            telemetryTracker.SaveRequestDate(uid);
+            telemetryService.SaveRequestDate(uid);
             return Ok();
         }
 
@@ -75,7 +72,7 @@ namespace AsbCloudWebApi.Controllers
                 await Task.Run(() => telemetryHubContext.Clients.Group($"well_{idWell}")
                 .SendAsync("ReceiveMessages", dtos), token).ConfigureAwait(false);
 
-            telemetryTracker.SaveRequestDate(uid);
+            telemetryService.SaveRequestDate(uid);
             return Ok();
         }
 
@@ -93,7 +90,7 @@ namespace AsbCloudWebApi.Controllers
         {
             await eventService.UpsertAsync(uid, events, token)
                 .ConfigureAwait(false);
-            telemetryTracker.SaveRequestDate(uid);
+            telemetryService.SaveRequestDate(uid);
             return Ok();
         }
 
@@ -108,7 +105,7 @@ namespace AsbCloudWebApi.Controllers
         public IActionResult PostUsers(string uid, [FromBody] List<TelemetryUserDto> users)
         {
             telemetryUserService.Upsert(uid, users);
-            telemetryTracker.SaveRequestDate(uid);
+            telemetryService.SaveRequestDate(uid);
             return Ok();
         }
 

AsbCloudWebApi/Controllers/TelemetryDataBaseController.cs

@@ -18,7 +18,6 @@ namespace AsbCloudWebApi.Controllers
     public abstract class TelemetryDataBaseController<TDto> : ControllerBase
         where TDto: ITelemetryData
     {
-        private readonly ITelemetryTracker telemetryTracker;
         private readonly ITelemetryService telemetryService;
         private readonly ITelemetryDataService<TDto> telemetryDataService;
         private readonly IWellService wellService;
@@ -27,13 +26,11 @@ namespace AsbCloudWebApi.Controllers
         public string SirnalRMethodGetDataName { get; protected set; } = "ReceiveData";
 
         public TelemetryDataBaseController(
-            ITelemetryTracker telemetryTracker, 
             ITelemetryService telemetryService, 
             ITelemetryDataService<TDto> telemetryDataService,
             IWellService wellService,
             IHubContext<TelemetryHub> telemetryHubContext)
         {
-            this.telemetryTracker = telemetryTracker;
             this.telemetryService = telemetryService;
             this.telemetryDataService = telemetryDataService;
             this.wellService = wellService;
@@ -60,7 +57,7 @@ namespace AsbCloudWebApi.Controllers
                 await Task.Run(() => telemetryHubContext.Clients.Group($"well_{idWell}")
                     .SendAsync(SirnalRMethodGetDataName, dtos), token).ConfigureAwait(false);
 
-            telemetryTracker.SaveRequestDate(uid);
+            telemetryService.SaveRequestDate(uid);
             return Ok();
         }
 

AsbCloudWebApi/Controllers/TelemetryDataSaubController.cs

@@ -11,13 +11,11 @@ namespace AsbCloudWebApi.Controllers
     public class TelemetryDataSaubController : TelemetryDataBaseController<TelemetryDataSaubDto>
     {
         public TelemetryDataSaubController(
-            ITelemetryTracker telemetryTracker,
             ITelemetryService telemetryService,
             ITelemetryDataService<TelemetryDataSaubDto> telemetryDataService,
             IWellService wellService,
             IHubContext<TelemetryHub> telemetryHubContext)
             : base(
-                  telemetryTracker,
                   telemetryService,
                   telemetryDataService,
                   wellService,

AsbCloudWebApi/Controllers/TelemetryDataSpinController.cs

@@ -11,13 +11,11 @@ namespace AsbCloudWebApi.Controllers
     public class TelemetryDataSpinController : TelemetryDataBaseController<TelemetryDataSpinDto>
     {
         public TelemetryDataSpinController(
-            ITelemetryTracker telemetryTracker,
             ITelemetryService telemetryService,
             ITelemetryDataService<TelemetryDataSpinDto> telemetryDataService,
             IWellService wellService,
             IHubContext<TelemetryHub> telemetryHubContext)
             : base(
-                  telemetryTracker,
                   telemetryService,
                   telemetryDataService,
                   wellService,

ConsoleApp1/DebugWellOperationsStatService.cs

@@ -21,7 +21,8 @@ namespace ConsoleApp1
                 .Options;
             using var db = new AsbCloudDbContext(options);
             var cacheDb = new CacheDb();
-            var wellService = new WellService(db, new TelemetryTracker(), cacheDb);
+            var telemetryService = new TelemetryService(db, new TelemetryTracker(), cacheDb);
+            var wellService = new WellService(db, telemetryService, cacheDb);
             var wellOptsStat = new WellOperationsStatService(db, cacheDb, wellService);
             var tvd = wellOptsStat.GetTvdAsync(1, default).Result;
             Print(tvd);