NKC/NKC_WF/WebUserControls/cmp_stackLoading.ascx.cs

using AppData;
using NKC_SDK;
using SteamWare;
using System;

namespace NKC_WF.WebUserControls
{
    public partial class cmp_stackLoading : BaseUserControl
    {
        protected void Page_Load(object sender, EventArgs e)
        {
            if (!Page.IsPostBack)
            {
                // svuoto input barcode...
                cmp_barcode.inputAcquired = "";
                lastCmd = "";
                cmp_stackNextloading.BatchId = BatchIdCurr;
                raiseEvent();
                doUpdate();
            }
            cmp_barcode.eh_doRefresh += Cmp_barcode_eh_doRefresh;
        }
        /// <summary>
        /// Comando barcode letto
        /// </summary>
        protected string lastCmd
        {
            get
            {
                return hfBarcode.Value;
            }
            set
            {
                hfBarcode.Value = value;
            }
        }
        public int BatchIdCurr
        {
            get
            {
                int answ = 0;
                try
                {
                    if (frmView.SelectedValue != null)
                    {
                        string selBatch = $"{frmView.SelectedValue}";
                        if (!string.IsNullOrEmpty(selBatch))
                        {
                            int.TryParse(selBatch, out answ);
                        }
                    }
                }
                catch
                { }
                return answ;
            }
        }
        public int StackId
        {
            set
            {
                hfStackId.Value = value.ToString();
                lastCmd = "";
                cmp_barcode.resetMessage();
                doUpdate();
            }
            get
            {
                int answ = 0;
                int.TryParse(hfStackId.Value, out answ);
                return answ;
            }
        }
        private void Cmp_barcode_eh_doRefresh(object sender, EventArgs e)
        {
            bool doRaiseEv = false;
            // processo evento..
            lastCmd = cmp_barcode.inputAcquired.ToUpper();
            if (lastCmd == "") doRaiseEv = true;
            // processiamo barcode letto
            decodedData decoData = DataLayer.man.decodeBcode(lastCmd);
            switch (decoData.codeType)
            {
                case codeType.UNK:
                    cmp_barcode.showOutput("text-danger", $"Unknown Data: {decoData.rawData} --> no action");
                    doRaiseEv = true;
                    break;
                case codeType.Item:
                case codeType.ItemGeneric:
                    cmp_barcode.showOutput("text-warning", $"Item - ignored: {decoData.description}");
                    doRaiseEv = true;
                    break;
                case codeType.Material:
                    cmp_barcode.showOutput("badge badge-warning", $"Material - ignored: {decoData.description}");
                    doRaiseEv = true;
                    break;
                case codeType.Sheet:
                    cmp_barcode.showOutput("badge badge-warning", $"Sheet - ignored: {decoData.description}");
                    doRaiseEv = true;
                    break;
                case codeType.Stack:
                    // verifico SE lo stack esista...
                    DS_App.StackListDataTable tabStack = DataLayer.man.taSTL.getByKey(decoData.codeInt);
                    if (tabStack.Count == 0)
                    {
                        cmp_barcode.showOutput("badge badge-danger", $"BUNK NOT FOUND: {decoData.description}");
                        doRaiseEv = true;
                    }
                    else
                    {
                        // verifico non sia già in lavorazione
                        if (currentBunkAlreadyWorking(decoData.codeInt))
                        {
                            cmp_barcode.showOutput("badge badge-success", $"BUNK in processing, {decoData.rawData}");
                            doRaiseEv = true;
                        }
                        else
                        {
                            // controllo sia quello RICHIESTO
                            if (decoData.codeInt == cmp_stackNextloading.StackIdReq)
                            {
                                // verifico SE i BUNKS correnti siano tutti stati completati (NumSheet == NumWorking)
                                if (currentBunkPrinted)
                                {
                                    cmp_barcode.showOutput("badge badge-success", $"BUNK OK, {decoData.rawData}");
                                    ComLib.taktMLCurrStack = decoData.code;
                                    // processo DB e salvo che lo stack è stato caricato in MACHINE LOAD
                                    int stackId = 0;
                                    try
                                    {
                                        var tabStacks = DataLayer.man.taSTL.getByDtmx(decoData.rawData);
                                        if (tabStack.Count == 1)
                                        {
                                            stackId = tabStack[0].StackID;
                                        }
                                    }
                                    catch
                                    { }
                                    // SE HO uno stackId valido (>0)...
                                    if (stackId > 0)
                                    {
                                        DataLayer.man.taSTL.updatePos(stackId, 5);
                                        // controllo status del bunk nel suo insieme...
                                        ComLib.updateBatchPositionByBunk(stackId);
                                        doRaiseEv = true;
                                    }
                                }
                                // altrimenti segnalo NON pronto x caricare prossimo
                                else
                                {
                                    cmp_barcode.showOutput("badge badge-danger", $"PREV BUNK NOT COMPLETED, {decoData.rawData}");
                                    doRaiseEv = true;
                                }
                            }
                            else
                            {
                                cmp_barcode.showOutput("badge badge-danger", $"WRONG BUNK, {decoData.rawData}");
                                doRaiseEv = true;
                            }
                        }
                    }
                    break;
                case codeType.Batch:
                    cmp_barcode.showOutput("badge badge-warning", $"Batch - ignored: {decoData.description}");
                    doRaiseEv = true;
                    break;
                default:
                    doRaiseEv = true;
                    break;
            }
            // reset comando
            cmp_barcode.inputAcquired = "";
            // aggiorno...
            doUpdate();
            // se richiesto faccio raiseEvent
            if (doRaiseEv)
            {
                cmp_stackNextloading.doUpdate();
                raiseEvent();
            }
        }
        protected bool currentBunkAlreadyWorking(int StackIdRequested)
        {
            bool answ = false;
            // leggo i dati del bunk...
            var currBunks = DataLayer.man.taSTL.getCurrByBatch(BatchIdCurr);
            if (currBunks.Count > 0)
            {
                // verifico x ogni bunk corrente
                foreach (var item in currBunks)
                {
                    // verifico se numSheet = NumWorging
                    bool checkFound = item.StackID == StackIdRequested;

                    // update answ
                    answ = answ || checkFound;
                }
            }
            return answ;
        }
        protected bool currentBunkPrinted
        {
            get
            {
                bool answ = true;
                // leggo i dati del bunk...
                var currBunks = DataLayer.man.taSTL.getCurrByBatch(BatchIdCurr);
                if (currBunks.Count > 0)
                {
                    // verifico x ogni bunk corrente
                    foreach (var item in currBunks)
                    {
                        // verifico se numSheet = NumWorging
                        bool checkNum = item.NumSheets == item.NumSheetsWorking;

                        // update answ
                        answ = answ && checkNum;
                    }
                }
                return answ;
            }
        }

