limanapp/LiMan.Api/Controllers/AppTaskController.cs

using Core;
using Core.DTO;
using ICSharpCode.SharpZipLib.Core;
using ICSharpCode.SharpZipLib.Zip;
using LiMan.APi.Data;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Configuration;
using NLog;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading.Tasks;

namespace LiMan.APi.Controllers
{
    [Route("api/apptask")]
    [ApiController]
    public class AppTaskController : ControllerBase
    {
        #region Public Constructors

        /// <summary>
        /// Init generico
        /// </summary>
        /// <param name="configuration"></param>
        /// <param name="DataService"></param>
        /// <param name="env"></param>
        public AppTaskController(IConfiguration configuration, ApiDataService DataService, IWebHostEnvironment env)
        {
            _configuration = configuration;
            this.env = env;
            dataService = DataService;
            Log.Info("Avviata classe TaskController");
        }

        #endregion Public Constructors

        #region Public Methods

        /// <summary>
        /// Elimina tutte le registrazioni req/run/done x device
        /// </summary>
        /// <param name="dev">dev richiedente</param>
        /// <param name="CurrReq">Obj AuthDataDTO con chiavi (master o app)</param>
        [HttpDelete("cleanup/{dev}")]
        public async Task<Dictionary<string, string>> TaskClearAll(string dev, [FromBody] TaskResultDTO CurrReq)
        {
            Dictionary<string, string> result = new Dictionary<string, string>();
            // verifica validità richiesta...
            if (CurrReq.IsValid)
            {
                // FixMe ToDo !!! effettuare verifica valori chiavi/imp/device...

                // elimina tutte le richieste x la macchina...
                var rawData = dataService.TaskListReset(CurrReq.CodImp);

                // registro updater...
                dataService.UpdaterRecordAction(CurrReq.CodImp, "TaskClearAll");

                if (rawData != null)
                {
                    result = rawData;
                }
                // salva in redis e toglie dai task da eseguire la richiesta relativa...

                // registro infine chiamata
                await dataService.recordCall(dev, CurrReq.CodImp, $"POST:api/apptask/clear/ | {CurrReq.MastKey} | {CurrReq.CodImp}");
            }
            return result;
        }

        /// <summary>
        /// Richiede elenco di task da eseguire x il dev richiedente
        /// </summary>
        /// <param name="dev">dev richiedente</param>
        /// <param name="AppKey">Cod Auth applicativo</param>
        /// <param name="CodImp">CodImp del dev</param>
        [HttpGet("pend/{dev}")]
        public async Task<Dictionary<string, string>> TaskGetPending(string dev, [FromHeader] string AppKey, [FromHeader] string CodImp)
        //public async Task<ActionResult<Dictionary<string, string>>> TaskGetPending(string dev, [FromHeader] string CodInst, [FromHeader] string CodImp)
        {
            Dictionary<string, string> result = new Dictionary<string, string>();
            // verifica validità richiesta...
            if (!string.IsNullOrEmpty(AppKey) && !string.IsNullOrEmpty(CodImp))
            {
                // FixMe ToDo !!! effettuare verifica valori chiavi/imp/device...

                // recupero da REDIS le richieste pending x la macchina...
                result = dataService.TaskListGet(CodImp);

                // registro updater...
                dataService.UpdaterRecordAction(CodImp, "TaskGetPending");

                // registro infine chiamata
                await dataService.recordCall(dev, CodImp, $"POST:api/apptask/pending/ | {dev} | {CodImp} | {AppKey}");
            }
            return result;
        }

        /// <summary>
        /// Registra risultato esecuzione task richiesti al device
        /// </summary>
        /// <param name="dev">dev richiedente</param>
        /// <param name="CurrReq">Obj AuthDataDTO con chiavi (master o app)</param>
        [HttpPost("done/{dev}")]
        public async Task<string> TaskSetDone(string dev, [FromBody] TaskResultDTO CurrReq)
        {
            string result = "NA";
            // verifica validità richiesta...
            if (CurrReq.IsValid)
            {
                // FixMe ToDo !!! effettuare verifica valori chiavi/imp/device...

                // recupero da REDIS le richieste pending x la macchina...
                int numDone = dataService.TaskSetDone(CurrReq.CodImp, CurrReq.DataPayload);

                // registro updater...
                dataService.UpdaterRecordAction(CurrReq.CodImp, "TaskSetDone");

                result = $"saved {numDone}/{CurrReq.DataPayload.Count}";
                // salva in redis e toglie dai task da eseguire la richiesta relativa...

                // registro infine chiamata
                await dataService.recordCall(CurrReq.CodImp, CurrReq.CodImp, $"POST:api/apptask/done/ | {CurrReq.MastKey} | {CurrReq.CodImp}");
            }
            return result;
        }

