Add new Backend structure with proper .NET 8 projects

src/Backend/DiunaBI.WebAPI/Controllers/LayersController.cs

@@ -0,0 +1,857 @@
+using System.Globalization;
+using System.Text;
+using Google.Apis.Sheets.v4;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.EntityFrameworkCore;
+using DiunaBI.Core.Models;
+using DiunaBI.Database.Context;
+using DiunaBI.Core.Services;
+using Google.Cloud.Firestore;
+using DiunaBI.Plugins.Morska.Importers;
+using DiunaBI.Plugins.Morska.Processors;
+using DiunaBI.Core.Services.Exports;
+
+namespace DiunaBI.WebAPI.Controllers;
+
+[ApiController]
+[Route("api/[controller]")]
+public class LayersController : Controller
+{
+    private readonly AppDbContext _db;
+    private readonly SpreadsheetsResource.ValuesResource? _googleSheetValues;
+    private readonly GoogleDriveHelper _googleDriveHelper;
+    private readonly IConfiguration _configuration;
+    private readonly LogsController _logsController;
+
+    public LayersController(
+        AppDbContext db,
+        GoogleSheetsHelper googleSheetsHelper,
+        GoogleDriveHelper googleDriveHelper,
+        IConfiguration configuration,
+        FirestoreDb firestoreDb
+    )
+    {
+        _db = db;
+        if (googleSheetsHelper.Service is not null)
+        {
+            _googleSheetValues = googleSheetsHelper.Service.Spreadsheets.Values;
+        }
+
+        _googleDriveHelper = googleDriveHelper;
+        _configuration = configuration;
+        _logsController = new LogsController(firestoreDb);
+    }
+
+    [HttpGet]
+    public IActionResult GetAll(int start, int limit, string? name, LayerType? type)
+    {
+        try
+        {
+            var response = _db.Layers.Where(x => !x.IsDeleted);
+            if (name != null)
+            {
+                response = response.Where(x => x.Name != null && x.Name.Contains(name));
+            }
+
+            if (type != null)
+            {
+                response = response.Where(x => x.Type == type);
+            }
+
+            return Ok(response
+                .OrderByDescending(x => x.Number)
+                .Skip(start).Take(limit).AsNoTracking().ToList());
+        }
+        catch (Exception e)
+        {
+            return BadRequest(e.ToString());
+        }
+    }
+
+    [HttpGet]
+    [Route("{id:guid}")]
+    public IActionResult Get(Guid id)
+    {
+        try
+        {
+            return Ok(_db.Layers
+                .Include(x => x.CreatedBy)
+                .Include(x => x.ModifiedBy)
+                .Include(x => x.Records).AsNoTracking().First(x => x.Id == id && !x.IsDeleted));
+        }
+        catch (Exception e)
+        {
+            return BadRequest(e.ToString());
+        }
+    }
+
+    [HttpGet]
+    [Route("getForPowerBI/{apiKey}/{number:int}")]
+    public IActionResult GetByNumber(string apiKey, int number)
+    {
+        if (apiKey != _configuration["apiKey"])
+        {
+            _logsController.AddEntry(new LogEntry
+            {
+                Title = $"Unauthorized request - wrong apiKey ({number})",
+                Type = LogEntryType.Warning,
+                LogType = LogType.PowerBi,
+                CreatedAt = DateTime.UtcNow
+            });
+            return Unauthorized();
+        }
+
+        try
+        {
+            if (
+                !Request.Headers.TryGetValue("Authorization", out var authHeader))
+            {
+                _logsController.AddEntry(new LogEntry
+                {
+                    Title = $"Unauthorized request - no authorization header ({number})",
+                    Type = LogEntryType.Warning,
+                    LogType = LogType.PowerBi,
+                    CreatedAt = DateTime.UtcNow
+                });
+                return Unauthorized();
+            }
+
+            var credentialsArr = authHeader.ToString().Split(" ");
+            if (credentialsArr.Length != 2)
+            {
+                _logsController.AddEntry(new LogEntry
+                {
+                    Title = $"Unauthorized request - wrong auth header format ({number})",
+                    Type = LogEntryType.Warning,
+                    LogType = LogType.PowerBi,
+                    CreatedAt = DateTime.UtcNow
+                });
+                return Unauthorized();
+            }
+
+            var authValue = Encoding.UTF8.GetString(Convert.FromBase64String(credentialsArr[1]));
+            var username = authValue.Split(':')[0];
+            var password = authValue.Split(':')[1];
+            if (username != _configuration["powerBI-user"] || password != _configuration["powerBI-pass"])
+            {
+                _logsController.AddEntry(new LogEntry
+                {
+                    Title = $"Unauthorized request - bad credentials ({number})",
+                    Type = LogEntryType.Warning,
+                    LogType = LogType.PowerBi,
+                    CreatedAt = DateTime.UtcNow
+                });
+                return Unauthorized();
+            }
+
+            _logsController.AddEntry(new LogEntry
+            {
+                Title = $"Sending data for layer {number}",
+                Type = LogEntryType.Info,
+                LogType = LogType.PowerBi,
+                CreatedAt = DateTime.UtcNow
+            });
+
+            return Ok(_db.Layers
+                .Include(x => x.CreatedBy)
+                .Include(x => x.Records).AsNoTracking().First(x => x.Number == number && !x.IsDeleted));
+        }
+        catch (Exception e)
+        {
+            _logsController.AddEntry(new LogEntry
+            {
+                Title = e.ToString(),
+                Type = LogEntryType.Error,
+                LogType = LogType.PowerBi,
+                CreatedAt = DateTime.UtcNow
+            });
+            return BadRequest(e.ToString());
+        }
+    }
+
+    [HttpGet]
+    [Route("getConfiguration/{apiKey}/{number:int}")]
+    public IActionResult GetConfigurationByNumber(string apiKey, int number)
+    {
+        if (apiKey != _configuration["apiKey"])
+        {
+            return Unauthorized();
+        }
+
+        try
+        {
+            if (
+                !Request.Headers.TryGetValue("Authorization", out var authHeader))
+            {
+                return Unauthorized();
+            }
+
+            var credentialsArr = authHeader.ToString().Split(" ");
+            if (credentialsArr.Length != 2)
+            {
+                return Unauthorized();
+            }
+
+            var authValue = Encoding.UTF8.GetString(Convert.FromBase64String(credentialsArr[1]));
+            var username = authValue.Split(':')[0];
+            var password = authValue.Split(':')[1];
+            if (username != _configuration["morska-user"] || password != _configuration["morska-pass"])
+            {
+                return Unauthorized();
+            }
+
+            var config = _db.Layers
+                .Include(x => x.Records)
+                .AsNoTracking()
+                .First(x => x.Number == number && !x.IsDeleted);
+
+            if (config is null)
+            {
+                return BadRequest();
+            }
+
+            var type = config.Records?.Where(x => x.Code == "Type").FirstOrDefault();
+            if (type is null || type.Desc1 != "ExternalConfiguration")
+            {
+                return BadRequest();
+            }
+
+            return Ok(config);
+        }
+        catch
+        {
+            return BadRequest();
+        }
+    }
+
+    [HttpGet]
+    [Route("exportToGoogleSheet/{id:guid}")]
+    public IActionResult ExportToGoogleSheet(Guid id)
+    {
+        if (_googleSheetValues is null)
+        {
+            throw new Exception("Google Sheets API not initialized");
+        }
+
+        var layer = _db.Layers
+            .Include(x => x.Records!.OrderByDescending(y => y.Code)).AsNoTracking().First(x => x.Id == id && !x.IsDeleted);
+
+        var export = new GoogleSheetExport(_googleDriveHelper, _googleSheetValues, _configuration);
+        export.Export(layer);
+        return Ok(true);
+    }
+
+    [HttpGet]
+    [Route("AutoImportWithQueue/{apiKey}")]
+    [AllowAnonymous]
+    public IActionResult AutoImportWithQueue(string apiKey)
+    {
+        if (Request.Host.Value != _configuration["apiLocalUrl"] || apiKey != _configuration["apiKey"])
+        {
+            return Unauthorized();
+        }
+
+        var importWorkerLayers = _db.Layers
+            .Include(x => x.Records)
+            .Where(x =>
+                x.Records!.Any(y => y.Code == "Type" && y.Desc1 == "ImportWorker") &&
+                x.Records!.Any(y => y.Code == "IsEnabled" && y.Desc1 == "True")
+            )
+            .OrderBy(x => x.CreatedAt)
+            .AsNoTracking()
+            .ToList();
+
+        if (importWorkerLayers.Count == 0)
+        {
+            _logsController.AddEntry(new LogEntry
+            {
+                Title = "No Layers to import.",
+                Type = LogEntryType.Info,
+                LogType = LogType.Queue,
+                CreatedAt = DateTime.UtcNow
+            });
+            return Ok();
+        }
+
+        foreach (var importWorker in importWorkerLayers)
+        {
+            try
+            {
+                /*
+                await _queue.AddJob(new QueueJob
+                {
+                    LayerId = importWorker.Id,
+                    Type = JobType.ImportWorker,
+                });
+                */
+            }
+            catch (Exception e)
+            {
+                _logsController.AddEntry(new LogEntry
+                {
+                    Title = $"Error while adding job into queue (import): {importWorker.Name}, {importWorker.Id}",
+                    Type = LogEntryType.Error,
+                    LogType = LogType.Queue,
+                    Message = e.ToString(),
+                    CreatedAt = DateTime.UtcNow
+                });
+            }
+        }
+        return Ok();
+    }
+
+    [HttpGet]
+    [Route("ProcessQueue/{apiKey}")]
+    [AllowAnonymous]
+    public IActionResult ProcessQueue(string apiKey)
+    {
+        /*
+        var allJobs = await _queue.GetJobs();
+        var importJobs = allJobs
+            .Where(x => x.Type == JobType.ImportWorker && x.Status == JobStatus.New);
+        
+        foreach (var job in importJobs)
+        {
+            job.Attempts = job.Attempts + 1;
+            //await _queue.UpdateJob(job);
+        }
+        */
+        return Ok();
+    }
+
+    [HttpGet]
+    [Route("AutoImport/{apiKey}/{nameFilter}")]
+    [AllowAnonymous]
+    public IActionResult AutoImport(string apiKey, string nameFilter)
+    {
+        if (Request.Host.Value != _configuration["apiLocalUrl"] || apiKey != _configuration["apiKey"])
+        {
+            return Unauthorized();
+        }
+
+        if (_googleSheetValues is null)
+        {
+            throw new Exception("Google Sheets API not initialized");
+        }
+
+        var importWorkerLayers = _db.Layers
+            .Include(x => x.Records)
+            .Where(x =>
+                x.Name != null && x.Name.Contains(nameFilter) &&
+                x.Records!.Any(y => y.Code == "Type" && y.Desc1 == "ImportWorker") &&
+                x.Records!.Any(y => y.Code == "IsEnabled" && y.Desc1 == "True")
+            )
+            .OrderByDescending(x => x.CreatedAt)
+            .AsNoTracking()
+            .ToList();
+        _logsController.AddEntry(new LogEntry
+        {
+            Title = $"Starting import: {nameFilter}, Admin layers count ({importWorkerLayers.Count})",
+            Type = LogEntryType.Info,
+            LogType = LogType.Import,
+            CreatedAt = DateTime.UtcNow
+        });
+        try
+        {
+            if (importWorkerLayers.Count == 0)
+            {
+                _logsController.AddEntry(new LogEntry
+                {
+                    Title = "No Layers to import.",
+                    Type = LogEntryType.Info,
+                    LogType = LogType.Import,
+                    CreatedAt = DateTime.UtcNow
+                });
+                return Ok();
+            }
+
+            foreach (var importWorker in importWorkerLayers)
+            {
+                try
+                {
+                    var type = importWorker.Records!.FirstOrDefault(x => x.Code == "ImportType")?.Desc1 ??
+                                "Standard";
+                    var source = importWorker.Records!.FirstOrDefault(x => x.Code == "Source")?.Desc1 ??
+                                "GoogleSheet";
+                    if (source == "DataInbox" && type == "Import-D3")
+                    {
+                        var d3Importer = new MorskaD3Importer(_db);
+                        d3Importer.Import(importWorker);
+                        _logsController.AddEntry(new LogEntry
+                        {
+                            Title = $"{importWorker.Name}, {importWorker.Id}",
+                            Type = LogEntryType.Info,
+                            LogType = LogType.Import,
+                            Message = "Success",
+                            CreatedAt = DateTime.UtcNow
+                        });
+                        continue;
+                    }
+                    switch (type)
+                    {
+                        case "D1":
+                            var d1Importer = new MorskaD1Importer(_db, _googleSheetValues);
+                            d1Importer.Import(importWorker);
+                            Thread.Sleep(5000); // be aware of GSheet API quota
+
+                            _logsController.AddEntry(new LogEntry
+                            {
+                                Title = $"{importWorker.Name}, {importWorker.Id}",
+                                Type = LogEntryType.Info,
+                                LogType = LogType.Import,
+                                Message = "Success",
+                                CreatedAt = DateTime.UtcNow
+                            });
+                            break;
+                        case "FK2":
+                            {
+                                var fk2Importer = new MorskaFk2Importer(_db, _googleSheetValues);
+                                fk2Importer.Import(importWorker);
+                                Thread.Sleep(5000); // be aware of GSheet API quota
+
+                                _logsController.AddEntry(new LogEntry
+                                {
+                                    Title = $"{importWorker.Name}, {importWorker.Id}",
+                                    Type = LogEntryType.Info,
+                                    LogType = LogType.Import,
+                                    Message = "Success",
+                                    CreatedAt = DateTime.UtcNow
+                                });
+                                break;
+                            }
+                        default:
+                            {
+                                var startDate = importWorker.Records!.FirstOrDefault(x => x.Code == "StartDate")?.Desc1;
+                                if (startDate == null)
+                                {
+                                    throw new Exception("StartDate record nod found");
+                                }
+
+                                var endDate = importWorker.Records!.First(x => x.Code == "EndDate").Desc1;
+                                if (endDate == null)
+                                {
+                                    throw new Exception("EndDate record nod found");
+                                }
+
+                                var startDateParsed = DateTime.ParseExact(startDate, "yyyy.MM.dd", null);
+                                var endDateParsed = DateTime.ParseExact(endDate, "yyyy.MM.dd", null);
+                                if (startDateParsed.Date <= DateTime.UtcNow.Date &&
+                                    endDateParsed.Date >= DateTime.UtcNow.Date)
+                                {
+                                    var importer = new MorskaImporter(_db, _googleSheetValues);
+                                    importer.Import(importWorker);
+                                    Thread.Sleep(5000); // be aware of GSheet API quota
+
+                                    _logsController.AddEntry(new LogEntry
+                                    {
+                                        Title = $"{importWorker.Name}, {importWorker.Id}",
+                                        Type = LogEntryType.Info,
+                                        LogType = LogType.Import,
+                                        Message = "Success",
+                                        CreatedAt = DateTime.UtcNow
+                                    });
+                                }
+                                else if (IsImportedLayerUpToDate(importWorker) == false)
+                                {
+                                    var importer = new MorskaImporter(_db, _googleSheetValues);
+                                    importer.Import(importWorker);
+                                    Thread.Sleep(5000); // be aware of GSheet API quota
+
+                                    _logsController.AddEntry(new LogEntry
+                                    {
+                                        Title = $"{importWorker.Name}, {importWorker.Id}",
+                                        Type = LogEntryType.Warning,
+                                        LogType = LogType.Import,
+                                        Message = "Success (reimported)",
+                                        CreatedAt = DateTime.UtcNow
+                                    });
+                                }
+                                else
+                                {
+                                    _logsController.AddEntry(new LogEntry
+                                    {
+                                        Title = $"{importWorker.Name}, {importWorker.Id}",
+                                        Type = LogEntryType.Warning,
+                                        LogType = LogType.Import,
+                                        Message = "importLayer records are up to date. Not processed.",
+                                        CreatedAt = DateTime.UtcNow
+                                    });
+                                }
+
+                                break;
+                            }
+                    }
+                }
+                catch (Exception e)
+                {
+                    _logsController.AddEntry(new LogEntry
+                    {
+                        Title = $"{importWorker.Name}, {importWorker.Id}",
+                        Type = LogEntryType.Error,
+                        LogType = LogType.Import,
+                        Message = e.ToString(),
+                        CreatedAt = DateTime.UtcNow
+                    });
+                }
+            }
+
+            return Ok();
+        }
+        catch (Exception e)
+        {
+            _logsController.AddEntry(new LogEntry
+            {
+                Title = "Process error",
+                Type = LogEntryType.Error,
+                LogType = LogType.Import,
+                Message = e.ToString(),
+                CreatedAt = DateTime.UtcNow
+            });
+            return BadRequest(e.ToString());
+        }
+    }
+
+    [HttpGet]
+    [Route("AutoProcess/{apiKey}")]
+    [AllowAnonymous]
+    public IActionResult AutoProcess(string apiKey)
+    {
+        if (Request.Host.Value != _configuration["apiLocalUrl"] || apiKey != _configuration["apiKey"])
+        {
+            return Unauthorized();
+        }
+
+        if (_googleSheetValues is null)
+        {
+            throw new Exception("Google Sheets API not initialized");
+        }
+
+        string[] processTypes =
+        [
+            "T3-SingleSource",
+            "T3-SourceYearSummary",
+            "T3-MultiSourceSummary", // AA
+            "T3-MultiSourceYearSummary", // AA/13
+            "T4-SingleSource",
+            "T5-LastValues",
+            "T1-R1",
+            "T4-R2",
+            "T1-R3"
+        ];
+
+        foreach (var type in processTypes)
+        {
+            try
+            {
+                var processWorkerLayers = _db.Layers
+                    .Include(x => x.Records)
+                    .Where(x =>
+                        x.Records!.Any(y => y.Code == "Type" && y.Desc1 == "ProcessWorker") &&
+                        x.Records!.Any(y => y.Code == "IsEnabled" && y.Desc1 == "True") &&
+                        x.Records!.Any(y => y.Code == "ProcessType" && y.Desc1 == type)
+                    )
+                    .OrderBy(x => x.CreatedAt)
+                    .AsNoTracking()
+                    .ToList();
+
+                foreach (var processWorker in processWorkerLayers)
+                {
+                    try
+                    {
+                        ProcessLayer(processWorker);
+                    }
+                    catch (Exception e)
+                    {
+                        _logsController.AddEntry(new LogEntry
+                        {
+                            Title = $"{processWorker.Name}, {processWorker.Id}",
+                            Type = LogEntryType.Error,
+                            LogType = LogType.Process,
+                            Message = e.ToString(),
+                            CreatedAt = DateTime.UtcNow
+                        });
+                    }
+                }
+            }
+            catch (Exception e)
+            {
+                _logsController.AddEntry(new LogEntry
+                {
+                    Title = "Process error",
+                    Type = LogEntryType.Error,
+                    LogType = LogType.Process,
+                    Message = e.ToString(),
+                    CreatedAt = DateTime.UtcNow
+                });
+            }
+        }
+
+        return Ok();
+    }
+
+    private void ProcessLayer(Layer processWorker)
+    {
+        if (_googleSheetValues == null)
+        {
+            throw new Exception("Google Sheets API not initialized");
+        }
+
+        var year = processWorker.Records?.SingleOrDefault(x => x.Code == "Year")?.Desc1;
+        if (year == null)
+        {
+            throw new Exception("Year record nod found");
+        }
+
+        var processType = processWorker.Records?.SingleOrDefault(x => x.Code == "ProcessType")?.Desc1;
+        switch (processType)
+        {
+            case null:
+                throw new Exception("ProcessType record not found");
+            case "T3-SourceYearSummary":
+                {
+                    var processor =
+                        new T3SourceYearSummaryProcessor(_db);
+                    processor.Process(processWorker);
+
+                    _logsController.AddEntry(new LogEntry
+                    {
+                        Title = $"{processWorker.Name}, {processWorker.Id}",
+                        Type = LogEntryType.Info,
+                        LogType = LogType.Process,
+                        Message = "Success",
+                        CreatedAt = DateTime.UtcNow
+                    });
+                    return;
+                }
+            case "T3-MultiSourceYearSummary":
+                {
+                    var processor =
+                        new T3MultiSourceYearSummaryProcessor(_db);
+                    processor.Process(processWorker);
+
+                    _logsController.AddEntry(new LogEntry
+                    {
+                        Title = $"{processWorker.Name}, {processWorker.Id}",
+                        Type = LogEntryType.Info,
+                        LogType = LogType.Process,
+                        Message = "Success",
+                        CreatedAt = DateTime.UtcNow
+                    });
+                    return;
+                }
+            case "T3-MultiSourceCopySelectedCodesYearSummary":
+                {
+                    var processor =
+                        new T3MultiSourceCopySelectedCodesYearSummaryProcessor(_db);
+                    processor.Process(processWorker);
+
+                    _logsController.AddEntry(new LogEntry
+                    {
+                        Title = $"{processWorker.Name}, {processWorker.Id}",
+                        Type = LogEntryType.Info,
+                        LogType = LogType.Process,
+                        Message = "Success",
+                        CreatedAt = DateTime.UtcNow
+                    });
+                    return;
+                }
+            case "T1-R1":
+                {
+                    var processor = new T1R1Processor(_db, _googleSheetValues);
+                    processor.Process(processWorker);
+
+                    _logsController.AddEntry(new LogEntry
+                    {
+                        Title = $"{processWorker.Name}, {processWorker.Id}",
+                        Type = LogEntryType.Info,
+                        LogType = LogType.Process,
+                        Message = "Success",
+                        CreatedAt = DateTime.UtcNow
+                    });
+                    return;
+                }
+            case "T4-R2":
+                {
+                    var processor = new T4R2Processor(_db, _googleSheetValues);
+                    processor.Process(processWorker);
+
+                    _logsController.AddEntry(new LogEntry
+                    {
+                        Title = $"{processWorker.Name}, {processWorker.Id}",
+                        Type = LogEntryType.Info,
+                        LogType = LogType.Process,
+                        Message = "Success",
+                        CreatedAt = DateTime.UtcNow
+                    });
+                    return;
+                }
+            case "T1-R3":
+                {
+                    var processor = new T1R3Processor(_db, _googleSheetValues);
+                    processor.Process(processWorker);
+
+                    _logsController.AddEntry(new LogEntry
+                    {
+                        Title = $"{processWorker.Name}, {processWorker.Id}",
+                        Type = LogEntryType.Info,
+                        LogType = LogType.Process,
+                        Message = "Success",
+                        CreatedAt = DateTime.UtcNow
+                    });
+                    return;
+                }
+        }
+
+        var month = processWorker.Records?.SingleOrDefault(x => x.Code == "Month")?.Desc1;
+        if (month == null)
+        {
+            throw new Exception("Month record not found");
+        }
+
+        switch (processType!)
+        {
+            case "T3-SingleSource":
+                {
+                    var t3SingleSource = new T3SingleSourceProcessor(_db);
+                    t3SingleSource.Process(processWorker);
+                    break;
+                }
+            case "T4-SingleSource":
+                {
+                    var t4SingleSource = new T4SingleSourceProcessor(_db);
+                    t4SingleSource.Process(processWorker);
+                    break;
+                }
+            case "T5-LastValues":
+                {
+                    var t5LastValues = new T5LastValuesProcessor(_db);
+                    t5LastValues.Process(processWorker);
+                    break;
+                }
+            case "T3-MultiSourceSummary":
+                {
+                    var t3MultiSourceSummary =
+                        new T3MultiSourceSummaryProcessor(_db);
+                    t3MultiSourceSummary.Process(processWorker);
+                    break;
+                }
+            case "T3-MultiSourceCopySelectedCodes":
+                {
+                    var t3MultiSourceCopySelectedCode =
+                        new T3MultiSourceCopySelectedCodesProcessor(_db);
+                    t3MultiSourceCopySelectedCode.Process(processWorker);
+                    break;
+                }
+        }
+
+        _logsController.AddEntry(new LogEntry
+        {
+            Title = $"{processWorker.Name}, {processWorker.Id}",
+            Type = LogEntryType.Info,
+            LogType = LogType.Process,
+            Message = "Success",
+            CreatedAt = DateTime.UtcNow
+        });
+    }
+
+    internal void SaveRecords(Guid id, ICollection<Record> records, Guid currentUserId)
+    {
+        var toDelete = _db.Records.Where(x => x.LayerId == id).ToList();
+        if (toDelete.Count > 0)
+        {
+            _db.Records.RemoveRange(toDelete);
+        }
+
+        foreach (var record in records)
+        {
+            record.CreatedById = currentUserId;
+            record.CreatedAt = DateTime.UtcNow;
+            record.ModifiedById = currentUserId;
+            record.ModifiedAt = DateTime.UtcNow;
+            record.LayerId = id;
+            _db.Records.Add(record);
+        }
+    }
+
+    private static void WriteToConsole(params string[] messages)
+    {
+        foreach (var message in messages)
+        {
+            Console.WriteLine($"DiunaLog: {message}");
+        }
+    }
+
+    private bool IsImportedLayerUpToDate(Layer importWorker)
+    {
+        if (_googleSheetValues is null)
+        {
+            throw new Exception("Google Sheets API not initialized");
+        }
+
+        var newestLayer = _db.Layers
+            .Include(x => x.Records)
+            .Where(x => x.ParentId == importWorker.Id)
+            .OrderByDescending(x => x.CreatedAt)
+            .AsNoTracking()
+            .FirstOrDefault();
+
+        if (newestLayer is null)
+        {
+            return true; // importWorker is not active yet, no check needed
+        }
+
+        var sheetId = importWorker.Records!.FirstOrDefault(x => x.Code == "SheetId")?.Desc1;
+        if (sheetId == null)
+        {
+            throw new Exception($"SheetId not found, {importWorker.Name}");
+        }
+
+        var sheetTabName = importWorker.Records!.FirstOrDefault(x => x.Code == "SheetTabName")?.Desc1;
+        if (sheetTabName == null)
+        {
+            throw new Exception($"SheetTabName not found, {importWorker.Name}");
+        }
+
+        var dataRange = importWorker.Records!.FirstOrDefault(x => x.Code == "DataRange")?.Desc1;
+        if (dataRange == null)
+        {
+            throw new Exception($"DataRange not found, {importWorker.Name}");
+        }
+
+        var dataRangeResponse = _googleSheetValues.Get(sheetId, $"{sheetTabName}!{dataRange}").Execute();
+        var data = dataRangeResponse.Values;
+
+        var isUpToDate = true;
+
+        for (var i = 0; i < data[1].Count; i++)
+        {
+            if (data[0][i].ToString() == "") continue;
+            var record = newestLayer.Records!.FirstOrDefault(x => x.Code == data[0][i].ToString());
+            if (record == null)
+            {
+                WriteToConsole("Code not found in DiunaBI", data[0][i].ToString()!);
+                isUpToDate = false;
+                continue;
+            }
+
+            if (!double.TryParse(data[1][i].ToString(), CultureInfo.GetCultureInfo("pl-PL"),
+                    out var value) ||
+                double.Abs((double)(record.Value1 - value)!) < 0.01) continue;
+            isUpToDate = false;
+        }
+
+        foreach (var record in newestLayer.Records!)
+        {
+            if (data[0].Contains(record.Code))
+            {
+                continue;
+            }
+
+            WriteToConsole($"Code not found in GoogleSheet: {record.Code}");
+            isUpToDate = false;
+        }
+
+        return isUpToDate;
+    }
+}