using global::Microsoft.AspNetCore.Components; using Microsoft.JSInterop; using MP.Data; using MP.Data.DatabaseModels; using MP.Data.Objects; using MP.Data.Services; using NLog; using System.Text; using static MP.Data.Objects.Enums; namespace MP_TAB3.Components { public partial class OdlMan { #region Public Properties [Parameter] public EventCallback E_MachSel { get; set; } /// /// Post update restituisco nuova lista dati /// [Parameter] public EventCallback> E_Updated { get; set; } [Parameter] public MappaStatoExpl? RecMSE { get => currRecMSE; set { // salvo SOLO SE non sono in conferma if (!setupActive) { currRecMSE = value; } } } #endregion Public Properties #region Protected Properties /// /// Dati produzione rilevati /// protected StatoProdModel? datiProdAct { get; set; } = null; /// /// Restituisce il codice IdxMacchina dell'altra tavola (se multi) altrimenti la stessa macchina... /// protected string idxMaccAltraTav { get { string answ = ""; try { // verifico se SIA una tavola (ha char "#") int iSharp = IdxMaccSel.IndexOf('#'); if (iSharp > 0) { // ora verifico SE ALTRA TAVOLA ha ODL... string nomeTav = IdxMaccSel.Substring(iSharp); string altraTav = nomeTav.Substring(0, nomeTav.Length - 1); altraTav += nomeTav.EndsWith("1") ? "2" : "1"; // sistemo nome answ = IdxMaccSel.Replace(nomeTav, altraTav); } } catch { } return answ; } } protected int IdxPOdlSel { get => idxPOdlSel; set { setupActive = value != 0; if (idxPOdlSel != value) { idxPOdlSel = value; showOdlDetail = value > 0; var pUpd = Task.Run(async () => { await ReloadPOdlDetailData(); }); pUpd.Wait(); } } } [Inject] protected IJSRuntime JSRuntime { get; set; } = null!; protected List ListODL { get; set; } = new List(); protected List ListODLAll { get; set; } = new List(); [Inject] protected MailService MailServ { get; set; } = null!; [Inject] protected MessageService MsgServ { get; set; } = null!; [Inject] protected NavigationManager NavMan { get; set; } = null!; /// /// Verifica ODL OK (ovvero caricato x macchina...) /// protected bool odlOk { get => IdxOdl > 0; } [Inject] protected StatusData SDService { get; set; } = null!; protected string SearchPodl { get => searchPodl; set { if (searchPodl != value) { searchPodl = value; var pUpd = Task.Run(async () => { await ReloadData(true); }); pUpd.Wait(); } } } protected bool ShowAll { get => showAll; set { if (showAll != value) { showAll = value; var pUpd = Task.Run(async () => { await ReloadData(true); }); pUpd.Wait(); } } } [Inject] protected SharedMemService SMServ { get; set; } = null!; [Inject] protected TabDataService TabDServ { get; set; } = null!; /// /// Verifica se la tavola SIA in fase di attrezzaggio, ovvero SE: /// - sia un impianto MULTI (= con + tavole) /// - sia già attrezzata /// protected bool tavHasOdl { get { bool answ = false; // se è multi controllo if (isMulti) { answ = !emptyOdlMacc; } return answ; } } #endregion Protected Properties #region Protected Methods /// /// Gestione display avanzamento step /// /// protected async Task advStep(int currStep) { currVal = currStep; nextVal = currVal + 1; await InvokeAsync(StateHasChanged); } protected async Task CheckAttr() { #if false // rileggo ODL await updateIdxOdl(); #endif // verifico attrezzaggio su macchina corrente o se multi su parent string idxMacc2check = isMulti ? IdxMaccParent : IdxMaccSel; StatoMacchineModel rigaStato = TabDServ.StatoMacchina(idxMacc2check); // calcolo stato attrezzaggio, hard coded!!! if (isMulti) { inAttr = (rigaStato.IdxStato == 2 && tavHasOdl); } else { inAttr = rigaStato.IdxStato == 2; } // se in attr --> carico podlCurr... if (inAttr && RecMSE != null) { await ReloadXDL(true); } else { // rileggo ODL await updateIdxOdl(); } } /// /// Restituisce il codice IdxMacchina dell'impianto PARENT (se multi) altrimenti la stessa macchina... /// protected string getIdxMaccParent() { string answ = IdxMaccSel; // se fosse multi controllo if (isMulti) { // verifico se SIA una tavola (ha char "#") int iSharp = IdxMaccSel.IndexOf('#'); if (iSharp > 0) { // sistemo nome answ = IdxMaccSel.Substring(0, iSharp); } } return answ; } protected void GoToMachDetail() { // navigo! NavMan.NavigateTo($"machine-detail"); } /// /// Annulla setup ODL (come se avesse fatto FINE PROD) /// /// /// protected async Task OdlAnnullaSetup() { if (!await JSRuntime.InvokeAsync("confirm", $"Confermi di voler annullare il setup ODL in corso, equivalente a registrare solo la fine produzione?")) return; // prima di tutto svuoto dati prod SDService.MachProdStRem(IdxMaccSel); // preparo gestione progress display MaxVal = 10; isProcessing = true; int currStep = 0; await advStep(currStep); // leggo idxOdl da ultimo odl attivo x macchina var odlLast = await TabDServ.OdlCurrByMacc(IdxMaccSel, true); int idxODLCurr = odlLast.IdxOdl; int idxEvento = 7; // !!!HARD CODED await advStep(currStep++); try { // confermo prod vecchio ODL await confermaProdOdl(true); await advStep(currStep++); // processo x macchina selezionata await TabDServ.OdlFineProd(idxODLCurr, IdxMaccSel); await advStep(currStep++); string evText = "Registrata ANNULLAMENTO ATTREZZAGGIO per ODL {0}"; StringBuilder sb = new StringBuilder(); sb.AppendLine(String.Format(evText, idxODLCurr)); await processaEvento(IdxMaccSel, idxEvento, sb.ToString(), idxODLCurr); await advStep(currStep++); // resetta PODL e rimuove ODL x poi TOGLIERE info di setup su macchina corrente await TabDServ.OdlClearSetup(idxODLCurr, IdxMaccSel); await advStep(currStep++); // se è multi processo ANCHE x altra tavola... if (isMulti) { sb.AppendLine("---"); var tabOdlAltra = await TabDServ.OdlCurrByMacc(idxMaccAltraTav, true); int idxOdlAltra = tabOdlAltra.IdxOdl; await TabDServ.OdlFineProd(idxOdlAltra, idxMaccAltraTav); sb.AppendLine(String.Format(evText, idxOdlAltra)); await processaEvento(idxMaccAltraTav, idxEvento, String.Format(evText, idxOdlAltra), idxOdlAltra); // resetta PODL e rimuove ODL x poi TOGLIERE info di setup su macchina corrente await TabDServ.OdlClearSetup(idxOdlAltra, idxMaccAltraTav); await advStep(currStep++); } await advStep(currStep++); // se è master --> chiamo update child! if (isMaster) { // hard coded 60gg last await TabDServ.OdlFixMachineSlave(IdxMaccSel, 60, 1); } await advStep(currStep++); // cancella dati correnti ODL DoRemoveCurrOdlData(false); await advStep(currStep++); } catch { } RecMSE = null; await InvokeAsync(StateHasChanged); // refresh finale checkAll(); await RefreshData(); await CheckAttr(); await advStep(currStep++); await FlushMpIoOdlCache(); isProcessing = false; await InvokeAsync(StateHasChanged); } /// /// Effettua ripresa ODL su tavola /// /// /// protected async Task OdlReopenTav() { if (!await JSRuntime.InvokeAsync("confirm", $"Confermi di voler riprendere in carico l'ODL precedente?")) return; // prima di tutto svuoto dati prod SDService.MachProdStRem(IdxMaccSel); MaxVal = 3; int currStep = 0; await advStep(currStep); isProcessing = true; // chiamo stored x riprendere ODL (toglie data chiusura...) var rowRes = await TabDServ.OdlReopenOdlMacc(IdxMaccSel); if (rowRes != null && rowRes.IdxOdl > 0) { // messaggio utente string evText = "Registrato riapertura ODL {0} | art {1}"; StringBuilder sb = new StringBuilder(); sb.AppendLine(String.Format(evText, rowRes.IdxOdl, rowRes.CodArticolo)); lblOut = sb.ToString(); } await advStep(currStep++); RecMSE = null; await InvokeAsync(StateHasChanged); // update button x setup da altra tavola... checkAll(); // faccio refresh e riporto await RefreshData(); await CheckAttr(); await advStep(currStep++); await FlushMpIoOdlCache(); // chiudo update... isProcessing = false; } /// /// Effettua split ODL da ALTRA tavola su tav corrente /// /// /// protected async Task OdlSetSameAsOtherTav() { if (!await JSRuntime.InvokeAsync("confirm", $"Confermi di voler impostare lo stesso ODL dell'altra tavola?")) return; // prima di tutto svuoto dati prod SDService.MachProdStRem(IdxMaccSel); MaxVal = 3; int currStep = 0; await advStep(currStep); isProcessing = true; // se ho ODL su altra macchina... if (IdxOdlAltra > 0) { await TabDServ.OdlDividiDaAltraTavola(IdxOdlAltra, MatrOpr, IdxMaccSel); // messaggio utente string evText = "Registrata inizio attrezzaggio da split ODL {0} (come da altra tavola)"; StringBuilder sb = new StringBuilder(); sb.AppendLine(String.Format(evText, IdxOdlAltra)); lblOut = sb.ToString(); } await advStep(currStep++); RecMSE = null; await InvokeAsync(StateHasChanged); // update button x setup da altra tavola... checkAll(); // faccio refresh e riporto await RefreshData(); await CheckAttr(); await advStep(currStep++); // chiudo update... isProcessing = false; } /// /// Registrazione Fine Setup / Inizio Produzione /// /// /// protected async Task OdlSetupEnd() { TimeSpan estDur = TimeSpan.FromMinutes((double)tcRichAttr * currPodl.NumPezzi); string stima = estDur.TotalHours > 1 ? $"{estDur.TotalHours:N1} ore" : $"{estDur.TotalMinutes:N1} min"; if (!await JSRuntime.InvokeAsync("confirm", $"PODL: {currPodl.IdxPromessa}{Environment.NewLine}Art: [{currPodl.CodArticolo}] {currPodl.DescArticolo}{Environment.NewLine}Pezzi: {currPodl.NumPezzi} * TCiclo: {tcRichAttr:N3}min{Environment.NewLine}Tempo stimato: {stima}{Environment.NewLine}{Environment.NewLine}Confermi la chiusura della fase di attrezzaggio?")) return; // prima di tutto svuoto dati prod SDService.MachProdStRem(IdxMaccSel); // preparo gestione progress display MaxVal = 8; int currStep = 0; await advStep(currStep); isProcessing = true; await confermaProdOdl(true); await advStep(currStep++); // se vedesse TCRich a zero lo reimposta a quello assegnato... if (tcRichAttr == 0) { tcRichAttr = currPodl.Tcassegnato; } // leggo idxOdl da ultimo odl attivo x macchina var currOdl = await TabDServ.OdlCurrByMacc(IdxMaccSel, false); int idxODLStart = currOdl.IdxOdl; int idxEvento = 1; // !!!HARD CODED // aggiorno note e tempo setup await TabDServ.OdlUpdate(idxODLStart, MatrOpr, tcRichAttr, PzPallet, noteAttr); // se abilitata gestione check TCiclo if (approvTCEnabled) { // controllo se TC Assegnato != TCRichiesto allora invio email x verifiche... if (currOdl.Tcassegnato != tcRichAttr) { // invio email! await SendWarnTcChangeReq(idxODLStart, currOdl.Tcassegnato, tcRichAttr); } } await advStep(currStep++); // processo chiusura setup string evText = "Registrata inizio produzione per ODL {0}"; StringBuilder sb = new StringBuilder(); sb.AppendLine(String.Format(evText, idxODLStart)); await processaEvento(IdxMaccSel, idxEvento, sb.ToString(), idxODLStart); // indico INIZIO SETUP su REDIS come EXE della macchina... string ts = string.Format("{0:yyMMdd}T{0:HHmmss.fff}Z", DateTime.Now); TabDServ.addTask4Machine(IdxMaccSel, taskType.stopSetup, $"TS:{ts}|MATR:{MatrOpr}|ODL:{idxODLStart}"); await advStep(currStep++); // se è multi processo chiusura setup x altra tavola... if (isMulti) { sb.AppendLine("---"); var tabOdlAltra = await TabDServ.OdlCurrByMacc(idxMaccAltraTav, true); int idxOdlAltra = tabOdlAltra.IdxOdl; sb.AppendLine(String.Format(evText, idxOdlAltra)); await processaEvento(idxMaccAltraTav, idxEvento, String.Format(evText, idxOdlAltra), idxOdlAltra); // invio su seconda tavola TabDServ.addTask4Machine(idxMaccAltraTav, taskType.stopSetup, $"TS:{ts}|MATR: {MatrOpr}| Master Machine: {IdxMaccSel}"); } await advStep(currStep++); // se è master --> chiamo update child! if (isMaster) { // invio eventi ad IOB slave... var slaveList = SMServ.ListM2S .Where(x => x.IdxMacchina.Equals(IdxMaccSel, StringComparison.InvariantCultureIgnoreCase)) .ToList(); foreach (var machine in slaveList) { // invio chiusura attrezzaggio ts = string.Format("{0:yyMMdd}T{0:HHmmss.fff}Z", DateTime.Now); string outData = $"TS:{ts}|MATR:{MatrOpr}|ODL:{idxODLStart}"; await processaEvento(machine.IdxMacchinaSlave, idxEvento, sb.ToString(), idxODLStart); TabDServ.addTask4Machine(machine.IdxMacchinaSlave, taskType.fixStopSetup, outData); } // hard coded 60gg last await TabDServ.OdlFixMachineSlave(IdxMaccSel, 60, 1); } await advStep(currStep++); // se c'è gestione SchedaTecnica --> chiamo procedura update x lotti if (enableSchedaTecnica) { await TabDServ.ElencoLottiUpsertByOdl(idxODLStart, true); } await advStep(currStep++); // riporto stringa lblOut = sb.ToString().Replace("---", "
"); // update buttons... checkAll(); // reset vari IdxPOdlSel = 0; inAttr = false; RecMSE = null; await InvokeAsync(StateHasChanged); // faccio refresh e riporto await RefreshData(); await CheckAttr(); await advStep(currStep++); await FlushMpIoOdlCache(); // chiudo update... isProcessing = false; await InvokeAsync(StateHasChanged); } /// /// Dichiarazione inizio attrezzaggio PODL indicato /// /// protected async Task OdlSetupStart() { TimeSpan estDur = TimeSpan.FromMinutes((double)tcRichAttr * currPodl.NumPezzi); string stima = estDur.TotalHours > 1 ? $"{estDur.TotalHours:N1} ore" : $"{estDur.TotalMinutes:N1} min"; if (!await JSRuntime.InvokeAsync("confirm", $"PODL: {currPodl.IdxPromessa}{Environment.NewLine}Art: [{currPodl.CodArticolo}] {currPodl.DescArticolo}{Environment.NewLine}Pezzi: {currPodl.NumPezzi} * TCiclo: {tcRichAttr:N3}min{Environment.NewLine}Tempo stimato: {stima}{Environment.NewLine}{Environment.NewLine}Confermi inizio della fase di attrezzaggio?")) return; /*************************************************** * comprende gestione machineSlave x fix ODL master --> slave * ***************************************************/ // preparo gestione progress display MaxVal = 11; int currStep = 0; // elimino dati status... SDService.MachProdStRem(IdxMaccSel); SDService.MachProdStRem(IdxMaccParent); if (isMulti) { try { StatoMacchineModel rigaStato = TabDServ.StatoMacchina(IdxMaccParent); // controllo se NON SONO già in attrezzaggio... inAttr = (rigaStato.IdxStato == 2); } catch { } } await advStep(currStep); isProcessing = true; DateTime adesso = DateTime.Now; await advStep(currStep++); // proseguo int idxODL_curr = 0; await confermaProdOdl(false); await advStep(currStep++); if (IdxPOdlSel > 0) { // se vedesse TCRich a zero lo reimposta a quello assegnato... if (tcRichAttr == 0) { tcRichAttr = currPodl.Tcassegnato; } if (enableSplitODL && !forceCloseOdl) { // splitto VECCHIO ODL (se fosse rimasto qualcosa da produrre e ne sia rimasto uno.......) try { var currOdl = await TabDServ.OdlCurrByMacc(IdxMaccSel, false); int idxODLTemp = currOdl.IdxOdl; decimal tcAss = currOdl.Tcassegnato; await TabDServ.OdlSplit(idxODLTemp, MatrOpr, IdxMaccSel, tcAss, PzPallet, $"inizio attrezzaggio, Sospensione ODL {idxODLTemp}, generato residuo con pari TCiclo: {tcAss}", false, 0); // se fosse multi processo ANCHE x altra tavola... if (isMulti) { var otherOdl = await TabDServ.OdlCurrByMacc(IdxMaccSel, false); int idxODLAlt = otherOdl.IdxOdl; decimal tcAssAlt = otherOdl.Tcassegnato; await TabDServ.OdlSplit(idxODLAlt, MatrOpr, idxMaccAltraTav, tcAssAlt, PzPallet, $"Inizio attrezzaggio, Sospensione ODL {idxODLAlt}, generato residuo con pari TCiclo: {tcAssAlt}", false, 0); } } catch (Exception exc) { Log.Error($"Error StartSetup.01{Environment.NewLine}{exc}"); } } await advStep(currStep++); // fix idxmacchina selezionata (x ogni macchina, singola o multi...) currPodl.IdxMacchina = IdxMaccSel; // 2018.07.24 verifico se devo lavorare come ODL classico o come RPO (Richiesta / // Promessa / ODL) if (enableRPO) { // creo nuovo ODL da promessa ed associo await TabDServ.PODL_startSetup(currPodl, MatrOpr, tcRichAttr, PzPallet, noteAttr, adesso); // salvo ODL attrezzato var newOdl = await TabDServ.OdlCurrByMacc(IdxMaccSel, true); idxODL_curr = newOdl.IdxOdl; } // ODL classico else { // avvio NUOVO ODL await TabDServ.OdlInizioSetup(IdxPOdlSel, MatrOpr, IdxMaccSel, tcRichAttr, PzPallet, noteAttr); // salvo ODL Current idxODL_curr = IdxPOdlSel; } await advStep(currStep++); // process evento int idxEvento = 2; // !!!HARD CODED string evText = "Registrato inizio attrezzaggio per ODL {0}"; StringBuilder sb = new StringBuilder(); sb.AppendLine(String.Format(evText, idxODL_curr)); await processaEvento(IdxMaccSel, idxEvento, sb.ToString(), idxODL_curr); await advStep(currStep++); // indico INIZIO SETUP su REDIS come EXE della macchina... string ts = string.Format("{0:yyMMdd}T{0:HHmmss.fff}Z", DateTime.Now); string outData = $"TS:{ts}|MATR:{MatrOpr}|ODL:{idxODL_curr}"; // aggiungo articolo, commessa, richiesta pezzi... try { var datiODL = await TabDServ.OdlCurrByMacc(IdxMaccSel, true); string setArtVal = $"{datiODL.CodArticolo}"; string setPzCommVal = $"{datiODL.NumPezzi}"; string setCommVal = $"ODL{datiODL.IdxOdl:00000000}"; // FIXME TODO: scrivere come sotto? testare valvital x linea LASCO TabDServ.addTask4Machine(IdxMaccSel, taskType.startSetup, outData); TabDServ.addTask4Machine(IdxMaccSel, taskType.setArt, setArtVal); TabDServ.addTask4Machine(IdxMaccSel, taskType.setComm, setCommVal); TabDServ.addTask4Machine(IdxMaccSel, taskType.setPzComm, setPzCommVal); TabDServ.MachineParamUpdate(IdxMaccSel, "setArt", setArtVal); TabDServ.MachineParamUpdate(IdxMaccSel, "setComm", setCommVal); TabDServ.MachineParamUpdate(IdxMaccSel, "setPzComm", setPzCommVal); TabDServ.addTask4Machine(IdxMaccSel, taskType.setParameter, "ForceUpdate"); await advStep(currStep++); // li aggiungo ANCHE sui PLC slave se ci sono... if (isMaster) { // calcolo gli slave... var slaveList = SMServ.ListM2S .Where(x => x.IdxMacchina.Equals(IdxMaccSel, StringComparison.InvariantCultureIgnoreCase)) .ToList(); foreach (var machine in slaveList) { outData = $"TS:{ts}|MATR:{MatrOpr}|Master Machine: {IdxMaccSel}"; // invio chiusura attrezzaggio TabDServ.addTask4Machine(machine.IdxMacchinaSlave, taskType.startSetup, outData); TabDServ.addTask4Machine(machine.IdxMacchinaSlave, taskType.setArt, setArtVal); TabDServ.addTask4Machine(machine.IdxMacchinaSlave, taskType.setComm, setCommVal); TabDServ.addTask4Machine(machine.IdxMacchinaSlave, taskType.setPzComm, setPzCommVal); TabDServ.MachineParamUpdate(machine.IdxMacchinaSlave, "setArt", setArtVal); TabDServ.MachineParamUpdate(machine.IdxMacchinaSlave, "setComm", setCommVal); TabDServ.MachineParamUpdate(machine.IdxMacchinaSlave, "setPzComm", setPzCommVal); TabDServ.addTask4Machine(machine.IdxMacchinaSlave, taskType.setParameter, "ForceUpdate"); } } await advStep(currStep++); } catch (Exception exc) { Log.Error($"Eccezione in invio task4machine{Environment.NewLine}{exc}"); } // se fosse multi CHIUDO ODL x altra tavola... if (isMulti) { // se NON sono in attrezzaggio// riattrezzaggio... if (!inAttr && !showSplitOdlRiattr) { int idxOdlAltra = 0; try { var tabOdlAltra = await TabDServ.OdlCurrByMacc(idxMaccAltraTav, true); idxOdlAltra = tabOdlAltra.IdxOdl; } catch (Exception exc) { Log.Error($"Errore Durante recupero idxOdlAltra {Environment.NewLine}{exc}"); } // procedo se ho ODL if (idxOdlAltra > 0) { sb.AppendLine("---"); await TabDServ.OdlFineProd(idxOdlAltra, idxMaccAltraTav); evText = $"Registrato inizio attrezzaggio per ODL {idxOdlAltra} (setup seconda tavola)"; sb.AppendLine(evText); await processaEvento(idxMaccAltraTav, idxEvento, evText, idxOdlAltra); } lblOut = sb.ToString().Replace("---", "
"); } // update buttons... checkAll(); } await advStep(currStep++); // se fosse master --> chiamo update child! if (isMaster) { // hard coded 60gg last await TabDServ.OdlFixMachineSlave(IdxMaccSel, 60, 1); } await advStep(currStep++); // resetto contapezzi redis... await TabDServ.saveCounter(IdxMaccSel, "0"); // imposto ODL su redis... TabDServ.saveCurrODL(IdxMaccSel, idxODL_curr); await advStep(currStep++); } else { lblOut = "Selezionare un ORDINE valido!"; } // refresh finale var tmpTCR = tcRichAttr; // faccio refresh e riporto await TabDServ.FlushOdlCache(); IdxPOdlSel = 0; RecMSE = null; await FlushMpIoOdlCache(); await InvokeAsync(StateHasChanged); await RefreshData(); await CheckAttr(); inAttr = true; tcRichAttr = tmpTCR; isProcessing = false; await InvokeAsync(StateHasChanged); } protected override void OnInitialized() { //baseLang = SMServ.GetConf("baseLang"); numDayOdl = SMServ.GetConfInt("numDaySelOdl"); forceCloseOdl = SMServ.GetConfBool("chkCloseOdl"); confRett = SMServ.GetConfBool("confRett"); enableSplitODL = SMServ.GetConfBool("enableSplitODL"); modoConfProd = SMServ.GetConfInt("modoConfProd"); enableRPO = SMServ.GetConfBool("enableRPO"); enableAnnullaSetup = SMServ.GetConfBool("enableAnnullaSetup"); enableSchedaTecnica = SMServ.GetConfBool("enableSchedaTecnica"); enableFixSetup = SMServ.GetConfBool("OptEnableFixSetup"); showChkCloseOdlVal = SMServ.GetConfBool("showChkCloseOdl"); showReopenOdlTav = SMServ.GetConfBool("showReopenOdlTav"); showSplitOdlOnTav = SMServ.GetConfBool("showSplitOdlOnTav"); enableRiattrezzaggio = SMServ.GetConfBool("enableRiattrezzaggio"); showOdlProvv = SMServ.GetConfBool("showOdlProvv"); gPeriodReopenOdlTav = SMServ.GetConfInt("gPeriodReopenOdlTav"); approvTCEnabled = SMServ.GetConfBool("OptAdmApprTempiEnabled"); string rawEmailDest = SMServ.GetConf("_adminEmail"); ShowAll = SMServ.GetConfBool("TAB_ShowAllPOdl"); emailAdmDest = rawEmailDest.Split(',').ToList(); } protected override async Task OnParametersSetAsync() { if (!setupActive) { if (RecMSE != null && !RecMSE.MostlyEquals(lastRecMSE)) { if (string.IsNullOrEmpty(IdxMaccSel)) { IdxMaccSel = RecMSE.IdxMacchina; } isMulti = SMServ.DictMacchMulti[RecMSE.IdxMacchina] == 1; if (isMulti) { var idxMSel = MsgServ.UserPrefGet(IdxMaccSel); if (!string.IsNullOrEmpty(idxMSel)) { IdxMaccSel = idxMSel; } } IdxMaccParent = getIdxMaccParent(); checkAll(); // verifica stato InAttr await CheckAttr(); //salvo lastRec... lastRecMSE = RecMSE; await ReloadData(true); } } // verifica conferma produzione datiProdAct = await TabDServ.StatoProdMacchina(IdxMaccSel, DateTime.Now); checkConfProd(); } protected async Task ProdEnd() { if (!await JSRuntime.InvokeAsync("confirm", $"Confermi fine produzione?")) return; // prima di tutto svuoto dati prod SDService.MachProdStRem(IdxMaccSel); // preparo gestione progress display MaxVal = 7; isProcessing = true; int currStep = 0; await advStep(currStep); // leggo idxOdl da ultimo odl attivo x macchina var currOdl = await TabDServ.OdlCurrByMacc(IdxMaccSel, false); SDService.MachProdStRem(IdxMaccSel); int idxODLCurr = currOdl.IdxOdl; int idxEvento = 7; // !!!HARD CODED confermo prod vecchio ODL await confermaProdOdl(false); await advStep(currStep++); // se chk flaggato ovvero richiesta di chiudere ODL procedo come prima (chiudendo ODL // senza averne altri...) if (forceCloseOdl) { // aggiungo try/catch x capire se sia qui che si "impasta" in chiusura ODL try { // processo x macchina selezionata await TabDServ.OdlFineProd(idxODLCurr, IdxMaccSel); string evText = "Registrata fine produzione per ODL {0}"; StringBuilder sb = new StringBuilder(); sb.AppendLine(String.Format(evText, idxODLCurr)); await processaEvento(IdxMaccSel, idxEvento, sb.ToString(), idxODLCurr); await advStep(currStep++); // se è multi processo ANCHE x altra tavola... if (isMulti) { sb.AppendLine("---"); var tabOdlAltra = await TabDServ.OdlCurrByMacc(idxMaccAltraTav, true); int idxOdlAltra = tabOdlAltra.IdxOdl; await TabDServ.OdlFineProd(idxOdlAltra, idxMaccAltraTav); sb.AppendLine(String.Format(evText, idxOdlAltra)); await processaEvento(idxMaccAltraTav, idxEvento, String.Format(evText, idxOdlAltra), idxOdlAltra); } await advStep(currStep++); // se è master --> chiamo update child! if (isMaster) { // hard coded 60gg last await TabDServ.OdlFixMachineSlave(IdxMaccSel, 60, 1); } await advStep(currStep++); // riporto stringa lblOut = sb.ToString().Replace("---", "
"); } catch (Exception exc) { Log.Error($"Eccezione in operazione chiusura ODL!{Environment.NewLine}{exc}"); // navigo! NavMan.NavigateTo($"machine-detail"); } } // altrimenti split ODL x completare IN FUTURO la produzione... else { try { // effettuo split su nuovo ODL await TabDServ.OdlSplit(idxODLCurr, MatrOpr, IdxMaccSel, currOdl.Tcassegnato, PzPallet, $"Fine Produzione, Sospensione ODL {idxODLCurr}, generato residuo con pari TCiclo: {currOdl.Tcassegnato}", false, 0); // processo chiusura setup await processaEvento(IdxMaccSel, idxEvento, $"Registrata fine produzione per ODL {idxODLCurr}, nuovo ODL per quantità residua", idxODLCurr); await advStep(currStep++); // se è multi processo ANCHE x altra tavola... if (isMulti) { var tabOdlAltra = await TabDServ.OdlCurrByMacc(idxMaccAltraTav, true); int idxOdlAltra = tabOdlAltra.IdxOdl; // effettuo split su nuovo ODL await TabDServ.OdlSplit(idxOdlAltra, MatrOpr, idxMaccAltraTav, tabOdlAltra.Tcassegnato, PzPallet, $"Fine Produzione, Sospensione ODL {idxOdlAltra}, generato residuo con pari TCiclo: {tabOdlAltra.Tcassegnato}", false, 0); // processo chiusura setup await processaEvento(idxMaccAltraTav, idxEvento, $"Registrata fine produzione per ODL {idxOdlAltra}, nuovo ODL per quantità residua", idxOdlAltra); } await advStep(currStep++); // se è master --> chiamo update child! if (isMaster) { // hard coded 60gg last await TabDServ.OdlFixMachineSlave(IdxMaccSel, 60, 1); } await advStep(currStep++); } catch (Exception exc) { Log.Error($"Eccezione in operazione Chiusura + Split ODL su nuovo! {Environment.NewLine}{exc}"); // navigo! NavMan.NavigateTo($"machine-detail"); } } // aggiunto esplicita endProd TabDServ.addTask4Machine(IdxMaccSel, taskType.endProd, ""); if (isMaster) { // calcolo gli slave... var slaveList = SMServ.ListM2S .Where(x => x.IdxMacchina.Equals(IdxMaccSel, StringComparison.InvariantCultureIgnoreCase)) .ToList(); foreach (var machine in slaveList) { // invio task x end produzione... TabDServ.addTask4Machine(machine.IdxMacchinaSlave, taskType.endProd, ""); } } await advStep(currStep++); await FlushMpIoOdlCache(); // faccio refresh e riporto IdxPOdlSel = 0; RecMSE = null; await InvokeAsync(StateHasChanged); currOdl = new ODLExpModel(); inAttr = false; IdxPOdlSel = 0; forceCloseOdl = true; //await Task.Delay(250); await RefreshData(); await CheckAttr(); await advStep(currStep++); isProcessing = false; await InvokeAsync(StateHasChanged); } protected async Task refreshAfterFixOdl(bool has2Refr) { if (has2Refr) { // prima di tutto svuoto dati prod SDService.MachProdStRem(IdxMaccSel); // update buttons... checkAll(); // reset vari IdxPOdlSel = 0; inAttr = false; IdxPOdlSel = 0; await RefreshData(); await CheckAttr(); await InvokeAsync(StateHasChanged); } } protected async Task RefreshData() { // refresh tabella dati tablet... RecMSE = null; // rileggo e salvo.. var ListMSE = await SDService.MseGetAll(true); if (ListMSE != null) { // salvo in LocalStorage... await MsgServ.SaveMse(ListMSE); // aggiorno MSE attuale RecMSE = ListMSE.Find(x => x.IdxMacchina == IdxMaccSel); await E_Updated.InvokeAsync(ListMSE); } // update dati liste ODL await ReloadData(true); } protected void SaveTCRich(decimal newTCRich) { tcRichAttr = newTCRich; } protected void SearchPodlReset() { SearchPodl = ""; } protected async Task SendFixEndSetup() { if (!await JSRuntime.InvokeAsync("confirm", $"Confermi invio FIX chiusura attrezzaggio ad impianto?")) return; // prima di tutto svuoto dati prod SDService.MachProdStRem(IdxMaccSel); string ts = string.Format("{0:yyMMdd}T{0:HHmmss.fff}Z", DateTime.Now); string outData = $"TS:{ts}|MATR:{MatrOpr}|ODL:{IdxOdl}"; TabDServ.addTask4Machine(IdxMaccSel, taskType.fixStopSetup, outData); outData = "Inserita richiesta invio Fix chiusura attrezzaggio " + outData; lblOut = outData; // se è master --> chiamo update child! if (isMaster) { // invio eventi ad IOB slave... var slaveList = SMServ.ListM2S .Where(x => x.IdxMacchina.Equals(IdxMaccSel, StringComparison.InvariantCultureIgnoreCase)) .ToList(); foreach (var machine in slaveList) { // invio chiusura attrezzaggio outData = $"TS:{ts}|MATR:{MatrOpr}|ODL:{IdxOdl}|master machine:{IdxMaccSel}"; TabDServ.addTask4Machine(machine.IdxMacchinaSlave, taskType.fixStopSetup, outData); } } } protected async Task SendWarnTcChangeReq(int idxOdl, decimal tcAss, decimal tcRich) { // carico altri parametri email... string oggetto = $"{SMServ.GetConf("Cliente")} | {SMServ.GetConf("oggettoChgTc")}"; ; string corpoChgTc = SMServ.GetConf("corpoChgTc"); string mittente = SMServ.GetConf("_fromEmail"); string baseUrlAdmin = SMServ.GetConf("baseUrlAdmin"); string pageUrlApprODL = SMServ.GetConf("pageUrlApprODL"); string pageUrl = $"{baseUrlAdmin}{pageUrlApprODL}"; string corpo = $"ODL: {idxOdl} | TC Assegnato: {tcAss:N3} | TC Rich: {tcRich}{Environment.NewLine}{Environment.NewLine}"; corpo += string.Format(corpoChgTc, Environment.NewLine, pageUrl); corpo = corpo.Replace($"{Environment.NewLine}", "
"); MailKitMailData mData = new MailKitMailData() { From = mittente, To = emailAdmDest, Subject = oggetto, Body = corpo }; bool done = await MailServ.SendAsync(mData); if (done) { Log.Info($"Inviata email notifica TC da approvare per ODL {idxOdl} inviato a {string.Join(",", emailAdmDest)}"); } else { Log.Error($"Errore in invio email notifica TC da approvare per ODL {idxOdl} | tentato invio a {string.Join(",", emailAdmDest)}"); } } protected async Task SetMacc(string selIdxMacc) { // imposto macchina IdxMaccSel = selIdxMacc; // recupero dati RecMSE = TabDServ.MseGetSub(IdxMaccParent, selIdxMacc, true); await ReloadData(true); await CheckAttr(); if (showOdlDetail || inAttr) { isProcessing = true; await ReloadXDL(true); isProcessing = false; } await E_MachSel.InvokeAsync(selIdxMacc); } protected async Task ShowRiattrezzaggio() { showSplitOdlRiattr = !showSplitOdlRiattr; if (showSplitOdlRiattr) { await ReloadXDL(true); } } protected async Task SplitOdl() { if (!await JSRuntime.InvokeAsync("confirm", $"Confermi richiesta riattrezzaggio ODL, con conseguente chiusura ODL corrente + split nuovo ODL con TC {tcRichAttr:N3}?")) return; // prima di tutto svuoto dati prod SDService.MachProdStRem(IdxMaccSel); // preparo gestione progress display MaxVal = 9; int currStep = 0; await advStep(currStep); isProcessing = true; // se vedesse TCRich a zero lo reimposta a quello assegnato... if (tcRichAttr == 0) { tcRichAttr = currPodl.Tcassegnato; } // leggo idxOdl da ultimo odl attivo x macchina var currOdl = await TabDServ.OdlCurrByMacc(IdxMaccSel, false); int idxODLSplit = currOdl.IdxOdl; int idxEvento = 1; // !!!HARD CODED await advStep(currStep++); // confermo prod vecchio ODL await confermaProdOdl(false); await advStep(currStep++); // effettuo split su nuovo ODL await TabDServ.OdlSplit(idxODLSplit, MatrOpr, IdxMaccSel, tcRichAttr, PzPallet, noteAttr, true, 0); await advStep(currStep++); // se c'è gestione SchedaTecnica --> chiamo procedura update x lotti if (enableSchedaTecnica) { await TabDServ.ElencoLottiUpsertByOdl(idxODLSplit, true); } await advStep(currStep++); // processo chiusura setup string evText = "Registrato Riattrezzaggio ODL (old :{0})"; StringBuilder sb = new StringBuilder(); sb.AppendLine(String.Format(evText, idxODLSplit)); await processaEvento(IdxMaccSel, idxEvento, sb.ToString(), idxODLSplit); await advStep(currStep++); // update buttons... checkAll(); // reset vari IdxPOdlSel = 0; inAttr = false; RecMSE = null; await advStep(currStep++); // faccio refresh e riporto await RefreshData(); await CheckAttr(); await advStep(currStep++); showSplitOdlRiattr = false; await ReloadXDL(true); // chiudo update... isProcessing = false; await InvokeAsync(StateHasChanged); } protected async Task ToggleOdlDetail() { showOdlDetail = !showOdlDetail; // se devo mostrare, carico dati ODL! if (showOdlDetail) { await ReloadXDL(true); } } protected string Traduci(string lemma) { return SMServ.Traduci($"{baseLang}_{lemma}".ToUpper()); } #endregion Protected Methods #region Private Fields private static Logger Log = LogManager.GetCurrentClassLogger(); private bool approvTCEnabled = false; private bool confRett = true; private double currVal = 0; private List emailAdmDest = new List(); private bool enableAnnullaSetup = false; private bool enableFixSetup = false; private bool enableRiattrezzaggio = false; private bool enableRPO = true; private bool enableSchedaTecnica = false; private bool enableSplitODL = false; private int expTimeMsec = 500; private bool forceCloseOdl = true; private int gPeriodReopenOdlTav = 1; private int idxPOdlSel = 0; private bool isMaster = false; private bool isMulti = false; private bool isProcessing = false; private bool isSlave = false; private int lastIdxPOdl = 0; private string lblOut = ""; private int MaxVal = 10; private int modoConfProd = 0; private double nextVal = 0; private string noteAttr = ""; private int numDayOdl = 5; private int PzPallet = 0; private string searchPodl = ""; private bool showAll = false; private bool showChkCloseOdlVal = false; private bool showOdlDetail = false; private bool showOdlProvv = false; private bool showPOdlData = true; private bool showReopenOdlTav = false; private bool showSplitOdlOnTav = false; private bool showSplitOdlRiattr = false; #endregion Private Fields #region Private Properties private bool annullaSetupVisible { get { bool answ = inAttr && enableAnnullaSetup && RecMSE != null && RecMSE.PezziConf == 0; // forzato: se è doppia tavola è SEMPRE false... if (isMulti) { answ = false; } // 2024.04.15 deciso con Gian di togliere la possibilità di annullare su doppia tavola (problema di doppio reset con conferme aperte su altra tavola) //DateTime adesso = DateTime.Now; //if (isMulti) //{ // var pUpd = Task.Run(async () => // { // // controllo ANCHE che la tav correntemente selezionata NON abbia pezzi da confermare // datiProdAct = await TabDServ.StatoProdMacchina(IdxMaccSel, adesso); // answ = datiProdAct.PzConfBuoni == 0 && datiProdAct.Pz2RecScarto == 0; // }); // pUpd.Wait(); //} return answ; } } private string baseLang { get => MsgServ.UserPrefGet("Lang"); } private bool cancelSetupEnabled { //get => InAttr && enableSchedaTecnica && enableAnnullaSetup; get => inAttr && enableAnnullaSetup; } private ODLExpModel currOdl { get; set; } = new ODLExpModel(); private PODLExpModel currPodl { get; set; } = new PODLExpModel(); private MappaStatoExpl? currRecMSE { get; set; } = null; /// /// Verifica se l'ALTRA macchina NON abbia ODL valido (== 0) /// private bool emptyOdlAltraMacc { get => IdxOdlAltra == 0; } /// /// Verifica se la macchina NON abbia ODL valido (== 0) /// private bool emptyOdlMacc { get => IdxOdl == 0; } private bool endProdDisabled { get => !odlOk || needConfProd; } /// /// Variabile idxMacc parent x selezione ODL /// private string IdxMaccParent { get; set; } = ""; private string IdxMaccSel { get; set; } = ""; /// /// Valore calcolato key ODL corrente... /// private int IdxOdl { get; set; } = 0; /// /// Valore calcolato key ODL altra tavola attivo... /// private int IdxOdlAltra { get; set; } = 0; private bool inAttr { get; set; } = false; private bool isLoading { get; set; } = false; private MappaStatoExpl? lastRecMSE { get; set; } = null; private string lblWarnBody { get => odlOk ? Traduci("ConfProdBeforeContinueBody") : Traduci("setOdlBeforeContinueBody"); } private string lblWarnHead { get => odlOk ? Traduci("ConfProdBeforeContinueHead") : Traduci("setOdlBeforeContinueHead"); } private int MatrOpr { get => MsgServ.MatrOpr; } private bool needConfProd { get; set; } = false; private int numPz2Conf { get { int answ = -1; if (datiProdAct != null) { answ = datiProdAct.Pz2RecTot; } else { answ = RecMSE != null ? RecMSE.PezziProd - RecMSE.PezziConf : 0; } return answ; } } private int numSca2Conf { get { int answ = -1; if (datiProdAct != null) { answ = datiProdAct.Pz2RecScarto; } return answ; } } private bool setupActive { get; set; } = false; /// /// Verifica visibilità btn riprendi ODL su 2° tavola SE: /// - sia un impianto MULTI (= con + tavole) /// - sia disattrezzata la tavola /// - in tab congif: se sia abilitato la ripresa ODL sulla seconda tavola /// - in tab config: sia il grace period /// - NON SIANO passati i minuti indicati dalla chiusura /// private bool showReopOdlTav { get { bool answ = false; // se è multi controllo if (isMulti) { // verifico se NON HA ODL... if (emptyOdlMacc) { if (!emptyOdlAltraMacc) { // verifico SE siamo nel gracePeriod... chiuso da meno di 1h DateTime adesso = DateTime.Now; DateTime dtChiusura = DateTime.Now.AddHours(-1); try { var lastOdl = TabDServ.OdlLastByMacc(IdxMaccSel, true); if (lastOdl != null) { dtChiusura = lastOdl.DataFine ?? DateTime.Now.AddHours(-1); } } catch { } // ora verifico SE E SOLO SE è ANCORA in attrezzaggio ora verifico SE // ALTRA TAVOLA ha ODL... if (dtChiusura.AddMinutes(gPeriodReopenOdlTav) > adesso) { answ = showReopenOdlTav; } } } } return answ; } } /// /// Verifica visibilità btn split ODL su 2° tavola SE: /// - sia un impianto MULTI (= con + tavole) /// - sia già attrezzata la prima tavola /// - in tab Congif: se sia abilitato lo split ODL sulla seconda tavola /// - la macchina SIA ANCORA in attrezzaggio (2019.07.08) = 2 /// private bool showSplitOdlOnTavVal { get { bool answ = false; // se è multi controllo if (isMulti) { // verifico se NON HA ODL ma ce l'ha altra tavola... if (emptyOdlMacc) { // ora verifico SE ALTRA TAVOLA ha ODL... if (!emptyOdlAltraMacc) { answ = showSplitOdlOnTav; } } } return answ; } } private decimal tcRichAttr { get; set; } = 0; private string txtBtnOdlDetail { get => showOdlDetail ? "Nascondi Dettaglio PODL" : "MOSTRA Dettaglio ODL Corrente"; } private string txtForceCloseOdl { get => forceCloseOdl ? Traduci("ForceCloseODL") : Traduci("SplitCurrODL"); } #endregion Private Properties #region Private Methods private void checkAll() { if (string.IsNullOrEmpty(IdxMaccParent)) { if (isMulti) { IdxMaccParent = getIdxMaccParent(); } else { IdxMaccParent = IdxMaccSel; } } } private void checkConfProd() { // calcolo conferma prod... needConfProd = RecMSE != null && datiProdAct != null; if (datiProdAct != null) { needConfProd = (datiProdAct.Pz2RecTot > 0 || datiProdAct.Pz2RecScarto != 0) && !isSlave; if (needConfProd) { StateHasChanged(); } } } /// /// verifica se sia necessario confermare la prod dell'ODL precedente prima di chiudere e lo /// fa in automatico... /// /// boolean, true = deve confermare 0 pezzi (es. in setup) private async Task confermaProdOdl(bool confZero) { // 2016.11.17 NOTA: introdotti scarti, li confermiamo SEMPRE a zero se in setup, per� da // valutare SE a FINE ATTREZZAGGIO chiedere num pezzi e num scarti (saldo zero buoni) da inserire... bool fatto = false; DateTime adesso = DateTime.Now; if (confZero) { // confermo produzione ZERO pezzi (in setup) if (confRett) { // confermo al netto dei pezzi lasciati... fatto = TabDServ.ConfermaProdMacchinaFull(IdxMaccSel, modoConfProd, 0, 0, 0, adesso, MatrOpr); } else { fatto = TabDServ.ConfermaProdMacchina(IdxMaccSel, modoConfProd, 0, 0, adesso, MatrOpr); } } else // se NON sono in setup verifico se ho pz da confermare { // recupero pz da confermare datiProdAct = await TabDServ.StatoProdMacchina(IdxMaccSel, adesso); checkConfProd(); if (datiProdAct.Pz2RecTot > 0) { // confermo produzione ZERO pezzi (in setup) if (confRett) { // confermo al netto dei pezzi lasciati... fatto = TabDServ.ConfermaProdMacchinaFull(IdxMaccSel, modoConfProd, datiProdAct.Pz2RecTot, 0, 0, adesso, MatrOpr); } else { fatto = TabDServ.ConfermaProdMacchina(IdxMaccSel, modoConfProd, datiProdAct.Pz2RecTot, 0, adesso, MatrOpr); } } } } /// /// Rimozione dati e parametri (TAB e su PLC) x ODL corrente /// private void DoRemoveCurrOdlData(bool nav2detail) { // invio task x end produzione... string setArtVal = "NO ART"; string setPzCommVal = "0"; string setCommVal = $"NO ODL"; // FIXME TODO: scrivere come sotto? testare valvital x linea LASCO TabDServ.addTask4Machine(IdxMaccSel, taskType.endProd, ""); TabDServ.addTask4Machine(IdxMaccSel, taskType.setArt, setArtVal); TabDServ.addTask4Machine(IdxMaccSel, taskType.setPzComm, setPzCommVal); TabDServ.addTask4Machine(IdxMaccSel, taskType.setComm, setCommVal); // se è master --> chiamo update child! if (isMaster) { // calcolo gli slave... var slaveList = SMServ.ListM2S .Where(x => x.IdxMacchina.Equals(IdxMaccSel, StringComparison.InvariantCultureIgnoreCase)) .ToList(); foreach (var machine in slaveList) { // invio task x end produzione... TabDServ.addTask4Machine(machine.IdxMacchinaSlave, taskType.endProd, ""); TabDServ.addTask4Machine(machine.IdxMacchinaSlave, taskType.setArt, setArtVal); TabDServ.addTask4Machine(machine.IdxMacchinaSlave, taskType.setPzComm, setPzCommVal); TabDServ.addTask4Machine(machine.IdxMacchinaSlave, taskType.setComm, setCommVal); } } // se richiesto rimando a pagina dettaglio... if (nav2detail) { NavMan.NavigateTo("machine-detail", true); } } private void fixTcNotePzPallet(bool reloadFromOdl) { if (tcRichAttr == 0 || string.IsNullOrEmpty(noteAttr) || PzPallet == 0) { tcRichAttr = reloadFromOdl || IdxPOdlSel == 0 ? currOdl.TCRichAttr : currPodl.Tcassegnato; noteAttr = reloadFromOdl || IdxPOdlSel == 0 ? currOdl.Note : currPodl.Note; PzPallet = reloadFromOdl || IdxPOdlSel == 0 ? currOdl.PzPallet : currPodl.PzPallet; } } /// /// Flush cache relativa a MP-IO x dati ODL /// /// private async Task FlushMpIoOdlCache() { // svuoto dalla cache REDIS del server IO... await TabDServ.ResetIoCache("CurrODL"); await TabDServ.ResetIoCache("CurrOdlRow"); await TabDServ.ResetIoCache("CurrStatoMacc"); await TabDServ.ResetIoCache("DtMac"); } /// /// processa evento richiesto /// /// /// /// /// private async Task processaEvento(string idxMaccCurr, int idxEvento, string userMsg, int idxODL) { inputComandoMapo inCmd; inputComandoMapo inCmd2; DateTime adesso = DateTime.Now; var rigaStato = TabDServ.StatoMacchina(idxMaccCurr); // processo evento... EventListModel newRec = new EventListModel() { IdxMacchina = idxMaccCurr, InizioStato = adesso, IdxTipo = idxEvento, CodArticolo = rigaStato.CodArticolo, Value = "", MatrOpr = MatrOpr, pallet = rigaStato.pallet }; // se realtime inCmd = await TabDServ.EvListInsert(newRec, Enums.tipoInputEvento.barcode); // se la macchina è MULTI (cod#tavola) e sonoa INIZIO/FINE attrezzaggio (idxEv <=2) // oppure FINE PROD processo ANCHE per la macchina madre... if (idxMaccCurr.IndexOf('#') > 0 && (idxEvento <= 2 || idxEvento == 7)) { EventListModel newRecParent = new EventListModel() { IdxMacchina = IdxMaccParent, InizioStato = adesso, IdxTipo = idxEvento, CodArticolo = rigaStato.CodArticolo, Value = "", MatrOpr = MatrOpr, pallet = rigaStato.pallet }; inCmd2 = await TabDServ.EvListInsert(newRecParent, Enums.tipoInputEvento.barcode); } // chiamo refresh MSE await TabDServ.RicalcMse(idxMaccCurr, 0); lblOut = userMsg; // loggo USR MSG Log.Info(userMsg); } private async Task ReloadData(bool forceReload) { isLoading = true; Log.Trace("OdlMan.ReloadData 01"); if (forceReload) { isMaster = SMServ.ListM2S .Where(x => x.IdxMacchina.Equals(RecMSE?.IdxMacchina, StringComparison.InvariantCultureIgnoreCase)) .ToList().Count > 0; isSlave = SMServ.ListM2S .Where(x => x.IdxMacchinaSlave.Equals(RecMSE?.IdxMacchina, StringComparison.InvariantCultureIgnoreCase)) .ToList().Count > 0; } if (!string.IsNullOrEmpty(IdxMaccSel)) { // 2024.04.11 passo macchina selezionata SE multi... era "IdxMaccParent" ListODLAll = await TabDServ.VSOdlGetUnused(IdxMaccSel, ShowAll, numDayOdl); // ListODLAll = await TabDServ.VSOdlGetUnused(IdxMaccParent, ShowAll, numDayOdl); if (string.IsNullOrEmpty(SearchPodl)) { ListODL = ListODLAll; } else { ListODL = ListODLAll.Where(x => x.label.Contains(SearchPodl, StringComparison.InvariantCultureIgnoreCase) || x.value == 0).ToList(); } Log.Trace($"OdlMan.ReloadData | found {ListODL.Count} rec"); if (forceReload) { if (!isMulti || (isMulti && IdxMaccSel.IndexOf("#") > 0)) { var rawData = await TabDServ.PezziProdMacchina(IdxMaccSel); datiProdAct = await TabDServ.StatoProdMacchina(IdxMaccSel, DateTime.Now); checkConfProd(); Log.Trace("OdlMan.ReloadData | check checkConfProd done"); } } await updateIdxOdl(); // aggiorno questi dati SOLO SE non sono in attrezzaggio if (!inAttr && !showSplitOdlRiattr) { // imposto tcRichAttr in base allo stato... if (odlOk) { // prendo TCRich da PODL... if (IdxPOdlSel > 0) { tcRichAttr = currPodl.Tcassegnato; noteAttr = currPodl.Note; PzPallet = currPodl.PzPallet; } else if (IdxOdl > 0) { tcRichAttr = currOdl.TCRichAttr; noteAttr = currOdl.Note; PzPallet = currOdl.PzPallet; } } } } isLoading = false; Log.Trace("OdlMan.ReloadData | END"); } private async Task ReloadPOdlDetailData() { if (IdxPOdlSel > 0) { await ReloadXDL(false); // solo se NON sno in attrezzaggio controllo se sia cambiato PODL if (IdxPOdlSel != lastIdxPOdl) { lastIdxPOdl = IdxPOdlSel; if (!inAttr && !showSplitOdlRiattr) { tcRichAttr = currPodl.Tcassegnato; noteAttr = currPodl.Note; PzPallet = currPodl.PzPallet; } } } } private async Task ReloadXDL(bool reloadFromOdl) { int currIdxPOdl = IdxPOdlSel; if (RecMSE != null) { if (reloadFromOdl) { currIdxPOdl = RecMSE.IdxPOdl ?? 0; } // se ho PODL valido... if (currIdxPOdl > 0) { currPodl = await TabDServ.PODLExp_getByKey(currIdxPOdl); } else { currPodl = new PODLExpModel() { IdxOdl = RecMSE.IdxOdl ?? 0, KeyRichiesta = "-", CodArticolo = RecMSE.CodArticolo, DescArticolo = RecMSE.CodArticolo, NumPezzi = RecMSE.NumPezzi, Tcassegnato = RecMSE.TCAssegnato }; } } // update a runtime dati ODL se assegnato if (currPodl.IdxOdl > 0) { currOdl = await TabDServ.OdlByIdx(currPodl.IdxOdl, false); } await updateIdxOdl(); // sistemo TCiclo, note, pzPallet.. fixTcNotePzPallet(reloadFromOdl); } private async Task updateIdxOdl() { // sistemo idxOdl... var tabOdl = await TabDServ.OdlCurrByMacc(IdxMaccSel, false); IdxOdl = tabOdl.IdxOdl; if (isMulti) { var tabOdlAltra = await TabDServ.OdlCurrByMacc(idxMaccAltraTav, false); IdxOdlAltra = tabOdlAltra.IdxOdl; } } #endregion Private Methods } }