        protected void checkVisibility()
        {
            lblLoaded.Visible = StackId != 0;
            frmView.Visible = !lblLoaded.Visible;
            // fix div di simulazione
            divSim.Visible = (memLayer.ML.CRS("environment") == "DEV");
        }

        public void doUpdate()
        {
            checkVisibility();
        }



        protected void frmView_DataBound(object sender, EventArgs e)
        {
            cmp_stackNextloading.BatchId = BatchIdCurr;
            raiseEvent();
        }

        protected void lbtAdvanceProd_Click(object sender, EventArgs e)
        {
            // chiama stored x cambiare dt dei vari processi governati dal prod...
            var currStack = DataLayer.man.taSTL.getCurrByBatch(BatchIdCurr);
            if (currStack != null)
            {
                if (currStack.Count > 0)
                {
                    int stackIdCurr = currStack[0].StackID;
                    DataLayer.man.taSHL.advanceInStack(stackIdCurr);
                }
                doUpdate();
                cmp_stackNextloading.doUpdate();
                // segnalo avanzamento su redis x pagina unload
                ComLib.advaceSheetRevByBunk(BatchIdCurr);
                raiseEvent();
            }
        }

        protected void lbtAdvanceBunk_Click(object sender, EventArgs e)
        {
            // simula invio barcode del PROSSIMO BUNK (SE necessario)
        }
    }
}