rebuild storing logic #23

Author: zetroot

src/NTorSpectator.Database/DatabaseInjector.cs

@@ -22,7 +22,8 @@ public static IServiceCollection AddDatabase(this IServiceCollection services, I
         services.AddDbContextPool<DataContext>(opts => opts.UseNpgsql(configuration.GetConnectionString("SpectatorDatabase")));
         services
             .AddTransient<ISitesRepository, SitesRepository>()
-            .AddTransient<IObservesRepository, ObservesRepository>();
+            .AddTransient<IObservesRepository, ObservesRepository>()
+            .AddTransient<IReportsRepository, ReportsRepository>();
 
         return services;
     }

src/NTorSpectator.Database/Repositories/ObservesRepository.cs

@@ -14,15 +14,15 @@ public ObservesRepository(DataContext context)
 
     public async Task<Observation?> GetLastObservationForSite(string siteUri)
     {
-        var siteId = await _context.Sites
-            .Where(x => x.SiteUri == siteUri)
-            .Select(x => x.Id)
-            .SingleAsync();
-        var observation = await _context.Observations.Where(x => x.SiteId == siteId).OrderByDescending(x => x.ObservedAt).FirstOrDefaultAsync();
+        var observation = await _context.Observations
+            .Include(x => x.Site)
+            .Where(x => x.Site.SiteUri == siteUri)
+            .OrderByDescending(x => x.ObservedAt)
+            .FirstOrDefaultAsync();
 
         return observation is null ?
             null :
-            new Observation { ObservedAt = observation.ObservedAt, IsAvailable = observation.IsAvailable };
+            new Observation { ObservedAt = observation.ObservedAt, IsAvailable = observation.IsAvailable, SiteUri = observation.Site.SiteUri};
     }
 
     public async Task AddNewObservation(string siteUri, bool isAvailable, DateTime timestamp)

src/NTorSpectator.Database/Repositories/ReportsRepository.cs

@@ -0,0 +1,49 @@
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+using NTorSpectator.Database.Models;
+using NTorSpectator.Services.Models;
+using NTorSpectator.Services.Persistent;
+
+namespace NTorSpectator.Database.Repositories;
+
+internal class ReportsRepository : IReportsRepository
+{
+    private readonly DataContext _context;
+    private readonly ILogger<ReportsRepository> _logger;
+
+    public ReportsRepository(DataContext context, ILogger<ReportsRepository> logger)
+    {
+        _context = context;
+        _logger = logger;
+    }
+
+    public async Task SaveReport(Report report)
+    {
+        var siteList = await _context.Sites.ToListAsync();
+        var reportDal = new ObservationReport();
+        foreach (var observation in report.Observations)
+        {
+            var site = siteList.SingleOrDefault(x => x.SiteUri == observation.SiteUri);
+            if (site is null)
+            {
+                _logger.LogWarning("Site is not found in database, won't save observation for uri {SiteUri}", observation.SiteUri);
+                continue;
+            }
+            reportDal.Observations.Add(new(){Site = site, ObservedAt = observation.ObservedAt, IsAvailable = observation.IsAvailable});
+        }
+
+        foreach (var siteEvent in report.Events)
+        {
+            var site = siteList.SingleOrDefault(x => x.SiteUri == siteEvent.SiteUri);
+            if (site is null)
+            {
+                _logger.LogWarning("Site is not found in database, won't save event for uri {SiteUri}", siteEvent.SiteUri);
+                continue;
+            }
+            reportDal.Events.Add(new(){Site = site, OccuredAt = siteEvent.OccuredAt, EventType = (int)siteEvent.Kind});
+        }
+
+        _context.Reports.Add(reportDal);
+        await _context.SaveChangesAsync();
+    }
+}

src/NTorSpectator.Services/BizlogicInjector.cs

@@ -4,8 +4,16 @@
 
 namespace NTorSpectator.Services;
 