        /// <summary>
        /// Registra in esecuzione itask richiesti al device
        /// </summary>
        /// <param name="dev">dev richiedente</param>
        /// <param name="CurrReq">Obj AuthDataDTO con chiavi (master o app)</param>
        [HttpPost("running/{dev}")]
        public async Task<string> TaskSetRunning(string dev, [FromBody] TaskResultDTO CurrReq)
        {
            string result = "NA";
            // verifica validità richiesta...
            if (CurrReq.IsValid)
            {
                // FixMe ToDo !!! effettuare verifica valori chiavi/imp/device...

                // recupero da REDIS le richieste pending x la macchina...
                int numDone = dataService.TaskSetRunning(CurrReq.CodImp, CurrReq.DataPayload);

                // registro updater...
                dataService.UpdaterRecordAction(CurrReq.CodImp, "TaskSetRunning");

                result = $"saved {numDone}/{CurrReq.DataPayload.Count}";

                // registro infine chiamata
                await dataService.recordCall(dev, CurrReq.CodImp, $"POST:api/apptask/running/ | {CurrReq.MastKey} | {CurrReq.CodImp}");
            }
            return result;
        }

        /// <summary>
        /// Caricamento file backup applicativo in formato ZIP via FORM POST (backup configurazione applicativo)
        /// </summary>
        /// <param name="CodApp">Applicazione di riferimento</param>
        /// <param name="AppKey">Chiave istanza</param>
        /// <param name="CodImp">CodImpiego istanza</param>
        /// <param name="DoUnzip">Richiesta UnZip file post caricamento</param>
        /// <param name="ForceApprov">Richiesta di approvazione salvataggio files modificati post upload + unzip</param>
        /// <param name="ZipFile">File da caricare ed estrarre</param>
        /// <returns></returns>
        [HttpPost("zipbackup")]
        public async Task<ActionResult<UploadResult>> ZipFileSaveExtract([FromForm] string CodApp,
                                                                    [FromForm] string AppKey,
                                                                    [FromForm] string CodImp,
                                                                    [FromForm] bool DoUnzip,
                                                                    [FromForm] bool ForceApprov,
                                                                    [FromForm] IFormFile ZipFile)
        {
            // preparo oggetti x risposta
            var resourcePath = new Uri($"{Request.Scheme}://{Request.Host}/api/filesave/");
            List<UploadResult> uploadResults = new List<UploadResult>();
            var uploadResult = new UploadResult();
            string CodInst = "";
            // max 20 mb
            long maxFileSize = 1024 * 1024 * 20;
            // in primis verifica CodImp e AppKey
            var sLicList = await SubLicGet(AppKey, CodImp);
            if (sLicList == null || sLicList.Count == 0)
            {
                Log.Error($"ZipUpload backup failed: received code not validated | CodApp: {CodApp} | AppKey: {AppKey} | CodImp: {CodImp}");
                uploadResult.ErrorCode = 3;
            }
            else
            {
                var fRec = sLicList.FirstOrDefault();
                if (fRec == null || fRec.LicenzaNav == null)
                {
                    Log.Error($"ZipUpload backup failed: Impossible to find CodInst for current data | CodApp: {CodApp} | AppKey: {AppKey} | CodImp: {CodImp}");
                    uploadResult.ErrorCode = 4;
                }
                else
                {
                    CodInst = fRec.LicenzaNav.CodInst;
                    string fileDir = env.ContentRootPath;
                    string relDir = env.EnvironmentName;
                    string authKey = "";
                    uploadResult.FileName = ZipFile.FileName;
                    // controllo size e procedo
                    if (ZipFile.Length == 0)
                    {
                        Log.Info($"{ZipFile.FileName} length is 0 (Err: 1)");
                        uploadResult.ErrorCode = 1;
                    }
                    else if (ZipFile.Length > maxFileSize)
                    {
                        Log.Info($"{ZipFile.FileName} of {CalcSize(ZipFile.Length)} is larger than the limit of {CalcSize(maxFileSize)} (Err: 2)");
                        uploadResult.ErrorCode = 2;
                    }
                    else
                    {
                        try
                        {
                            relDir = _configuration["ServerConf:FileShareAppBackup"];
                            fileDir = Path.Combine(relDir, CodApp, CodInst);
                            if (!Directory.Exists(fileDir))
                            {
                                Directory.CreateDirectory(fileDir);
                            }
                            var filePath = Path.Combine(fileDir, ZipFile.FileName);

                            // elimino se ci fosse già il file...
                            if (System.IO.File.Exists(filePath))
                            {
                                System.IO.File.Delete(filePath);
                            }

                            // salvo da filestream a file locale
                            using (FileStream fs = new(filePath, FileMode.Create))
                            {
                                await ZipFile.CopyToAsync(fs);
                            }

                            // log!
                            Log.Info($"{ZipFile.FileName} saved at {filePath}");
                            uploadResult.Uploaded = true;
                            uploadResult.StoredFileName = ZipFile.FileName;
                            // se richiesto unzip eseguo
                            if (DoUnzip)
                            {
                                bool extractDone = false;
                                // recupero applicativi connessi
                                var listLic = await dataService.AppDtoSearch(CodInst, CodApp, false);
                                var currLic = listLic.Where(x => x.IsActive).FirstOrDefault();
                                // procedo SOLO SE ho una licenza attiva x questo cliente
                                if (currLic != null)
                                {
                                    // esegue unzip
                                    await Task.Run(() =>
                                    {
                                        System.IO.Compression.ZipFile.ExtractToDirectory(filePath, fileDir, true);
                                    });
                                    extractDone = true;

                                    // elimino zip e altro...
                                    if (extractDone)
                                    {
                                        System.IO.File.Delete(filePath);
                                    }

                                    // se richiesta auto approvazione eseguo...
                                    string reqAppFile = Path.Combine(fileDir, "ChangeApprove.req");
                                    if (System.IO.File.Exists(reqAppFile))
                                    {
                                        System.IO.File.Delete(reqAppFile);
                                    }
                                    if (ForceApprov)
                                    {
                                        // FixMe ToDo !!!
                                        // deve chiamare metodo x approvare, in MP-PROG, la directory dei
                                        // documenti caricati.. x ora segnaposto con file (così se scansiona
                                        // trova e approva)...
                                        System.IO.File.WriteAllText(reqAppFile, authKey);
                                    }
                                }
                            }
                        }
                        catch (IOException ex)
                        {
                            Log.Error($"{ZipFile.FileName} error on upload (Err: 3): {ex.Message}");
                            uploadResult.ErrorCode = 3;
                        }
                    }
                    Log.Info($"ZipUpload backup completed | CodInst: {CodInst} | CodApp: {CodApp} | {uploadResults.Count} files");
                }
            }
            uploadResults.Add(uploadResult);

            // registro updater...
            dataService.UpdaterRecordAction(CodImp, "ZipFileSaveExtract");

            return new CreatedResult(resourcePath, uploadResult);
        }

