magman/TestConsoleApp/MagmanController.cs

using EgwProxy.DataLayer.Controllers;
using EgwProxy.DataLayer.DbModel;
using EgwProxy.MagMan;
using EgwProxy.MagMan.DTO;
using NLog;
using NLog.Fluent;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Configuration;
using System.Runtime.Remoting.Messaging;
using System.Text;
using System.Threading.Tasks;

namespace DemoApp
{
    public class MagmanController
    {
        #region Public Constructors

        /// <summary>
        /// Init controller gestione MagmanSync
        /// </summary>
        /// <param name="serverUrl">URL del server</param>
        /// <param name="authToken">Token di autorizzazione</param>
        public MagmanController(string ServerAddress, string AuthToken)
        {
            commLib = new DataSyncro(ServerAddress, AuthToken);
            bool servOk = commLib.CheckRemote();
            Log.Info($"Avviato MagmanController | server: {ServerAddress} | timeout: standard (500ms)|  CheckRemote OK: {servOk}");
        }

        #endregion Public Constructors

        #region Public Enums

        /// <summary>
        /// Enum del risultato della sincronizzazione
        /// 0:  ALL_OK
        /// </summary>
        public enum SyncResult
        {
            ALL_OK = 0,
            ERR_ND,
            ERR_ServerKo,
            ERR_CloudMatNotSent,
            ERR_CloudResNotSent,
            ERR_SrcMatNotFound,
            ERR_MergeMatEmpty,
            ERR_CloudMatEmpty,
            ERR_Res2SendEmpty,
            ERR_InvSendError,
            ERR_AliasMatEmpty,
            ERR_CloudAliasNotSent,
            ERR_ProjIdNotFound,
            ERR_ProjNotSync,
            RES_CheckChanged,
            RES_CheckEqual,
            RES_CheckND,
            ERR_AllProjSyncUncomplete,
            ERR_LogMaccSyncUncomplete,
            ERR_ProjCloudIdNotFound
        }

        #endregion Public Enums

        #region Public Methods

        /// <summary>
        /// Esegue sync dei dati LogMacchina su cloud:
        /// - upload
        /// - cicla secondo parametri indicati
        /// </summary>
        /// <param name="batchSize">num record da inviare in ogni singolo batch (std: 50)</param>
        /// <param name="num2send">num max di record da inviare (std: 1000)</param>
        /// <param name="tryFixProj">Ture: cerca di sistemare prodId e prodId prima di inviare</param>
        /// <returns></returns>
        public SyncResult CloudLogMaccSyncro(int batchSize = 50, int num2send = 1000, bool tryFixProj = false)
        {
            SyncResult answ = SyncResult.ERR_ND;
            // verifico server ok
            bool servOk = commLib.CheckRemote();
            if (!servOk)
            {
                answ = SyncResult.ERR_ServerKo;
            }
            else
            {
                int numSent = 0;
                using (LogMachineController lmDbContr = new LogMachineController())
                {
                    bool okSend = false;
                    // se richiesto PRIMA fa il try-fix prodId e prodId
                    if (tryFixProj)
                    {
                        bool fixDone = lmDbContr.TryFixProjCloudId();
                    }
                    // elenco record da inviare...
                    List<LogMachineModel> recList = lmDbContr.GetUnsentAsc(num2send);
                    // controllo ci sia qulcosa da inviare...
                    if (recList.Count > 0)
                    {
                        // fintanto che ce ne sono procedo...
                        while (numSent < num2send)
                        {
                            var currList = recList
                                           .Skip(numSent)
                                           .Take(batchSize)
                                           .ToList();
                            // converto il blocco
                            var listDto = currList
                                            .Select(x => LogMachineController.ConvToItemDto(x))
                                            .ToList();
                            // invio!
                            okSend = commLib.LogMachineSend(listDto);
                            if (okSend)
                            {
                                // registro dati inviati...
                                lmDbContr.SetDtSent(currList);
                                Log.Info($"Inviati {batchSize}rec | {numSent} --> {numSent + batchSize}");
                                numSent += batchSize;
                            }
                            // altrimenti esco con errore...
                            else
                            {
                                Log.Info($"Errore in invio: {batchSize}rec | inviati {numSent} di {recList.Count}");
                                // registro errore
                                answ = SyncResult.ERR_LogMaccSyncUncomplete;
                                // condizione uscita
                                numSent = num2send + 1;
                            }
                        }
                    }
                }
            }
            return answ;
        }

        /// <summary>
        /// Esegue sync dei dati PROJ su cloud (se NON sincronizzati):
        /// </summary>
        /// <returns></returns>
        public SyncResult ProjAllSyncro()
        {
            SyncResult answ = SyncResult.ERR_ND;
            // verifico server ok
            bool servOk = commLib.CheckRemote();
            if (!servOk)
            {
                answ = SyncResult.ERR_ServerKo;
            }
            else
            {
                int numSent = 0;
                using (ProdController lmDbContr = new ProdController())
                {
                    bool syncEnabled = true;
                    // elenco record da inviare...
                    List<ProdModel> recList = lmDbContr.GetUnsentAsc();
                    // controllo ci sia qulcosa da inviare...
                    if (recList.Count > 0)
                    {
                        foreach (var item in recList)
                        {
                            if (syncEnabled)
                            {
                                answ = ProjSyncro(item.ProdId);
                                if (answ != SyncResult.ALL_OK)
                                {
                                    // disabilito altri sync
                                    syncEnabled = false;
                                    // loggo
                                    Log.Error($"ProjAllSyncro | Errore in sincornizzazione progetto: prodId: {item.ProdId} | prodDbId: {item.ProdDbId} record");
                                    // salvo errore
                                    answ = SyncResult.ERR_AllProjSyncUncomplete;
                                }
                                else
                                {
                                    numSent++;
                                }
                            }
                        }
                        // loggo completato
                        Log.Info($"ProjAllSyncro | Eseguita sincronizzazione di {numSent}/{recList.Count} record");
                    }
                }
            }
            return answ;
        }