+/// <summary>
+/// Injects business logic into application
+/// </summary>
 public static class BizlogicInjector
 {
+    /// <summary>
+    /// Inject bizlogic services into DI
+    /// </summary>
+    /// <param name="services">DI containEr</param>
+    /// <returns></returns>
     public static IServiceCollection AddBizLogic(this IServiceCollection services)
     {
         services.AddTransient<ISitesCatalogue, SitesCatalogue>()

src/NTorSpectator.Services/IReporter.cs

@@ -1,7 +1,15 @@
+using NTorSpectator.Services.Models;
+
 namespace NTorSpectator.Services;
 
+/// <summary>
+/// Mastodon toots sender
+/// </summary>
 public interface IReporter
 {
-    Task ReportWentDown(string siteUri, DateTime lastSeen);
-    Task ReportCameUp(string siteUri);
+    /// <summary>
+    /// Publish toot with report data
+    /// </summary>
+    /// <param name="report">Report to publish</param>
+    Task PublishReportData(Report report);
 }

src/NTorSpectator.Services/ISiteObserver.cs

@@ -1,6 +1,22 @@
+using NTorSpectator.Services.Models;
+
 namespace NTorSpectator.Services;
 
+/// <summary>
+/// Service which deals with sites observations 
+/// </summary>
 public interface ISiteObserver
 {
-    Task AddNewObservation(string siteUri, bool isAvailable);
+    /// <summary>
+    /// Saves report into database
+    /// </summary>
+    /// <param name="report">Report to save</param>
+    Task SaveReport(Report report);
+
+    /// <summary>
+    /// Generate event for this observation
+    /// </summary>
+    /// <param name="observation">Observation to generate event based on it</param>
+    /// <returns>Event if site availability changed. Null - otherwise</returns>
+    Task<AvailabilityEvent?> GenerateEvent(Observation observation);
 }

src/NTorSpectator.Services/ISitesCatalogue.cs

@@ -14,5 +14,9 @@ public interface ISitesCatalogue
     /// <returns>true if the site was added, otherwise - false</returns>
     Task<bool> AddIfNotExists(string siteUri);
 
+    /// <summary>
+    /// Get all sites from the persistent site catalogue
+    /// </summary>
+    /// <returns></returns>
     Task<IReadOnlyCollection<Site>> GetAllSites();
 }

src/NTorSpectator.Services/Logic/SiteObserver.cs

@@ -1,50 +1,47 @@
 using Microsoft.Extensions.Logging;
+using NTorSpectator.Services.Models;
 using NTorSpectator.Services.Persistent;
 
 namespace NTorSpectator.Services.Logic;
 
-public class SiteObserver : ISiteObserver
+internal class SiteObserver : ISiteObserver
 {
-    private readonly IReporter _reporter;
-    private readonly IObservesRepository _repo;
+    private readonly IObservesRepository _observationsRepository;
     private readonly ILogger<SiteObserver> _logger;
+    private readonly IReportsRepository _reportsRepository;
 
-    public SiteObserver(IReporter reporter, IObservesRepository repo, ILogger<SiteObserver> logger)
+    public SiteObserver(IReporter reporter, IObservesRepository observationsRepository, ILogger<SiteObserver> logger, IReportsRepository reportsRepository)
     {
-        _reporter = reporter;
-        _repo = repo;
+        _observationsRepository = observationsRepository;
         _logger = logger;
+        _reportsRepository = reportsRepository;
     }
 
-    public async Task AddNewObservation(string siteUri, bool isAvailable)
+    public async Task<AvailabilityEvent?> GenerateEvent(Observation observation)
     {
-        using var _ = _logger.BeginScope(new Dictionary<string, object> { { "SiteUri", siteUri }, { "IsAvailable", isAvailable } });
+        using var _ = _logger.BeginScope(new Dictionary<string, object> { { "SiteUri", observation.SiteUri }, { "IsAvailable", observation.IsAvailable } });
         _logger.LogDebug("Got new observation to save");
-        var previousObservation = await _repo.GetLastObservationForSite(siteUri);
-        await _repo.AddNewObservation(siteUri, isAvailable, DateTime.UtcNow);
-        _logger.LogInformation("Saved new observation");
+        var previousObservation = await _observationsRepository.GetLastObservationForSite(observation.SiteUri);
         if (previousObservation is null)
         {
             _logger.LogDebug("This is first observation for site. Won't compare with previous");
-            return;
+            return null;
         }
 
-        if (previousObservation.IsAvailable == isAvailable)
+        if (previousObservation.IsAvailable == observation.IsAvailable)
         {
-            _logger.LogDebug("Site availability has not changed, nothing to report");
-            return;   
+            _logger.LogDebug("Site availability has not changed, won't create event");
+            return null;   
         }
 
-        if (isAvailable)
+        _logger.LogDebug("Site availability changed! Will create new event");
+        return new()
         {
-            await _reporter.ReportCameUp(siteUri);
-            _logger.LogInformation("Reported site came up");
-        }
-        else
-        {
-            await _reporter.ReportWentDown(siteUri, previousObservation.ObservedAt);
-            _logger.LogInformation("Reported site went down");
-        }
-        
+            SiteUri = observation.SiteUri,
+            OccuredAt = observation.ObservedAt,
+            Kind = observation.IsAvailable ? AvailabilityEvent.EventType.Up : AvailabilityEvent.EventType.Down
+        }; 
     }
+
+    public Task SaveReport(Report report) => _reportsRepository.SaveReport(report);
 }

src/NTorSpectator.Services/Models/AvailabilityEvent.cs

@@ -0,0 +1,43 @@
+namespace NTorSpectator.Services.Models;
+
+/// <summary>
+/// One event for the site: came up or gone down
+/// </summary>
+public class AvailabilityEvent
+{
+    /// <summary>
+    /// Site url
+    /// </summary>
+    public required string SiteUri { get; init; }
+    
+    /// <summary>
+    /// Site came up or gone down
+    /// </summary>
+    public EventType Kind { get; set; }
+    
+    /// <summary>
+    /// When the event has occured
+    /// </summary>
+    public DateTime OccuredAt { get; set; }
+    
+    /// <summary>
+    /// Event types - down or up
+    /// </summary>
+    public enum EventType
+    {
+        /// <summary>
+        /// No value
+        /// </summary>
+        None = 0,
+        
+        /// <summary>
+        /// Site gone down
+        /// </summary>
+        Down = -1,
+        
+        /// <summary>
+        /// Site came up
+        /// </summary>
+        Up = 1
+    }
+}

src/NTorSpectator.Services/Models/Observation.cs

@@ -14,4 +14,9 @@ public class Observation
     /// Is available
     /// </summary>
     public bool IsAvailable { get; set; }
+    
+    /// <summary>
+    /// Site uri, which was observed
+    /// </summary>
+    public required string SiteUri { get; init; } 
 }