Samuele Locatelli
1037 lines
37 KiB
C#
1037 lines
37 KiB
C#
using GPW.CORE.Data.DbModels;
|
|
using Microsoft.Extensions.Configuration;
|
|
using Microsoft.Extensions.Logging;
|
|
using Newtonsoft.Json;
|
|
using NLog;
|
|
using RestSharp;
|
|
using StackExchange.Redis;
|
|
using System.Web;
|
|
using static GPW.CORE.Data.LiManObj;
|
|
using static System.Net.Mime.MediaTypeNames;
|
|
|
|
namespace GPW.CORE.Data.Services
|
|
{
|
|
/// <summary>
|
|
/// Servizi e dati condivisi a livello applicazione
|
|
/// </summary>
|
|
public class LicenseService
|
|
{
|
|
#region Public Constructors
|
|
|
|
/// <summary>
|
|
/// Init classe
|
|
/// </summary>
|
|
/// <param name="configuration"></param>
|
|
/// <param name="logger"></param>
|
|
/// <param name="redisConnMult"></param>
|
|
public LicenseService(IConfiguration configuration, IConnectionMultiplexer redisConnMult)
|
|
{
|
|
_configuration = configuration;
|
|
// Conf cache
|
|
redisConn = redisConnMult;
|
|
redisDb = this.redisConn.GetDatabase();
|
|
}
|
|
|
|
#endregion Public Constructors
|
|
|
|
#region Public Events
|
|
|
|
public event Action EA_InfoUpdated = null!;
|
|
|
|
#endregion Public Events
|
|
|
|
#region Public Properties
|
|
|
|
public List<LiManObj.AttivazioneDTO> ActivList { get; set; } = new List<LiManObj.AttivazioneDTO>();
|
|
public List<AnagKeyValueModel> AKVList { get; set; } = new List<AnagKeyValueModel>();
|
|
public string Applicazione { get; set; } = "";
|
|
public LiManObj.ApplicativoDTO AppLicense { get; set; } = new LiManObj.ApplicativoDTO();
|
|
|
|
public bool DoCheckLicOk
|
|
{
|
|
get
|
|
{
|
|
// verifico num dip attivi <= num licenze attive...
|
|
|
|
return true;
|
|
// verificare vecchia implementazione x check licenze (utenti attivi <= utenti licenza) + check payload (elenco hash utenti)
|
|
//return (licenzeGPW.checkLicenze && licenzeGPW.checkPayload);
|
|
}
|
|
}
|
|
|
|
public bool HasActivData
|
|
{
|
|
get
|
|
{
|
|
bool answ = ValidData;
|
|
// se ok controllo che ci siano attivazioni
|
|
if (answ)
|
|
{
|
|
// provo classe locale...
|
|
answ = ActivList != null && ActivList.Count > 0;
|
|
// se non le avessi carico!
|
|
if (!answ)
|
|
{
|
|
var pUpd = Task.Run(async () =>
|
|
{
|
|
ActivList = await ActivListCache();
|
|
});
|
|
pUpd.Wait();
|
|
answ = ActivList != null && ActivList.Count > 0;
|
|
}
|
|
}
|
|
return answ;
|
|
}
|
|
}
|
|
|
|
public bool HasAppData
|
|
{
|
|
get
|
|
{
|
|
bool answ = !string.IsNullOrEmpty(AppLicense.CodApp);
|
|
// se ok controllo che ci siano attivazioni
|
|
if (!answ)
|
|
{
|
|
var pUpd = Task.Run(async () =>
|
|
{
|
|
AppLicense = await AppLicCache();
|
|
});
|
|
pUpd.Wait();
|
|
answ = !string.IsNullOrEmpty(AppLicense.CodApp);
|
|
}
|
|
return answ;
|
|
}
|
|
}
|
|
|
|
public DateTime infoExpiry { get; set; } = DateTime.Today.AddDays(1);
|
|
|
|
public string Installazione { get; set; } = "";
|
|
|
|
public string MasterKey { get; set; } = "";
|
|
|
|
/// <summary>
|
|
/// Num licenze autorizzate dal DB
|
|
/// </summary>
|
|
public int NumLicDb
|
|
{
|
|
get
|
|
{
|
|
int answ = 0;
|
|
if (AKVList != null && AKVList.Count > 0)
|
|
{
|
|
answ = getAVKInt(Installazione);
|
|
}
|
|
return answ;
|
|
}
|
|
}
|
|
|
|
public bool ValidData
|
|
{
|
|
get
|
|
{
|
|
// controllo valori string base
|
|
bool checkData = !string.IsNullOrEmpty(Installazione) && !string.IsNullOrEmpty(Applicazione) && !string.IsNullOrEmpty(MasterKey);
|
|
return checkData;
|
|
}
|
|
}
|
|
|
|
#endregion Public Properties
|
|
|
|
#region Public Methods
|
|
|
|
public async Task<List<LiManObj.AttivazioneDTO>> ActivListCache()
|
|
{
|
|
List<LiManObj.AttivazioneDTO> dbResult = new List<LiManObj.AttivazioneDTO>();
|
|
string cacheKey = $"{rKeyAttByLic}:{MasterKey}";
|
|
string rawData = await getRSV(cacheKey);
|
|
if (!string.IsNullOrEmpty(rawData))
|
|
{
|
|
var cacheRes = JsonConvert.DeserializeObject<List<LiManObj.AttivazioneDTO>?>(rawData);
|
|
if (cacheRes != null)
|
|
{
|
|
dbResult = cacheRes;
|
|
}
|
|
}
|
|
|
|
return await Task.FromResult(dbResult);
|
|
}
|
|
|
|
public async Task<LiManObj.ApplicativoDTO> AppLicCache()
|
|
{
|
|
LiManObj.ApplicativoDTO dbResult = new LiManObj.ApplicativoDTO();
|
|
string cacheKey = $"{rKeyLic}:{MasterKey}";
|
|
string rawData = await getRSV(cacheKey);
|
|
if (!string.IsNullOrEmpty(rawData))
|
|
{
|
|
var cacheRes = JsonConvert.DeserializeObject<LiManObj.ApplicativoDTO>(rawData);
|
|
if (cacheRes != null)
|
|
{
|
|
dbResult = cacheRes;
|
|
}
|
|
}
|
|
|
|
return await Task.FromResult(dbResult);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Recupera DTO dati attivazione licenza dato codice impiego
|
|
/// </summary>
|
|
/// <param name="CodImpiego"></param>
|
|
/// <returns></returns>
|
|
public AttivazioneDTO? GetOnlineActivationInfo(string CodImpiego)
|
|
{
|
|
AttivazioneDTO? answ = null;
|
|
// cerco online
|
|
RestClient client = new RestClient(apiUrl);
|
|
//client.Authenticator = new HttpBasicAuthenticator("username", "password");
|
|
string MKeyEnc = HttpUtility.UrlEncode(MasterKey);
|
|
var request = new RestRequest($"/api/attivazioni/verifica?chiave={MKeyEnc}&CodImpiego={CodImpiego}");
|
|
var response = client.Get(request);
|
|
// controllo risposta
|
|
if (response.StatusCode == System.Net.HttpStatusCode.OK)
|
|
{
|
|
// verifico risposta
|
|
string rawData = $"{response.Content}";
|
|
if (!string.IsNullOrEmpty(rawData) && rawData.Length > 2)
|
|
{
|
|
try
|
|
{
|
|
// deserializzo
|
|
answ = JsonConvert.DeserializeObject<AttivazioneDTO>(rawData);
|
|
}
|
|
catch
|
|
{ }
|
|
}
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Calcola HASH del codice impiego = payload utente
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public string HashDip(DipendentiModel recDip)
|
|
{
|
|
DataValidator cDV = new DataValidator(recDip);
|
|
string hash = cDV.HashDip;
|
|
return hash;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Init della classe con variabili di base da Redis/DB
|
|
/// </summary>
|
|
public bool InitAkv()
|
|
{
|
|
bool fatto = false;
|
|
Installazione = getAVKStr("installazione");
|
|
MasterKey = getAVKStr(Installazione);
|
|
fatto = !string.IsNullOrEmpty($"{Installazione}{MasterKey}");
|
|
return fatto;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Init della classe x licenza applicativo
|
|
/// </summary>
|
|
public async Task<bool> RefreshApplic()
|
|
{
|
|
bool fatto = false;
|
|
if (string.IsNullOrEmpty(AppLicense.CodApp))
|
|
{
|
|
var onlineLic = await OnlineApplicationData();
|
|
if (onlineLic != null)
|
|
{
|
|
// scadenza info a 15 gg...
|
|
int numDays = 15;
|
|
AppLicense = onlineLic;
|
|
fatto = await setAppLicData(AppLicense, numDays);
|
|
}
|
|
}
|
|
return fatto;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Init della classe con variabili di base da Redis/DB
|
|
/// </summary>
|
|
public async Task<bool> RefreshLicense()
|
|
{
|
|
bool fatto = false;
|
|
var onlineAct = await OnlineActivationList();
|
|
if (onlineAct != null)
|
|
{
|
|
if (onlineAct.Count > 0)
|
|
{
|
|
// scadenza info a 15 gg...
|
|
int numDays = 15;
|
|
infoExpiry = DateTime.Now.AddDays(numDays);
|
|
ActivList = onlineAct;
|
|
fatto = await setActivList(onlineAct, numDays);
|
|
}
|
|
}
|
|
return fatto;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Effettua refresh Payload su server (Remoto) e recupera info licenza in locale (sovrascrivendo info locali Redis)
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public bool RefreshPayload()
|
|
{
|
|
bool answ = false;
|
|
// svuoto payload calcolato
|
|
ExecFlushRedisPattern((RedisValue)$"{rkeyPayload}:*");
|
|
// cerco online
|
|
RestClient client = new RestClient(apiUrl);
|
|
string MKeyEnc = HttpUtility.UrlEncode(MasterKey);
|
|
var request = new RestRequest($"/api/licenza/refreshPayload");
|
|
string newEnigma = DataValidator.CalcHash($"{DateTime.Now:yyyyMMddHHmmss}");
|
|
LicenseCoord newBody = new LicenseCoord()
|
|
{
|
|
MasterKey = MasterKey,
|
|
CodInst = Installazione,
|
|
CodApp = Applicazione,
|
|
Enigma = newEnigma
|
|
};
|
|
request.AddJsonBody(newBody);
|
|
var response = client.Post(request);
|
|
// controllo risposta
|
|
if (response.StatusCode == System.Net.HttpStatusCode.OK)
|
|
{
|
|
answ = true;
|
|
// salvo in redis contenuto serializzato
|
|
string rawData = $"{response.Content}";
|
|
// salvo in redis per 7 gg
|
|
setRSV(rKeyLic, rawData, TimeSpan.FromDays(7));
|
|
}
|
|
Log.Info($"Richiesta RefreshPayload eseguita");
|
|
return answ;
|
|
}
|
|
|
|
public async Task<bool> resetActivList()
|
|
{
|
|
await Task.Delay(1);
|
|
string rKey = $"{rKeyAttByLic}:{MasterKey}";
|
|
bool answ = false;
|
|
try
|
|
{
|
|
// imposta vuoto e scade tra 1 ms...
|
|
await redisDb.StringSetAsync(rKey, "", TimeSpan.FromMilliseconds(1));
|
|
//attende 1 ms...
|
|
await Task.Delay(2);
|
|
if (EA_InfoUpdated != null)
|
|
{
|
|
EA_InfoUpdated?.Invoke();
|
|
}
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
|
|
public void ResetLicenseData()
|
|
{
|
|
ExecFlushRedisPattern((RedisValue)$"{rKeyAttByLic}:*");
|
|
ExecFlushRedisPattern((RedisValue)$"{rKeyLic}:*");
|
|
ExecFlushRedisPattern((RedisValue)$"{rkeyPayload}:*");
|
|
ExecFlushRedisPattern((RedisValue)$"{rkeyTickets}:*");
|
|
}
|
|
|
|
public void ResetTicketCache()
|
|
{
|
|
ExecFlushRedisPattern((RedisValue)$"{rkeyTickets}:*");
|
|
// ricarico
|
|
var newList = getTickets();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Tenta invio di un ticket x licenza indicata
|
|
/// </summary>
|
|
/// <param name="contName"></param>
|
|
/// <param name="contEmail"></param>
|
|
/// <param name="contPhone"></param>
|
|
/// <param name="reqBody"></param>
|
|
/// <param name="codImpiego"></param>
|
|
/// <param name="idxSubLic"></param>
|
|
/// <returns></returns>
|
|
public bool SendTicketReq(string contName, string contEmail, string contPhone, string reqBody, string codImpiego, int idxSubLic)
|
|
{
|
|
bool answ = false;
|
|
// cerco online
|
|
RestClient client = new RestClient(apiUrl);
|
|
string MKeyEnc = HttpUtility.UrlEncode(MasterKey);
|
|
var request = new RestRequest($"/api/ticket/sendReq");
|
|
|
|
SupportRequest richiesta = new SupportRequest()
|
|
{
|
|
ContactName = contName,
|
|
ContactEmail = contEmail,
|
|
ContactPhone = contPhone,
|
|
ReqBody = reqBody,
|
|
CodInst = Installazione,
|
|
CodApp = Applicazione,
|
|
MasterKey = MasterKey,
|
|
idxSubLic = idxSubLic,
|
|
CodImp = codImpiego,
|
|
Tipo = TipologiaTicket.Licenze
|
|
};
|
|
|
|
request.AddJsonBody(richiesta);
|
|
var response = client.Post(request);
|
|
|
|
// controllo risposta
|
|
if (response.StatusCode == System.Net.HttpStatusCode.OK)
|
|
{
|
|
// verifico risposta
|
|
string rawData = response.Content;
|
|
try
|
|
{
|
|
if (rawData.StartsWith("["))
|
|
{
|
|
// deserializzo
|
|
List<TicketDTO> tickets = JsonConvert.DeserializeObject<List<TicketDTO>>(rawData);
|
|
answ = tickets != null;
|
|
}
|
|
else
|
|
{
|
|
// deserializzo singolo
|
|
TicketDTO tickets = JsonConvert.DeserializeObject<TicketDTO>(rawData);
|
|
answ = tickets != null;
|
|
}
|
|
}
|
|
catch
|
|
{ }
|
|
}
|
|
Log.Info($"Richiesta SendTicketReq inviata | idxSub: {idxSubLic}");
|
|
return answ;
|
|
}
|
|
|
|
public async Task<bool> setActivList(List<LiManObj.AttivazioneDTO> newActList, int numDays)
|
|
{
|
|
bool fatto = false;
|
|
string rKey = $"{rKeyAttByLic}:{MasterKey}";
|
|
var rawData = JsonConvert.SerializeObject(newActList);
|
|
await setRSVAsync(rKey, rawData, numDays * 24);
|
|
fatto = true;
|
|
if (EA_InfoUpdated != null)
|
|
{
|
|
EA_InfoUpdated?.Invoke();
|
|
}
|
|
return fatto;
|
|
}
|
|
|
|
public async Task<bool> setAppLicData(LiManObj.ApplicativoDTO newAppDto, int numDays)
|
|
{
|
|
bool fatto = false;
|
|
string cacheKey = $"{rKeyLic}:{MasterKey}";
|
|
var rawData = JsonConvert.SerializeObject(newAppDto);
|
|
await setRSVAsync(cacheKey, rawData, numDays * 24);
|
|
fatto = true;
|
|
if (EA_InfoUpdated != null)
|
|
{
|
|
EA_InfoUpdated?.Invoke();
|
|
}
|
|
return fatto;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Tenta attivazione licenza dato codice impiego
|
|
/// </summary>
|
|
/// <param name="CodImpiego"></param>
|
|
/// <returns></returns>
|
|
public bool TryActivation(string CodImpiego, string Chiave)
|
|
{
|
|
bool answ = false;
|
|
// cerco online
|
|
RestClient client = new RestClient(apiUrl);
|
|
//client.Authenticator = new HttpBasicAuthenticator("username", "password");
|
|
string MKeyEnc = HttpUtility.UrlEncode(MasterKey);
|
|
var request = new RestRequest($"/api/attivazioni");
|
|
Dictionary<string, string> parDict = new Dictionary<string, string>();
|
|
parDict.Add(CodImpiego, Chiave);
|
|
UserLicenseRequest newBody = new UserLicenseRequest()
|
|
{
|
|
MasterKey = MasterKey,
|
|
ParamDict = parDict
|
|
};
|
|
request.AddJsonBody(newBody);
|
|
var response = client.Post(request);
|
|
// controllo risposta
|
|
if (response.StatusCode == System.Net.HttpStatusCode.OK)
|
|
{
|
|
// verifico risposta
|
|
string rawData = $"{response.Content}";
|
|
try
|
|
{
|
|
// deserializzo
|
|
AttivazioneDTO datiAttivazione = JsonConvert.DeserializeObject<AttivazioneDTO>(rawData);
|
|
answ = datiAttivazione != null;
|
|
ResetLicenseData();
|
|
}
|
|
catch
|
|
{ }
|
|
}
|
|
Log.Info($"Richiesta tryActivation | CodImpiego: {CodImpiego}");
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Tenta attivazione licenze dato dizionario codici impiego + chiavi
|
|
/// </summary>
|
|
/// <param name="ParamsList">Dizionario parametri attivazione di tipo (CodImpiego,Chiave)</param>
|
|
/// <returns></returns>
|
|
public async Task<bool> TryActivationMult(Dictionary<string, string> ParamsList)
|
|
{
|
|
bool answ = false;
|
|
// cerco online
|
|
RestClient client = new RestClient(apiUrl);
|
|
//client.Authenticator = new HttpBasicAuthenticator("username", "password");
|
|
string MKeyEnc = HttpUtility.UrlEncode(MasterKey);
|
|
var request = new RestRequest($"/api/attivazioni");
|
|
UserLicenseRequest newBody = new UserLicenseRequest()
|
|
{
|
|
MasterKey = MasterKey,
|
|
ParamDict = ParamsList
|
|
};
|
|
request.AddJsonBody(newBody);
|
|
var response = client.Post(request);
|
|
// controllo risposta
|
|
if (response.StatusCode == System.Net.HttpStatusCode.OK)
|
|
{
|
|
// verifico risposta
|
|
string rawData = $"{response.Content}";
|
|
try
|
|
{
|
|
if (rawData.Contains("["))
|
|
{
|
|
// deserializzo
|
|
List<AttivazioneDTO> datiAttivazione = JsonConvert.DeserializeObject<List<AttivazioneDTO>>(rawData);
|
|
answ = datiAttivazione != null;
|
|
}
|
|
else
|
|
{
|
|
// deserializzo singolo
|
|
AttivazioneDTO datiAttivazione = JsonConvert.DeserializeObject<AttivazioneDTO>(rawData);
|
|
answ = datiAttivazione != null;
|
|
ResetLicenseData();
|
|
await RefreshLicense();
|
|
}
|
|
}
|
|
catch
|
|
{ }
|
|
}
|
|
Log.Info($"Richiesta tryActivationMult | num params: {ParamsList.Count}");
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Tenta refresh licenza dato codice impiego (aggiorna la authKey...)
|
|
/// </summary>
|
|
/// <param name="CodImpiego"></param>
|
|
/// <returns></returns>
|
|
public async Task<bool> TryRefreshActivation(string CodImpiego, string Chiave)
|
|
{
|
|
bool answ = false;
|
|
// cerco online
|
|
RestClient client = new RestClient(apiUrl);
|
|
//client.Authenticator = new HttpBasicAuthenticator("username", "password");
|
|
string MKeyEnc = HttpUtility.UrlEncode(MasterKey);
|
|
var request = new RestRequest($"/api/attivazioni/refreshKey");
|
|
Dictionary<string, string> parDict = new Dictionary<string, string>();
|
|
parDict.Add(CodImpiego, Chiave);
|
|
UserLicenseRequest newBody = new UserLicenseRequest()
|
|
{
|
|
MasterKey = MasterKey,
|
|
ParamDict = parDict
|
|
};
|
|
request.AddJsonBody(newBody);
|
|
var response = client.Post(request);
|
|
// controllo risposta
|
|
if (response.StatusCode == System.Net.HttpStatusCode.OK)
|
|
{
|
|
// verifico risposta
|
|
string rawData = $"{response.Content}";
|
|
try
|
|
{
|
|
if (rawData.Contains("["))
|
|
{
|
|
// deserializzo
|
|
List<AttivazioneDTO> datiAttivazione = JsonConvert.DeserializeObject<List<AttivazioneDTO>>(rawData);
|
|
answ = datiAttivazione != null;
|
|
}
|
|
else
|
|
{
|
|
// deserializzo singolo
|
|
AttivazioneDTO datiAttivazione = JsonConvert.DeserializeObject<AttivazioneDTO>(rawData);
|
|
answ = datiAttivazione != null;
|
|
ResetLicenseData();
|
|
await RefreshLicense();
|
|
}
|
|
}
|
|
catch
|
|
{ }
|
|
}
|
|
Log.Info($"Richiesta TryRefreshActivation | CodImpiego: {CodImpiego}");
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Tenta rimozione licenza dato codice impiego
|
|
/// </summary>
|
|
/// <param name="CodImpiego"></param>
|
|
/// <returns></returns>
|
|
public async Task<bool> TryRemoveActivation(string CodImpiego, string Chiave)
|
|
{
|
|
bool answ = false;
|
|
// cerco online
|
|
RestClient client = new RestClient(apiUrl);
|
|
//client.Authenticator = new HttpBasicAuthenticator("username", "password");
|
|
string MKeyEnc = HttpUtility.UrlEncode(MasterKey);
|
|
var request = new RestRequest($"/api/attivazioni/removeKey");
|
|
Dictionary<string, string> parDict = new Dictionary<string, string>();
|
|
parDict.Add(CodImpiego, Chiave);
|
|
UserLicenseRequest newBody = new UserLicenseRequest()
|
|
{
|
|
MasterKey = MasterKey,
|
|
ParamDict = parDict
|
|
};
|
|
request.AddJsonBody(newBody);
|
|
var response = client.Post(request);
|
|
// controllo risposta
|
|
if (response.StatusCode == System.Net.HttpStatusCode.OK)
|
|
{
|
|
// verifico risposta
|
|
string rawData = $"{response.Content}";
|
|
try
|
|
{
|
|
bool.TryParse(rawData, out answ);
|
|
ResetLicenseData();
|
|
await RefreshLicense();
|
|
}
|
|
catch
|
|
{ }
|
|
}
|
|
Log.Info($"Richiesta TryRemoveActivation | CodImpiego: {CodImpiego} | answ: {answ}");
|
|
return answ;
|
|
}
|
|
|
|
#endregion Public Methods
|
|
|
|
#region Protected Fields
|
|
|
|
/// <summary>
|
|
/// Chiave redis x attivazioni della licenza
|
|
/// </summary>
|
|
protected const string rKeyAttByLic = "GPW.CORE:LongCache:AttByLic";
|
|
|
|
/// <summary>
|
|
/// Chiave redis x info licenza
|
|
/// </summary>
|
|
protected const string rKeyLic = "GPW.CORE:LongCache:LicData";
|
|
|
|
/// <summary>
|
|
/// Info payload
|
|
/// </summary>
|
|
protected const string rkeyPayload = "GPW.CORE:LongCache:Payload";
|
|
|
|
/// <summary>
|
|
/// Info tickets
|
|
/// </summary>
|
|
protected const string rkeyTickets = "GPW.CORE:LongCache:Tickets";
|
|
|
|
protected Random rnd = new Random();
|
|
|
|
#endregion Protected Fields
|
|
|
|
#region Protected Methods
|
|
|
|
/// <summary>
|
|
/// Verifica attivazione licenza dato codice impiego
|
|
/// </summary>
|
|
/// <param name="CodImpiego"></param>
|
|
/// <returns></returns>
|
|
protected async Task<bool> CheckActivation(string CodImpiego)
|
|
{
|
|
bool answ = false;
|
|
// cerco online
|
|
RestClient client = new RestClient(apiUrl);
|
|
//client.Authenticator = new HttpBasicAuthenticator("username", "password");
|
|
string MKeyEnc = HttpUtility.UrlEncode(MasterKey);
|
|
var request = new RestRequest($"/api/attivazioni/verifica?chiave={MKeyEnc}&CodImpiego={CodImpiego}");
|
|
var response = client.Get(request);
|
|
// controllo risposta
|
|
if (response.StatusCode == System.Net.HttpStatusCode.OK)
|
|
{
|
|
// verifico risposta
|
|
string rawData = $"{response.Content}";
|
|
try
|
|
{
|
|
// deserializzo
|
|
var datiAttivazione = JsonConvert.DeserializeObject<AttivazioneDTO>(rawData);
|
|
if (datiAttivazione != null)
|
|
{
|
|
answ = datiAttivazione != null && datiAttivazione.CodImpiego == CodImpiego;
|
|
}
|
|
}
|
|
catch
|
|
{ }
|
|
}
|
|
return await Task.FromResult(answ);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Verifica attivazione licenza dato codice impiego
|
|
/// </summary>
|
|
/// <param name="CodImpiego"></param>
|
|
/// <returns></returns>
|
|
protected bool CheckActivationUnlocked(string CodImpiego)
|
|
{
|
|
bool answ = false;
|
|
// cerco online
|
|
RestClient client = new RestClient(apiUrl);
|
|
//client.Authenticator = new HttpBasicAuthenticator("username", "password");
|
|
string MKeyEnc = HttpUtility.UrlEncode(MasterKey);
|
|
var request = new RestRequest($"/api/attivazioni/verifica?chiave={MKeyEnc}&CodImpiego={CodImpiego}");
|
|
var response = client.Get(request);
|
|
// controllo risposta
|
|
if (response.StatusCode == System.Net.HttpStatusCode.OK)
|
|
{
|
|
// verifico risposta
|
|
string rawData = $"{response.Content}";
|
|
try
|
|
{
|
|
// deserializzo
|
|
var datiAttivazione = JsonConvert.DeserializeObject<AttivazioneDTO>(rawData);
|
|
if (datiAttivazione != null)
|
|
{
|
|
// verifico se il veto sia scaduto
|
|
answ = datiAttivazione.VetoUnlock <= DateTime.Today;
|
|
}
|
|
}
|
|
catch
|
|
{ }
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Cerca di recuperare valore double da elenco AKV
|
|
/// </summary>
|
|
/// <param name="varReq">Chiave AKV richiesta</param>
|
|
/// <returns></returns>
|
|
protected double getAVKDouble(string varReq)
|
|
{
|
|
double answ = 0;
|
|
if (AKVList != null && AKVList.Count > 0)
|
|
{
|
|
var currRec = AKVList.Where(x => x.NomeVar == varReq).FirstOrDefault();
|
|
if (currRec != null)
|
|
{
|
|
answ = currRec.ValFloat ?? 0;
|
|
}
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Cerca di recuperare valore int da elenco AKV
|
|
/// </summary>
|
|
/// <param name="varReq">Chiave AKV richiesta</param>
|
|
/// <returns></returns>
|
|
protected int getAVKInt(string varReq)
|
|
{
|
|
int answ = 0;
|
|
if (AKVList != null && AKVList.Count > 0)
|
|
{
|
|
var currRec = AKVList.Where(x => x.NomeVar == varReq).FirstOrDefault();
|
|
if (currRec != null)
|
|
{
|
|
answ = currRec.ValInt ?? 0;
|
|
}
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Cerca di recuperare valore string da elenco AKV
|
|
/// </summary>
|
|
/// <param name="varReq">Chiave AKV richiesta</param>
|
|
/// <returns></returns>
|
|
protected string getAVKStr(string varReq)
|
|
{
|
|
string answ = "";
|
|
if (AKVList != null && AKVList.Count > 0)
|
|
{
|
|
var currRec = AKVList.Where(x => x.NomeVar == varReq).FirstOrDefault();
|
|
if (currRec != null)
|
|
{
|
|
answ = $"{currRec.ValString}";
|
|
}
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Recupero chiave da redis
|
|
/// </summary>
|
|
/// <param name="rKey"></param>
|
|
/// <returns></returns>
|
|
protected async Task<string> getRSV(string rKey)
|
|
{
|
|
string answ = "";
|
|
string? rawData = await redisDb.StringGetAsync(rKey);
|
|
if (!string.IsNullOrEmpty(rawData))
|
|
{
|
|
answ = rawData;
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Salvataggio chiave in Redis
|
|
/// </summary>
|
|
/// <param name="rKey"></param>
|
|
/// <param name="rVal"></param>
|
|
/// <param name="TTL"></param>
|
|
/// <returns></returns>
|
|
protected bool setRSV(string rKey, string rVal, TimeSpan TTL)
|
|
{
|
|
bool fatto = false;
|
|
fatto = redisDb.StringSet(rKey, rVal, TTL);
|
|
return fatto;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Salvataggio chiave in Redis Async
|
|
/// </summary>
|
|
/// <param name="rKey"></param>
|
|
/// <param name="rVal"></param>
|
|
/// <param name="TTL"></param>
|
|
/// <returns></returns>
|
|
protected async Task<bool> setRSVAsync(string rKey, string rVal, TimeSpan TTL)
|
|
{
|
|
bool fatto = false;
|
|
fatto = await redisDb.StringSetAsync(rKey, rVal, TTL);
|
|
return fatto;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Salvataggio chiave in Redis Async
|
|
/// </summary>
|
|
/// <param name="rKey"></param>
|
|
/// <param name="rVal"></param>
|
|
/// <param name="cacheMult"></param>
|
|
/// <returns></returns>
|
|
protected async Task<bool> setRSVAsync(string rKey, string rVal, int cacheMult)
|
|
{
|
|
bool fatto = false;
|
|
fatto = await redisDb.StringSetAsync(rKey, rVal, getCache(cacheMult));
|
|
return fatto;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Salvataggio chiave INT in Redis Async
|
|
/// </summary>
|
|
/// <param name="rKey"></param>
|
|
/// <param name="rValInt"></param>
|
|
/// <param name="cacheMult"></param>
|
|
/// <returns></returns>
|
|
protected async Task<bool> setRSVAsync(string rKey, int rValInt, int cacheMult)
|
|
{
|
|
return await setRSVAsync(rKey, $"{rValInt}", cacheMult);
|
|
}
|
|
|
|
#endregion Protected Methods
|
|
|
|
#region Private Fields
|
|
|
|
private static IConfiguration? _configuration;
|
|
|
|
/// <summary>
|
|
/// URL dell'API x chiamate gestione licenze
|
|
/// </summary>
|
|
private static string apiUrl = "https://liman.egalware.com/ELM.API/";
|
|
|
|
private static Logger Log = LogManager.GetCurrentClassLogger();
|
|
|
|
/// <summary>
|
|
/// Oggetto per connessione a REDIS
|
|
/// </summary>
|
|
private IConnectionMultiplexer redisConn;
|
|
|
|
//ISubscriber sub = redis.GetSubscriber();
|
|
/// <summary>
|
|
/// Oggetto DB redis da impiegare x chiamate R/W
|
|
/// </summary>
|
|
private IDatabase redisDb = null!;
|
|
|
|
#endregion Private Fields
|
|
|
|
#region Private Methods
|
|
|
|
/// <summary>
|
|
/// Esegue flush memoria redis dato pat2Flush
|
|
/// </summary>
|
|
/// <param name="pat2Flush"></param>
|
|
/// <returns></returns>
|
|
private bool ExecFlushRedisPattern(RedisValue pat2Flush)
|
|
{
|
|
bool answ = false;
|
|
var masterEndpoint = redisConn.GetEndPoints()
|
|
.Where(ep => redisConn.GetServer(ep).IsConnected && !redisConn.GetServer(ep).IsReplica)
|
|
.FirstOrDefault();
|
|
|
|
// sepattern è "*" elimino intero DB...
|
|
if (masterEndpoint != null && (pat2Flush.Equals(new RedisValue("*")) || pat2Flush == RedisValue.Null))
|
|
{
|
|
redisConn.GetServer(masterEndpoint).FlushDatabase(database: redisDb.Database);
|
|
}
|
|
else
|
|
{
|
|
var server = redisConn.GetServer(masterEndpoint);
|
|
var keys = server.Keys(database: redisDb.Database, pattern: pat2Flush, pageSize: 1000);
|
|
var batch = new List<RedisKey>();
|
|
foreach (var key in keys)
|
|
{
|
|
batch.Add(key);
|
|
|
|
// Flush in batches of 1000
|
|
if (batch.Count >= 1000)
|
|
{
|
|
foreach (var item in batch)
|
|
redisDb.KeyDelete(item);
|
|
|
|
batch.Clear();
|
|
}
|
|
}
|
|
|
|
// Flush remaining keys
|
|
foreach (var item in batch)
|
|
redisDb.KeyDelete(item);
|
|
}
|
|
answ = true;
|
|
#if false
|
|
var listEndpoints = redisConn.GetEndPoints();
|
|
foreach (var endPoint in listEndpoints)
|
|
{
|
|
//var server = redisConnAdmin.GetServer(listEndpoints[0]);
|
|
var server = redisConn.GetServer(endPoint);
|
|
if (server != null)
|
|
{
|
|
var keyList = server.Keys(redisDb.Database, pattern);
|
|
foreach (var item in keyList)
|
|
{
|
|
redisDb.KeyDelete(item);
|
|
}
|
|
answ = true;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Durata cache da moltiplicatore (orario) + perturbazione percentuale (+/-10%)
|
|
/// </summary>
|
|
private TimeSpan getCache(int cacheMult)
|
|
{
|
|
return TimeSpan.FromHours((double)cacheMult * rnd.Next(900, 1100) / 1000);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Recupera num ticket da sistema LiMan online
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
private async Task<List<TicketDTO>> getTickets()
|
|
{
|
|
List<TicketDTO> answ = new List<TicketDTO>();
|
|
#if false
|
|
// cerco in cache locale...
|
|
string rawData = memLayer.ML.getRSV(rkeyTickets);
|
|
if (!string.IsNullOrEmpty(rawData))
|
|
{
|
|
answ = JsonConvert.DeserializeObject<List<TicketDTO>>(rawData);
|
|
}
|
|
// se vuoto rileggo
|
|
if (answ.Count == 0)
|
|
{
|
|
// cerco online
|
|
RestClient client = new RestClient(apiUrl);
|
|
//client.Authenticator = new HttpBasicAuthenticator("username", "password");
|
|
string MKeyEnc = HttpUtility.UrlEncode(MasterKey);
|
|
var request = new RestRequest($"/api/ticket/{installazione}?CodApp={applicazione}&Chiave={MKeyEnc}");
|
|
var response = client.Get(request);
|
|
// controllo risposta
|
|
if (response.StatusCode == System.Net.HttpStatusCode.OK)
|
|
{
|
|
// salvo in redis contenuto serializzato
|
|
rawData = response.Content;
|
|
// deserializzo
|
|
answ = JsonConvert.DeserializeObject<List<TicketDTO>>(rawData);
|
|
// salvo in redis per TTL std
|
|
memLayer.ML.setRSV(rkeyTickets, rawData, 20);
|
|
}
|
|
}
|
|
#endif
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elenco attivazioni attuali
|
|
/// </summary>
|
|
private async Task<List<LiManObj.AttivazioneDTO>?> OnlineActivationList()
|
|
{
|
|
List<LiManObj.AttivazioneDTO>? answ = new List<LiManObj.AttivazioneDTO>();
|
|
// cerco online
|
|
RestClient client = new RestClient(apiUrl);
|
|
//client.Authenticator = new HttpBasicAuthenticator("username", "password");
|
|
string MKeyEnc = HttpUtility.UrlEncode(MasterKey);
|
|
var request = new RestRequest($"/api/attivazioni/?chiave={MKeyEnc}", Method.Get);
|
|
var response = await client.GetAsync(request);
|
|
// controllo risposta
|
|
if (response.StatusCode == System.Net.HttpStatusCode.OK)
|
|
{
|
|
// salvo in redis contenuto serializzato
|
|
string rawData = $"{response.Content}";
|
|
answ = JsonConvert.DeserializeObject<List<LiManObj.AttivazioneDTO>?>(rawData);
|
|
}
|
|
return await Task.FromResult(answ);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Dati Applicativo
|
|
/// </summary>
|
|
private async Task<LiManObj.ApplicativoDTO?> OnlineApplicationData()
|
|
{
|
|
LiManObj.ApplicativoDTO? answ = new LiManObj.ApplicativoDTO();
|
|
// cerco online
|
|
RestClient client = new RestClient(apiUrl);
|
|
//client.Authenticator = new HttpBasicAuthenticator("username", "password");
|
|
string ValEnc = HttpUtility.UrlEncode(Applicazione);
|
|
var request = new RestRequest($"/api/applicazione/{Installazione}?CodApp={ValEnc}", Method.Get);
|
|
var response = await client.GetAsync(request);
|
|
// controllo risposta
|
|
if (response.StatusCode == System.Net.HttpStatusCode.OK)
|
|
{
|
|
// salvo in redis contenuto serializzato
|
|
string rawData = $"{response.Content}";
|
|
var rawList = JsonConvert.DeserializeObject<List<LiManObj.ApplicativoDTO>>(rawData);
|
|
if (rawList != null)
|
|
{
|
|
answ = rawList.FirstOrDefault();
|
|
}
|
|
//answ = JsonConvert.DeserializeObject<LiManObj.ApplicativoDTO>(rawData);
|
|
}
|
|
return await Task.FromResult(answ);
|
|
}
|
|
|
|
private void ReportUpdated()
|
|
{
|
|
if (EA_InfoUpdated != null)
|
|
{
|
|
EA_InfoUpdated?.Invoke();
|
|
}
|
|
}
|
|
|
|
#endregion Private Methods
|
|
}
|
|
} |