limanapp/LiMan.Api/Controllers/ReleaseController.cs

using Core.DTO;
using Core;
using LiMan.APi.Data;
using LiMan.DB.DTO;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using NLog;
using System.Collections.Generic;
using System.Threading.Tasks;
using System.Linq;
using LiMan.DB.DBModels;
using Microsoft.Extensions.Configuration;
using Org.BouncyCastle.Asn1.Crmf;
using System;

namespace LiMan.APi.Controllers
{
    /// <summary>
    /// Controller gestione RELEASE applicativi
    /// </summary>
    [Route("api/release")]
    [ApiController]
    public class ReleaseController : ControllerBase
    {
        #region Public Constructors

        /// <summary>
        /// Init generico
        /// </summary>
        /// <param name="DataService"></param>
        public ReleaseController(ApiDataService DataService)
        {
            dataService = DataService;
            Log.Info("Avviata classe ReleaseController");
        }

        #endregion Public Constructors

        #region Public Methods

        /// <summary>
        /// Recupera elenco dati Release (rilasciate) GET api/release/EgtBW
        /// </summary>
        /// <param name="id">Codice Applicazione</param>
        /// <returns></returns>
        [HttpGet("{id}")]
        [Obsolete("Please use POST with api/release/getall instead.", false)]
        public async Task<List<ReleaseDTO>> Get(string id)
        {
            var result = await dataService.ReleaseGetByApp(id);
            await dataService.recordCall(id, id, $"GET:api/release/{id}");
            return result;
        }

        /// <summary>
        /// Recupera elenco dati Release (rilasciate) data versione minima GET api/release/filt/EgtBW
        /// </summary>
        /// <param name="id">Codice Applicazione</param>
        /// <param name="VersMin">Versione minima richiesta (attuale)</param>
        /// <returns></returns>
        [HttpGet("filt/{id}")]
        [Obsolete("Please use POST with api/release/getfilt instead.", false)]
        public async Task<List<ReleaseDTO>> GetFilt(string id, string VersMin)
        {
            var result = await dataService.ReleaseGetByAppVers(id, VersMin);
            await dataService.recordCall(id, id, $"GET:api/release/filt/{id}");
            return result;
        }

        /// <summary>
        /// Recupera elenco dati Release (rilasciate) data versione minima e massima GET api/release/filtLimit/EgtBW
        /// </summary>
        /// <param name="id">Codice Applicazione</param>
        /// <param name="VersMin">Versione minima richiesta (attuale)</param>
        /// <param name="VersMax">Versione massima consentita</param>
        /// <returns></returns>
        [HttpGet("filtLimit/{id}")]
        [Obsolete("Please use POST with api/release/getlimit instead.", false)]
        public async Task<List<ReleaseDTO>> GetFiltLimit(string id, string VersMin, string VersMax)
        {
            var result = await dataService.ReleaseGetByAppVersLimit(id, VersMin, VersMax);
            await dataService.recordCall(id, id, $"GET:api/release/filtLimit/{id}");
            return result;
        }

        /// <summary>
        /// Recupera elenco dati Release (rilasciate) POST api/release/getall
        /// </summary>
        /// <param name="CurrRequest">Obj ReleaseReqDTO con chiavi (master o app)</param>
        [HttpPost("getall")]
        public async Task<List<ReleaseDTO>> GetReleases([FromBody] ReleaseReqDTO CurrRequest)
        {
            List<ReleaseDTO> result = new List<ReleaseDTO>();
            // verifica validità richiesta...
            if (CheckReqKeys(CurrRequest))
            {
                result = await dataService.ReleaseGetByApp(CurrRequest.CodApp);
                await dataService.recordCall(CurrRequest.CodApp, CurrRequest.CodApp, $"POST:api/release/getall/ | {CurrRequest.MastKey} | {CurrRequest.CodImp} | {CurrRequest.CodApp}");
            }
            return result;
        }

        /// <summary>
        /// Recupera elenco dati Release CRITICHE rilasciate (se sono ultima per singola CodApp)
        /// POST api/release/get-critical
        /// </summary>
        /// <param name="CurrRequest">Obj ReleaseReqDTO con chiavi (master o app)</param>
        [HttpPost("getcritical")]
        public async Task<Dictionary<string, ReleaseDTO>> GetReleasesCritical([FromBody] ReleaseReqDTO CurrRequest)
        {
            Dictionary<string, ReleaseDTO> result = new Dictionary<string, ReleaseDTO>();
            // verifica validità richiesta...
            if (CheckReqKeys(CurrRequest))
            {
                result = await dataService.ReleaseGetCritical();
                await dataService.recordCall(CurrRequest.CodApp, CurrRequest.CodApp, $"POST:api/release/getcritical/ | {CurrRequest.MastKey} | {CurrRequest.CodImp} | {CurrRequest.CodApp}");
            }
            return result;
        }

        /// <summary>
        /// Recupera elenco dati Release (rilasciate) data versione minima POST api/release/getfilt
        /// </summary>
        /// <param name="CurrRequest">Obj ReleaseReqDTO con chiavi (master o app)</param>
        [HttpPost("getfilt")]
        public async Task<List<ReleaseDTO>> GetReleasesFilt([FromBody] ReleaseReqDTO CurrRequest)
        {
            List<ReleaseDTO> result = new List<ReleaseDTO>();
            // verifica validità richiesta...
            if (CheckReqKeys(CurrRequest))
            {
                result = await dataService.ReleaseGetByAppVers(CurrRequest.CodApp, CurrRequest.VersMin);
                await dataService.recordCall(CurrRequest.CodApp, CurrRequest.CodApp, $"POST:api/release/getfilt/ | {CurrRequest.MastKey} | {CurrRequest.CodImp} | {CurrRequest.CodApp}");
            }
            return result;
        }

