Samuele Locatelli
1073 lines
42 KiB
C#
1073 lines
42 KiB
C#
using EgwControlCenter.Core.DTO;
|
|
using EgwControlCenter.Core.Models;
|
|
using Newtonsoft.Json;
|
|
using NLog;
|
|
using RestSharp;
|
|
using System.Diagnostics;
|
|
using System.Web;
|
|
|
|
namespace EgwControlCenter.Core
|
|
{
|
|
public class ReleaseChecker
|
|
{
|
|
#region Public Constructors
|
|
|
|
/// <summary>
|
|
/// Init classe ReleaseChecker
|
|
/// </summary>
|
|
/// <param name="appDir"></param>
|
|
/// <param name="dataDir"></param>
|
|
/// <param name="confName"></param>
|
|
public ReleaseChecker(string appDir, string dataDir, string confName)
|
|
{
|
|
InitObj(appDir, dataDir, confName);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Init classe ReleaseChecker
|
|
/// </summary>
|
|
/// <param name="appDir"></param>
|
|
/// <param name="dataDir"></param>
|
|
public ReleaseChecker(string appDir, string dataDir)
|
|
{
|
|
InitObj(appDir, dataDir, CNameStd);
|
|
}
|
|
|
|
#endregion Public Constructors
|
|
|
|
#region Public Properties
|
|
|
|
/// <summary>
|
|
/// Path file di conf check
|
|
/// </summary>
|
|
public string ConfPath
|
|
{
|
|
get => Path.Combine(DataDir, ConfName);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Path file di conf check
|
|
/// </summary>
|
|
public string ConfPathTemplate
|
|
{
|
|
get => Path.Combine(AppDir, ConfName);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Richiesta enroll corrente (se presente come file oppure nuova...)
|
|
/// </summary>
|
|
public EnrollRequestDTO CurrEnrollData
|
|
{
|
|
get
|
|
{
|
|
DateTime adesso = DateTime.Now;
|
|
EnrollRequestDTO answ = new EnrollRequestDTO();
|
|
// cerco se presente il file di enroll request
|
|
if (File.Exists(EnrollReqPath))
|
|
{
|
|
// leggo il file e verifico sia ancora valido...
|
|
var rawData = File.ReadAllText(EnrollReqPath);
|
|
if (!string.IsNullOrEmpty(rawData))
|
|
{
|
|
answ = JsonConvert.DeserializeObject<EnrollRequestDTO>(rawData) ?? new EnrollRequestDTO();
|
|
// verifico validità scadenza...
|
|
if (answ.DtScadenza < adesso)
|
|
{
|
|
answ = new EnrollRequestDTO();
|
|
// elimino file scaduto...
|
|
File.Delete(EnrollReqPath);
|
|
}
|
|
}
|
|
}
|
|
return answ;
|
|
}
|
|
set
|
|
{
|
|
DateTime adesso = DateTime.Now;
|
|
// verifico la scadenza sia valida...
|
|
if (value.DtScadenza > adesso)
|
|
{
|
|
// salvo!
|
|
var rawData = JsonConvert.SerializeObject(value, Formatting.Indented);
|
|
if (rawData != null && rawData.Length > 2)
|
|
{
|
|
File.WriteAllText(EnrollReqPath, rawData);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Configurazione degli oggetti da monitorare
|
|
/// </summary>
|
|
public PatrolSettings CurrPatrolCont { get; set; } = new PatrolSettings();
|
|
|
|
/// <summary>
|
|
/// Elenco degli oggetti stato dei programmi monitorati
|
|
/// </summary>
|
|
public List<VersStatusDTO> ListAppStatus { get; set; } = new List<VersStatusDTO>();
|
|
|
|
#endregion Public Properties
|
|
|
|
#region Public Methods
|
|
|
|
/// <summary>
|
|
/// Esegue verifica remota attivazioni, e di conseguenza eventualmente attiva/elimina...
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public async Task<bool> CheckAttivazioni()
|
|
{
|
|
bool fatto = false;
|
|
try
|
|
{
|
|
// verifico release da remoto aggiorno obj
|
|
var activRec = await AttivazioneGetRemote(CurrPatrolCont.MainKey, CurrPatrolCont.CodImpiego);
|
|
if (activRec != null && activRec.CodImpiego == CurrPatrolCont.CodImpiego && activRec.Chiave == CurrPatrolCont.AppKey)
|
|
{
|
|
// sono a posto!
|
|
fatto = true;
|
|
}
|
|
else
|
|
{
|
|
// creo nuovo record attivazione...
|
|
var actRes = await AttivazioneTrySet(CurrPatrolCont.MainKey, CurrPatrolCont.CodImpiego, CurrPatrolCont.AppKey);
|
|
fatto = actRes != null && actRes.CodImpiego == CurrPatrolCont.CodImpiego && actRes.Chiave == CurrPatrolCont.AppKey;
|
|
}
|
|
if (fatto)
|
|
{
|
|
// salvo status...
|
|
SaveConfig();
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Error($"Errore in CheckAttivazioni{Environment.NewLine}{exc}");
|
|
}
|
|
return fatto;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Esegue verifica remota se ci siano release CRITICAL attive e le accoda immediatamente
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public async Task<bool> CheckCriticalReport()
|
|
{
|
|
bool setUpdated = false;
|
|
try
|
|
{
|
|
// scarica il tracciato di TUTTE le releases critiche attive
|
|
Dictionary<string, ReleaseDTO> listRemote = await GetRemoteCritical();
|
|
|
|
// primo check: confrontra con elenco salvato...
|
|
foreach (var item in listRemote)
|
|
{
|
|
// se è stato aggionto
|
|
if (!CriticalRelCurrent.ContainsKey(item.Key))
|
|
{
|
|
var locStatus = ListStatus.Where(x => x.CodApp == item.Key).FirstOrDefault();
|
|
// --> verifico se faccia parte dell'elenco
|
|
//if (locStatus!=null && locStatus.CodApp==item.Key)
|
|
if (locStatus != null)
|
|
{
|
|
// inserisco in listRemote la rel critical trovata...
|
|
List<ReleaseDTO> ListRem = new List<ReleaseDTO>();
|
|
ListRem.Add(item.Value);
|
|
if (ListRem != null)
|
|
{
|
|
locStatus.ListRemote = ListRem;
|
|
locStatus.LastUpdateRem = DateTime.Now;
|
|
// indico checkOk a true
|
|
setUpdated = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// aggiorna set rel current
|
|
CriticalRelCurrent = listRemote;
|
|
|
|
// se ho fatto aggiornamenti locali salvo!
|
|
if (setUpdated)
|
|
{
|
|
SaveStatus();
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Error($"Errore in CheckCriticalReport{Environment.NewLine}{exc}");
|
|
}
|
|
return setUpdated;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Verifica se il server remoto sia in buono stato...
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public async Task<bool> CheckRemote()
|
|
{
|
|
// in questo caso la richiesta è per la generica app UpdateManager...
|
|
string CodApp = "UpdateManager";
|
|
bool answ = false;
|
|
try
|
|
{
|
|
// client chiamate rest
|
|
var client = new RestClient(restOptFast);
|
|
// provo cmq ad inizializzare la richiesta
|
|
ReleaseReqDTO reqDto = new ReleaseReqDTO()
|
|
{
|
|
CodApp = CodApp,
|
|
CodImp = CurrPatrolCont.CodImpiego,
|
|
AppKey = CurrPatrolCont.AppKey
|
|
};
|
|
// Chiamo il metodo!
|
|
if (useAppKey && reqDto.IsValid)
|
|
{
|
|
var actReq = new RestRequest($"/api/health", Method.Get);
|
|
// effettuo vera chiamata
|
|
var currResp = await client.GetAsync(actReq);
|
|
if (currResp.StatusCode == System.Net.HttpStatusCode.OK && currResp.Content != null)
|
|
{
|
|
var rawData = $"{currResp.Content}";
|
|
answ = rawData.Contains("OK", StringComparison.InvariantCultureIgnoreCase);
|
|
}
|
|
else
|
|
{
|
|
Log.Error($"Errore in ricezione info REST CheckRemote | StatusCode: {currResp.StatusCode} | content: {currResp.Content}");
|
|
}
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Error($"Eccezione in fase gestione REST services CheckRemote{Environment.NewLine}{exc}");
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Esegue verifica remota versioni x i sw tracciati
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public async Task<bool> CheckRemoteReleases()
|
|
{
|
|
bool fatto = false;
|
|
try
|
|
{
|
|
// ciclo x ogni item da controllare
|
|
foreach (var item in ListStatus)
|
|
{
|
|
if (item.CurrLocal != null)
|
|
{
|
|
// verifico release da remoto aggiorno obj
|
|
var ListRem = await GetRemoteRel(item.CodApp, item.CurrLocal.VersNum);
|
|
if (ListRem != null)
|
|
{
|
|
item.ListRemote = ListRem;
|
|
item.LastUpdateRem = DateTime.Now;
|
|
}
|
|
}
|
|
}
|
|
// salvo status...
|
|
SaveStatus();
|
|
fatto = true;
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Error($"Errore in CheckRemoteReleases{Environment.NewLine}{exc}");
|
|
}
|
|
return fatto;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Effettua un tentativo di enroll richiedendo info x gestione auth
|
|
/// </summary>
|
|
/// <param name="InfoData">Dizionario info da associare all'enroll</param>
|
|
/// <returns></returns>
|
|
public async Task<EnrollRequestDTO> GetNewEnroll(Dictionary<string, string> InfoData)
|
|
{
|
|
EnrollRequestDTO answ = new EnrollRequestDTO();
|
|
try
|
|
{
|
|
// client chiamate rest
|
|
var client = new RestClient(restOptStd);
|
|
// Chiamo il metodo!
|
|
var actReq = new RestRequest($"/api/enroller/getNewEnrollRec", Method.Post);
|
|
string payload = JsonConvert.SerializeObject(InfoData);
|
|
actReq.AddJsonBody(payload);
|
|
// effettuo vera chiamata
|
|
var currResp = await client.PostAsync(actReq);
|
|
if (currResp.StatusCode == System.Net.HttpStatusCode.OK && currResp.Content != null)
|
|
{
|
|
// mi restituisce info
|
|
var recEnroll = JsonConvert.DeserializeObject<EnrollRequestDTO>(currResp.Content);
|
|
if (recEnroll != null)
|
|
{
|
|
// verifico che contenga il dizionario allegato alla richiesta...
|
|
if (Utils.CompareDict(recEnroll.DictAttrib, InfoData))
|
|
{
|
|
answ = recEnroll;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Error($"Eccezione in fase gestione REST services GetNewEnroll{Environment.NewLine}{exc}");
|
|
}
|
|
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Effettua verifica stato record enroll (dato valore EnrollData...)
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public async Task<EnrollRequestDTO> CheckCurrEnroll()
|
|
{
|
|
EnrollRequestDTO answ = new EnrollRequestDTO();
|
|
// procedo se ho valori in CurrEnrollData...
|
|
if (CurrEnrollData.IdReq > 0)
|
|
{
|
|
try
|
|
{
|
|
// client chiamate rest
|
|
var client = new RestClient(restOptStd);
|
|
// Chiamo il metodo!
|
|
var actReq = new RestRequest($"/api/enroller/{CurrEnrollData.IdReq}?passcode={CurrEnrollData.Passcode}", Method.Get);
|
|
// effettuo vera chiamata
|
|
var currResp = await client.GetAsync(actReq);
|
|
if (currResp.StatusCode == System.Net.HttpStatusCode.OK && currResp.Content != null)
|
|
{
|
|
// mi restituisce info
|
|
var recEnroll = JsonConvert.DeserializeObject<EnrollRequestDTO>(currResp.Content);
|
|
if (recEnroll != null)
|
|
{
|
|
answ = recEnroll;
|
|
}
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Error($"Eccezione in fase gestione REST services CheckCurrEnroll{Environment.NewLine}{exc}");
|
|
}
|
|
}
|
|
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Effettua verifica stato record enroll
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public async Task<LicenzaDTO> GetEnrollLic()
|
|
{
|
|
LicenzaDTO answ = new LicenzaDTO();
|
|
// procedo se ho valori in CurrEnrollData...
|
|
if (CurrEnrollData.IdReq > 0)
|
|
{
|
|
try
|
|
{
|
|
// client chiamate rest
|
|
var client = new RestClient(restOptStd);
|
|
// Chiamo il metodo!
|
|
var actReq = new RestRequest($"/api/enroller/getLicense/{CurrEnrollData.IdReq}?passcode={CurrEnrollData.Passcode}&idLic={CurrEnrollData.IdxLic}", Method.Get);
|
|
// effettuo vera chiamata
|
|
var currResp = await client.GetAsync(actReq);
|
|
if (currResp.StatusCode == System.Net.HttpStatusCode.OK && currResp.Content != null)
|
|
{
|
|
// mi restituisce info
|
|
var recEnroll = JsonConvert.DeserializeObject<LicenzaDTO>(currResp.Content);
|
|
if (recEnroll != null)
|
|
{
|
|
answ = recEnroll;
|
|
}
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Error($"Eccezione in fase gestione REST services GetEnrollLic{Environment.NewLine}{exc}");
|
|
}
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
public bool HasUpdate()
|
|
{
|
|
bool answ = false;
|
|
//se ho record locali cerco il + recente
|
|
if (ListStatus != null && ListStatus.Count > 0)
|
|
{
|
|
foreach (var item in ListStatus)
|
|
{
|
|
answ = item.HasUpdate();
|
|
if (answ)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// DataOra ultimo check locale
|
|
/// </summary>
|
|
public DateTime LastChecked()
|
|
{
|
|
DateTime answ = new DateTime(DateTime.Today.Year, 1, 1);
|
|
//se ho record locali cerco il + recente
|
|
if (ListStatus != null && ListStatus.Count > 0)
|
|
{
|
|
var primo = ListStatus
|
|
.OrderByDescending(x => x.LastUpdateLoc)
|
|
.FirstOrDefault();
|
|
if (primo != null)
|
|
{
|
|
answ = primo.LastUpdateLoc;
|
|
}
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Effettua rilettura configurazione + init
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public bool ReloadConfData()
|
|
{
|
|
bool fatto = false;
|
|
try
|
|
{
|
|
ReloadData();
|
|
fatto = true;
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Error($"Eccezione in ReloadConfData{Environment.NewLine}{exc}");
|
|
}
|
|
return fatto;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Effettua reset configurazione sovrascrivendo da template
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public bool ResetConf()
|
|
{
|
|
bool fatto = false;
|
|
try
|
|
{
|
|
File.Copy(ConfPathTemplate, ConfPath, true);
|
|
ReloadData();
|
|
fatto = true;
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Error($"Eccezione in ResetConf{Environment.NewLine}{exc}");
|
|
}
|
|
return fatto;
|
|
}
|
|
|
|
//Salvataggio configurazioni
|
|
public void SaveConfig()
|
|
{
|
|
var rawData = JsonConvert.SerializeObject(CurrPatrolCont, Formatting.Indented);
|
|
if (rawData != null && rawData.Length > 2)
|
|
{
|
|
File.WriteAllText(ConfPath, rawData);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Aggiorna (se necessario) lo stato degli oggetti da monitorare
|
|
/// </summary>
|
|
/// <param name="doRefresh"></param>
|
|
/// <returns></returns>
|
|
public bool UpdateLocalStatus(bool doRefresh)
|
|
{
|
|
bool fatto = false;
|
|
// se non forzato verifico file dello status salvato x necessità refresh
|
|
if (!doRefresh)
|
|
{
|
|
doRefresh = CheckScaduto();
|
|
}
|
|
// verifico se procedere...
|
|
if (doRefresh)
|
|
{
|
|
// nuovo obj controlli
|
|
List<TargetStatus> newListStatus = new List<TargetStatus>();
|
|
// ciclo x ogni item da controllare
|
|
foreach (var item in CurrPatrolCont.TargetList)
|
|
{
|
|
// verifico contenuto secondo tipo
|
|
if (item != null && item.IsEnabled)
|
|
{
|
|
switch (item.ApplicationType)
|
|
{
|
|
case CoreEnum.AppType.None:
|
|
break;
|
|
|
|
case CoreEnum.AppType.Cli:
|
|
break;
|
|
|
|
case CoreEnum.AppType.Machine:
|
|
// processo la folder indicata e cerco tutte le macchine contenute
|
|
if (Directory.Exists(item.BasePath))
|
|
{
|
|
// recupero elenco sottodirectory = macchine
|
|
var dirList = Directory.GetDirectories(item.BasePath);
|
|
// ciclo e cerco i file mlde...
|
|
foreach (var currDir in dirList)
|
|
{
|
|
// cerco se ci sia un file mlde...
|
|
var fileFound = Directory.GetFiles(currDir, "*.mlde");
|
|
if (fileFound != null && fileFound.Count() > 0)
|
|
{
|
|
// prendo il primo...
|
|
var tgtFile = fileFound.FirstOrDefault() ?? "";
|
|
var currRelDto = MldeGetRelease(tgtFile);
|
|
if (currRelDto != null)
|
|
{
|
|
string codApp = Path.GetFileName(currDir);
|
|
newListStatus.Add(new TargetStatus()
|
|
{
|
|
CodApp = codApp,
|
|
CurrLocal = currRelDto,
|
|
LastUpdateLoc = DateTime.Now
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
break;
|
|
|
|
case CoreEnum.AppType.WebApp:
|
|
break;
|
|
|
|
case CoreEnum.AppType.WinApp:
|
|
// processo la folder indicata e cerco tutte le app contenute
|
|
if (Directory.Exists(item.BasePath))
|
|
{
|
|
// recupero elenco sottodirectory = applicativi da verificare
|
|
var dirList = Directory.GetDirectories(item.BasePath);
|
|
// ciclo e cerco i file secondo SearchPatterne...
|
|
foreach (var currDir in dirList)
|
|
{
|
|
// default ogni exe...
|
|
string sPattern = "*.exe";
|
|
if (!string.IsNullOrEmpty(item.SearchPattern))
|
|
{
|
|
sPattern = item.SearchPattern;
|
|
}
|
|
// cerco se ci siano file candidati...
|
|
var foundList = Directory.GetFiles(currDir, sPattern);
|
|
if (foundList != null && foundList.Count() > 0)
|
|
{
|
|
// ciclo!
|
|
foreach (var fileFound in foundList)
|
|
{
|
|
var currRelDto = ExeGetRelease(fileFound, item.UpdateEnabled);
|
|
if (currRelDto != null)
|
|
{
|
|
string codApp = Path.GetFileName(currDir);
|
|
newListStatus.Add(new TargetStatus()
|
|
{
|
|
CodApp = codApp,
|
|
ApplicationType = item.ApplicationType,
|
|
CurrLocal = currRelDto,
|
|
LastUpdateLoc = DateTime.Now
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
// aggiungo oggetto TargetStatus
|
|
}
|
|
// aggiorno obj...
|
|
ListStatus = newListStatus;
|
|
// salvo status...
|
|
SaveStatus();
|
|
fatto = true;
|
|
}
|
|
return fatto;
|
|
}
|
|
|
|
#endregion Public Methods
|
|
|
|
#region Protected Properties
|
|
|
|
/// <summary>
|
|
/// Periodo minimo per autorefresh versioni (default 1 gg)
|
|
/// NB: in lettura viene perturbato causalmente di 3 min...
|
|
/// </summary>
|
|
protected TimeSpan AutoRefreshVeto { get; set; } = TimeSpan.FromMinutes(30);
|
|
|
|
/// <summary>
|
|
/// Elenco degli oggetti stato dei programmi monitorati
|
|
/// </summary>
|
|
protected List<TargetStatus> ListStatus { get; set; } = new List<TargetStatus>();
|
|
|
|
#endregion Protected Properties
|
|
|
|
#region Private Fields
|
|
|
|
/// <summary>
|
|
/// Classe logger
|
|
/// </summary>
|
|
private static Logger Log = LogManager.GetCurrentClassLogger();
|
|
|
|
/// <summary>
|
|
/// Conf client RestSharp fast (usato x check remote):
|
|
/// - base URI al sito
|
|
/// - timeout 5 sec
|
|
/// </summary>
|
|
private static RestClientOptions restOptFast = new RestClientOptions { Timeout = TimeSpan.FromSeconds(5), BaseUrl = new Uri(Const.apiUrl) };
|
|
|
|
/// <summary>
|
|
/// Conf client RestSharp standard:
|
|
/// - base URI al sito
|
|
/// - timeout 1 min
|
|
/// </summary>
|
|
private static RestClientOptions restOptStd = new RestClientOptions { Timeout = TimeSpan.FromSeconds(60), BaseUrl = new Uri(Const.apiUrl) };
|
|
|
|
private Random rnd = new Random();
|
|
|
|
/// <summary>
|
|
/// Indica se usare la chaive appKey x i metodi di recupero informazioni 8elenco versioni...)
|
|
/// </summary>
|
|
private bool useAppKey = true;
|
|
|
|
#endregion Private Fields
|
|
|
|
#region Private Properties
|
|
|
|
private string AppDir { get; set; } = "";
|
|
private string CNameStd { get; set; } = "ConfPatrol.json";
|
|
private string ConfName { get; set; } = "";
|
|
private Dictionary<string, ReleaseDTO> CriticalRelCurrent { get; set; } = new Dictionary<string, ReleaseDTO>();
|
|
private string DataDir { get; set; } = "";
|
|
|
|
/// <summary>
|
|
/// Path file salvataggio Enroll Request (se presente)
|
|
/// </summary>
|
|
private string EnrollReqPath
|
|
{
|
|
get => Path.Combine(DataDir, ERName);
|
|
}
|
|
|
|
private string ERName { get; set; } = "EnrollReq.json";
|
|
private string LSName { get; set; } = "LastStatus.json";
|
|
|
|
/// <summary>
|
|
/// Path file salvataggio status
|
|
/// </summary>
|
|
private string StatusPath
|
|
{
|
|
get => Path.Combine(DataDir, LSName);
|
|
//get => Path.Combine(ApplicationDeployment.CurrentDeployment.DataDirectory, LSName);
|
|
}
|
|
|
|
#endregion Private Properties
|
|
|
|
#region Private Methods
|
|
|
|
/// <summary>
|
|
/// Verifica recuperandola (se presente) una SubLicenza applicativa
|
|
/// </summary>
|
|
/// <param name="MasterKey"></param>
|
|
/// <param name="CodImp"></param>
|
|
/// <returns></returns>
|
|
private async Task<AttivazioneDTO> AttivazioneGetRemote(string MasterKey, string CodImp)
|
|
{
|
|
AttivazioneDTO answ = new AttivazioneDTO();
|
|
try
|
|
{
|
|
// client chiamate rest
|
|
var client = new RestClient(restOptStd);
|
|
// Chiamo il metodo!
|
|
string MKeyEnc = HttpUtility.UrlEncode(MasterKey);
|
|
var checkRel = new RestRequest($"/api/attivazioni/verifica/?chiave={MKeyEnc}&codImpiego={CodImp}", Method.Get);
|
|
// effettuo vera chiamata
|
|
var currResp = await client.GetAsync(checkRel);
|
|
if (currResp.StatusCode == System.Net.HttpStatusCode.OK && currResp.Content != null)
|
|
{
|
|
// salvo in redis contenuto serializzato
|
|
string rawData = $"{currResp.Content}";
|
|
var currVal = JsonConvert.DeserializeObject<AttivazioneDTO>(rawData);
|
|
if (currVal != null)
|
|
{
|
|
answ = currVal;
|
|
}
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Error($"Eccezione in fase gestione REST services AttivazioneGetRemote{Environment.NewLine}{exc}");
|
|
}
|
|
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Effettua un tentativo di attivazione SubLicenza da main key + cod impiego
|
|
/// </summary>
|
|
/// <param name="MasterKey"></param>
|
|
/// <param name="CodImp"></param>
|
|
/// <param name="AppKey"></param>
|
|
/// <returns></returns>
|
|
private async Task<AttivazioneDTO> AttivazioneTrySet(string MasterKey, string CodImp, string AppKey)
|
|
{
|
|
AttivazioneDTO answ = new AttivazioneDTO();
|
|
try
|
|
{
|
|
// client chiamate rest
|
|
var client = new RestClient(restOptStd);
|
|
var paramDict = new Dictionary<string, string>();
|
|
paramDict.Add(CodImp, AppKey);
|
|
// preparo oggetto richiesta...
|
|
SubLicenseRequestDTO reqDto = new SubLicenseRequestDTO()
|
|
{
|
|
MasterKey = MasterKey,
|
|
LicType = CoreEnum.TipoLicenza.AppSubLic,
|
|
ParamDict = paramDict
|
|
};
|
|
// Chiamo il metodo!
|
|
var actReq = new RestRequest($"/api/attivazioni", Method.Post);
|
|
string payload = JsonConvert.SerializeObject(reqDto);
|
|
actReq.AddJsonBody(payload);
|
|
// effettuo vera chiamata
|
|
var currResp = await client.PostAsync(actReq);
|
|
if (currResp.StatusCode == System.Net.HttpStatusCode.OK && currResp.Content != null)
|
|
{
|
|
// mi restituisce elenco attivazioni
|
|
var currList = JsonConvert.DeserializeObject<List<AttivazioneDTO>>(currResp.Content);
|
|
if (currList != null)
|
|
{
|
|
// se contiene anche la richiesta è ok...
|
|
var recUpd = currList.FirstOrDefault(x => x.CodImpiego == CodImp && x.Chiave == AppKey);
|
|
if (recUpd != null)
|
|
{
|
|
answ = recUpd;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Error($"Eccezione in fase gestione REST services AttivazioneTrySet{Environment.NewLine}{exc}");
|
|
}
|
|
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Verifica se il check sia scaduto rispetto ad AutoRefreshVeto
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
private bool CheckScaduto()
|
|
{
|
|
bool answ = false;
|
|
DateTime adesso = DateTime.Now;
|
|
// ciclo per ogni oggetto della lista...
|
|
foreach (var item in ListStatus)
|
|
{
|
|
if (item.LastUpdateLoc.Add(AutoRefreshVeto).Add(TimeSpan.FromSeconds(rnd.Next(-60, 120))) < adesso)
|
|
{
|
|
answ = true;
|
|
// esco!
|
|
break;
|
|
}
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Recupera oggetto releaseDTO da file exe indicato analizzando ver number
|
|
/// </summary>
|
|
/// <param name="filePath"></param>
|
|
/// <returns></returns>
|
|
private ReleaseDTO? ExeGetRelease(string filePath, bool canInstall)
|
|
{
|
|
ReleaseDTO? answ = null;
|
|
if (File.Exists(filePath))
|
|
{
|
|
FileVersionInfo fileVersInfo = FileVersionInfo.GetVersionInfo(filePath);
|
|
// string codApp = fileVersInfo.ProductName;
|
|
string codApp = Path.GetFileNameWithoutExtension(filePath);
|
|
string versNum = $"{fileVersInfo.ProductVersion}";
|
|
string versTxt = $"{fileVersInfo.FileVersion}";
|
|
// creo OBJ e lo restituisco...
|
|
answ = new ReleaseDTO()
|
|
{
|
|
CodApp = codApp,
|
|
LocalPath = filePath,
|
|
ReleaseDate = DateTime.Now,
|
|
VersNum = versNum,
|
|
VersText = versTxt,
|
|
CanInstall = canInstall
|
|
};
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Recupera elenco applicazioni con ultima release CRITICAL
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
private async Task<Dictionary<string, ReleaseDTO>> GetRemoteCritical()
|
|
{
|
|
// in questo caso la richiesta è per la generica app UpdateManager...
|
|
string CodApp = "UpdateManager";
|
|
Dictionary<string, ReleaseDTO> answ = new Dictionary<string, ReleaseDTO>();
|
|
try
|
|
{
|
|
// client chiamate rest
|
|
var client = new RestClient(restOptStd);
|
|
// provo cmq ad inizializzare la richiesta
|
|
ReleaseReqDTO reqDto = new ReleaseReqDTO()
|
|
{
|
|
CodApp = CodApp,
|
|
CodImp = CurrPatrolCont.CodImpiego,
|
|
AppKey = CurrPatrolCont.AppKey
|
|
};
|
|
// Chiamo il metodo!
|
|
if (useAppKey && reqDto.IsValid)
|
|
{
|
|
var actReq = new RestRequest($"/api/release/getcritical", Method.Post);
|
|
string payload = JsonConvert.SerializeObject(reqDto);
|
|
actReq.AddJsonBody(payload);
|
|
// effettuo vera chiamata
|
|
var currResp = await client.PostAsync(actReq);
|
|
if (currResp.StatusCode == System.Net.HttpStatusCode.OK && currResp.Content != null)
|
|
{
|
|
var currList = JsonConvert.DeserializeObject<Dictionary<string, ReleaseDTO>>(currResp.Content);
|
|
if (currList != null)
|
|
{
|
|
answ = currList;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Log.Error($"Errore in ricezione info REST GetRemoteCritical | StatusCode: {currResp.StatusCode} | content: {currResp.Content}");
|
|
}
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Error($"Eccezione in fase gestione REST services GetRemoteCritical{Environment.NewLine}{exc}");
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Recupera le rel remote data una applicazione e la versione di partenza di interesse
|
|
/// </summary>
|
|
/// <param name="CodApp"></param>
|
|
/// <param name="CurrVers"></param>
|
|
/// <returns></returns>
|
|
private async Task<List<ReleaseDTO>> GetRemoteRel(string CodApp, string CurrVers)
|
|
{
|
|
List<ReleaseDTO> answ = new List<ReleaseDTO>();
|
|
try
|
|
{
|
|
// client chiamate rest
|
|
var client = new RestClient(restOptStd);
|
|
// provo cmq ad inizializzare la richiesta
|
|
ReleaseReqDTO reqDto = new ReleaseReqDTO()
|
|
{
|
|
CodApp = CodApp,
|
|
CodImp = CurrPatrolCont.CodImpiego,
|
|
AppKey = CurrPatrolCont.AppKey,
|
|
VersMin = CurrVers
|
|
};
|
|
// Chiamo il metodo!
|
|
if (useAppKey && reqDto.IsValid)
|
|
{
|
|
var actReq = new RestRequest($"/api/release/getfilt", Method.Post);
|
|
string payload = JsonConvert.SerializeObject(reqDto);
|
|
actReq.AddJsonBody(payload);
|
|
// effettuo vera chiamata
|
|
var currResp = await client.PostAsync(actReq);
|
|
if (currResp.StatusCode == System.Net.HttpStatusCode.OK && currResp.Content != null)
|
|
{
|
|
var currList = JsonConvert.DeserializeObject<List<ReleaseDTO>>(currResp.Content);
|
|
if (currList != null)
|
|
{
|
|
answ = currList;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
var checkRel = new RestRequest($"/api/release/filt/{CodApp}?VersMin={CurrVers}", Method.Get);
|
|
// effettuo vera chiamata
|
|
var currResp = await client.GetAsync(checkRel);
|
|
if (currResp.StatusCode == System.Net.HttpStatusCode.OK && currResp.Content != null)
|
|
{
|
|
var currList = JsonConvert.DeserializeObject<List<ReleaseDTO>>(currResp.Content);
|
|
if (currList != null)
|
|
{
|
|
answ = currList;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Error($"Eccezione in fase gestione REST services GetRemoteRel{Environment.NewLine}{exc}");
|
|
}
|
|
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// init privato oggetti
|
|
/// </summary>
|
|
/// <param name="appDir"></param>
|
|
/// <param name="dataDir"></param>
|
|
/// <param name="confName"></param>
|
|
private void InitObj(string appDir, string dataDir, string confName)
|
|
{
|
|
AppDir = appDir;
|
|
DataDir = dataDir;
|
|
ConfName = confName;
|
|
// imposto veto controlli secondo config verifico path...
|
|
if (string.IsNullOrEmpty(AppDir))
|
|
{
|
|
AppDir = AppDomain.CurrentDomain.BaseDirectory;
|
|
}
|
|
// copio il file di conf SE mancasse...
|
|
if (!File.Exists(ConfPath))
|
|
{
|
|
File.Copy(ConfPathTemplate, ConfPath);
|
|
}
|
|
ReloadData();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Recupera oggetto releaseDTO da file indicato
|
|
/// </summary>
|
|
/// <param name="filePath"></param>
|
|
/// <returns></returns>
|
|
private ReleaseDTO? MldeGetRelease(string filePath)
|
|
{
|
|
ReleaseDTO? answ = null;
|
|
if (File.Exists(filePath))
|
|
{
|
|
string versNum = "0.0.0.0";
|
|
string versTxt = "0.0.0.0";
|
|
string codApp = "";
|
|
// leggo una riga alla volta e cerco le chiavi
|
|
using (StreamReader reader = new StreamReader(filePath))
|
|
{
|
|
string? line;
|
|
bool stop = false;
|
|
while ((line = reader.ReadLine()) != null && !stop)
|
|
{
|
|
if (line.StartsWith("PP_VER"))
|
|
{
|
|
// splitto e prendo secondo
|
|
var splitTxt = line.Split("=");
|
|
if (splitTxt.Length > 1)
|
|
{
|
|
versTxt = splitTxt[1].Trim().Replace("'", "").Trim();
|
|
}
|
|
}
|
|
else if (line.StartsWith("PP_NVER"))
|
|
{
|
|
// splitto e prendo secondo
|
|
var splitTxt = line.Split("=");
|
|
if (splitTxt.Length > 1)
|
|
{
|
|
versNum = splitTxt[1].Trim().Replace("'", "").Trim();
|
|
}
|
|
}
|
|
else if (line.StartsWith("MACH_NAME"))
|
|
{
|
|
// splitto e prendo secondo
|
|
var splitTxt = line.Split("=");
|
|
if (splitTxt.Length > 1)
|
|
{
|
|
codApp = splitTxt[1].Trim().Replace("'", "").Trim();
|
|
}
|
|
}
|
|
// se ho trovato tutto esco!
|
|
stop = !string.IsNullOrEmpty(versNum) && !string.IsNullOrEmpty(versTxt) && !string.IsNullOrEmpty(codApp);
|
|
}
|
|
}
|
|
// creo OBJ e lo restituisco...
|
|
answ = new ReleaseDTO()
|
|
{
|
|
CodApp = codApp,
|
|
ReleaseDate = DateTime.Now,
|
|
VersNum = versNum,
|
|
VersText = versTxt
|
|
};
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Rilegge i dati di configurazione e ultimo stato salvato
|
|
/// </summary>
|
|
private void ReloadData()
|
|
{
|
|
if (File.Exists(ConfPath))
|
|
{
|
|
var rawData = File.ReadAllText(ConfPath);
|
|
if (!string.IsNullOrEmpty(rawData))
|
|
{
|
|
CurrPatrolCont = JsonConvert.DeserializeObject<PatrolSettings>(rawData) ?? new PatrolSettings();
|
|
// imposto il veto dalla conf...
|
|
AutoRefreshVeto = TimeSpan.FromMinutes(CurrPatrolCont.VetoCheckMinutes);
|
|
}
|
|
}
|
|
// cerco se presente file status precedente e lo ricarico...
|
|
if (File.Exists(StatusPath))
|
|
{
|
|
var rawData = File.ReadAllText(StatusPath);
|
|
if (!string.IsNullOrEmpty(rawData))
|
|
{
|
|
ListStatus = JsonConvert.DeserializeObject<List<TargetStatus>>(rawData) ?? new List<TargetStatus>();
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Effettua salvataggio obj status
|
|
/// </summary>
|
|
private void SaveStatus()
|
|
{
|
|
var rawData = JsonConvert.SerializeObject(ListStatus, Formatting.Indented);
|
|
if (rawData != null && rawData.Length > 2)
|
|
{
|
|
File.WriteAllText(StatusPath, rawData);
|
|
}
|
|
// aggiorno obj calcolato versioni...
|
|
ListAppStatus = ListStatus
|
|
.Select(x => new VersStatusDTO
|
|
{
|
|
CodApp = x.CodApp,
|
|
LocalPath = x.CurrLocal.LocalPath,
|
|
UrlDownload = x.CurrRemote.UrlDownload,
|
|
ApplicationType = x.ApplicationType,
|
|
VersNumCurr = x.CurrLocal.VersNum,
|
|
VersNumLast = x.CurrRemote.VersNum,
|
|
RelTagsLast = x.CurrRemote.RelTags,
|
|
HasUpdate = x.HasUpdate(),
|
|
CanInstall = x.CurrLocal.CanInstall
|
|
})
|
|
.ToList();
|
|
}
|
|
|
|
#endregion Private Methods
|
|
}
|
|
} |