        /// <summary>
        /// Esegue invio info avanzamento di un SINGOLO PROD dato il suo Id + info avanzamento
        /// </summary>
        /// <param name="prodId">ID del progetto (locale)</param>
        /// <param name="procTime">Tempo complessivo di lavorazione</param>
        /// <param name="valAct">
        /// Valore attuale a completamento (tipicamente numero barre/num pezzi DA FARE)
        /// </param>
        /// <param name="valMax">
        /// Valore massimo a completamento (tipicamente numero barre/num pezzi DA FARE)
        /// </param>
        /// <returns>Risultato sincronizzazione</returns>
        public SyncResult ProjSendProg(int prodId, double procTime, double valAct, double valMax)
        {
            SyncResult answ = SyncResult.ERR_ND;
            // verifico server ok
            bool servOk = commLib.CheckRemote();
            if (!servOk)
            {
                answ = SyncResult.ERR_ServerKo;
            }
            else
            {
                using (ProdController dbContr = new ProdController())
                {
                    // in primis recupero item
                    var currRec = dbContr.FindByProdId(prodId);
                    if (currRec == null)
                    {
                        answ = SyncResult.ERR_ProjIdNotFound;
                    }
                    else
                    {
                        // verifico ci sia cloud ID...
                        if (currRec.ProjCloudId == 0)
                        {
                            answ = SyncResult.ERR_ProjCloudIdNotFound;
                        }
                        else
                        {
                            try
                            {
                                // preparo obj da inviare...
                                ProjectProgrDTO projProgrDTO = new ProjectProgrDTO()
                                {
                                    ProjCloudId = currRec.ProjCloudId,
                                    ValAct = valAct,
                                    ValMax = valMax,
                                    ProcTimeReal = procTime
                                };
                                // invio e recupero ID...
                                bool fatto = commLib.ProjectProgrSend(projProgrDTO);
                                // se inviato, faccio upgrade locale...
                                if (!fatto)
                                {
                                    answ = SyncResult.ERR_ProjNotSync;
                                }
                                else
                                {
                                    answ = SyncResult.ALL_OK;
                                }
                            }
                            catch
                            {
                                answ = SyncResult.ERR_ServerKo;
                            }
                        }
                    }
                }
            }
            return answ;
        }

        /// <summary>
        /// Esegue sync di un SINGOLO PROD (cloud proj):
        /// - legge il progetto locale + upload x sync (verso cloud)
        /// - riceve ID cloud e aggiorna in locale...
        /// </summary>
        /// <param name="ProdId">Id del Prod da sincronizzare (invio dati con eventuale fix prodId)</param>
        /// <returns>Risultato sincronizzazione</returns>
        public SyncResult ProjSyncro(int ProdId)
        {
            int cloudId = 0;
            SyncResult answ = ProjSyncro(ProdId, ref cloudId);
            return answ;
        }

        /// <summary>
        /// Esegue sync di un SINGOLO PROD (cloud proj):
        /// - legge il progetto locale + upload x sync (verso cloud)
        /// - riceve ID cloud e aggiorna in locale...
        /// </summary>
        /// <param name="ProdId">Id del Prod da sincronizzare (invio dati con eventuale fix prodId)</param>
        /// <param name="ProjCloudId">
        /// Id del Prod in rete (eventualmente creato) che verrà RESTITUITO x reference
        /// </param>
        /// <returns>Risultato sincronizzazione</returns>
        public SyncResult ProjSyncro(int ProdId, ref int ProjCloudId)
        {
            SyncResult answ = SyncResult.ERR_ND;
            // verifico server ok
            bool servOk = commLib.CheckRemote();
            if (!servOk)
            {
                answ = SyncResult.ERR_ServerKo;
            }
            else
            {
                using (ProdController dbContr = new ProdController())
                {
                    // in primis recupero item
                    var currRec = dbContr.FindByProdId(ProdId);
                    if (currRec == null)
                    {
                        answ = SyncResult.ERR_ProjIdNotFound;
                    }
                    else
                    {
                        try
                        {
                            // preparo obj da inviare...
                            var projDto = ProdController.ConvToDto(currRec);
                            // invio e recupero ID...
                            ProjCloudId = commLib.ProjectSend(projDto);
                            // se inviato, faccio upgrade locale...
                            if (ProjCloudId == 0)
                            {
                                answ = SyncResult.ERR_ProjNotSync;
                            }
                            else
                            {
                                // verifico SE SIA da scrivere cloud ID...
                                if (ProjCloudId != currRec.ProjCloudId)
                                {
                                    dbContr.UpdateCloudId(ProdId, ProjCloudId);
                                }
                                answ = SyncResult.ALL_OK;
                            }
                        }
                        catch
                        {
                            answ = SyncResult.ERR_ServerKo;
                        }
                    }
                }
            }
            return answ;
        }

        #endregion Public Methods

        #region Private Fields

        private DataSyncro commLib = null;

        /// <summary>
        /// Istanza logger
        /// </summary>
        private NLog.Logger Log = LogManager.GetCurrentClassLogger();

        #endregion Private Fields
    }
}