DiunaBI/WebAPI/Controllers/LayersController.cs

using System.Globalization;
using System.Text;
using DiunaBIWebAPI.dataImporters;
using Google.Apis.Sheets.v4;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using WebAPI.dataProcessors;
using WebAPI.Exports;
using WebAPI.Models;

namespace WebAPI.Controllers
{
    [ApiController]
    [Route("api/[controller]")]
    public class LayersController : Controller
    {
        private readonly AppDbContext _db;
        private readonly SpreadsheetsResource.ValuesResource? _googleSheetValues;
        private readonly GoogleDriveHelper _googleDriveHelper;
        // private GoogleSheetsHelper _googleSheetsHelper;
        private readonly IConfiguration _configuration;
        private readonly LogsController _logsController;

        public LayersController(
            AppDbContext db,
            GoogleSheetsHelper googleSheetsHelper,
            GoogleDriveHelper googleDriveHelper,
            IConfiguration configuration)
        {
            _db = db;
            if (googleSheetsHelper.Service is not null)
            {
                _googleSheetValues = googleSheetsHelper.Service.Spreadsheets.Values;
            }

            //_googleSheetsHelper = googleSheetsHelper;
            _googleDriveHelper = googleDriveHelper;
            _configuration = configuration;
            _logsController = new LogsController(googleSheetsHelper, googleDriveHelper, configuration);
        }

        [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).ToList());
            }
            catch (Exception e)
            {
                return BadRequest(e.ToString());
            }
        }

        [HttpGet]
        [Route("{id}")]
        public IActionResult Get(Guid id)
        {
            try
            {
                return Ok(_db.Layers
                    .Include(x => x.CreatedBy)
                    .Include(x => x.Records).First(x => x.Id == id && !x.IsDeleted));
            }
            catch (Exception e)
            {
                return BadRequest(e.ToString());
            }
        }

        [HttpGet]
        [Route("getForPowerBI/{apiKey}/{number}")]
        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).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("exportToGoogleSheet/{id}")]
        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)).First(x => x.Id == id && !x.IsDeleted);

            var export = new googleSheetExport(_googleDriveHelper, _googleSheetValues, _configuration);
            export.export(layer);
            return Ok(true);
        }

        [HttpGet]
        [Route("AutoImport/{apiKey}")]
        [AllowAnonymous]
        public IActionResult AutoImport(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");
            }

            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")
                    //&& x.Records!.Any(x => x.Code == "ImportType" && x.Desc1 == "FK2")
                )
                .OrderBy(x => x.CreatedAt)
                .ToList();
            try
            {
                if (!importWorkerLayers.Any())
                {
                    _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";

                        if (type == "FK2")
                        {
                            var importer = new MorskaFk2Importer(_db, _googleSheetValues, this);
                            importer.import(importWorker);

                            _logsController.AddEntry(new LogEntry
                            {
                                Title = $"{importWorker.Name}, {importWorker.Id}",
                                Type = LogEntryType.info,
                                LogType = LogType.import,
                                Message = "Success",
                                CreatedAt = DateTime.UtcNow
                            });
                        }
                        else
                        {
                            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, this);
                                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)
                            {
                                MorskaImporter importer = new MorskaImporter(_db, _googleSheetValues, this);
                                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 of date. Not processed.",
                                    CreatedAt = DateTime.UtcNow
                                });
                            }
                        }
                    }
                    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",
                "T1-R1",
                "T4-R2"
            };

            foreach (string type in processTypes)
            {
                try
                {
                    _logsController.AddEntry(new LogEntry
                    {
                        Title = $"Processing: {type}",
                        Type = LogEntryType.info,
                        LogType = LogType.process,
                        CreatedAt = DateTime.UtcNow,
                    });

                    List<Layer> 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)
                        .ToList();

                    if (!processWorkerLayers.Any())
                    {
                        _logsController.AddEntry(new LogEntry
                        {
                            Title = "No Layers to process.",
                            Type = LogEntryType.info,
                            LogType = LogType.process,
                            CreatedAt = DateTime.UtcNow,
                        });
                    }

                    foreach (Layer 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":
                {
                    T3SourceYearSummaryProcessor processor =
                        new T3SourceYearSummaryProcessor(_db, _googleSheetValues, this);
                    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":
                {
                    T3MultiSourceYearSummaryProcessor processor =
                        new T3MultiSourceYearSummaryProcessor(_db, _googleSheetValues, this, _logsController);
                    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":
                {
                    T3MultiSourceCopySelectedCodesYearSummaryProcessor processor =
                        new T3MultiSourceCopySelectedCodesYearSummaryProcessor(_db, _googleSheetValues, this);
                    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":
                {
                    T1R1Processor processor = new T1R1Processor(_db, _googleSheetValues, this, _logsController);
                    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, this, _logsController);
                    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":
                {
                    T3SingleSourceProcessor processor = new T3SingleSourceProcessor(_db, _googleSheetValues, this);
                    processor.process(processWorker);
                    break;
                }
                case "T4-SingleSource":
                {
                    T4SingleSourceProcessor processor = new T4SingleSourceProcessor(_db, _googleSheetValues, this);
                    processor.process(processWorker);
                    break;
                }
                case "T3-MultiSourceSummary":
                {
                    T3MultiSourceSummaryProcessor processor =
                        new T3MultiSourceSummaryProcessor(_db, _googleSheetValues, this, _logsController);
                    processor.process(processWorker);
                    break;
                }
                case "T3-MultiSourceCopySelectedCodes":
                {
                    T3MultiSourceCopySelectedCodesProcessor processor =
                        new T3MultiSourceCopySelectedCodesProcessor(_db, _googleSheetValues, this);
                    processor.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)
        {
            List<Record> toDelete = _db.Records.Where(x => x.LayerId == id).ToList();
            if (toDelete.Count > 0)
            {
                _db.Records.RemoveRange(toDelete);
            }

            foreach (Record 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 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)
                .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;
                WriteToConsole(
                    $"Code: {data[0][i]}. DiunaBI: {record.Value1:N2}. GoogleSheet: {data[1][i]}");
                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;
        }
    }
}