Refactor processors

src/Backend/DiunaBI.Plugins.Morska/Processors/T4SingleSourceProcessor.cs

@@ -1,8 +1,8 @@
 using Microsoft.EntityFrameworkCore;
-using DiunaBI.Core.Models;
-using DiunaBI.Core.Database.Context;
 using Microsoft.Extensions.Logging;
 using Google.Apis.Sheets.v4;
+using DiunaBI.Core.Models;
+using DiunaBI.Core.Database.Context;
 
 namespace DiunaBI.Plugins.Morska.Processors;
 
@@ -14,6 +14,12 @@ public class T4SingleSourceProcessor : MorskaBaseProcessor
     private readonly SpreadsheetsResource.ValuesResource _googleSheetValues;
     private readonly ILogger<T4SingleSourceProcessor> _logger;
 
+    // Configuration properties loaded from layer records
+    private int Year { get; set; }
+    private int Month { get; set; }
+    private string? SourceLayer { get; set; }
+    private string? Source { get; set; }
+
     public T4SingleSourceProcessor(
         AppDbContext db,
         SpreadsheetsResource.ValuesResource googleSheetValues,
@@ -26,70 +32,196 @@ public class T4SingleSourceProcessor : MorskaBaseProcessor
 
     public override void Process(Layer processWorker)
     {
-        _logger.LogInformation("T4SingleSource: Starting processing for {ProcessWorkerName} ({ProcessWorkerId})", 
-            processWorker.Name, processWorker.Id);
-
-        var year = int.Parse(processWorker.Records?.SingleOrDefault(x => x.Code == "Year")?.Desc1!);
-        var month = int.Parse(processWorker.Records?.SingleOrDefault(x => x.Code == "Month")?.Desc1!);
-        var sourceLayer = processWorker.Records?.SingleOrDefault(x => x.Code == "SourceLayer")?.Desc1;
-        if (sourceLayer == null)
+        try
         {
-            throw new Exception("SourceLayer record not found");
+            _logger.LogInformation("{ProcessorType}: Starting processing for {ProcessWorkerName} ({ProcessWorkerId})",
+                ProcessorType, processWorker.Name, processWorker.Id);
+
+            // Load configuration from layer records
+            LoadConfiguration(processWorker);
+
+            // Validate required configuration
+            ValidateConfiguration();
+
+            // Perform the actual processing
+            PerformProcessing(processWorker);
+
+            _logger.LogInformation("{ProcessorType}: Successfully completed processing for {ProcessWorkerName}",
+                ProcessorType, processWorker.Name);
+        }
+        catch (Exception e)
+        {
+            _logger.LogError(e, "{ProcessorType}: Failed to process {ProcessWorkerName} ({ProcessWorkerId})",
+                ProcessorType, processWorker.Name, processWorker.Id);
+            throw;
+        }
+    }
+
+    private void LoadConfiguration(Layer processWorker)
+    {
+        if (processWorker.Records == null)
+        {
+            throw new InvalidOperationException("ProcessWorker has no records");
         }
 
-        var sourceImportWorker = _db.Layers.SingleOrDefault(x => x.Name == sourceLayer && !x.IsDeleted && !x.IsCancelled);
+        // Load year
+        var yearStr = GetRecordValue(processWorker.Records, "Year");
+        if (string.IsNullOrEmpty(yearStr) || !int.TryParse(yearStr, out var year))
+        {
+            throw new InvalidOperationException("Year record not found or invalid");
+        }
+        Year = year;
+
+        // Load month
+        var monthStr = GetRecordValue(processWorker.Records, "Month");
+        if (string.IsNullOrEmpty(monthStr) || !int.TryParse(monthStr, out var month))
+        {
+            throw new InvalidOperationException("Month record not found or invalid");
+        }
+        Month = month;
+
+        // Load source layer
+        SourceLayer = GetRecordValue(processWorker.Records, "SourceLayer");
+        if (string.IsNullOrEmpty(SourceLayer))
+        {
+            throw new InvalidOperationException("SourceLayer record not found");
+        }
+
+        // Load source
+        Source = GetRecordValue(processWorker.Records, "Source");
+        if (string.IsNullOrEmpty(Source))
+        {
+            throw new InvalidOperationException("Source record not found");
+        }
+
+        _logger.LogDebug("{ProcessorType}: Configuration loaded - Year: {Year}, Month: {Month}, SourceLayer: {SourceLayer}, Source: {Source}",
+            ProcessorType, Year, Month, SourceLayer, Source);
+    }
+
+    private void ValidateConfiguration()
+    {
+        var errors = new List<string>();
+
+        if (Year < 2000 || Year > 3000) errors.Add($"Invalid year: {Year}");
+        if (Month < 1 || Month > 12) errors.Add($"Invalid month: {Month}");
+        if (string.IsNullOrEmpty(SourceLayer)) errors.Add("SourceLayer is required");
+        if (string.IsNullOrEmpty(Source)) errors.Add("Source is required");
+
+        if (errors.Any())
+        {
+            throw new InvalidOperationException($"Configuration validation failed: {string.Join(", ", errors)}");
+        }
+
+        _logger.LogDebug("{ProcessorType}: Configuration validation passed", ProcessorType);
+    }
+
+    private void PerformProcessing(Layer processWorker)
+    {
+        _logger.LogDebug("{ProcessorType}: Processing data for Year: {Year}, Month: {Month}, Source: {Source}",
+            ProcessorType, Year, Month, Source);
+
+        // Get source import worker
+        var sourceImportWorker = GetSourceImportWorker();
+
+        // Get or create processed layer
+        var processedLayer = GetOrCreateProcessedLayer(processWorker);
+
+        // Get data source
+        var dataSource = GetDataSource(sourceImportWorker);
+
+        // Process records (simple copy)
+        var newRecords = ProcessRecords(dataSource);
+
+        // Save results
+        SaveProcessedLayer(processedLayer, newRecords);
+
+        _logger.LogInformation("{ProcessorType}: Successfully processed {RecordCount} records for layer {LayerName} ({LayerId})",
+            ProcessorType, newRecords.Count, processedLayer.Name, processedLayer.Id);
+    }
+
+    private Layer GetSourceImportWorker()
+    {
+        var sourceImportWorker = _db.Layers
+            .Where(x => x.Name == SourceLayer && !x.IsDeleted && !x.IsCancelled)
+            .FirstOrDefault();
+
         if (sourceImportWorker == null)
         {
-            throw new Exception("SourceImportWorker layer not found");
+            throw new InvalidOperationException($"SourceImportWorker layer not found: {SourceLayer}");
         }
 
-        var source = processWorker.Records?.SingleOrDefault(x => x.Code == "Source")?.Desc1;
-        if (source == null) 
-        {
-            throw new Exception("Source record not found");
-        }
+        _logger.LogDebug("{ProcessorType}: Found source import worker {LayerName} ({LayerId})",
+            ProcessorType, sourceImportWorker.Name, sourceImportWorker.Id);
 
+        return sourceImportWorker;
+    }
+
+    private Layer GetOrCreateProcessedLayer(Layer processWorker)
+    {
         var processedLayer = _db.Layers
-            .Where(x => x.ParentId == processWorker.Id
-                        && !x.IsDeleted && !x.IsCancelled)
+            .Where(x => x.ParentId == processWorker.Id && !x.IsDeleted && !x.IsCancelled)
             .OrderByDescending(x => x.CreatedAt)
             .FirstOrDefault();
 
-        var isNew = false;
         if (processedLayer == null)
         {
-            isNew = true;
             processedLayer = new Layer
             {
                 Id = Guid.NewGuid(),
                 Type = LayerType.Processed,
                 ParentId = processWorker.Id,
-                Number = _db.Layers.Count() + 1
+                Number = _db.Layers.Count() + 1,
+                CreatedById = Guid.Parse("F392209E-123E-4651-A5A4-0B1D6CF9FF9D"),
+                ModifiedById = Guid.Parse("F392209E-123E-4651-A5A4-0B1D6CF9FF9D"),
+                CreatedAt = DateTime.UtcNow,
+                ModifiedAt = DateTime.UtcNow
             };
-            processedLayer.Name = $"L{processedLayer.Number}-P-{year}/{month:D2}-{source}-T4";
-            processedLayer.CreatedById = Guid.Parse("F392209E-123E-4651-A5A4-0B1D6CF9FF9D");
+            processedLayer.Name = $"L{processedLayer.Number}-P-{Year}/{Month:D2}-{Source}-T4";
+
+            _logger.LogDebug("{ProcessorType}: Created new processed layer {LayerName}",
+                ProcessorType, processedLayer.Name);
+        }
+        else
+        {
             processedLayer.ModifiedById = Guid.Parse("F392209E-123E-4651-A5A4-0B1D6CF9FF9D");
-            processedLayer.CreatedAt = DateTime.UtcNow;
             processedLayer.ModifiedAt = DateTime.UtcNow;
+
+            _logger.LogDebug("{ProcessorType}: Using existing processed layer {LayerName}",
+                ProcessorType, processedLayer.Name);
         }
 
-        processedLayer.ModifiedById = Guid.Parse("F392209E-123E-4651-A5A4-0B1D6CF9FF9D");
-        processedLayer.ModifiedAt = DateTime.UtcNow;
+        return processedLayer;
+    }
 
+    private Layer GetDataSource(Layer sourceImportWorker)
+    {
         var dataSource = _db.Layers
+            .Where(x => x.ParentId == sourceImportWorker.Id && !x.IsDeleted && !x.IsCancelled)
             .Include(x => x.Records)
-            .Where(x => x.ParentId == sourceImportWorker.Id
-                        && !x.IsDeleted && !x.IsCancelled)
             .OrderByDescending(x => x.CreatedAt)
             .AsNoTracking()
             .FirstOrDefault();
 
         if (dataSource == null)
         {
-            throw new Exception($"DataSource not found, {sourceImportWorker.Name}");
+            throw new InvalidOperationException($"DataSource not found for source import worker: {sourceImportWorker.Name}");
         }
 
-        var newRecords = dataSource.Records!.Select(record => new Record
+        _logger.LogDebug("{ProcessorType}: Found data source {LayerName} with {RecordCount} records",
+            ProcessorType, dataSource.Name, dataSource.Records?.Count ?? 0);
+
+        return dataSource;
+    }
+
+    private List<Record> ProcessRecords(Layer dataSource)
+    {
+        if (dataSource.Records == null || dataSource.Records.Count == 0)
+        {
+            _logger.LogWarning("{ProcessorType}: Data source contains no records", ProcessorType);
+            return new List<Record>();
+        }
+
+        var newRecords = dataSource.Records.Select(record => new Record
         {
             Id = Guid.NewGuid(),
             Code = record.Code,
@@ -99,30 +231,46 @@ public class T4SingleSourceProcessor : MorskaBaseProcessor
             ModifiedAt = DateTime.UtcNow
         }).ToList();
 
-        if (isNew)
+        _logger.LogDebug("{ProcessorType}: Created {RecordCount} copied records from data source",
+            ProcessorType, newRecords.Count);
+
+        return newRecords;
+    }
+
+    private void SaveProcessedLayer(Layer processedLayer, List<Record> newRecords)
+    {
+        var existsInDb = _db.Layers.Any(x => x.Id == processedLayer.Id);
+
+        if (!existsInDb)
         {
             _db.Layers.Add(processedLayer);
+            _logger.LogDebug("{ProcessorType}: Added new processed layer to database", ProcessorType);
         }
         else
         {
             _db.Layers.Update(processedLayer);
+            _logger.LogDebug("{ProcessorType}: Updated existing processed layer in database", ProcessorType);
         }
 
         SaveRecords(processedLayer.Id, newRecords);
         _db.SaveChanges();
 
-        _logger.LogInformation("T4SingleSource: Successfully completed processing for {ProcessWorkerName} ({ProcessWorkerId})", 
-            processWorker.Name, processWorker.Id);
+        _logger.LogDebug("{ProcessorType}: Saved {RecordCount} records for layer {LayerId}",
+            ProcessorType, newRecords.Count, processedLayer.Id);
     }
 
     private void SaveRecords(Guid layerId, ICollection<Record> records)
     {
+        // Remove existing records for this layer
         var toDelete = _db.Records.Where(x => x.LayerId == layerId).ToList();
         if (toDelete.Count > 0)
         {
             _db.Records.RemoveRange(toDelete);
+            _logger.LogDebug("{ProcessorType}: Removed {DeletedCount} existing records for layer {LayerId}",
+                ProcessorType, toDelete.Count, layerId);
         }
 
+        // Add new records
         foreach (var record in records)
         {
             record.CreatedById = Guid.Parse("F392209E-123E-4651-A5A4-0B1D6CF9FF9D");
@@ -133,6 +281,12 @@ public class T4SingleSourceProcessor : MorskaBaseProcessor
             _db.Records.Add(record);
         }
 
-        _logger.LogDebug("T4SingleSource: Saved {RecordCount} records for layer {LayerId}", records.Count, layerId);
+        _logger.LogDebug("{ProcessorType}: Added {RecordCount} new records for layer {LayerId}",
+            ProcessorType, records.Count, layerId);
+    }
+
+    private string? GetRecordValue(ICollection<Record> records, string code)
+    {
+        return records.FirstOrDefault(x => x.Code == code)?.Desc1;
     }
 }