        #endregion Public Methods

        #region Protected Properties

        /// <summary>
        /// Dataservice x accesso DB
        /// </summary>
        protected ApiDataService dataService { get; set; } = null!;

        #endregion Protected Properties

        #region Protected Methods

        /// <summary>
        /// Restituisce size calcolata
        /// </summary>
        /// <param name="origSize"></param>
        /// <returns></returns>
        protected string CalcSize(long origSize)
        {
            return MeasureUtils.SizeSuffix(origSize, 1);
        }

        #endregion Protected Methods

        #region Private Fields

        private static IConfiguration _configuration;

        /// <summary>
        /// Classe per logging
        /// </summary>
        private static Logger Log = LogManager.GetCurrentClassLogger();

        private readonly IWebHostEnvironment env;

        #endregion Private Fields

        #region Private Methods

        /// <summary>
        /// Verifica validità codici
        /// </summary>
        /// <param name="AppKey"></param>
        /// <param name="CodImp"></param>
        /// <returns></returns>
        private async Task<List<DB.DBModels.SubLicenzaModel>> SubLicGet(string AppKey, string CodImp)
        {
            List<DB.DBModels.SubLicenzaModel> listRes = await dataService.AttivazioniGetAppImp(AppKey, CodImp);
            return listRes;
        }

        #endregion Private Methods
    }
}