862 lines
40 KiB
C#
862 lines
40 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Threading.Tasks;
|
|
using AyCode.Core.Extensions;
|
|
using AyCode.Core.Loggers;
|
|
using AyCode.Services.Nav.Ekaer;
|
|
using AyCode.Services.SignalRs;
|
|
using DocumentFormat.OpenXml.Office2010.Excel;
|
|
using FruitBank.Common.Dtos;
|
|
using FruitBank.Common.Entities;
|
|
using FruitBank.Common.Interfaces;
|
|
using FruitBank.Common.Loggers;
|
|
using FruitBank.Common.Models;
|
|
using FruitBank.Common.Server;
|
|
using FruitBank.Common.Server.Interfaces;
|
|
using FruitBank.Common.Server.Services.Ekaer;
|
|
using FruitBank.Common.Services.Ekaer;
|
|
using FruitBank.Common.SignalRs;
|
|
using LinqToDB;
|
|
using Mango.Nop.Core.Dtos;
|
|
using Mango.Nop.Core.Loggers;
|
|
using Mango.Nop.Core.Models;
|
|
using Nop.Core;
|
|
using Nop.Core.Domain.Customers;
|
|
using Nop.Core.Domain.Orders;
|
|
using Nop.Plugin.Misc.FruitBankPlugin.Domains.DataLayer;
|
|
using Nop.Plugin.Misc.FruitBankPlugin.Factories;
|
|
using Nop.Plugin.Misc.FruitBankPlugin.Services;
|
|
using Nop.Services.Customers;
|
|
using Nop.Services.Localization;
|
|
using Nop.Web.Framework.Controllers;
|
|
using NUglify.Helpers;
|
|
|
|
namespace Nop.Plugin.Misc.FruitBankPlugin.Controllers
|
|
{
|
|
//https://linq2db.github.io/articles/sql/Join-Operators.html
|
|
public class FruitBankDataController(
|
|
FruitBankDbContext ctx,
|
|
FruitBankAttributeService fruitBankAttributeService,
|
|
MeasurementService measurementService,
|
|
IWorkContext workContext,
|
|
ICustomerService customerService,
|
|
ICustomerRegistrationService customerRegistrationService,
|
|
ILocalizationService localizationService,
|
|
PreOrderConversionService preorderConversionService,
|
|
IFruitBankEkaerService fruitBankEkaerService,
|
|
IEkaerSettings ekaerSettings,
|
|
IEnumerable<IAcLogWriterBase> logWriters)
|
|
: BasePluginController, IFruitBankDataControllerServer
|
|
{
|
|
private const int LastShippingDays = 15;
|
|
private readonly ILogger _logger = new Logger<FruitBankDataController>(logWriters.ToArray());
|
|
|
|
[SignalR(SignalRTags.ProcessAndSaveFullShippingJson)]
|
|
public async Task<List<Partner>> ProcessAndSaveFullShippingJson(string fullShippingJson, int customerId)
|
|
{
|
|
return await measurementService.ProcessAndSaveFullShippingJson(fullShippingJson, customerId);
|
|
}
|
|
|
|
[SignalR(SignalRTags.GetGenericAttributeDtosByEntityIdAndKeyGroup)]
|
|
public async Task<List<GenericAttributeDto>> GetGenericAttributeDtosByEntityIdAndKeyGroup(int productId, string keyGroup, int storeId)
|
|
{
|
|
return await ctx.GetGenericAttributeDtosByEntityIdAndKeyGroup(productId, keyGroup, storeId);
|
|
}
|
|
|
|
[SignalR(SignalRTags.AddGenericAttributeDto)]
|
|
public async Task<GenericAttributeDto> AddGenericAttributeDto(GenericAttributeDto genericAttributeDto)
|
|
{
|
|
await ctx.GenericAttributeDtos.InsertAsync(genericAttributeDto);
|
|
return await ctx.GenericAttributeDtos.GetByIdAsync(genericAttributeDto.Id);
|
|
}
|
|
|
|
[SignalR(SignalRTags.UpdateGenericAttributeDto)]
|
|
public async Task<GenericAttributeDto> UpdateGenericAttributeDto(GenericAttributeDto genericAttributeDto)
|
|
{
|
|
await ctx.GenericAttributeDtos.UpdateAsync(genericAttributeDto);
|
|
return await ctx.GenericAttributeDtos.GetByIdAsync(genericAttributeDto.Id);
|
|
}
|
|
|
|
[SignalR(SignalRTags.GetStockQuantityHistoryDtos)]
|
|
public async Task<List<StockQuantityHistoryDto>> GetStockQuantityHistoryDtos()
|
|
{
|
|
_logger.Detail($"GetStockQuantityHistoryDtos invoked; lastDaysCount: {LastShippingDays}");
|
|
|
|
var fromDateUtc = DateTime.UtcNow.Date.AddDays(-LastShippingDays);
|
|
return await ctx.StockQuantityHistoryDtos.GetAll(true).Where(sqh => sqh.CreatedOnUtc >= fromDateUtc).ToListAsync();
|
|
}
|
|
|
|
[SignalR(SignalRTags.GetStockQuantityHistoryDtosByProductId)]
|
|
public async Task<List<StockQuantityHistoryDto>> GetStockQuantityHistoryDtosByProductId(int productId)
|
|
{
|
|
_logger.Detail($"GetStockQuantityHistoryDtosByProductId invoked; productId: {productId}; lastDaysCount: {LastShippingDays}");
|
|
|
|
var fromDateUtc = DateTime.UtcNow.Date.AddDays(-LastShippingDays);
|
|
return await ctx.StockQuantityHistoryDtos.GetByProductIdAsync(productId, true).Where(sqh => sqh.CreatedOnUtc >= fromDateUtc).ToListAsync();
|
|
}
|
|
|
|
[SignalR(SignalRTags.GetMeasuringModels)]
|
|
public Task<List<MeasuringModel>> GetMeasuringModels()
|
|
{
|
|
throw new NotImplementedException("GetMeasuringModels");
|
|
}
|
|
|
|
[SignalR(SignalRTags.GetPartners)]
|
|
public async Task<List<Partner>> GetPartners()
|
|
{
|
|
_logger.Detail($"GetPartners invoked");
|
|
|
|
return await ctx.Partners.GetAll().ToListAsync();
|
|
}
|
|
|
|
[SignalR(SignalRTags.GetPartnerById)]
|
|
public async Task<Partner> GetPartnerById(int id)
|
|
{
|
|
_logger.Detail($"GetPartnerById invoked; id: {id}");
|
|
|
|
//var customers = await ctx.GetCustormersBySystemRoleName("Measuring").ToListAsync();
|
|
//_logger.Error($"COUNT: {customers.Count}");
|
|
|
|
return await ctx.Partners.GetByIdAsync(id);
|
|
}
|
|
|
|
[SignalR(SignalRTags.AddPartner)]
|
|
public async Task<Partner> AddPartner(Partner partner)
|
|
{
|
|
ArgumentNullException.ThrowIfNull(partner);
|
|
|
|
_logger.Detail($"AddPartner invoked; id: {partner.Id}");
|
|
|
|
await ctx.Partners.InsertAsync(partner);
|
|
return await ctx.Partners.GetByIdAsync(partner.Id, partner.ShippingDocuments != null);
|
|
}
|
|
|
|
[SignalR(SignalRTags.UpdatePartner)]
|
|
public async Task<Partner> UpdatePartner(Partner partner)
|
|
{
|
|
ArgumentNullException.ThrowIfNull(partner);
|
|
|
|
_logger.Detail($"UpdatePartner invoked; id: {partner.Id}");
|
|
|
|
await ctx.Partners.UpdateAsync(partner);
|
|
return await ctx.Partners.GetByIdAsync(partner.Id, partner.ShippingDocuments != null);
|
|
}
|
|
|
|
[SignalR(SignalRTags.GetCargoPartners)]
|
|
public async Task<List<CargoPartner>> GetCargoPartners()
|
|
{
|
|
_logger.Detail($"GetCargoPartners invoked");
|
|
|
|
return await ctx.CargoPartners.GetAll(true).ToListAsync();
|
|
}
|
|
|
|
[SignalR(SignalRTags.GetCargoPartnerById)]
|
|
public async Task<CargoPartner> GetCargoPartnerById(int id)
|
|
{
|
|
_logger.Detail($"GetCargoPartnerById invoked; id: {id}");
|
|
return await ctx.CargoPartners.GetByIdAsync(id, true);
|
|
}
|
|
|
|
[SignalR(SignalRTags.AddCargoPartner)]
|
|
public async Task<CargoPartner> AddCargoPartner(CargoPartner cargoPartner)
|
|
{
|
|
ArgumentNullException.ThrowIfNull(cargoPartner);
|
|
|
|
_logger.Detail($"AddCargoPartner invoked; id: {cargoPartner.Id}");
|
|
|
|
await ctx.CargoPartners.InsertAsync(cargoPartner);
|
|
return await ctx.CargoPartners.GetByIdAsync(cargoPartner.Id, cargoPartner.CargoTrucks != null);
|
|
}
|
|
|
|
[SignalR(SignalRTags.UpdateCargoPartner)]
|
|
public async Task<CargoPartner> UpdateCargoPartner(CargoPartner cargoPartner)
|
|
{
|
|
ArgumentNullException.ThrowIfNull(cargoPartner);
|
|
|
|
_logger.Detail($"UpdateCargoPartner invoked; id: {cargoPartner.Id}");
|
|
|
|
await ctx.CargoPartners.UpdateAsync(cargoPartner);
|
|
return await ctx.CargoPartners.GetByIdAsync(cargoPartner.Id, cargoPartner.CargoTrucks != null);
|
|
}
|
|
|
|
|
|
[SignalR(SignalRTags.GetCargoTrucks)]
|
|
public async Task<List<CargoTruck>> GetCargoTrucks()
|
|
{
|
|
_logger.Detail($"GetCargoTrucks invoked");
|
|
|
|
return await ctx.CargoTrucks.GetAll(true).ToListAsync();
|
|
}
|
|
|
|
[SignalR(SignalRTags.GetCargoTruckById)]
|
|
public async Task<CargoTruck> GetCargoTruckById(int id)
|
|
{
|
|
_logger.Detail($"GetCargoTruckById invoked; id: {id}");
|
|
return await ctx.CargoTrucks.GetByIdAsync(id, true);
|
|
}
|
|
|
|
[SignalR(SignalRTags.GetCargoTrucksByCargoPartnerId)]
|
|
public async Task<List<CargoTruck>> GetCargoTrucksByCargoPartnerId(int cargoPartnerId)
|
|
{
|
|
_logger.Detail($"GetCargoTrucksByCargoPartnerId invoked; cargoPartnerId: {cargoPartnerId}");
|
|
return await ctx.CargoTrucks.GetByCargoPartnerId(cargoPartnerId, true).ToListAsync();
|
|
}
|
|
|
|
[SignalR(SignalRTags.AddCargoTruck)]
|
|
public async Task<CargoTruck> AddCargoTruck(CargoTruck cargoTruck)
|
|
{
|
|
ArgumentNullException.ThrowIfNull(cargoTruck);
|
|
|
|
_logger.Detail($"AddCargoTruck invoked; id: {cargoTruck.Id}");
|
|
|
|
await ctx.CargoTrucks.InsertAsync(cargoTruck);
|
|
return await ctx.CargoTrucks.GetByIdAsync(cargoTruck.Id, true);
|
|
}
|
|
|
|
[SignalR(SignalRTags.UpdateCargoTruck)]
|
|
public async Task<CargoTruck> UpdateCargoTruck(CargoTruck cargoTruck)
|
|
{
|
|
ArgumentNullException.ThrowIfNull(cargoTruck);
|
|
|
|
_logger.Detail($"UpdateCargoTruck invoked; id: {cargoTruck.Id}");
|
|
|
|
await ctx.CargoTrucks.UpdateAsync(cargoTruck);
|
|
return await ctx.CargoTrucks.GetByIdAsync(cargoTruck.Id, true);
|
|
}
|
|
|
|
[SignalR(SignalRTags.GetPartnerDepots)]
|
|
public async Task<List<PartnerDepot>> GetPartnerDepots()
|
|
{
|
|
_logger.Detail($"GetPartnerDepots invoked");
|
|
|
|
return await ctx.PartnerDepots.GetAll(true).ToListAsync();
|
|
}
|
|
|
|
[SignalR(SignalRTags.GetPartnerDepotById)]
|
|
public async Task<PartnerDepot> GetPartnerDepotById(int id)
|
|
{
|
|
_logger.Detail($"GetPartnerDepotById invoked; id: {id}");
|
|
return await ctx.PartnerDepots.GetByIdAsync(id, true);
|
|
}
|
|
|
|
[SignalR(SignalRTags.GetPartnerDepotsByPartnerId)]
|
|
public async Task<List<PartnerDepot>> GetPartnerDepotsByPartnerId(int partnerId)
|
|
{
|
|
_logger.Detail($"GetPartnerDepotsByPartnerId invoked; partnerId: {partnerId}");
|
|
return await ctx.PartnerDepots.GetByPartnerId(partnerId, true).ToListAsync();
|
|
}
|
|
|
|
[SignalR(SignalRTags.AddPartnerDepot)]
|
|
public async Task<PartnerDepot> AddPartnerDepot(PartnerDepot partnerDepot)
|
|
{
|
|
ArgumentNullException.ThrowIfNull(partnerDepot);
|
|
|
|
_logger.Detail($"AddPartnerDepot invoked; id: {partnerDepot.Id}");
|
|
|
|
await ctx.PartnerDepots.InsertAsync(partnerDepot);
|
|
return await ctx.PartnerDepots.GetByIdAsync(partnerDepot.Id, true);
|
|
}
|
|
|
|
[SignalR(SignalRTags.UpdatePartnerDepot)]
|
|
public async Task<PartnerDepot> UpdatePartnerDepot(PartnerDepot partnerDepot)
|
|
{
|
|
ArgumentNullException.ThrowIfNull(partnerDepot);
|
|
|
|
_logger.Detail($"UpdatePartnerDepot invoked; id: {partnerDepot.Id}");
|
|
|
|
await ctx.PartnerDepots.UpdateAsync(partnerDepot);
|
|
return await ctx.PartnerDepots.GetByIdAsync(partnerDepot.Id, true);
|
|
}
|
|
|
|
[SignalR(SignalRTags.GetEkaerHistories)]
|
|
public async Task<List<EkaerHistory>> GetEkaerHistories(EkaerHistoryFilter ekaerHistoryFilter)
|
|
{
|
|
_logger.Detail($"GetEkaerHistories invoked; ekaerHistoryFilter: {ekaerHistoryFilter}");
|
|
|
|
// Szerver-oldali szűrés (a tabokhoz) a StatusId int-oszlopon — a helper-ek nem fordulnak SQL-re,
|
|
// ezért közvetlen StatusId-összehasonlítás. All / ismeretlen → minden.
|
|
IQueryable<EkaerHistory> query = ctx.EkaerHistories.GetAll();
|
|
query = ekaerHistoryFilter switch
|
|
{
|
|
EkaerHistoryFilter.ToSubmit => query.Where(eh => eh.StatusId != (int)EkaerStatus.Sent && eh.StatusId != (int)EkaerStatus.SentWithMissingData),
|
|
EkaerHistoryFilter.Sent => query.Where(eh => eh.StatusId == (int)EkaerStatus.Sent),
|
|
EkaerHistoryFilter.NeedsCompletion => query.Where(eh => eh.StatusId == (int)EkaerStatus.SentWithMissingData),
|
|
_ => query,
|
|
};
|
|
|
|
return await query.ToListAsync();
|
|
}
|
|
|
|
[SignalR(SignalRTags.GetEkaerHistoryById)]
|
|
public async Task<EkaerHistory> GetEkaerHistoryById(int id)
|
|
{
|
|
_logger.Detail($"GetEkaerHistoryById invoked; id: {id}");
|
|
return await ctx.EkaerHistories.GetByIdAsync(id);
|
|
}
|
|
|
|
[SignalR(SignalRTags.GetEkaerHistoriesByForeignKey)]
|
|
public async Task<List<EkaerHistory>> GetEkaerHistoriesByForeignKey(int foreignKey)
|
|
{
|
|
_logger.Detail($"GetEkaerHistoriesByForeignKey invoked; foreignKey: {foreignKey}");
|
|
return await ctx.EkaerHistories.GetByForeignKey(foreignKey).ToListAsync();
|
|
}
|
|
|
|
[SignalR(SignalRTags.AddEkaerHistory)]
|
|
public async Task<EkaerHistory> AddEkaerHistory(EkaerHistory ekaerHistory)
|
|
{
|
|
ArgumentNullException.ThrowIfNull(ekaerHistory);
|
|
|
|
_logger.Detail($"AddEkaerHistory invoked; id: {ekaerHistory.Id}");
|
|
|
|
await ctx.EkaerHistories.InsertAsync(ekaerHistory);
|
|
return await ctx.EkaerHistories.GetByIdAsync(ekaerHistory.Id);
|
|
}
|
|
|
|
[SignalR(SignalRTags.UpdateEkaerHistory)]
|
|
public async Task<EkaerHistory> UpdateEkaerHistory(EkaerHistory ekaerHistory)
|
|
{
|
|
ArgumentNullException.ThrowIfNull(ekaerHistory);
|
|
|
|
_logger.Detail($"UpdateEkaerHistory invoked; id: {ekaerHistory.Id}");
|
|
|
|
await ctx.EkaerHistories.UpdateAsync(ekaerHistory);
|
|
return await ctx.EkaerHistories.GetByIdAsync(ekaerHistory.Id);
|
|
}
|
|
|
|
[SignalR(SignalRTags.GenerateEkaerXmlDocument)]
|
|
public async Task<EkaerHistory> GenerateEkaerXmlDocument(int foreignKey, bool isOutgoing)
|
|
{
|
|
_logger.Detail($"GenerateEkaerXmlDocument invoked; foreignKey: {foreignKey}; isOutgoing: {isOutgoing}");
|
|
|
|
// Upsert: (ForeignKey + IsOutgoing) párra EGY rekord — az újragenerálás nem duplikál.
|
|
var ekaerHistory = await ctx.EkaerHistories.GetByForeignKey(foreignKey).FirstOrDefaultAsync(eh => eh.IsOutgoing == isOutgoing);
|
|
|
|
if (!isOutgoing)
|
|
{
|
|
// Bejövő: a GetAll(true) a mapperhez kellő teljes gráfot tölti (Partner, Items+ProductDto, Shipping→járművek).
|
|
var shippingDocument = await ctx.ShippingDocuments.GetByIdAsync(foreignKey, true)
|
|
?? throw new ArgumentException($"ShippingDocument not found; id: {foreignKey}", nameof(foreignKey));
|
|
ekaerHistory = fruitBankEkaerService.GenerateEkaerXmlDocument(shippingDocument, ekaerHistory);
|
|
}
|
|
else
|
|
{
|
|
// Kimenő: a GetByIdAsync(true) betölti a Customer-t, tételeket, palettákat (GrossWeight) és a ProductDto-t.
|
|
var order = await ctx.OrderDtos.GetByIdAsync(foreignKey, true)
|
|
?? throw new ArgumentException($"Order not found; id: {foreignKey}", nameof(foreignKey));
|
|
ekaerHistory = fruitBankEkaerService.GenerateEkaerXmlDocument(order, ekaerHistory);
|
|
}
|
|
|
|
if (ekaerHistory.Id > 0) await ctx.EkaerHistories.UpdateAsync(ekaerHistory);
|
|
else await ctx.EkaerHistories.InsertAsync(ekaerHistory);
|
|
|
|
return await ctx.EkaerHistories.GetByIdAsync(ekaerHistory.Id) ?? ekaerHistory;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Idempotens rekord-létrehozás: ha a (foreignKey, isOutgoing) párra már van EkaerHistory, azt adja vissza
|
|
/// érintetlenül; különben új Pending rekordot hoz létre. A generálás (XmlDoc) külön lépés: GenerateEkaerXmlDocument.
|
|
/// </summary>
|
|
[SignalR(SignalRTags.CreateEkaerHistory)]
|
|
public async Task<EkaerHistory> CreateEkaerHistory(int foreignKey, bool isOutgoing)
|
|
{
|
|
_logger.Detail($"CreateEkaerHistory invoked; foreignKey: {foreignKey}; isOutgoing: {isOutgoing}");
|
|
|
|
var existing = await ctx.EkaerHistories.GetByForeignKey(foreignKey).FirstOrDefaultAsync(eh => eh.IsOutgoing == isOutgoing);
|
|
if (existing != null) return existing;
|
|
|
|
// A forrás-entitás léte irányfüggő: bejövő → ShippingDocument, kimenő → Order.
|
|
if (!isOutgoing)
|
|
{
|
|
_ = await ctx.ShippingDocuments.GetByIdAsync(foreignKey, false)
|
|
?? throw new ArgumentException($"ShippingDocument not found; id: {foreignKey}", nameof(foreignKey));
|
|
}
|
|
else
|
|
{
|
|
_ = await ctx.OrderDtos.GetByIdAsync(foreignKey, false)
|
|
?? throw new ArgumentException($"Order not found; id: {foreignKey}", nameof(foreignKey));
|
|
}
|
|
|
|
var ekaerHistory = new EkaerHistory { ForeignKey = foreignKey, IsOutgoing = isOutgoing, Status = EkaerStatus.Pending };
|
|
await ctx.EkaerHistories.InsertAsync(ekaerHistory);
|
|
|
|
return await ctx.EkaerHistories.GetByIdAsync(ekaerHistory.Id) ?? ekaerHistory;
|
|
}
|
|
|
|
/// <summary>
|
|
/// A megadott dátumtól kezdődő, EKÁER-rekord nélküli szállítólevelekre Pending rekordot hoz létre.
|
|
/// User-vezérelt (toolbar gomb) — szándékosan NINCS automata rekord-érzékelés: a létrehozás explicit,
|
|
/// idempotens, és bármikor újrafuttatható (maga a gomb a "reconciliation").
|
|
/// </summary>
|
|
[SignalR(SignalRTags.CreateMissingEkaerHistories)]
|
|
public async Task<int> CreateMissingEkaerHistories(DateTime fromDate)
|
|
{
|
|
_logger.Detail($"CreateMissingEkaerHistories invoked; fromDate: {fromDate:yyyy-MM-dd}");
|
|
|
|
// Bejövő: rekord nélküli szállítólevelek a dátumtól — Partnerrel és tételekkel betöltve a kapuhoz
|
|
// (IsEkaer-mentesség + tömeg/érték küszöb). A fájl-blobokat NEM töltjük (csak Partner + Items).
|
|
var candidates = await ctx.ShippingDocuments.GetAll()
|
|
.Where(sd => sd.ShippingDate >= fromDate)
|
|
.Where(sd => !ctx.EkaerHistories.Table.Any(eh => eh.ForeignKey == sd.Id && !eh.IsOutgoing))
|
|
.LoadWith(sd => sd.Partner)
|
|
.LoadWith(sd => sd.ShippingItems)
|
|
.ToListAsync();
|
|
|
|
var missingInbound = new List<EkaerHistory>();
|
|
foreach (var doc in candidates)
|
|
{
|
|
// Explicit mentesítés (pl. nagybani piac, azonos cím — nincs közúti fuvar a partnerek között).
|
|
if (doc.Partner?.IsEkaer == false) continue;
|
|
|
|
var items = doc.ShippingItems ?? [];
|
|
var totalWeight = items.Sum(i => i.MeasuredGrossWeight);
|
|
var rateToHuf = EkaerValueCalculator.ResolveRateToHuf(doc.Partner?.Currency, ekaerSettings.EurHufRate);
|
|
var totalValueHuf = items.Sum(EkaerValueCalculator.ItemLineValue) * rateToHuf;
|
|
|
|
// Küszöb alatt (tömeg ÉS érték is) → nem kötelező EKÁER → nem hozunk létre sort.
|
|
if (totalWeight < ekaerSettings.ThresholdWeightKg && totalValueHuf < ekaerSettings.ThresholdValueHuf) continue;
|
|
|
|
missingInbound.Add(new EkaerHistory { ForeignKey = doc.Id, IsOutgoing = false, StatusId = (int)EkaerStatus.Pending });
|
|
}
|
|
|
|
// Kimenő: rekord nélküli, lezárt (Complete) rendelések, DateOfReceipt a dátumtól (jövőbeli is — előre-bejelentés).
|
|
var missingOutgoing = await ctx.OrderDtos.GetAllByOrderStatus(OrderStatus.Complete, false)
|
|
.Where(o => o.GenericAttributes.Any(ga => ga.Key == nameof(OrderDto.DateOfReceipt) && DateTime.Parse(ga.Value) >= fromDate.Date))
|
|
.Where(o => !ctx.EkaerHistories.Table.Any(eh => eh.ForeignKey == o.Id && eh.IsOutgoing))
|
|
.Select(o => new EkaerHistory { ForeignKey = o.Id, IsOutgoing = true, StatusId = (int)EkaerStatus.Pending })
|
|
.ToListAsync();
|
|
|
|
var createdCount = 0;
|
|
|
|
foreach (var ekaerHistory in missingInbound.Concat(missingOutgoing))
|
|
{
|
|
try
|
|
{
|
|
await ctx.EkaerHistories.InsertAsync(ekaerHistory);
|
|
createdCount++;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.Error($"CreateMissingEkaerHistories; insert failed; ForeignKey: {ekaerHistory.ForeignKey}; IsOutgoing: {ekaerHistory.IsOutgoing}", ex);
|
|
}
|
|
}
|
|
|
|
_logger.Info($"CreateMissingEkaerHistories; created: {createdCount} (inbound: {missingInbound.Count}, outgoing: {missingOutgoing.Count}); fromDate: {fromDate:yyyy-MM-dd}");
|
|
return createdCount;
|
|
}
|
|
|
|
[SignalR(SignalRTags.GetShippings)]
|
|
public async Task<List<Shipping>> GetShippings()
|
|
{
|
|
_logger.Detail($"GetShippings invoked; lastDaysCount: {LastShippingDays}");
|
|
|
|
var fromDateUtc = DateTime.UtcNow.Date.AddDays(-LastShippingDays);
|
|
return await ctx.Shippings.GetAll(true).Where(s => s.ShippingDate >= fromDateUtc).ToListAsync();
|
|
//return await ctx.Shippings.Table.LoadWith(sd => sd.ShippingDocuments).ThenLoad(si => si.ShippingItems).ToListAsync();
|
|
}
|
|
|
|
[SignalR(SignalRTags.GetNotMeasuredShippings)]
|
|
public async Task<List<Shipping>> GetNotMeasuredShippings()
|
|
{
|
|
_logger.Detail($"GetNotMeasuredShippings invoked; lastDaysCount: {LastShippingDays}");
|
|
|
|
var startTime = DateTime.Now;
|
|
var shippings = await ctx.Shippings.GetAllNotMeasured(true, LastShippingDays).ToListAsync();
|
|
|
|
_logger.Detail($"GetNotMeasuredShippings; shippingsCount: {shippings.Count}; dbResponse: {(DateTime.Now - startTime).TotalSeconds} sec.");
|
|
return shippings;
|
|
|
|
}
|
|
|
|
[SignalR(SignalRTags.GetShippingById)]
|
|
public async Task<Shipping> GetShippingById(int id)
|
|
{
|
|
_logger.Detail($"GetShippingById invoked; id: {id}");
|
|
|
|
return await ctx.Shippings.GetByIdAsync(id, true);
|
|
}
|
|
|
|
[SignalR(SignalRTags.AddShipping)]
|
|
public async Task<Shipping> AddShipping(Shipping shipping)
|
|
{
|
|
ArgumentNullException.ThrowIfNull(shipping);
|
|
|
|
_logger.Detail($"AddShipping invoked; id: {shipping.Id}");
|
|
|
|
await ctx.Shippings.InsertAsync(shipping);
|
|
return await ctx.Shippings.GetByIdAsync(shipping.Id, true);
|
|
}
|
|
|
|
[SignalR(SignalRTags.UpdateShipping)]
|
|
public async Task<Shipping> UpdateShipping(Shipping shipping)
|
|
{
|
|
ArgumentNullException.ThrowIfNull(shipping);
|
|
|
|
_logger.Detail($"UpdateShipping invoked; id: {shipping.Id}");
|
|
|
|
await ctx.Shippings.UpdateAsync(shipping);
|
|
return await ctx.Shippings.GetByIdAsync(shipping.Id, true);
|
|
}
|
|
|
|
[SignalR(SignalRTags.GetShippingItems)]
|
|
public async Task<List<ShippingItem>> GetShippingItems()
|
|
{
|
|
_logger.Detail($"GetShippingItems invoked; lastDaysCount: {LastShippingDays}");
|
|
|
|
var fromDateUtc = DateTime.UtcNow.Date.AddDays(-LastShippingDays);
|
|
return await ctx.ShippingItems.GetAll(true).Where(si => si.ShippingDocument.Shipping == null ||
|
|
si.ShippingDocument.Shipping.ShippingDate >= fromDateUtc).ToListAsync();
|
|
}
|
|
|
|
[SignalR(SignalRTags.GetShippingItemsByDocumentId)]
|
|
public async Task<List<ShippingItem>> GetShippingItemsByDocumentId(int shippingDocumentId)
|
|
{
|
|
_logger.Detail($"GetShippingItemsByDocumentId invoked");
|
|
|
|
return await ctx.ShippingItems.GetAllByShippingDocumentIdAsync(shippingDocumentId, true).ToListAsync();
|
|
}
|
|
|
|
[SignalR(SignalRTags.GetShippingItemsByShippingId)]
|
|
public async Task<List<ShippingItem>> GetShippingItemsByShippingId(int shippingId)
|
|
{
|
|
_logger.Detail($"GetShippingItemsByShippingId invoked");
|
|
|
|
return await ctx.ShippingItems.GetAllByShippingIdAsync(shippingId, true).ToListAsync();
|
|
}
|
|
|
|
[SignalR(SignalRTags.GetShippingItemsByPartnerId)]
|
|
public async Task<List<ShippingItem>> GetShippingItemsByPartnerId(int partnerId)
|
|
{
|
|
_logger.Detail($"GetShippingItemsByPartnerId invoked");
|
|
|
|
return await ctx.ShippingItems.GetAllByPartnerIdAsync(partnerId, true).ToListAsync();
|
|
}
|
|
|
|
[SignalR(SignalRTags.GetShippingItemById)]
|
|
public async Task<ShippingItem> GetShippingItemById(int id)
|
|
{
|
|
_logger.Detail($"GetShippingItemById invoked; id: {id}");
|
|
|
|
var shippingItem = await ctx.ShippingItems.GetByIdAsync(id, true);
|
|
return shippingItem;
|
|
}
|
|
|
|
[SignalR(SignalRTags.AddShippingItem)]
|
|
public async Task<ShippingItem> AddShippingItem(ShippingItem shippingItem)
|
|
{
|
|
ArgumentNullException.ThrowIfNull(shippingItem);
|
|
|
|
_logger.Detail($"AddShippingItem invoked; id: {shippingItem.Id}");
|
|
|
|
if (!await ctx.AddShippingItemAsync(shippingItem)) return null;
|
|
|
|
// Update IncomingQuantity — EventConsumer handles conversion separately
|
|
if (shippingItem.ProductId.HasValue && shippingItem.QuantityOnDocument > 0)
|
|
await preorderConversionService.SyncIncomingQuantityAsync(
|
|
shippingItem.ProductId.Value, 0, shippingItem.QuantityOnDocument);
|
|
|
|
return await ctx.ShippingItems.GetByIdAsync(shippingItem.Id, true);
|
|
}
|
|
|
|
[SignalR(SignalRTags.UpdateShippingItem)]
|
|
public async Task<ShippingItem> UpdateShippingItem(ShippingItem shippingItem)
|
|
{
|
|
ArgumentNullException.ThrowIfNull(shippingItem);
|
|
|
|
_logger.Detail($"UpdateShippingItem invoked; id: {shippingItem.Id}");
|
|
|
|
// Load BEFORE the update to capture previous ProductId and QuantityOnDocument
|
|
var oldItem = await ctx.ShippingItems.GetByIdAsync(shippingItem.Id, false);
|
|
|
|
if (!await ctx.UpdateShippingItemSafeAsync(shippingItem)) return null;
|
|
|
|
if (oldItem != null)
|
|
{
|
|
var productChanged = oldItem.ProductId != shippingItem.ProductId;
|
|
var quantityChanged = oldItem.QuantityOnDocument != shippingItem.QuantityOnDocument;
|
|
|
|
if (productChanged && shippingItem.ProductId.HasValue)
|
|
{
|
|
// Full replacement: swap stock, order items, preorder items
|
|
await preorderConversionService.ReplaceShippingItemProductAsync(
|
|
shippingItem.Id, shippingItem.ProductId.Value, oldItem);
|
|
}
|
|
else if (quantityChanged && shippingItem.ProductId.HasValue)
|
|
{
|
|
// Only quantity changed: sync IncomingQuantity delta
|
|
await preorderConversionService.SyncIncomingQuantityAsync(
|
|
shippingItem.ProductId.Value,
|
|
oldItem.QuantityOnDocument,
|
|
shippingItem.QuantityOnDocument);
|
|
|
|
// If quantity increased, trigger conversion
|
|
// (EventConsumer also fires this, double-call is idempotent)
|
|
if (shippingItem.QuantityOnDocument > oldItem.QuantityOnDocument)
|
|
_ = Task.Run(async () => await preorderConversionService
|
|
.ConvertPreOrdersForProductsAsync(
|
|
new List<int> { shippingItem.ProductId.Value },
|
|
shippingItem.ShippingDocumentId));
|
|
}
|
|
}
|
|
|
|
return await ctx.ShippingItems.GetByIdAsync(shippingItem.Id, shippingItem.ShippingDocument != null);
|
|
}
|
|
|
|
[SignalR(SignalRTags.UpdateMeasuredShippingItem)]
|
|
public async Task<ShippingItem> UpdateMeasuredShippingItem(ShippingItem shippingItem)
|
|
{
|
|
ArgumentNullException.ThrowIfNull(shippingItem);
|
|
|
|
_logger.Detail($"UpdateMeasuredShippingItem invoked; id: {shippingItem.Id}");
|
|
|
|
if (!await ctx.UpdateMeasuredShippingItemSafeAsync(shippingItem)) return null;
|
|
return await ctx.ShippingItems.GetByIdAsync(shippingItem.Id, shippingItem.ShippingDocument != null);
|
|
}
|
|
|
|
[SignalR(SignalRTags.GetShippingItemPallets)]
|
|
public async Task<List<ShippingItemPallet>> GetShippingItemPallets()
|
|
{
|
|
_logger.Detail($"GetShippingItemPallets invoked; lastDaysCount: {LastShippingDays}");
|
|
|
|
var fromDateUtc = DateTime.UtcNow.Date.AddDays(-LastShippingDays);
|
|
|
|
return await ctx.ShippingItemPallets.GetAll(true).Where(sip => sip.ShippingItem.ShippingDocument.Shipping == null ||
|
|
sip.ShippingItem.ShippingDocument.Shipping.ShippingDate >= fromDateUtc).ToListAsync();
|
|
}
|
|
|
|
[SignalR(SignalRTags.AddShippingItemPallet)]
|
|
public async Task<ShippingItemPallet> AddShippingItemPallet(ShippingItemPallet shippingItemPallet)
|
|
{
|
|
ArgumentNullException.ThrowIfNull(shippingItemPallet);
|
|
|
|
_logger.Detail($"AddShippingItemPallet invoked; {shippingItemPallet}");
|
|
|
|
if (!await ctx.AddShippingItemPalletSafeAsync(shippingItemPallet)) return null;
|
|
return await ctx.ShippingItemPallets.GetByIdAsync(shippingItemPallet.Id, false);
|
|
}
|
|
|
|
[SignalR(SignalRTags.UpdateShippingItemPallet)]
|
|
public async Task<ShippingItemPallet> UpdateShippingItemPallet(ShippingItemPallet shippingItemPallet)
|
|
{
|
|
ArgumentNullException.ThrowIfNull(shippingItemPallet);
|
|
|
|
_logger.Detail($"UpdateShippingItemPallet invoked; {shippingItemPallet}");
|
|
|
|
if (!await ctx.UpdateShippingItemPalletSafeAsync(shippingItemPallet)) return null;
|
|
return await ctx.ShippingItemPallets.GetByIdAsync(shippingItemPallet.Id, false);
|
|
}
|
|
|
|
[SignalR(SignalRTags.AddOrUpdateMeasuredShippingItemPallets)]
|
|
public async Task<ShippingItem> AddOrUpdateMeasuredShippingItemPallets(List<ShippingItemPallet> shippingItemPallets)
|
|
{
|
|
// ArgumentNullException.ThrowIfNull(shippingItemPallets);
|
|
|
|
// _logger.Detail($"AddOrUpdateMeasuredShippingItemPallets invoked; count: {shippingItemPallets.Count}");
|
|
|
|
// if (shippingItemPallets.Count == 0) return null;
|
|
|
|
// var shippingItemId = shippingItemPallets.FirstOrDefault()!.ShippingItemId;
|
|
// if (shippingItemId <= 0 || shippingItemPallets.Any(x => x.ShippingItemId != shippingItemId)) return null;
|
|
|
|
// var shippingItem = await ctx.ShippingItems.GetByIdAsync(shippingItemId, false);
|
|
// shippingItem.ShippingItemPallets = shippingItemPallets.Where(sip => sip.IsValidMeasuringValues(shippingItem.IsMeasurable)).ToList();
|
|
|
|
// return await UpdateMeasuredShippingItem(shippingItem);
|
|
|
|
return null;
|
|
}
|
|
|
|
[SignalR(SignalRTags.AddOrUpdateMeasuredShippingItemPallet)]
|
|
public async Task<ShippingItemPallet> AddOrUpdateMeasuredShippingItemPallet(ShippingItemPallet shippingItemPallet)
|
|
{
|
|
ArgumentNullException.ThrowIfNull(shippingItemPallet);
|
|
|
|
_logger.Detail($"AddOrUpdateMeasuredShippingItemPallet invoked; {shippingItemPallet}");
|
|
|
|
if (!await ctx.AddOrUpdateShippingItemPalletSafeAsync(shippingItemPallet)) return null;
|
|
|
|
var savedShippingItemPallet = await ctx.ShippingItemPallets.GetByIdAsync(shippingItemPallet.Id, true);
|
|
//update average weight and quantity on Product
|
|
await measurementService.CalculateAndSetAverageWeight(savedShippingItemPallet);
|
|
|
|
//return await ctx.ShippingItemPallets.GetByIdAsync(shippingItemPallet.Id, false);
|
|
return shippingItemPallet;
|
|
}
|
|
|
|
[SignalR(SignalRTags.GetShippingDocuments)]
|
|
public async Task<List<ShippingDocument>> GetShippingDocuments()
|
|
{
|
|
_logger.Detail($"GetShippingDocuments invoked; lastDaysCount: {LastShippingDays}");
|
|
|
|
var fromDateUtc = DateTime.UtcNow.Date.AddDays(-LastShippingDays);
|
|
return await ctx.ShippingDocuments.GetAll(true).Where(sd => sd.Shipping == null || sd.Shipping.ShippingDate >= fromDateUtc).ToListAsync();
|
|
}
|
|
|
|
[SignalR(SignalRTags.GetShippingDocumentById)]
|
|
public async Task<ShippingDocument> GetShippingDocumentById(int id)
|
|
{
|
|
_logger.Detail($"GetShippingDocumentById invoked; id: {id}");
|
|
|
|
return await ctx.ShippingDocuments.GetByIdAsync(id, true);
|
|
}
|
|
|
|
[SignalR(SignalRTags.GetShippingDocumentsByShippingId)]
|
|
public async Task<List<ShippingDocument>> GetShippingDocumentsByShippingId(int shippingId)
|
|
{
|
|
_logger.Detail($"GetShippingDocumentsByShippingId invoked; shippingId: {shippingId}");
|
|
|
|
return await ctx.ShippingDocuments.GetAllByShippingIdAsync(shippingId, true).ToListAsync();
|
|
}
|
|
[SignalR(SignalRTags.GetShippingDocumentsByProductId)]
|
|
public async Task<List<ShippingDocument>> GetShippingDocumentsByProductId(int productId)
|
|
{
|
|
_logger.Detail($"GetShippingDocumentsByProductId invoked; productId: {productId}");
|
|
|
|
return await ctx.ShippingDocuments.GetAllByProductIdAsync(productId, true).ToListAsync();
|
|
}
|
|
[SignalR(SignalRTags.GetShippingDocumentsByPartnerId)]
|
|
public async Task<List<ShippingDocument>> GetShippingDocumentsByPartnerId(int partnerId)
|
|
{
|
|
_logger.Detail($"GetShippingDocumentsByPartnerId invoked; partnerId: {partnerId}");
|
|
|
|
return await ctx.ShippingDocuments.GetAllByPartnerIdAsync(partnerId, true).ToListAsync();
|
|
}
|
|
|
|
[SignalR(SignalRTags.AddShippingDocument)]
|
|
public async Task<ShippingDocument> AddShippingDocument(ShippingDocument shippingDocument)
|
|
{
|
|
ArgumentNullException.ThrowIfNull(shippingDocument);
|
|
|
|
_logger.Detail($"AddShippingDocument invoked; id: {shippingDocument.Id}");
|
|
|
|
await ctx.ShippingDocuments.InsertAsync(shippingDocument);
|
|
|
|
if(shippingDocument.ShippingItems != null)
|
|
{
|
|
foreach (var item in shippingDocument.ShippingItems)
|
|
{
|
|
var product = await ctx.Products.GetByIdAsync(item.ProductId);
|
|
if(product != null)
|
|
{
|
|
product.ProductCost = Convert.ToDecimal(item.UnitPriceOnDocument);
|
|
}
|
|
}
|
|
}
|
|
|
|
return await ctx.ShippingDocuments.GetByIdAsync(shippingDocument.Id, shippingDocument.Shipping != null || shippingDocument.Partner != null);
|
|
}
|
|
|
|
[SignalR(SignalRTags.UpdateShippingDocument)]
|
|
public async Task<ShippingDocument> UpdateShippingDocument(ShippingDocument shippingDocument)
|
|
{
|
|
ArgumentNullException.ThrowIfNull(shippingDocument);
|
|
|
|
_logger.Detail($"UpdateShippingDocument invoked; id: {shippingDocument.Id}");
|
|
|
|
await ctx.ShippingDocuments.UpdateAsync(shippingDocument);
|
|
return await ctx.ShippingDocuments.GetByIdAsync(shippingDocument.Id, shippingDocument.Shipping != null || shippingDocument.Partner != null);
|
|
}
|
|
|
|
[SignalR(SignalRTags.GetMeasuringUsers)]
|
|
public async Task<List<CustomerDto>> GetMeasuringUsers()
|
|
{
|
|
_logger.Detail($"GetMeasuringUsers invoked");
|
|
|
|
var customers = await ctx.GetCustomersBySystemRoleName(FruitBankConst.MeasuringRoleSystemName).Select(c => new CustomerDto(c)).ToListAsync();
|
|
return customers; //.ToModelDto<CustomerDto>();
|
|
}
|
|
|
|
[SignalR(SignalRTags.GetCustomerRolesByCustomerId)]
|
|
public async Task<List<CustomerRole>> GetCustomerRolesByCustomerId(int customerId)
|
|
{
|
|
_logger.Detail($"GetCustomerRolesByCustomerId invoked; customerId: {customerId}");
|
|
return await ctx.GetCustomerRolesByCustomerId(customerId).ToListAsync();
|
|
}
|
|
|
|
[SignalR(SignalRTags.GetProductDtos)]
|
|
public async Task<List<ProductDto>> GetProductDtos()
|
|
{
|
|
_logger.Detail($"GetProductDtos invoked");
|
|
return await ctx.ProductDtos.GetAll(false).ToListAsync();
|
|
}
|
|
|
|
//[SignalR(SignalRTags.GetAllMeasuringProductDtos)]
|
|
//public async Task<List<MeasuringProductDto>> GetAllMeasuringProductDtos()
|
|
//{
|
|
// _logger.Detail($"GetAllMeasuringProductDtos invoked");
|
|
// return await ctx.GetAllMeasuringProductDtos(false).ToListAsync();
|
|
//}
|
|
|
|
[SignalR(SignalRTags.GetMeasuringProductDtoById)]
|
|
public async Task<ProductDto?> GetProductDtoById(int productId)
|
|
{
|
|
_logger.Detail($"GetProductDtoById invoked; productId: {productId}");
|
|
return await ctx.ProductDtos.GetByIdAsync(productId, true);
|
|
}
|
|
|
|
[SignalR(SignalRTags.AuthenticateUser)]
|
|
public async Task<MgLoginModelResponse> LoginMeasuringUser(MgLoginModelRequest loginModelRequest)
|
|
{
|
|
var customerEmail = loginModelRequest?.Email;
|
|
var customerPassword = loginModelRequest?.Password;
|
|
|
|
_logger.Detail($"LoginMeasuringUser invoked; customerEmail; {customerEmail}");
|
|
|
|
var resultLoginModel = new MgLoginModelResponse();
|
|
|
|
if (!customerEmail.IsNullOrWhiteSpace() && !customerPassword.IsNullOrWhiteSpace())
|
|
{
|
|
var loginResult = await customerRegistrationService.ValidateCustomerAsync(customerEmail, customerPassword);
|
|
|
|
switch (loginResult)
|
|
{
|
|
case CustomerLoginResults.Successful:
|
|
{
|
|
var customer = await customerService.GetCustomerByEmailAsync(customerEmail);
|
|
|
|
var isInMeasuringRole = await customerService.IsInCustomerRoleAsync(customer, FruitBankConst.MeasuringRoleSystemName);
|
|
if (!isInMeasuringRole)
|
|
{
|
|
resultLoginModel.ErrorMessage = "Is not in MeauringRole!";
|
|
break;
|
|
}
|
|
|
|
//var actionResult = await customerRegistrationService.SignInCustomerAsync(customer, returnUrl, loginModel.RememberMe);
|
|
|
|
//await _workContext.SetCurrentCustomerAsync(customer);
|
|
//await _authenticationService.SignInAsync(customer, isPersist);
|
|
////raise event
|
|
//await _eventPublisher.PublishAsync(new CustomerLoggedinEvent(customer));
|
|
|
|
resultLoginModel.CustomerDto = new CustomerDto(customer); //customer.ToModel<CustomerDto>();
|
|
break;
|
|
}
|
|
case CustomerLoginResults.CustomerNotExist:
|
|
resultLoginModel.ErrorMessage = await localizationService.GetResourceAsync("Account.Login.WrongCredentials.CustomerNotExist");
|
|
break;
|
|
case CustomerLoginResults.Deleted:
|
|
resultLoginModel.ErrorMessage = await localizationService.GetResourceAsync("Account.Login.WrongCredentials.Deleted");
|
|
break;
|
|
case CustomerLoginResults.NotActive:
|
|
resultLoginModel.ErrorMessage = await localizationService.GetResourceAsync("Account.Login.WrongCredentials.NotActive");
|
|
break;
|
|
case CustomerLoginResults.NotRegistered:
|
|
resultLoginModel.ErrorMessage = await localizationService.GetResourceAsync("Account.Login.WrongCredentials.NotRegistered");
|
|
break;
|
|
case CustomerLoginResults.LockedOut:
|
|
resultLoginModel.ErrorMessage = await localizationService.GetResourceAsync("Account.Login.WrongCredentials.LockedOut");
|
|
break;
|
|
case CustomerLoginResults.WrongPassword:
|
|
default:
|
|
resultLoginModel.ErrorMessage = await localizationService.GetResourceAsync("Account.Login.WrongCredentials");
|
|
break;
|
|
}
|
|
}
|
|
else resultLoginModel.ErrorMessage = await localizationService.GetResourceAsync("Account.Login.WrongCredentials");
|
|
|
|
if (!resultLoginModel.ErrorMessage.IsNullOrWhiteSpace()) _logger.Error($"{resultLoginModel.ErrorMessage}; email: {customerEmail}");
|
|
return resultLoginModel;
|
|
}
|
|
}
|
|
}
|