limanapp/LiMan.Api/Controllers/AttivazioniController.cs

using Core;
using LiMan.APi.Data;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using NLog;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

namespace LiMan.APi.Controllers
{
    /// <summary>
    /// Controller elemento Attivazioni (come licenza derivata x singolo utente di GPW)
    /// </summary>
    [Route("api/attivazioni")]
    [ApiController]
    public class AttivazioniController : ControllerBase
    {
        #region Private Fields

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

        #endregion Private Fields

        #region Public Constructors

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

        #endregion Public Constructors

        #region Protected Properties

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

        #endregion Protected Properties

        #region Public Methods

        /// <summary>
        /// Eliminazione di un set di attivazioni (SE SCADUTE)
        /// </summary>
        // POST api/attivazioni/removeKey
        [HttpPost("removeKey")]
        public async Task<bool> removeKey([FromBody] UserLicenseRequest CurrRequest)
        {
            bool done = await dataService.AttivazioniDelete(CurrRequest.MasterKey, CurrRequest.ParamDict);
            // se ho qualcosa da loggare...
            foreach (var item in CurrRequest.ParamDict)
            {
                // registro 1 riga x ogni record...
                await dataService.recordCall(CurrRequest.MasterKey, $"POST:api/attivazioni/removeKey:{item.Key}|{item.Value}");
            }
            return done;
        }

        /// <summary>
        /// Recupero record di sub licenza (con chiavi anonimizzate)
        /// </summary>
        /// <param name="chiave">Licenza MASTER</param>
        /// <returns></returns>
        // GET api/attivazioni/5
        [HttpGet]
        public async Task<List<DB.DTO.AttivazioneDTO>> Get(string chiave)
        {
            List<DB.DTO.AttivazioneDTO> result = new List<DB.DTO.AttivazioneDTO>();
            var dbResult = await dataService.AttivazioniByMasterKey(chiave, false);
            result = (dbResult != null) ? dbResult : result;
            await dataService.recordCall(chiave, $"GET:api/attivazioni:{chiave}");
            return result;
        }

        /// <summary>
        /// Richiesta attivazione di una lista di chiavi di licenza sub
        /// </summary>
        /// <param name="CurrRequest">Obj Richiesta con licenza MASTER + Elenco codici impiego (key) + valori in formato dizionari</param>
        // POST api/attivazioni
        [HttpPost]
        public async Task<List<DB.DTO.AttivazioneDTO>> Post([FromBody] UserLicenseRequest CurrRequest)
        {
            List<DB.DTO.AttivazioneDTO> currData = new List<DB.DTO.AttivazioneDTO>();
            // giorni veto riattivazione: 60 x lic utente GPW, 7 altrimenti
            int dayVeto = CurrRequest.LicType == Core.Enum.TipoLicenza.UserKey ? 60 : 7;
            // eseguo tentativo generazione attivazioni da licenza...
            bool done = await dataService.AttivazioniTryAdd(CurrRequest.MasterKey, CurrRequest.ParamDict, dayVeto, CurrRequest.LicType);
            currData = await dataService.AttivazioniByMasterKey(CurrRequest.MasterKey, false);
            // se ho qualcosa da loggare...
            foreach (var item in CurrRequest.ParamDict)
            {
                // registro 1 riga x ogni record...
                await dataService.recordCall(CurrRequest.MasterKey, $"POST:api/attivazioni:{item.Key}|{item.Value}");
            }
            return currData;
        }

        /// <summary>
        /// Richiesta di refresh delle key associate ai CodImpiego da una lista di chiavi di licenza sub
        /// </summary>
        /// <param name="CurrRequest">Obj Richiesta con licenza MASTER + Elenco codici impiego (key) + valori in formato dizionari</param>
        // POST api/attivazioni/refreshKey
        [HttpPost("refreshKey")]
        public async Task<List<DB.DTO.AttivazioneDTO>> refreshKey([FromBody] UserLicenseRequest CurrRequest)
        {
            List<DB.DTO.AttivazioneDTO> currData = new List<DB.DTO.AttivazioneDTO>();

            // eseguo tentativo generazione attivazioni da licenza...
            bool done = await dataService.AttivazioniTryRefresh(CurrRequest.MasterKey, CurrRequest.ParamDict);
            currData = await dataService.AttivazioniByMasterKey(CurrRequest.MasterKey, false);
            // se ho qualcosa da loggare...
            foreach (var item in CurrRequest.ParamDict)
            {
                // registro 1 riga x ogni record...
                await dataService.recordCall(CurrRequest.MasterKey, $"POST:api/attivazioni/refreshKey:{item.Key}__{item.Value}");
            }
            return currData;
        }

        /// <summary>
        /// Eliminazione di TUTTE le attivazioni SCADUTE
        /// </summary>
        /// <param name="chiave">Licenza MASTER</param>
        // DELETE api/attivazioni/resetAvail
        [HttpDelete("resetAvail")]
        public async Task<bool> ResetAvail(string chiave)
        {
            bool done = await dataService.AttivazioniResetAvail(chiave);
            await dataService.recordCall(chiave, $"DELETE:api/attivazioni/resetAvail:{chiave}");
            return done;
        }

        /// <summary>
        /// Verifica recupero un record di sub licenza
        /// </summary>
        /// <param name="chiave">Licenza MASTER</param>
        /// <param name="codImpiego">Codice univoco impiego licenza</param>
        /// <returns></returns>
        // GET api/attivazioni/verifica/5?codImpiego=abcd
        [HttpGet("verifica")]
        public async Task<DB.DTO.AttivazioneDTO> VerificaImpiego(string chiave, string codImpiego)
        {
            DB.DTO.AttivazioneDTO result = new DB.DTO.AttivazioneDTO();
            var dbResult = await dataService.AttivazioneSearch(chiave, codImpiego, false);
            result = (dbResult != null) ? dbResult : result;
            await dataService.recordCall(chiave, $"GET:api/attivazioni/verifica:{chiave}__{codImpiego}");
            return result;
        }

        #endregion Public Methods
    }
}