Samuele Locatelli
1842 lines
67 KiB
C#
1842 lines
67 KiB
C#
using Egw.Window.Data;
|
|
using EgwCoreLib.Lux.Core;
|
|
using EgwCoreLib.Lux.Core.RestPayload;
|
|
using EgwCoreLib.Lux.Data.DbModel.Catalog;
|
|
using EgwCoreLib.Lux.Data.DbModel.Config;
|
|
using EgwCoreLib.Lux.Data.DbModel.Sales;
|
|
using EgwCoreLib.Lux.Data.DbModel.Utils;
|
|
using EgwCoreLib.Lux.Data.Domains;
|
|
using EgwCoreLib.Lux.Data.Services.Config;
|
|
using EgwCoreLib.Lux.Data.Services.General;
|
|
using EgwCoreLib.Lux.Data.Services.Items;
|
|
using EgwCoreLib.Lux.Data.Services.Sales;
|
|
using EgwCoreLib.Lux.Data.Services.Utils;
|
|
using Microsoft.AspNetCore.Components;
|
|
using Microsoft.AspNetCore.Components.Forms;
|
|
using Microsoft.JSInterop;
|
|
using Newtonsoft.Json;
|
|
using NLog;
|
|
using WebWindowComplex;
|
|
using WebWindowComplex.DTO;
|
|
using static EgwCoreLib.Lux.Core.Enums;
|
|
using static WebWindowComplex.LayoutConst;
|
|
|
|
namespace Lux.UI.Components.Compo.Offer
|
|
{
|
|
public partial class OfferRowMan : IDisposable
|
|
{
|
|
#region Public Properties
|
|
|
|
[Parameter]
|
|
public OfferModel CurrRecord { get; set; } = default!;
|
|
|
|
[Parameter]
|
|
public DisplayMode DisplayMode { get; set; } = DisplayMode.Standard;
|
|
|
|
[Parameter]
|
|
public EventCallback<bool> EC_Updated { get; set; }
|
|
|
|
[Parameter]
|
|
public EventCallback<string> EC_Action { get; set; }
|
|
|
|
#endregion Public Properties
|
|
|
|
#region Public Methods
|
|
|
|
/// <summary>
|
|
/// Dispose sottoscrizione canale
|
|
/// </summary>
|
|
public void Dispose()
|
|
{
|
|
DLService.PipeUpdate.EA_NewMessage -= PipeUpdate_EA_NewMessage;
|
|
DLService.PipePng.EA_NewMessage -= PipePng_EA_NewMessage;
|
|
DLService.PipeSvg.EA_NewMessage -= PipeSvg_EA_NewMessage;
|
|
DLService.PipeHwOpt.EA_NewMessage -= PipeHwOpt_EA_NewMessage;
|
|
DLService.PipeProfElement.EA_NewMessage -= PipeProfElement_EA_NewMessage;
|
|
DLService.PipeProfList.EA_NewMessage -= PipeProfList_EA_NewMessage;
|
|
DLService.PipeShape.EA_NewMessage -= PipeShape_EA_NewMessage;
|
|
}
|
|
|
|
#endregion Public Methods
|
|
|
|
#region Protected Methods
|
|
|
|
/// <summary>
|
|
/// Verifica after render x stato interattivo pagina
|
|
/// </summary>
|
|
/// <param name="firstRender"></param>
|
|
protected override void OnAfterRender(bool firstRender)
|
|
{
|
|
if (firstRender)
|
|
{
|
|
// JS interop or data fetches go here
|
|
isInteractive = true;
|
|
}
|
|
}
|
|
|
|
private Task ReqEditRow()
|
|
{
|
|
return EC_Action.InvokeAsync("EditRow");
|
|
}
|
|
|
|
/// <summary>
|
|
/// init obj
|
|
/// </summary>
|
|
protected override async Task OnInitializedAsync()
|
|
{
|
|
ConfInit();
|
|
prevJwd = "";
|
|
await ReloadBaseList();
|
|
DLService.PipeUpdate.EA_NewMessage += PipeUpdate_EA_NewMessage;
|
|
DLService.PipePng.EA_NewMessage += PipePng_EA_NewMessage;
|
|
DLService.PipeSvg.EA_NewMessage += PipeSvg_EA_NewMessage;
|
|
DLService.PipeHwOpt.EA_NewMessage += PipeHwOpt_EA_NewMessage;
|
|
DLService.PipeProfElement.EA_NewMessage += PipeProfElement_EA_NewMessage;
|
|
DLService.PipeProfList.EA_NewMessage += PipeProfList_EA_NewMessage;
|
|
DLService.PipeShape.EA_NewMessage += PipeShape_EA_NewMessage;
|
|
}
|
|
|
|
protected override async Task OnParametersSetAsync()
|
|
{
|
|
await ORService.FixImgTypeAsync(OfferID);
|
|
await ReloadDataAsync();
|
|
UpdateTable();
|
|
}
|
|
|
|
#endregion Protected Methods
|
|
|
|
#region Private Fields
|
|
|
|
private static Logger Log = LogManager.GetCurrentClassLogger();
|
|
|
|
/// <summary>
|
|
/// Boolean selezione prodotto da aggiungere (template)
|
|
/// </summary>
|
|
private bool addFromTemplate = false;
|
|
|
|
private List<GenValueModel> AllColors = new();
|
|
|
|
private List<EnvirParamModel> AllConfEnvir = new();
|
|
|
|
private List<GlassModel> AllConfGlass = new();
|
|
|
|
private List<HardwareModel> AllConfHardware = new();
|
|
|
|
private List<WoodModel> AllConfWood = new();
|
|
|
|
private List<OfferRowModel> AllRecords = new List<OfferRowModel>();
|
|
|
|
private string apiUrl = "";
|
|
|
|
private List<string> AvailColorMaterialList = new List<string>();
|
|
|
|
private List<string> AvailFamilyHardwareList = new List<string>();
|
|
|
|
private List<string> AvailGlassList = new List<string>();
|
|
|
|
private List<Egw.Window.Data.Hardware> AvailHardwareList = new();
|
|
|
|
private List<string> AvailMaterialList = new List<string>();
|
|
|
|
/// <summary>
|
|
/// Lista profili da DB
|
|
/// </summary>
|
|
private List<ProfileModel> AvailProfileList = new();
|
|
|
|
/// <summary>
|
|
/// Lista profili da Redis (old way)
|
|
/// </summary>
|
|
private List<string> AvailProfileListOld = new List<string>();
|
|
|
|
private Dictionary<string, List<Threshold>> AvailThresholdDict = new Dictionary<string, List<Threshold>>();
|
|
|
|
/// <summary>
|
|
/// Base path x network share files
|
|
/// </summary>
|
|
private string basePath = "unsafe_uploads";
|
|
|
|
private string calcTag = "calc";
|
|
|
|
private EgwMultiEngineManager.Data.Constants.EXECENVIRONMENTS cEnvir = EgwMultiEngineManager.Data.Constants.EXECENVIRONMENTS.WINDOW;
|
|
|
|
/// <summary>
|
|
/// Channel update HwOptions
|
|
/// </summary>
|
|
private string chHwOpt = "";
|
|
|
|
/// <summary>
|
|
/// Channel update PNG
|
|
/// </summary>
|
|
private string chPng = "";
|
|
|
|
/// <summary>
|
|
/// Channel update Profile List
|
|
/// </summary>
|
|
private string chProfElem = "";
|
|
|
|
/// <summary>
|
|
/// Channel update Profile List
|
|
/// </summary>
|
|
private string chProfList = "";
|
|
|
|
/// <summary>
|
|
/// Channel update Shape
|
|
/// </summary>
|
|
private string chShape = "";
|
|
|
|
/// <summary>
|
|
/// Channel update SVG
|
|
/// </summary>
|
|
private string chSvg = "";
|
|
|
|
private List<AreaProfiles> currAreaProfiles = new();
|
|
|
|
private List<BomItemDTO>? CurrBomList = null;
|
|
|
|
/// <summary>
|
|
/// Predisposizione valori live SVG/JWD
|
|
/// </summary>
|
|
private LivePayload CurrData = new LivePayload();
|
|
|
|
/// <summary>
|
|
/// Modalit� editint attiva
|
|
/// </summary>
|
|
private EditMode CurrEditMode = EditMode.None;
|
|
|
|
private Dictionary<int, string> currGroupShape = new();
|
|
|
|
private Dictionary<int, string> currHwOption = new();
|
|
|
|
private int currPage = 1;
|
|
|
|
private string currPng = "";
|
|
|
|
private List<ProfilePayload> currProfList = new();
|
|
|
|
private string currSvg = "";
|
|
|
|
/// <summary>
|
|
/// Record in Edit corrente x modifica file/serializzato
|
|
/// </summary>
|
|
private OfferRowModel? EditRecord = null;
|
|
|
|
/// <summary>
|
|
/// Abilita edit massivo record ITEM
|
|
/// </summary>
|
|
private bool enableMassEdit = false;
|
|
|
|
private string genericBasePath = "";
|
|
|
|
private string imgBasePath = "";
|
|
|
|
/// <summary>
|
|
/// Semaforo x definire se sia gia in modalita ionterattiva o di prerendering
|
|
/// </summary>
|
|
private bool isInteractive = false;
|
|
|
|
private bool isLoading = false;
|
|
|
|
private List<TemplateModel> ListAllCatalog = new();
|
|
|
|
private List<TemplateModel> ListCataloghi = new();
|
|
|
|
private List<OfferRowModel> ListRecords = new();
|
|
|
|
private List<TemplateRowModel> ListTemplateAll = new();
|
|
|
|
private int numRecord = 10;
|
|
|
|
/// <summary>
|
|
/// Versione originale (pre edit)
|
|
/// </summary>
|
|
private string origJwd = "";
|
|
|
|
private List<string> PreparedFile = new();
|
|
|
|
/// <summary>
|
|
/// Versione precedente JWD x test e confronto
|
|
/// </summary>
|
|
private string prevJwd = "";
|
|
|
|
/// <summary>
|
|
/// Dizionario richieste
|
|
/// </summary>
|
|
private Dictionary<string, string> reqDict = new Dictionary<string, string>();
|
|
|
|
/// <summary>
|
|
/// Configurazione elenchi anagrafiche
|
|
/// </summary>
|
|
private BaseListPayload SetupList = new BaseListPayload();
|
|
|
|
private int totalCount = 0;
|
|
|
|
#endregion Private Fields
|
|
|
|
#region Private Properties
|
|
|
|
private Dictionary<string, List<Threshold>> AvailThreshold { get; set; } = new Dictionary<string, List<Threshold>>()
|
|
{
|
|
{"Profilo78", new List<Threshold>() { new Threshold(3, "Bottom")}},
|
|
{"ProfiloSaomad", new List<Threshold>(){ new Threshold(3, "Bottom")}}
|
|
#if false
|
|
{"Profilo78", new List<Threshold>() { new Threshold(3, "Bottom"), new Threshold(1, "Threshold")}},
|
|
{"ProfiloSaomad", new List<Threshold>(){ new Threshold(3, "Bottom"), new Threshold(2, "BottomWaterdrip"), new Threshold(1, "Threshold")}}
|
|
#endif
|
|
};
|
|
|
|
[Inject]
|
|
private IConfigDataService CDService { get; set; } = default!;
|
|
|
|
[Inject]
|
|
private IConfGlassService CGService { get; set; } = null!;
|
|
|
|
[Inject]
|
|
private IConfiguration Config { get; set; } = default!;
|
|
|
|
[Inject]
|
|
private IConfProfileService CPService { get; set; } = null!;
|
|
|
|
[Inject]
|
|
private ICalcRuidService CRService { get; set; } = default!;
|
|
|
|
[Inject]
|
|
private ICalcRequestService CService { get; set; } = default!;
|
|
|
|
[Inject]
|
|
private IWebHostEnvironment CurrEnv { get; set; } = default!;
|
|
|
|
[Inject]
|
|
private IConfWoodService CWService { get; set; } = null!;
|
|
|
|
[Inject]
|
|
private IDataLayerServices DLService { get; set; } = default!;
|
|
|
|
[Inject]
|
|
private IEnvirParamService EPService { get; set; } = null!;
|
|
|
|
[Inject]
|
|
private IFileService FService { get; set; } = default!;
|
|
|
|
/// <summary>
|
|
/// Costo totale calcolato x offerta
|
|
/// </summary>
|
|
private double GrandTotCost
|
|
{
|
|
get => AllRecords != null && AllRecords.Count > 0 ? AllRecords.Sum(x => x.TotalCost) : 0;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Margine medio calcolato x offerta
|
|
/// </summary>
|
|
private double GrandTotMargin
|
|
{
|
|
get
|
|
{
|
|
double answ = 0;
|
|
if (AllRecords != null && AllRecords.Count > 0)
|
|
{
|
|
double totPrice = AllRecords.Sum(x => x.TotalPrice);
|
|
double totCost = AllRecords.Sum(x => x.TotalCost);
|
|
if (totPrice > 0)
|
|
{
|
|
answ = (totPrice - totCost) / totPrice;
|
|
}
|
|
}
|
|
return answ;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Importo totale calcolato x offerta
|
|
/// </summary>
|
|
private double GrandTotNumItems
|
|
{
|
|
get
|
|
{
|
|
double answ = 0;
|
|
if (AllRecords != null && AllRecords.Count > 0)
|
|
{
|
|
answ = AllRecords.Sum(x => x.ProdItemQtyTot);
|
|
}
|
|
return answ;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Importo totale calcolato x offerta
|
|
/// </summary>
|
|
private double GrandTotPrice
|
|
{
|
|
get => AllRecords != null && AllRecords.Count > 0 ? AllRecords.Sum(x => x.TotalPrice) : 0;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Num totale obj calcolato x offerta
|
|
/// </summary>
|
|
private double GrandTotQty
|
|
{
|
|
get => AllRecords != null && AllRecords.Count > 0 ? AllRecords.Sum(x => x.Qty) : 0;
|
|
}
|
|
|
|
[Inject]
|
|
private IGenValService GVService { get; set; } = default!;
|
|
|
|
[Inject]
|
|
private IWebHostEnvironment HostEnv { get; set; } = default!;
|
|
|
|
[Inject]
|
|
private IImageCacheService ICService { get; set; } = default!;
|
|
|
|
[Inject]
|
|
private IItemService ItemService { get; set; } = null!;
|
|
|
|
[Inject]
|
|
private IJSRuntime JSRuntime { get; set; } = default!;
|
|
|
|
/// <summary>
|
|
/// ID Offerta corrente
|
|
/// </summary>
|
|
private int OfferID
|
|
{
|
|
get => CurrRecord.OfferID;
|
|
}
|
|
|
|
[Inject]
|
|
private IOfferRowService ORService { get; set; } = default!;
|
|
|
|
[Inject]
|
|
private IOfferService OService { get; set; } = default!;
|
|
|
|
[Inject]
|
|
private ITemplateRowService TRService { get; set; } = default!;
|
|
|
|
[Inject]
|
|
private ITemplateService TService { get; set; } = default!;
|
|
|
|
#endregion Private Properties
|
|
|
|
#region Private Methods
|
|
|
|
private string noteCss => EditRecord == null ? "btn-success" : "btn-primary bg-gradient";
|
|
|
|
/// <summary>
|
|
/// Effettua vera richiesta della BOM
|
|
/// </summary>
|
|
/// <param name="currRec"></param>
|
|
/// <returns></returns>
|
|
private async Task callBomUpdate(OfferRowModel currRec)
|
|
{
|
|
// salvo richiesta BOM su record
|
|
currRec.AwaitBom = true;
|
|
currRec.AwaitPrice = true;
|
|
await ORService.UpdateAwaitStateAsync(currRec.OfferRowID, true, true);
|
|
|
|
// preparo la domanda serializzata
|
|
Dictionary<string, string> DictExec = new Dictionary<string, string>();
|
|
// verifico parametri da conf envir...
|
|
var envRec = AllConfEnvir.FirstOrDefault(x => x.EnvirID == currRec.Envir);
|
|
string serKey = envRec != null ? envRec.SerStrucKey : "SerializedData";
|
|
// cablata la BOM
|
|
DictExec.Add("Mode", $"{(int)Egw.Window.Data.Enums.QuestionModes.BOM}");
|
|
// UID cablato x ora...
|
|
DictExec.Add("UID", currRec.OfferRowUID);
|
|
// aggiungo file secondo ambiente...
|
|
switch (currRec.Envir)
|
|
{
|
|
case EgwMultiEngineManager.Data.Constants.EXECENVIRONMENTS.WINDOW:
|
|
DictExec.Add(serKey, currRec.SerStruct);
|
|
break;
|
|
|
|
case EgwMultiEngineManager.Data.Constants.EXECENVIRONMENTS.BEAM:
|
|
case EgwMultiEngineManager.Data.Constants.EXECENVIRONMENTS.WALL:
|
|
case EgwMultiEngineManager.Data.Constants.EXECENVIRONMENTS.CABINET:
|
|
// rileggo da file...
|
|
string folderPath = FolderPath(currRec.OfferID);
|
|
string rawData = FService.LoadFileContent(folderPath, currRec.FileResource);
|
|
DictExec.Add(serKey, rawData);
|
|
DictExec.Add("FileName", currRec.FileName);
|
|
break;
|
|
|
|
case EgwMultiEngineManager.Data.Constants.EXECENVIRONMENTS.NULL:
|
|
default:
|
|
break;
|
|
}
|
|
|
|
CalcRequestDTO req = new CalcRequestDTO()
|
|
{
|
|
EnvType = currRec.Envir,
|
|
DictExec = DictExec
|
|
};
|
|
|
|
await InvokeAsync(StateHasChanged);
|
|
|
|
// chiamo la chiamata POST alla API, che manda la richiesta via REDIS
|
|
await CService.CallRestPost($"{apiUrl}/{genericBasePath}", $"{calcTag}/{currRec.OfferRowUID}", req);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Effettua vera richiesta update IMG
|
|
/// </summary>
|
|
/// <param name="currRec"></param>
|
|
/// <returns></returns>
|
|
private async Task callImgUpdate(OfferRowModel currRec)
|
|
{
|
|
// preparo la domanda serializzata
|
|
Dictionary<string, string> DictExec = new Dictionary<string, string>();
|
|
// verifico parametri da conf envir...
|
|
var envRec = AllConfEnvir.FirstOrDefault(x => x.EnvirID == currRec.Envir);
|
|
string serKey = envRec != null ? envRec.SerStrucKey : "SerializedData";
|
|
// cablata la BOM
|
|
DictExec.Add("Mode", $"{(int)Egw.Window.Data.Enums.QuestionModes.PREVIEW}");
|
|
// UID cablato x ora...
|
|
DictExec.Add("UID", currRec.OfferRowUID);
|
|
// aggiungo file secondo ambiente...
|
|
switch (currRec.Envir)
|
|
{
|
|
case EgwMultiEngineManager.Data.Constants.EXECENVIRONMENTS.WINDOW:
|
|
DictExec.Add(serKey, currRec.SerStruct);
|
|
break;
|
|
|
|
case EgwMultiEngineManager.Data.Constants.EXECENVIRONMENTS.BEAM:
|
|
case EgwMultiEngineManager.Data.Constants.EXECENVIRONMENTS.WALL:
|
|
case EgwMultiEngineManager.Data.Constants.EXECENVIRONMENTS.CABINET:
|
|
// rileggo da file...
|
|
string folderPath = FolderPath(currRec.OfferID);
|
|
string rawData = FService.LoadFileContent(folderPath, currRec.FileResource);
|
|
DictExec.Add(serKey, rawData);
|
|
DictExec.Add("FileName", currRec.FileName);
|
|
break;
|
|
|
|
case EgwMultiEngineManager.Data.Constants.EXECENVIRONMENTS.NULL:
|
|
default:
|
|
break;
|
|
}
|
|
|
|
CalcRequestDTO req = new CalcRequestDTO()
|
|
{
|
|
EnvType = currRec.Envir,
|
|
DictExec = DictExec
|
|
};
|
|
|
|
await InvokeAsync(StateHasChanged);
|
|
|
|
// chiamo la chiamata POST alla API, che manda la richiesta via REDIS
|
|
await CService.CallRestPost($"{apiUrl}/{genericBasePath}", $"{calcTag}/{currRec.OfferRowUID}", req);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Effettua vera richiesta della BOM
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
private async Task callRefreshProfList()
|
|
{
|
|
Dictionary<string, string> DictExec = new Dictionary<string, string>();
|
|
var cMode = Egw.Window.Data.Enums.QuestionModes.CONFIG;
|
|
var cSubMode = Egw.Window.Data.Enums.QuestionConfSubModes.PROFILELIST;
|
|
// compongo righiesta
|
|
string reqUid = "Default";
|
|
DictExec.Add("Mode", $"{(int)cMode}");
|
|
DictExec.Add("UID", reqUid);
|
|
// creo registrazione richiesta...
|
|
var ruid = await CRService.AddRequestAsync($"{cEnvir}", $"{cMode}-{cSubMode}", reqUid);
|
|
// aggiungo RUID effettivo
|
|
DictExec.Add("RUID", ruid);
|
|
DictExec.Add("SubMode", $"{(int)cSubMode}");
|
|
CalcRequestDTO req = new CalcRequestDTO()
|
|
{
|
|
EnvType = cEnvir,
|
|
DictExec = DictExec
|
|
};
|
|
// chiamo la chiamata POST alla API, che manda la richiesta via REDIS
|
|
await CService.CallRestPost($"{apiUrl}/{genericBasePath}", $"{calcTag}/{reqUid}", req);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Chiude edit andando eventualmente a salvare
|
|
/// </summary>
|
|
/// <param name="args"></param>
|
|
/// <returns></returns>
|
|
private async Task CloseEdit(bool doSave)
|
|
{
|
|
// Proseguo solo se sono in interattivo (NO prerender pagina)
|
|
if (isInteractive)
|
|
{
|
|
// ...se ho editing
|
|
if (EditRecord != null)
|
|
{
|
|
bool updateBom = false;
|
|
// SE richiesto salvataggio...
|
|
if (doSave)
|
|
{
|
|
// salvo su DB!
|
|
await ORService.UpdateSerStructAsync(EditRecord.OfferRowID, prevJwd);
|
|
// salvo nel record corrente!
|
|
EditRecord.SerStruct = prevJwd;
|
|
updateBom = true;
|
|
}
|
|
else
|
|
// altrimenti ricalcolo valore salvato
|
|
{
|
|
prevJwd = EditRecord.SerStruct;
|
|
CurrData.CurrJwd = EditRecord.SerStruct;
|
|
}
|
|
if (updateBom)
|
|
{
|
|
await callBomUpdate(EditRecord);
|
|
}
|
|
// aggiorno nel dizionari
|
|
if (reqDict.ContainsKey("SerializedData"))
|
|
{
|
|
reqDict["SerializedData"] = prevJwd;
|
|
}
|
|
|
|
if (reqDict != null && reqDict.Count > 0)
|
|
{
|
|
// chiamo richiesta update
|
|
CalcRequestDTO calcRequestDTO = new CalcRequestDTO();
|
|
calcRequestDTO.EnvType = EditRecord.Envir;
|
|
calcRequestDTO.DictExec = reqDict;
|
|
// chiamo la chiamata POST alla API, che manda la richiesta via REDIS
|
|
await ICService.CallRestPost($"{apiUrl}/{genericBasePath}", $"{calcTag}/{EditRecord.OfferRowUID}", calcRequestDTO);
|
|
}
|
|
EditRecord = null;
|
|
CurrEditMode = EditMode.None;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Chiude edit con preprocess x caso JWD
|
|
/// </summary>
|
|
/// <param name="args"></param>
|
|
/// <returns></returns>
|
|
private Task CloseEditJwd(DataSave infoSave)
|
|
{
|
|
prevJwd = infoSave.currJwd;
|
|
return CloseEdit(infoSave.ForceSave);
|
|
}
|
|
|
|
private void ClosePopup()
|
|
{
|
|
CurrEditMode = EditMode.None;
|
|
EditRecord = null;
|
|
addFromTemplate = false;
|
|
}
|
|
|
|
private void ConfInit()
|
|
{
|
|
basePath = Config.GetValue<string>("ServerConf:FileSharePath") ?? "unsafe_uploads";
|
|
apiUrl = Config.GetValue<string>("ServerConf:Prog.ApiUrl") ?? "";
|
|
imgBasePath = Config.GetValue<string>("ServerConf:ImageBaseUrl") ?? "";
|
|
genericBasePath = Config.GetValue<string>("ServerConf:GenericBaseUrl") ?? "";
|
|
calcTag = Config.GetValue<string>("ServerConf:CalcTag") ?? "calc";
|
|
chHwOpt = Config.GetValue<string>("ServerConf:ChannelHwOpt") ?? "";
|
|
chPng = Config.GetValue<string>("ServerConf:ChannelPng") ?? "";
|
|
chProfElem = Config.GetValue<string>("ServerConf:ChannelProfElem") ?? "";
|
|
chProfList = Config.GetValue<string>("ServerConf:ChannelProfList") ?? "";
|
|
chShape = Config.GetValue<string>("ServerConf:ChannelShape") ?? "";
|
|
chSvg = Config.GetValue<string>("ServerConf:ChannelSvg") ?? "";
|
|
}
|
|
|
|
/// <summary>
|
|
/// Esecuzione azione richiesta
|
|
/// </summary>
|
|
/// <param name="actReq">Azione richiesta</param>
|
|
private void DoAction(LayoutConst.DataAction actReq)
|
|
{
|
|
switch (actReq)
|
|
{
|
|
case LayoutConst.DataAction.None:
|
|
break;
|
|
|
|
case LayoutConst.DataAction.ResetDictShape:
|
|
CurrData.DictShape = new Dictionary<int, string>();
|
|
break;
|
|
|
|
case LayoutConst.DataAction.ResetHwOpt:
|
|
CurrData.DictOptionsXml = new Dictionary<int, string>();
|
|
break;
|
|
|
|
case DataAction.ResetDimElem:
|
|
CurrData.ProfElementList = new List<AreaProfiles>();
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Aggiunge una nuova riga vuota come nota sotto il record selezionato oppure in coda...
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
private async Task DoAddNote()
|
|
{
|
|
int numRow = AllRecords.Count + 1;
|
|
if (EditRecord != null)
|
|
{
|
|
numRow = EditRecord.RowNum + 1;
|
|
}
|
|
OfferRowModel newNote = new OfferRowModel()
|
|
{
|
|
Note = $"--- Nuova nota | {DateTime.Now:ddd yyyy.MM.dd HH:mm:ss}---",
|
|
OfferID = CurrRecord.OfferID,
|
|
Envir = CurrRecord.Envir,
|
|
RowNum = numRow,
|
|
OfferRowUID = "",
|
|
SellingItemID = null,
|
|
Qty = 0,
|
|
BomCost = 0,
|
|
BomPrice = 0,
|
|
StepCost = 0,
|
|
StepPrice = 0
|
|
};
|
|
await ORService.UpsertAsync(newNote);
|
|
await ReloadDataAsync();
|
|
UpdateTable();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Aggiunge una nuova riga ordine in coda...
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
private async Task DoAddOrderRow(TemplateRowModel selTemplate)
|
|
{
|
|
int numRow = AllRecords.Count + 1;
|
|
if (EditRecord != null)
|
|
{
|
|
numRow = EditRecord.RowNum + 1;
|
|
}
|
|
// SOLO SE è un oggetto calcolabile (JWD, BTL...) richiedo update img e BOM
|
|
bool needRecalc = (selTemplate.SellingItemNav != null && selTemplate.SellingItemNav.HasBOM);
|
|
// creo riga!
|
|
OfferRowModel newSOR = new OfferRowModel()
|
|
{
|
|
AwaitBom = needRecalc,
|
|
AwaitPrice = needRecalc,
|
|
OfferID = CurrRecord.OfferID,
|
|
Envir = CurrRecord.Envir,
|
|
Inserted = DateTime.Now,
|
|
RowNum = numRow,
|
|
OfferRowUID = "",
|
|
Qty = 1,
|
|
SellingItemID = selTemplate.SellingItemID,
|
|
SerStruct = selTemplate.SerStruct,
|
|
BomCost = 0,
|
|
BomPrice = 0,
|
|
StepCost = 0,
|
|
StepPrice = 0
|
|
};
|
|
// SE FOSSE NON calcolabile aggiungo costi std
|
|
if (!needRecalc && selTemplate.SellingItemNav != null)
|
|
{
|
|
// recupero costi da ancestor
|
|
newSOR.BomCost = selTemplate.SellingItemNav?.Cost ?? 0;
|
|
newSOR.BomPrice = newSOR.BomCost * (1 + selTemplate.SellingItemNav?.Margin) ?? 1;
|
|
newSOR.BomOk = true;
|
|
newSOR.ItemOk = true;
|
|
newSOR.ProdItemQty = 1;
|
|
}
|
|
addFromTemplate = false;
|
|
var dbRec = await ORService.UpsertAsync(newSOR);
|
|
// chiamo ricalcolo BOM e IMG...
|
|
if (dbRec != null)
|
|
{
|
|
// SOLO SE è un oggetto calcolabile (JWD, BTL...) richiedo update img e BOM
|
|
if (needRecalc)
|
|
{
|
|
await callBomUpdate(dbRec);
|
|
await callImgUpdate(dbRec);
|
|
// imposto ad editing record secondo tipo
|
|
if (dbRec.Envir == EgwMultiEngineManager.Data.Constants.EXECENVIRONMENTS.WINDOW)
|
|
{
|
|
DoEditJwd(dbRec);
|
|
}
|
|
else
|
|
{
|
|
DoEditFile(dbRec);
|
|
}
|
|
}
|
|
}
|
|
await ReloadDataAsync();
|
|
UpdateTable();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Annullamento modifica
|
|
/// </summary>
|
|
/// <param name="curRec"></param>
|
|
/// <returns></returns>
|
|
private async Task DoCancel()
|
|
{
|
|
isLoading = true;
|
|
CurrEditMode = EditMode.None;
|
|
EditRecord = null;
|
|
await Task.Delay(20);
|
|
await OService.FlushCacheOffersAsync();
|
|
await Task.Delay(20);
|
|
await ReloadDataAsync();
|
|
UpdateTable();
|
|
isLoading = false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Clona riga richiesta
|
|
/// </summary>
|
|
/// <param name="rec2clone"></param>
|
|
private async Task DoClone(OfferRowModel rec2clone)
|
|
{
|
|
if (!await JSRuntime.InvokeAsync<bool>("confirm", $"Confermi di voler duplicare la riga corrente?"))
|
|
return;
|
|
|
|
// calcolo indice riga...
|
|
int numRow = totalCount + 1;
|
|
bool needRecalc = (rec2clone.SellingItemNav != null && rec2clone.SellingItemNav.HasBOM);
|
|
OfferRowModel newRec = new OfferRowModel()
|
|
{
|
|
AwaitBom = needRecalc,
|
|
AwaitPrice = needRecalc,
|
|
Envir = rec2clone.Envir,
|
|
FileName = rec2clone.FileName,
|
|
FileResource = rec2clone.FileResource,
|
|
FileSize = rec2clone.FileSize,
|
|
Inserted = DateTime.Now,
|
|
ItemBOM = rec2clone.ItemBOM,
|
|
ItemSteps = rec2clone.ItemSteps,
|
|
Modified = DateTime.Now,
|
|
Note = rec2clone.Note,
|
|
OfferID = OfferID,
|
|
OfferRowUID = "",
|
|
Qty = rec2clone.Qty,
|
|
RowNum = numRow,
|
|
SellingItemID = rec2clone.SellingItemID,
|
|
SerStruct = rec2clone.SerStruct,
|
|
StepCost = rec2clone.StepCost,
|
|
StepPrice = rec2clone.StepPrice,
|
|
BomCost = needRecalc ? 0 : rec2clone.BomCost,
|
|
BomPrice = needRecalc ? 0 : rec2clone.BomPrice,
|
|
BomOk = needRecalc ? false : true,
|
|
ItemOk = needRecalc ? false : true,
|
|
ProdItemQty = needRecalc ? 0 : rec2clone.ProdItemQty
|
|
};
|
|
|
|
// salvo sul DB
|
|
await ORService.UpsertAsync(newRec);
|
|
// chiamo update record che non hanno UID x questo ordine
|
|
await ORService.FixImgTypeAsync(OfferID);
|
|
var list2fix = await ORService.FixUidAsync(OfferID);
|
|
if (list2fix != null && list2fix.Count > 0)
|
|
{
|
|
// rileggo i miei record...
|
|
await ReloadDataAsync();
|
|
var listCalc = SorListCalc();
|
|
foreach (var item in listCalc)
|
|
{
|
|
// se è con BOM calcolabile...
|
|
if (item.SellingItemNav != null && item.SellingItemNav.HasBOM)
|
|
{
|
|
// se UID e' tra quelli da ricalcolare ed e' calcolabile...
|
|
if (list2fix.Contains(item.OfferRowUID))
|
|
{
|
|
// chiedo BOM e immagine
|
|
await callBomUpdate(item);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
await ReloadDataAsync();
|
|
UpdateTable();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Eliminazione riga offerta
|
|
/// </summary>
|
|
/// <param name="rec2del"></param>
|
|
/// <returns></returns>
|
|
private async Task DoDelete(OfferRowModel rec2del)
|
|
{
|
|
if (!await JSRuntime.InvokeAsync<bool>("confirm", $"Confermi di voler eliminare la riga corrente?<br/>Codice: {rec2del.OfferRowUID} | {rec2del.Note} | importo tot: {rec2del.TotalPrice}"))
|
|
return;
|
|
|
|
await ORService.DeleteAsync(rec2del);
|
|
// elimino cache img
|
|
await ICService.DeleteSvgAsync(rec2del.OfferRowUID, rec2del.Envir);
|
|
await ReloadDataAsync();
|
|
UpdateTable();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Va in edit della riga richiesta
|
|
/// </summary>
|
|
/// <param name="curRec"></param>
|
|
private void DoEdit(OfferRowModel curRec)
|
|
{
|
|
// imposto edit record
|
|
EditRecord = curRec;
|
|
/// modalita edit: gestione valori campi record
|
|
CurrEditMode = EditMode.RecData;
|
|
isLoading = false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Edit del file:
|
|
/// - abilitazione fileUpload
|
|
/// - anteprima grande (live)
|
|
/// </summary>
|
|
/// <param name="curRec"></param>
|
|
private void DoEditFile(OfferRowModel curRec)
|
|
{
|
|
EditRecord = curRec;
|
|
/// modalit�edit: gestione JWD
|
|
CurrEditMode = EditMode.File;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Apre editor finestre del record richiesto
|
|
/// </summary>
|
|
/// <param name="curRec"></param>
|
|
private void DoEditJwd(OfferRowModel curRec)
|
|
{
|
|
EditRecord = curRec;
|
|
/// modalit�edit: gestione JWD
|
|
CurrEditMode = EditMode.SerStruc;
|
|
// preparazione dati da record corrente
|
|
PrepareWindowData(EditRecord.SerStruct);
|
|
// reset prev
|
|
prevJwd = "";
|
|
}
|
|
|
|
private async Task DoRecalcOffer(bool forceResetCalc)
|
|
{
|
|
isLoading = true;
|
|
if (forceResetCalc)
|
|
{
|
|
await setAwaitPrice(true, false);
|
|
UpdateTable();
|
|
await InvokeAsync(StateHasChanged);
|
|
await Task.Delay(300);
|
|
}
|
|
await OService.UpdateCostAsync(OfferID);
|
|
if (forceResetCalc)
|
|
{
|
|
await Task.Delay(300);
|
|
await setAwaitPrice(false, true);
|
|
}
|
|
|
|
// rileggo dati
|
|
await ReloadDataAsync();
|
|
UpdateTable();
|
|
isLoading = false;
|
|
await EC_Updated.InvokeAsync(true);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Salvataggio edit record + reload
|
|
/// </summary>
|
|
/// <param name="curRec"></param>
|
|
/// <returns></returns>
|
|
private async Task DoSave(OfferRowModel curRec)
|
|
{
|
|
isLoading = true;
|
|
// salvo record modificato...
|
|
await ORService.UpsertAsync(curRec);
|
|
// reset
|
|
CurrEditMode = EditMode.None;
|
|
EditRecord = null;
|
|
await OService.FlushCacheOffersAsync();
|
|
await ReloadDataAsync();
|
|
UpdateTable();
|
|
isLoading = false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Seleziono riga senza cambiare modalit� editing
|
|
/// </summary>
|
|
/// <param name="curRec"></param>
|
|
private void DoSelect(OfferRowModel curRec)
|
|
{
|
|
// imposto edit record
|
|
EditRecord = curRec;
|
|
/// modalit�edit: gestione valori campi record
|
|
CurrEditMode = EditMode.None;
|
|
}
|
|
|
|
private async Task DoSelectItem()
|
|
{
|
|
addFromTemplate = true;
|
|
ListCataloghi = ListAllCatalog.Where(x => x.Envir == CurrRecord.Envir).ToList();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Imposta modalita edit ciclo di lavoro
|
|
/// </summary>
|
|
/// <param name="currRow"></param>
|
|
private Task DoSwapJobCycle(OfferRowModel currRow)
|
|
{
|
|
CurrEditMode = EditMode.JobCycle;
|
|
return selectBom(currRow);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Imposta modalita ad edit BOM
|
|
/// </summary>
|
|
/// <param name="currRow"></param>
|
|
private Task DoSwapMat(OfferRowModel currRow)
|
|
{
|
|
CurrEditMode = EditMode.BOM;
|
|
return selectBom(currRow);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Prepara URL x download file JWD
|
|
/// </summary>
|
|
/// <param name="currUid"></param>
|
|
/// <param name="objType"></param>
|
|
/// <param name="envir"></param>
|
|
/// <returns></returns>
|
|
private string DownloadUrl(string currUid, string objType = "SOR", EgwMultiEngineManager.Data.Constants.EXECENVIRONMENTS envir = EgwMultiEngineManager.Data.Constants.EXECENVIRONMENTS.WINDOW)
|
|
{
|
|
return $"{apiUrl}/file/{currUid}?objType={objType}&env={envir}";
|
|
}
|
|
|
|
/// <summary>
|
|
/// Salvataggio del JWD aggiornato nella mia riga di offerta
|
|
/// </summary>
|
|
/// <param name="CurrArgs"></param>
|
|
private async Task ExecRequest(Dictionary<string, string> CurrArgs)
|
|
{
|
|
// Proseguo solo se sono in interattivo (NO prerender pagina)
|
|
if (isInteractive)
|
|
{
|
|
// ...se ho editing
|
|
if (EditRecord != null)
|
|
{
|
|
// SE contiene il mio Jwd...
|
|
if (CurrArgs.ContainsKey("SerializedData"))
|
|
{
|
|
string serStruct = CurrArgs["SerializedData"];
|
|
// controllo SE variato...
|
|
if (!prevJwd.Equals(serStruct) || !EgwCoreLib.Utils.DictUtils.DictAreEqual(reqDict, CurrArgs))
|
|
{
|
|
// aggiorno val prev
|
|
reqDict = CurrArgs;
|
|
prevJwd = serStruct;
|
|
// aggiorno live data
|
|
CurrData.CurrJwd = serStruct;
|
|
// chiamo richiesta update
|
|
CalcRequestDTO calcRequestDTO = new CalcRequestDTO();
|
|
calcRequestDTO.EnvType = EditRecord.Envir;
|
|
calcRequestDTO.DictExec = reqDict;
|
|
// chiamo la chiamata POST alla API, che manda la richiesta via REDIS
|
|
await ICService.CallRestPost($"{apiUrl}/{genericBasePath}", $"{calcTag}/{EditRecord.OfferRowUID}", calcRequestDTO);
|
|
#if false
|
|
// salvo su DB!
|
|
await DLService.OffertRowUpdateSerStruct(EditRecord.OfferRowID, serStruct);
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Path da parent record
|
|
/// </summary>
|
|
/// <param name="objID"></param>
|
|
/// <returns></returns>
|
|
private string FolderPath(int objID)
|
|
{
|
|
return $"SO-{objID:X8}";
|
|
}
|
|
|
|
/// <summary>
|
|
/// Svuota cache corrente + rilegge dati
|
|
/// </summary>
|
|
private async Task ForceReloadData()
|
|
{
|
|
isLoading = true;
|
|
CurrEditMode = EditMode.None;
|
|
EditRecord = null;
|
|
await Task.Delay(20);
|
|
await OService.FlushCacheOffersAsync();
|
|
await Task.Delay(20);
|
|
await ReloadDataAsync();
|
|
UpdateTable();
|
|
isLoading = false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Display fileSize scalato
|
|
/// </summary>
|
|
/// <param name="size"></param>
|
|
/// <returns></returns>
|
|
private string fSize(long size)
|
|
{
|
|
return EgwCoreLib.Utils.FileHelpers.SizeSuffix(size, 1);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Formattazione testo come html x display
|
|
/// </summary>
|
|
private MarkupString HtmlConv(string rawData)
|
|
{
|
|
return (MarkupString)rawData.Replace(Environment.NewLine, "<br />").Replace("\n", "<br />");//.Replace(" ", " ");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Calcolo URL immagine
|
|
/// </summary>
|
|
/// <param name="tipoImg"></param>
|
|
/// <param name="imgUid"></param>
|
|
/// <param name="env"></param>
|
|
/// <returns></returns>
|
|
private string imgUrl(EgwCoreLib.Lux.Core.Enums.ImageType tipoImg, string imgUid, string env)
|
|
{
|
|
string answ = "";
|
|
switch (tipoImg)
|
|
{
|
|
case EgwCoreLib.Lux.Core.Enums.ImageType.Calculated:
|
|
// cast string su env..
|
|
EgwMultiEngineManager.Data.Constants.EXECENVIRONMENTS envir = EgwMultiEngineManager.Data.Constants.EXECENVIRONMENTS.WINDOW;
|
|
Enum.TryParse(env, out envir);
|
|
answ = ICService.ImageUrl($"{apiUrl}/{imgBasePath}", false, imgUid, envir);
|
|
break;
|
|
|
|
case EgwCoreLib.Lux.Core.Enums.ImageType.ND:
|
|
case EgwCoreLib.Lux.Core.Enums.ImageType.Fixed:
|
|
answ = $"{apiUrl}/{imgBasePath}/static/{imgUid}";
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Forza parametri generali selezionati nell'offerta
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
private async Task OfferForceParameters()
|
|
{
|
|
if (!await JSRuntime.InvokeAsync<bool>("confirm", $"Confermi di voler impostare i parametri selezionati per l'offerta?"))
|
|
return;
|
|
// recupero obj dizionario x i parametri compresi...
|
|
ParamDict CurrSel = new ParamDict(CurrRecord.DictPresel);
|
|
// metto a waiting tutte le righe con bom...
|
|
var listCalc = SorListCalc();
|
|
foreach (var item in listCalc)
|
|
{
|
|
await ORService.UpdateAwaitStateAsync(item.OfferRowID, true, true);
|
|
// poich� non � gestito evento ritorno update window interno si "scassa" --> try catch/ if FALSE
|
|
try
|
|
{
|
|
string rColor = CurrSel.GetVal("Color");
|
|
string rGlass = CurrSel.GetVal("Glass");
|
|
string rProfile = CurrSel.GetVal("Profile");
|
|
string rWood = CurrSel.GetVal("Wood");
|
|
var newSerStruct = SerialMan.MassUpdate((string)item.SerStruct, null, null, rColor, rWood, rGlass, rProfile);
|
|
await ORService.UpdateSerStructAsync(item.OfferRowID, newSerStruct);
|
|
}
|
|
catch
|
|
{ }
|
|
}
|
|
await InvokeAsync(StateHasChanged);
|
|
|
|
// verifica preliminare UID
|
|
await ORService.FixUidAsync(OfferID);
|
|
await ORService.FixImgTypeAsync(OfferID);
|
|
|
|
// ricalcolo di tutte le BOM e relativi prezzi...
|
|
foreach (var item in listCalc)
|
|
{
|
|
// chiedo BOM e immagine
|
|
await callBomUpdate(item);
|
|
}
|
|
|
|
//await DoRecalcTemplate();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Aggiornamento costing completo:
|
|
/// - verifica UID
|
|
/// - ricalcolo BOM
|
|
/// - update prezzi
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
private async Task OfferUpdateAllCosting()
|
|
{
|
|
if (!await JSRuntime.InvokeAsync<bool>("confirm", $"Confermi di voler ricalcolare/validare in toto l'offerta?"))
|
|
return;
|
|
|
|
// metto a waiting tutte le righe con bom...
|
|
var listCalc = SorListCalc();
|
|
foreach (var item in listCalc)
|
|
{
|
|
await ORService.UpdateAwaitStateAsync(item.OfferRowID, true, true);
|
|
}
|
|
await InvokeAsync(StateHasChanged);
|
|
|
|
// verifica preliminare UID
|
|
await ORService.FixUidAsync(OfferID);
|
|
await ORService.FixImgTypeAsync(OfferID);
|
|
|
|
// fixme todo da riverificare con calcolo BOM funzionante
|
|
#if false
|
|
// rileggo i record...
|
|
await ReloadDataAsync();
|
|
#endif
|
|
// ricalcolo di tutte le BOM e relativi prezzi...
|
|
foreach (var item in listCalc)
|
|
{
|
|
// verifico SE sia calcolabile...
|
|
if (item.CalcEnabled)
|
|
{
|
|
// chiedo BOM e immagine
|
|
await callBomUpdate(item);
|
|
}
|
|
}
|
|
#if false
|
|
await DoRecalcOffer();
|
|
#endif
|
|
}
|
|
|
|
/// <summary>
|
|
/// Verifica e ricalcolo dei prezzi degli items nell'offerta
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
private async Task OfferUpdatePrices()
|
|
{
|
|
if (!await JSRuntime.InvokeAsync<bool>("confirm", $"Confermi di voler ricalcolare a costi correnti offerta?"))
|
|
return;
|
|
|
|
await DoRecalcOffer(true);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Ricevuto HwOpt, processo
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
private async void PipeHwOpt_EA_NewMessage(object? sender, EventArgs e)
|
|
{
|
|
// vale SOLO SE sono in editing...
|
|
if (EditRecord != null)
|
|
{
|
|
// aggiorno visualizzazione
|
|
PubSubEventArgs currArgs = (PubSubEventArgs)e;
|
|
// conversione on-the-fly SVG da mostrare
|
|
if (!string.IsNullOrEmpty(currArgs.newMessage))
|
|
{
|
|
if (currArgs.msgUid.Equals($"{chHwOpt}:{EditRecord.OfferRowUID}"))
|
|
{
|
|
// se non è vuoto deserializzo
|
|
if (currArgs.newMessage.Count() > 2)
|
|
{
|
|
var rawDict = JsonConvert.DeserializeObject<Dictionary<int, string>>(currArgs.newMessage) ?? new Dictionary<int, string>();
|
|
currHwOption = rawDict;
|
|
}
|
|
else
|
|
{
|
|
currHwOption = new Dictionary<int, string>();
|
|
}
|
|
// salvo in live data...
|
|
CurrData.DictOptionsXml = currHwOption;
|
|
}
|
|
await InvokeAsync(StateHasChanged);
|
|
}
|
|
}
|
|
}
|
|
|
|
private async void PipePng_EA_NewMessage(object? sender, EventArgs e)
|
|
{
|
|
// vale SOLO SE sono in editing...
|
|
if (EditRecord != null)
|
|
{
|
|
// aggiorno visualizzazione
|
|
PubSubEventArgs currArgs = (PubSubEventArgs)e;
|
|
// conversione on-the-fly SVG da mostrare
|
|
if (!string.IsNullOrEmpty(currArgs.newMessage))
|
|
{
|
|
if (currArgs.msgUid.Equals($"{chPng}:{EditRecord.OfferRowUID}"))
|
|
{
|
|
currPng = currArgs.newMessage;
|
|
// non devo passarlo al componente...
|
|
#if false
|
|
// salvo in live data...
|
|
CurrData.SvgPreview = currSvg;
|
|
#endif
|
|
}
|
|
await InvokeAsync(StateHasChanged);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Ricevuto ProfElem, processo
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
private async void PipeProfElement_EA_NewMessage(object? sender, EventArgs e)
|
|
{
|
|
// vale SOLO SE sono in editing...
|
|
if (EditRecord != null)
|
|
{
|
|
// aggiorno visualizzazione
|
|
PubSubEventArgs currArgs = (PubSubEventArgs)e;
|
|
// conversione on-the-fly SVG da mostrare
|
|
if (!string.IsNullOrEmpty(currArgs.newMessage))
|
|
{
|
|
if (currArgs.msgUid.StartsWith($"{chProfElem}:{EditRecord.OfferRowUID}"))
|
|
{
|
|
// deserializzo il dizionario delle risposte...
|
|
var rawDict = JsonConvert.DeserializeObject<List<AreaProfiles>>(currArgs.newMessage);
|
|
currAreaProfiles = rawDict ?? new List<AreaProfiles>();
|
|
CurrData.ProfElementList = currAreaProfiles;
|
|
}
|
|
await InvokeAsync(StateHasChanged);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Ricevuta profile list, processo
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
private async void PipeProfList_EA_NewMessage(object? sender, EventArgs e)
|
|
{
|
|
// vale SOLO SE sono in editing...
|
|
if (EditRecord != null)
|
|
{
|
|
// aggiorno visualizzazione
|
|
PubSubEventArgs currArgs = (PubSubEventArgs)e;
|
|
// conversione on-the-fly SVG da mostrare
|
|
if (!string.IsNullOrEmpty(currArgs.newMessage))
|
|
{
|
|
if (currArgs.msgUid.Equals($"{chProfList}:{EditRecord.OfferRowUID}"))
|
|
{
|
|
try
|
|
{
|
|
// nuova gestione da DB: attendo 500ms che il DB sia aggiornato
|
|
await Task.Delay(500);
|
|
// rileggo DB x info profili
|
|
AvailProfileList = await CPService.GetAllAsync();
|
|
// converto i profili nel nuovo formato x payload...
|
|
var profList = AvailProfileList.Select(x => new ProfilePayload()
|
|
{
|
|
ProfileName = x.Code,
|
|
ThresholdList = x.ThresholdList,
|
|
ParameterDict = x.ProfileDataDict
|
|
}).ToList();
|
|
SetupList.ProfileList = profList;
|
|
}
|
|
catch
|
|
{ }
|
|
}
|
|
await InvokeAsync(StateHasChanged);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Ricevuta shape, procersso
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
private async void PipeShape_EA_NewMessage(object? sender, EventArgs e)
|
|
{
|
|
// vale SOLO SE sono in editing...
|
|
if (EditRecord != null)
|
|
{
|
|
#if false
|
|
// aggiorno visualizzazione
|
|
PubSubEventArgs currArgs = (PubSubEventArgs)e;
|
|
// conversione on-the-fly SVG da mostrare
|
|
if (!string.IsNullOrEmpty(currArgs.newMessage))
|
|
{
|
|
if (currArgs.msgUid.Equals($"{shapeChannel}:{EditRecord.OfferRowUID}"))
|
|
{
|
|
currGroupShape = currArgs.newMessage;
|
|
// salvo in live data...
|
|
CurrData.DictShape = currGroupShape;
|
|
}
|
|
await InvokeAsync(StateHasChanged);
|
|
}
|
|
#endif
|
|
|
|
// aggiorno visualizzazione
|
|
PubSubEventArgs currArgs = (PubSubEventArgs)e;
|
|
// conversione on-the-fly SVG da mostrare
|
|
if (!string.IsNullOrEmpty(currArgs.newMessage))
|
|
{
|
|
if (currArgs.msgUid.StartsWith($"{chShape}:{EditRecord.OfferRowUID}"))
|
|
{
|
|
// deserializzo il dizionario delle risposte...
|
|
var rawDict = JsonConvert.DeserializeObject<Dictionary<int, string>>(currArgs.newMessage);
|
|
#if false
|
|
int groupId = 0;
|
|
// verifica del groupID...
|
|
int.TryParse(currArgs.msgUid.Replace($"{shapeChannel}:{windowUid}:", ""), out groupId);
|
|
if (currGroupShape.ContainsKey(groupId))
|
|
{
|
|
currGroupShape[groupId] = currArgs.newMessage;
|
|
}
|
|
else
|
|
{
|
|
currGroupShape.Add(groupId, currArgs.newMessage);
|
|
}
|
|
#endif
|
|
currGroupShape = rawDict ?? new Dictionary<int, string>();
|
|
CurrData.DictShape = currGroupShape;
|
|
}
|
|
await InvokeAsync(StateHasChanged);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Ricevuto SVG, se � il mio lo aggiorno...
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
private async void PipeSvg_EA_NewMessage(object? sender, EventArgs e)
|
|
{
|
|
// vale SOLO SE sono in editing...
|
|
if (EditRecord != null)
|
|
{
|
|
// aggiorno visualizzazione
|
|
PubSubEventArgs currArgs = (PubSubEventArgs)e;
|
|
// conversione on-the-fly SVG da mostrare
|
|
if (!string.IsNullOrEmpty(currArgs.newMessage))
|
|
{
|
|
if (currArgs.msgUid.Equals($"{chSvg}:{EditRecord.OfferRowUID}"))
|
|
{
|
|
currSvg = currArgs.newMessage;
|
|
// salvo in live data...
|
|
CurrData.SvgPreview = currSvg;
|
|
}
|
|
await InvokeAsync(StateHasChanged);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Task verifica update ricevuti
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
private async void PipeUpdate_EA_NewMessage(object? sender, EventArgs e)
|
|
{
|
|
// aggiorno visualizzazione
|
|
PubSubEventArgs currArgs = (PubSubEventArgs)e;
|
|
// conversione on-the-fly SVG da mostrare
|
|
if (!string.IsNullOrEmpty(currArgs.newMessage))
|
|
{
|
|
// cerco se faccia parte dei record correnti...
|
|
var recFound = AllRecords.Any(x => x.OfferRowUID == currArgs.newMessage);
|
|
if (recFound)
|
|
{
|
|
isLoading = true;
|
|
await Task.Delay(1);
|
|
// se si tratta dell'UID corrente --> fa update
|
|
await DoRecalcOffer(false);
|
|
await InvokeAsync(StateHasChanged);
|
|
}
|
|
}
|
|
await Task.Delay(1);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Preparazione dati x componente edit JWD
|
|
/// </summary>
|
|
/// <param name="currJwd"></param>
|
|
private void PrepareWindowData(string currJwd)
|
|
{
|
|
// converto i profili nel nuovo formato x payload...
|
|
var profList = AvailProfileList.Select(x => new ProfilePayload()
|
|
{
|
|
ProfileName = x.Code,
|
|
ThresholdList = x.ThresholdList,
|
|
ParameterDict = x.ProfileDataDict
|
|
}).ToList();
|
|
|
|
// preparo conf oggetti x controllo
|
|
SetupList = new BaseListPayload()
|
|
{
|
|
ColorMaterial = AvailColorMaterialList,
|
|
FamilyHardware = AvailFamilyHardwareList,
|
|
Glass = AvailGlassList,
|
|
Hardware = AvailHardwareList,
|
|
Material = AvailMaterialList,
|
|
ProfileList = profList
|
|
};
|
|
CurrData = new LivePayload()
|
|
{
|
|
CurrJwd = currJwd,
|
|
SvgPreview = "" //currSvg
|
|
};
|
|
}
|
|
|
|
/// <summary>
|
|
/// init classi configurazione
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
private async Task ReloadBaseList()
|
|
{
|
|
// leggo cataloghi e template relativi...
|
|
ListAllCatalog = await TService.GetAllAsync();
|
|
ListTemplateAll = await TRService.GetAllAsync();
|
|
|
|
// lettura config setup varie da DB/Cache Redis
|
|
AllConfEnvir = await EPService.GetAllAsync();
|
|
AllConfGlass = await CGService.GetAllAsync();
|
|
AvailProfileList = await CPService.GetAllAsync();
|
|
|
|
// FixMe Todo: eliminare da REDIS e usare elenco DB solamente...
|
|
var rawProfiles = await CDService.ProfileListAsync(cEnvir, "Default");
|
|
// se fosse vuoto chiamo update...
|
|
if (rawProfiles == null || rawProfiles.Count == 0)
|
|
{
|
|
await callRefreshProfList();
|
|
// aspetto 200ms... e richiedo!
|
|
await Task.Delay(200);
|
|
rawProfiles = await CDService.ProfileListAsync(cEnvir, "Default");
|
|
}
|
|
AvailProfileListOld = rawProfiles;
|
|
|
|
var rawHw = await CDService.HwModelListAsync(cEnvir, "HW.AGB");
|
|
// hw filtro solo validi...
|
|
AllConfHardware = rawHw
|
|
.Where(x => !x.FamilyName.Equals(x.Description, StringComparison.OrdinalIgnoreCase))
|
|
.ToList();
|
|
AllConfWood = await CWService.GetAllAsync();
|
|
AllColors = await GVService.GetFiltAsync("WoodCol");
|
|
// conversione tipi
|
|
AvailGlassList = AllConfGlass
|
|
.Select(x => x.Description)
|
|
.ToList();
|
|
AvailFamilyHardwareList = AllConfHardware
|
|
.DistinctBy(x => x.FamilyName)
|
|
.OrderBy(x => x.FamilyName)
|
|
.Select(x => x.FamilyName)
|
|
.ToList();
|
|
AvailHardwareList = AllConfHardware
|
|
.Select(x => new Egw.Window.Data.Hardware(x.Id, x.FamilyName, x.Description, x.OpeningType, x.Shape, x.SashQty, x.SashPosition))
|
|
.ToList();
|
|
AvailMaterialList = AllConfWood
|
|
.Select(x => x.Description)
|
|
.ToList();
|
|
// FixMe Todo: aggiunta profili (manca anche nel costruttore...)
|
|
AvailColorMaterialList = AllColors
|
|
.OrderBy(x => x.Index)
|
|
.Select(x => x.ValString)
|
|
.ToList();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Legge i dati dei record completi
|
|
/// </summary>
|
|
private async Task ReloadDataAsync()
|
|
{
|
|
if (OfferID > 0)
|
|
{
|
|
AllRecords = await ORService.GetByParentAsync(OfferID);
|
|
totalCount = AllRecords.Count();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Lancia la richiesta di ricaolo della BOM dal JWD (o equivalente)
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
private async Task RequestBom(OfferRowModel currRec)
|
|
{
|
|
if (!await JSRuntime.InvokeAsync<bool>("confirm", $"Confermi di voler ricalcolare la BOM?"))
|
|
return;
|
|
|
|
await callBomUpdate(currRec);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Css di verifica riga selezionata
|
|
/// </summary>
|
|
/// <param name="selRow"></param>
|
|
/// <returns></returns>
|
|
private string RowClass(OfferRowModel selRow)
|
|
{
|
|
return EditRecord != null && EditRecord.OfferRowID == selRow.OfferRowID ? "table-info" : "";
|
|
}
|
|
|
|
#if false
|
|
/// <summary>
|
|
/// Aggiunge una nuova riga ordine in coda...
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
protected async Task DoAddOrderRowFromSellItem(int sellItemID)
|
|
{
|
|
int numRow = AllRecords.Count + 1;
|
|
if (EditRecord != null)
|
|
{
|
|
numRow = EditRecord.RowNum + 1;
|
|
}
|
|
OfferRowModel newSOR = new OfferRowModel()
|
|
{
|
|
AwaitBom = true,
|
|
AwaitPrice = true,
|
|
OfferID = CurrRecord.OfferID,
|
|
Envir = CurrRecord.Envir,
|
|
Inserted = DateTime.Now,
|
|
RowNum = numRow,
|
|
OfferRowUID = "",
|
|
Qty = 1,
|
|
SellingItemID = sellItemID,
|
|
BomCost = 0,
|
|
BomPrice = 0,
|
|
StepCost = 0,
|
|
StepPrice = 0
|
|
};
|
|
// se è window aggiungo "{}" come serStruct sennò non la prende bene...
|
|
if (CurrRecord.Envir == EgwMultiEngineManager.Data.Constants.EXECENVIRONMENTS.WINDOW)
|
|
{
|
|
newSOR.SerStruct = "{}";
|
|
}
|
|
addFromTemplate = false;
|
|
await DLService.OffertRowUpsert(newSOR);
|
|
await ReloadDataAsync();
|
|
UpdateTable();
|
|
}
|
|
#endif
|
|
#if false
|
|
/// <summary>
|
|
/// Calcolo URL immagine
|
|
/// </summary>
|
|
/// <param name="imgUid"></param>
|
|
/// <param name="env"></param>
|
|
/// <returns></returns>
|
|
protected string imgUrl(string imgUid, string env)
|
|
{
|
|
// cast string su env..
|
|
EgwMultiEngineManager.Data.Constants.EXECENVIRONMENTS envir = EgwMultiEngineManager.Data.Constants.EXECENVIRONMENTS.WINDOW;
|
|
Enum.TryParse(env, out envir);
|
|
return ICService.ImageUrl($"{apiUrl}/{imgBasePath}", false, imgUid, envir);
|
|
}
|
|
#endif
|
|
|
|
/// <summary>
|
|
/// Salvataggio dei dati del file caricato
|
|
/// </summary>
|
|
/// <param name="fileDict">Dizionario info file</param>
|
|
private void SaveFile(Dictionary<string, string> fileDict)
|
|
{
|
|
// verifico di essere in edit...
|
|
if (EditRecord != null)
|
|
{
|
|
string folderPath = FolderPath(EditRecord.OfferID);
|
|
// verifico di avere parametri...
|
|
if (fileDict != null && fileDict.Count > 0)
|
|
{
|
|
string secureName = "";
|
|
string content = "";
|
|
if (fileDict.ContainsKey("secureName"))
|
|
{
|
|
secureName = fileDict["secureName"];
|
|
}
|
|
if (fileDict.ContainsKey("content"))
|
|
{
|
|
content = fileDict["content"];
|
|
}
|
|
if (!string.IsNullOrEmpty(folderPath) && !string.IsNullOrEmpty(secureName) && !string.IsNullOrEmpty(content))
|
|
{
|
|
// salvo!
|
|
FService.SaveFileContent(folderPath, secureName, content);
|
|
}
|
|
}
|
|
// altrimenti signifca cleanup eventuale vecchio file...
|
|
else
|
|
{
|
|
FService.DeleteOldFile(folderPath, EditRecord.FileResource);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Selezione e fix dati BOM
|
|
/// </summary>
|
|
/// <param name="currRow"></param>
|
|
/// <returns></returns>
|
|
private async Task selectBom(OfferRowModel currRow)
|
|
{
|
|
EditRecord = currRow;
|
|
//CurrBomList = DLService.OffertGetBomList(EditRecord);
|
|
CurrBomList = BomCalculator.GetBomList(EditRecord.ItemBOM);
|
|
if (CurrBomList.Any(x => x.ItemID == 0))
|
|
{
|
|
CurrBomList = await ItemService.GetBomFixItemIdAsync(CurrBomList);
|
|
}
|
|
}
|
|
|
|
private async Task setAwaitPrice(bool awaitPrice, bool flushCache)
|
|
{
|
|
foreach (var item in AllRecords)
|
|
{
|
|
item.AwaitPrice = awaitPrice;
|
|
await ORService.UpdateAwaitStateAsync(item.OfferRowID, null, awaitPrice, flushCache);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Verifia ammissibilit� display btn ricalcolo BOM da item
|
|
/// </summary>
|
|
/// <param name="reqItem"></param>
|
|
/// <returns></returns>
|
|
private bool ShowBom(OfferRowModel reqItem)
|
|
{
|
|
bool answ = false;
|
|
if (DisplayMode == EgwCoreLib.Lux.Core.Enums.DisplayMode.Edit)
|
|
{
|
|
switch (reqItem.Envir)
|
|
{
|
|
case EgwMultiEngineManager.Data.Constants.EXECENVIRONMENTS.WINDOW:
|
|
answ = !string.IsNullOrEmpty(reqItem.SerStruct) && reqItem.SerStruct.Length > 2;
|
|
break;
|
|
|
|
case EgwMultiEngineManager.Data.Constants.EXECENVIRONMENTS.BEAM:
|
|
case EgwMultiEngineManager.Data.Constants.EXECENVIRONMENTS.WALL:
|
|
case EgwMultiEngineManager.Data.Constants.EXECENVIRONMENTS.CABINET:
|
|
// da cambiare con ricerca file su disco?!?
|
|
answ = !string.IsNullOrEmpty(reqItem.FileResource) && !string.IsNullOrEmpty(reqItem.FileName);
|
|
break;
|
|
|
|
case EgwMultiEngineManager.Data.Constants.EXECENVIRONMENTS.NULL:
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elenco SalesOfferRows calcolabili:
|
|
/// - contengono serializzazione come JWD
|
|
/// - contengono file come BTL
|
|
/// </summary>
|
|
private List<OfferRowModel> SorListCalc()
|
|
{
|
|
var rawList = AllRecords
|
|
.Where(x => (!string.IsNullOrEmpty(x.SerStruct) && x.SerStruct.Length > 2) || (!string.IsNullOrEmpty(x.FileName) && !string.IsNullOrEmpty(x.FileResource)))
|
|
.ToList();
|
|
return rawList ?? new List<OfferRowModel>();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Toggle visibilit� modifica file indicando ID della OfferRow corrente (o zero se deselect)
|
|
/// </summary>
|
|
private void ToggleFileEdit(OfferRowModel? currRec)
|
|
{
|
|
CurrEditMode = currRec == null ? EditMode.None : EditMode.File;
|
|
EditRecord = currRec;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Salva nel record corrente la BOM aggiornata e poi ricalcola importo...
|
|
/// </summary>
|
|
/// <param name="newBomList"></param>
|
|
/// <exception cref="NotImplementedException"></exception>
|
|
private async Task UpdateBom(List<BomItemDTO> newBomList)
|
|
{
|
|
if (EditRecord != null)
|
|
{
|
|
// salvo BOM nel record corrente...
|
|
bool fatto = await ORService.UpdateBomAsync(EditRecord.OfferRowID, newBomList);
|
|
// ricalcolo offerta completa
|
|
await ReloadDataAsync();
|
|
UpdateTable();
|
|
// rilegge il record da elenco appena rinfrescato...
|
|
int offerRowId = EditRecord.OfferRowID;
|
|
var updRec = AllRecords.FirstOrDefault(x => x.OfferRowID == offerRowId);
|
|
if (updRec != null)
|
|
{
|
|
CurrBomList = new List<BomItemDTO>();
|
|
// fa refresh dei dati della BOM visualizzata
|
|
await selectBom(updRec);
|
|
await InvokeAsync(StateHasChanged);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Filtro e paginazione
|
|
/// </summary>
|
|
private void UpdateTable()
|
|
{
|
|
// fix paginazione
|
|
ListRecords = AllRecords
|
|
.OrderBy(x => x.RowNum)
|
|
.Skip(numRecord * (currPage - 1))
|
|
.Take(numRecord)
|
|
.ToList();
|
|
isLoading = false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Esegue lettura file + invio richiesta specifica
|
|
/// </summary>
|
|
/// <param name="e"></param>
|
|
/// <returns></returns>
|
|
|
|
private async Task UploadFile(InputFileChangeEventArgs e)
|
|
{
|
|
// Proseguo solo se sono in interattivo (NO prerender pagina)
|
|
if (isInteractive)
|
|
{
|
|
if (EditRecord != null)
|
|
{
|
|
// init dizionari arg richiesta update
|
|
Dictionary<string, string> fileArgs = new Dictionary<string, string>();
|
|
|
|
// leggo il contenuto del PRIMO (singolo) file
|
|
IBrowserFile file = e.File;
|
|
// limite file size (al momento 10 MB)
|
|
var maxAllowedSize = 10 * 1024 * 1024;
|
|
|
|
using var stream = file.OpenReadStream(maxAllowedSize);
|
|
using var reader = new StreamReader(stream);
|
|
string rawContent = await reader.ReadToEndAsync();
|
|
|
|
// calcolo il nome del file trusted...
|
|
string trustedFileName = Path.GetRandomFileName();
|
|
EditRecord.FileResource = trustedFileName;
|
|
EditRecord.FileName = file.Name;
|
|
EditRecord.FileSize = rawContent.LongCount();
|
|
// salvo sul DB i dati (nome, nome sicuro, size...)
|
|
await ORService.UpdateFileDataAsync(EditRecord);
|
|
|
|
// parametri richiesta
|
|
fileArgs.Add("Mode", $"{(int)Egw.Window.Data.Enums.QuestionModes.PREVIEW}");
|
|
fileArgs.Add("SubMode", "2");
|
|
fileArgs.Add("FileName", $"{file.Name}");
|
|
fileArgs.Add("Height", "1200");
|
|
fileArgs.Add("Width", "1800");
|
|
//fileArgs.Add("Btl", rawContent);
|
|
fileArgs.Add("SerializedData", rawContent);
|
|
// invio!
|
|
CalcRequestDTO calcRequestDTO = new CalcRequestDTO();
|
|
calcRequestDTO.EnvType = EgwMultiEngineManager.Data.Constants.EXECENVIRONMENTS.BEAM;
|
|
calcRequestDTO.DictExec = fileArgs;
|
|
await ICService.CallRestPost($"{apiUrl}/{genericBasePath}", $"{calcTag}/{EditRecord.OfferRowUID}", calcRequestDTO);
|
|
|
|
// ora chiedo anche la BOM!
|
|
|
|
#if false
|
|
// salvo in locale il file: SISTEMARE PERMESSI
|
|
saveFileContent(EditFileRecord.OfferRowUID, trustedFileName, rawContent);
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion Private Methods
|
|
}
|
|
} |