812 lines
28 KiB
C#
812 lines
28 KiB
C#
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 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;
|
|
}
|
|
|
|
_googleDriveHelper = googleDriveHelper;
|
|
_configuration = configuration;
|
|
_logsController = new LogsController(googleSheetsHelper, _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:guid}")]
|
|
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: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).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: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)).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)
|
|
.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)
|
|
.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";
|
|
switch (type)
|
|
{
|
|
case "D1":
|
|
var d1Importer = new MorskaD1Importer(_db, _googleSheetValues, this);
|
|
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, this);
|
|
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, 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)
|
|
{
|
|
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.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
|
|
});
|
|
}
|
|
|
|
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_OLD",
|
|
"T1-R1",
|
|
"T4-R2",
|
|
"T1-R3"
|
|
];
|
|
|
|
foreach (var type in processTypes)
|
|
{
|
|
try
|
|
{
|
|
_logsController.AddEntry(new LogEntry
|
|
{
|
|
Title = $"Processing: {type}",
|
|
Type = LogEntryType.Info,
|
|
LogType = LogType.Process,
|
|
CreatedAt = DateTime.UtcNow
|
|
});
|
|
|
|
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)
|
|
.ToList();
|
|
|
|
if (processWorkerLayers.Count == 0)
|
|
{
|
|
_logsController.AddEntry(new LogEntry
|
|
{
|
|
Title = "No Layers to process.",
|
|
Type = LogEntryType.Info,
|
|
LogType = LogType.Process,
|
|
CreatedAt = DateTime.UtcNow
|
|
});
|
|
}
|
|
|
|
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, 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":
|
|
{
|
|
var processor =
|
|
new T3MultiSourceYearSummaryProcessor(_db, 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":
|
|
{
|
|
var processor =
|
|
new T3MultiSourceCopySelectedCodesYearSummaryProcessor(_db, 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_OLD":
|
|
{
|
|
var processor = new T1R1OldProcessor(_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 "T1-R1":
|
|
{
|
|
var 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, this, _logsController, _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, this, _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, this);
|
|
{
|
|
t3SingleSource.Process(processWorker);
|
|
break;
|
|
}
|
|
case "T4-SingleSource":
|
|
{
|
|
var t4SingleSource = new T4SingleSourceProcessor(_db, this);
|
|
t4SingleSource.Process(processWorker);
|
|
break;
|
|
}
|
|
case "T5-LastValues":
|
|
{
|
|
var t5LastValues = new T5LastValuesProcessor(_db, this);
|
|
t5LastValues.Process(processWorker);
|
|
break;
|
|
}
|
|
case "T3-MultiSourceSummary":
|
|
{
|
|
var t3MultiSourceSummary =
|
|
new T3MultiSourceSummaryProcessor(_db, this, _logsController);
|
|
t3MultiSourceSummary.Process(processWorker);
|
|
break;
|
|
}
|
|
case "T3-MultiSourceCopySelectedCodes":
|
|
{
|
|
var t3MultiSourceCopySelectedCode =
|
|
new T3MultiSourceCopySelectedCodesProcessor(_db, this);
|
|
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)
|
|
.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;
|
|
}
|
|
} |