        /// <summary>
        /// Recupera elenco dati Release (rilasciate) data versione minima e massima POST api/release/getlimit
        /// </summary>
        /// <param name="CurrRequest">Obj ReleaseReqDTO con chiavi (master o app)</param>
        [HttpPost("getlimit")]
        public async Task<List<ReleaseDTO>> GetReleasesLimit([FromBody] ReleaseReqDTO CurrRequest)
        {
            List<ReleaseDTO> result = new List<ReleaseDTO>();
            // verifica validità richiesta...
            if (CheckReqKeys(CurrRequest))
            {
                result = await dataService.ReleaseGetByAppVersLimit(CurrRequest.CodApp, CurrRequest.VersMin, CurrRequest.VersMax);
                await dataService.recordCall(CurrRequest.CodApp, CurrRequest.CodApp, $"POST:api/release/getlimit/ | {CurrRequest.MastKey} | {CurrRequest.CodImp} | {CurrRequest.CodApp}");
            }
            return result;
        }

        /// <summary>
        /// Salva una nuova release dell'applicativo (eventualmente sovrascrivendo) POST api/release/save
        /// </summary>
        /// <param name="CurrRequest">Obj Richiesta</param>
        [HttpPost("save")]
        public async Task<ReleaseDTO> save([FromBody] AppRelVersion CurrRequest)
        {
            ReleaseDTO result = new ReleaseDTO()
            {
                CodApp = CurrRequest.CodApp,
                ReleaseDate = CurrRequest.ReleaseDate,
                VersNum = CurrRequest.VersNum,
                VersText = CurrRequest.VersText,
                RelTags = CurrRequest.RelTags.ToUpper()
            };
            // controllo valori
            if (CurrRequest.IsValid)
            {
                // verifica preliminare licenza x upload
                var licUploader = await dataService.LicenzeSearch(CurrRequest.CodInst, CurrRequest.UplAppID, CurrRequest.MasterKey, false);
                if (licUploader != null && licUploader.Count > 0)
                {
                    // in primis cerco app...
                    var appList = await dataService.ApplicativiGetAll();
                    ApplicativoModel recApp = new ApplicativoModel();
                    if (appList != null)
                    {
                        recApp = appList.FirstOrDefault(x => x.CodApp == CurrRequest.CodApp);
                    }
                    // nel caso mancasse la aggiungo
                    if (recApp == null || string.IsNullOrEmpty(recApp.CodApp) || recApp.CodApp != CurrRequest.CodApp)
                    {
                        recApp = new ApplicativoModel()
                        {
                            CodApp = CurrRequest.CodApp,
                            Descrizione = "Nuova APP da POST api/release/save",
                            TplConnString = "",
                            Tipo = CurrRequest.Tipo
                        };
                        await dataService.ApplicativoUpsert(recApp);
                    }
                    //converto in una release...
                    ReleaseModel newRec = new ReleaseModel()
                    {
                        CodApp = CurrRequest.CodApp,
                        ReleaseDate = CurrRequest.ReleaseDate,
                        RelTags = CurrRequest.RelTags.ToUpper(),
                        VersNum = CurrRequest.VersNum,
                        VersText = CurrRequest.VersText
                    };
                    // registro versione eventualmente gestendo nuovo applicativo
                    var insRes = await dataService.ReleaseUpsert(newRec);
                    if (insRes)
                    {
                        Log.Info($"Release recorded | {CurrRequest.CodApp} | {CurrRequest.VersNum} | {CurrRequest.VersText} | {CurrRequest.ReleaseDate} | {CurrRequest.RelTags}");
                    }
                }
                // recupero vers applicativo...
                var rawResult = await dataService.ReleaseGetByApp(CurrRequest.CodApp);
                if (rawResult != null && rawResult.Count > 0)
                {
                    result = rawResult.Where(x => x.VersText == CurrRequest.VersText).FirstOrDefault();
                }
                // fisso nostra install
                await dataService.recordCall(CurrRequest.CodInst, CurrRequest.CodApp, $"POST:api/release/save:{CurrRequest.CodApp}");
            }
            else
            {
                Log.Error($"Errore: licenza UpdateManager non trovata | {CurrRequest.MasterKey}");
                await dataService.recordCall(CurrRequest.CodInst, CurrRequest.CodApp, $"ERROR POST:api/release/save:{CurrRequest.CodApp} | {CurrRequest.MasterKey}");
            }
            return result;
        }

        #endregion Public Methods

        #region Protected Properties

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

        #endregion Protected Properties

        #region Private Fields

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

        #endregion Private Fields

        #region Private Methods

        /// <summary>
        /// Verifica validità richiesta
        /// - dati presenti in chiamata
        /// - combinazioni CodApp + chiavi valide/attive
        /// </summary>
        /// <param name="currReq"></param>
        /// <returns></returns>
        private bool CheckReqKeys(ReleaseReqDTO currReq)
        {
            bool answ = currReq.IsValid;
            if (answ)
            {
                // verifica validità chiavi... TBD!!!
            }
            return answ;
        }

        #endregion Private Methods
    }
}