Samuele Locatelli
1640 lines
67 KiB
C#
1640 lines
67 KiB
C#
using EgwControlCenter.Core.DTO;
|
|
using EgwControlCenter.Core.Models;
|
|
using EgwCoreLib.Utils;
|
|
using Newtonsoft.Json;
|
|
using NLog;
|
|
using RestSharp;
|
|
using System.Data.SqlTypes;
|
|
using System.Diagnostics;
|
|
using System.Linq;
|
|
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>
|
|
/// Dizionario files licenze trovati
|
|
/// </summary>
|
|
public Dictionary<string, string> LicenceFilesDict { get; set; } = new Dictionary<string, string>();
|
|
|
|
/// <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, CodImpiego);
|
|
if (activRec != null && activRec.CodImpiego == CodImpiego && activRec.Chiave == CurrPatrolCont.AppKey)
|
|
{
|
|
// sono a posto!
|
|
fatto = true;
|
|
}
|
|
else
|
|
{
|
|
// creo nuovo record attivazione...
|
|
var actRes = await AttivazioneTrySet(CurrPatrolCont.MainKey, CodImpiego, CurrPatrolCont.AppKey);
|
|
fatto = actRes != null && actRes.CodImpiego == 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 answ aggiornamenti locali salvo!
|
|
if (setUpdated)
|
|
{
|
|
SaveStatus();
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Error($"Errore in CheckCriticalReport{Environment.NewLine}{exc}");
|
|
}
|
|
return setUpdated;
|
|
}
|
|
|
|
/// <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>
|
|
/// 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 = 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)
|
|
{
|
|
// cerco per tipo di app se ci siano info del num di installazioni impiegate
|
|
// verifico release da remoto aggiorno obj
|
|
var ListRem = await GetRemoteRel(item.CodApp, item.CurrLocal.VersNum, item.CurrLocal.NumImp);
|
|
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 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;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Log.Error($"Errore in ricezione REST services GetEnrollLic | statusCode{currResp.StatusCode} | content: {currResp.Content}");
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Error($"Eccezione in fase gestione REST services GetEnrollLic{Environment.NewLine}{exc}");
|
|
}
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <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;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Log.Error($"Errore in ricezione REST services GetNewEnroll | statusCode{currResp.StatusCode} | content: {currResp.Content}");
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Error($"Eccezione in fase gestione REST services GetNewEnroll{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;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Salvataggio configurazioni
|
|
/// </summary>
|
|
public void SaveConfig()
|
|
{
|
|
var rawData = JsonConvert.SerializeObject(CurrPatrolCont, Formatting.Indented);
|
|
if (rawData != null && rawData.Length > 2)
|
|
{
|
|
File.WriteAllText(ConfPath, rawData);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Salva elenco dei vari item applicativi gestiti (x pulizia eventuali NON gestiti)...
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public async Task<int> SetManaged()
|
|
{
|
|
// in questo caso la richiesta è per la generica app UpdateManager...
|
|
int answ = 0;
|
|
try
|
|
{
|
|
// client chiamate rest
|
|
var client = new RestClient(restOptFast);
|
|
// provo cmq ad inizializzare la richiesta
|
|
ManDeclareDTO reqDto = new ManDeclareDTO()
|
|
{
|
|
CodImp = CodImpiego,
|
|
AppKey = CurrPatrolCont.AppKey,
|
|
ListCodApp = ListStatus.Select(x => x.CodApp).ToList()
|
|
};
|
|
// Chiamo il metodo!
|
|
if (useAppKey && reqDto.IsValid)
|
|
{
|
|
var actReq = new RestRequest($"/api/release/setmanaged", 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 rawData = $"{currResp.Content}";
|
|
if (!string.IsNullOrEmpty(rawData))
|
|
{
|
|
int.TryParse(rawData, out answ);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Log.Error($"Errore in ricezione info REST SetManaged | StatusCode: {currResp.StatusCode} | content: {currResp.Content}");
|
|
}
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Error($"Eccezione in fase gestione REST services SetManaged{Environment.NewLine}{exc}");
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Richiede dizionario dei task da eseguire localmente
|
|
/// </summary>
|
|
/// <param name="devName">Nome device</param>
|
|
/// <returns></returns>
|
|
public async Task<Dictionary<string, string>> TaskGetReq(string devName)
|
|
{
|
|
Dictionary<string, string> taskReq = new Dictionary<string, string>();
|
|
try
|
|
{
|
|
// client chiamate rest
|
|
var client = new RestClient(restOptStd);
|
|
// Chiamo il metodo!
|
|
var actReq = new RestRequest($"/api/apptask/pend/{devName}", Method.Get);
|
|
actReq.AddHeader("AppKey", CurrPatrolCont.AppKey);
|
|
actReq.AddHeader("CodImp", CodImpiego);
|
|
//actReq.AddHeader
|
|
// effettuo vera chiamata
|
|
var currResp = await client.GetAsync(actReq);
|
|
if (currResp.StatusCode == System.Net.HttpStatusCode.OK && currResp.Content != null)
|
|
{
|
|
// mi aspetto un dizionario...
|
|
var rawResp = JsonConvert.DeserializeObject<Dictionary<string, string>>(currResp.Content);
|
|
if (rawResp != null)
|
|
{
|
|
taskReq = rawResp;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Log.Error($"Errore in ricezione REST services TaskGetReq | statusCode{currResp.StatusCode} | content: {currResp.Content}");
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Error($"Eccezione in fase gestione REST services TaskGetReq{Environment.NewLine}{exc}");
|
|
}
|
|
return taskReq;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Invia un dizionario di task completato (x richieste o salvataggio da EgwACC)
|
|
/// </summary>
|
|
/// <param name="devName"></param>
|
|
/// <param name="taskRes"></param
|
|
/// <returns></returns>
|
|
public string TaskSetDone(string devName, Dictionary<string, string> taskRes)
|
|
{
|
|
string answ = TaskPostInfo(devName, taskRes, "done");
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Invia un dizionario di task completato (x richieste o salvataggio da EgwACC)
|
|
/// </summary>
|
|
/// <param name="devName"></param>
|
|
/// <param name="taskRes"></param
|
|
/// <returns></returns>
|
|
public async Task<string> TaskSetDoneAsync(string devName, Dictionary<string, string> taskRes)
|
|
{
|
|
string answ = await TaskPostInfoAsync(devName, taskRes, "done");
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Invia un dizionario che dovrebbe comprendere tutte le richieste task (da chiudere) + eventuali altri dati da salvare
|
|
/// </summary>
|
|
/// <param name="devName"></param>
|
|
/// <param name="taskRes"></param>
|
|
/// <returns></returns>
|
|
public async Task<string> TaskSetRunningAsync(string devName, Dictionary<string, string> taskRes)
|
|
{
|
|
string answ = await TaskPostInfoAsync(devName, taskRes, "running");
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// Invia un dizionario che dovrebbe comprendere tutte le richieste task (da chiudere) + eventuali altri dati da salvare
|
|
/// </summary>
|
|
/// <param name="devName"></param>
|
|
/// <param name="taskRes"></param>
|
|
/// <returns></returns>
|
|
public string TaskSetRunning(string devName, Dictionary<string, string> taskRes)
|
|
{
|
|
string answ = TaskPostInfo(devName, taskRes, "running");
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Aggiorna info files licenza (se configurato e se trovate)
|
|
/// </summary>
|
|
/// <param name="doRefresh"></param>
|
|
/// <returns></returns>
|
|
public bool UpdateLicenceInfo()
|
|
{
|
|
/*-------------------------------------------
|
|
* Ricerca licenze: algoritmo
|
|
* - parte da un percorso di base
|
|
* - cerca x ogni cartella la sottocartella /Config/ i files *.ini
|
|
* - prende i files che contengono "Licence="
|
|
* - considera solo i file con valore valido x Licence
|
|
* - prende il relativo file *.lic indicato (stessa folder)
|
|
* - legge e riporta intero contenuto nel record dizionario:
|
|
* - chiave = percorso file *.lic
|
|
* - valore = contenuto file
|
|
*-------------------------------------------*/
|
|
|
|
bool fatto = false;
|
|
// nuovo obj licenze...
|
|
Dictionary<string, string> newLicDict = new Dictionary<string, string>();
|
|
// ciclo SOLO gli oggetti licenza info
|
|
var licTgt = CurrPatrolCont
|
|
.TargetList
|
|
.Where(x => x.ApplicationType == CoreEnum.AppType.LicenceApp)
|
|
.ToList();
|
|
int numFound = 0;
|
|
foreach (var item in licTgt)
|
|
{
|
|
try
|
|
{
|
|
// verifico contenuto secondo tipo
|
|
if (item != null && item.IsEnabled)
|
|
{
|
|
// processo la folder indicata e cerco tutte le macchine contenute
|
|
if (Directory.Exists(item.BasePath))
|
|
{
|
|
// recupero elenco sottodirectory = possibili conf applicativi
|
|
var dirList = Directory.GetDirectories(item.BasePath);
|
|
// ciclo x cercare i files...
|
|
foreach (var currDir in dirList)
|
|
{
|
|
string prgName = Path.GetFileName(currDir);
|
|
// compongo ricerca della cartella Config dentro la folder target
|
|
string confPath = Path.Combine(currDir, "Config");
|
|
// verifico se esiste directory...
|
|
if (Directory.Exists(confPath))
|
|
{
|
|
// cerco se ci sia un file di quelli richiesti...
|
|
var fileFound = Directory.GetFiles(confPath, item.SearchPattern);
|
|
if (fileFound != null && fileFound.Count() > 0)
|
|
{
|
|
// ciclo su tutti i file candidati...
|
|
foreach (var file in fileFound)
|
|
{
|
|
// vincolo dei soli file con nome uguale alla folder ancestor...
|
|
string iniName = Path.GetFileName(file);
|
|
if (iniName.ToLower().StartsWith($"{prgName.ToLower()}."))
|
|
{
|
|
string licName = LicSearchFileName(file);
|
|
if (!string.IsNullOrEmpty(licName))
|
|
{
|
|
var contDir = Path.GetDirectoryName(file);
|
|
if (!string.IsNullOrEmpty(contDir))
|
|
{
|
|
string licPath = Path.Combine(contDir, licName);
|
|
if (File.Exists(licPath))
|
|
{
|
|
// leggo il contenuto e salvo...
|
|
var licContent = File.ReadAllText(licPath);
|
|
if (!newLicDict.ContainsKey(licPath))
|
|
{
|
|
newLicDict.Add(licPath, licContent);
|
|
numFound++;
|
|
}
|
|
else
|
|
{
|
|
newLicDict[licPath] = licContent;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Error($"Eccezione in UpdateLicenceInfo{Environment.NewLine}{exc}");
|
|
}
|
|
}
|
|
// aggiorno obj...
|
|
LicenceFilesDict = newLicDict;
|
|
// salvo info licenze...
|
|
SaveLicDict();
|
|
fatto = numFound > 0;
|
|
|
|
return fatto;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Oggetto assembly x ricavare info versione & co
|
|
/// </summary>
|
|
private System.Reflection.AssemblyName? CurrAssembly { get; set; } = null;
|
|
|
|
/// <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>();
|
|
// FixMe ToDo !!!
|
|
// ciclo x ogni item da controllare, riscrivere x fare per gruppi omogenei
|
|
foreach (var item in CurrPatrolCont.TargetList)
|
|
{
|
|
// verifico contenuto secondo tipo
|
|
if (item != null && item.IsEnabled)
|
|
{
|
|
switch (item.ApplicationType)
|
|
{
|
|
case CoreEnum.AppType.EgwACC:
|
|
// si tratta dell'applicazione stessa...
|
|
if (CurrAssembly != null && !string.IsNullOrEmpty(CurrAssembly.Name))
|
|
{
|
|
string codApp = CurrAssembly.Name ?? "EgwControlCenter.App";
|
|
codApp = codApp.Replace(".exe", "");
|
|
string versNum = $"{CurrAssembly.Version}";
|
|
var myRelDto = new ReleaseDTO()
|
|
{
|
|
CodApp = codApp,
|
|
CanInstall = true,
|
|
IsActive = true,
|
|
NumImp = 1,
|
|
ReleaseDate = DateTime.Today,
|
|
VersNum = versNum,
|
|
VersText = versNum
|
|
};
|
|
newListStatus.Add(new TargetStatus()
|
|
{
|
|
CodApp = codApp,
|
|
CurrLocal = myRelDto,
|
|
LastUpdateLoc = DateTime.Now
|
|
});
|
|
|
|
}
|
|
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.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);
|
|
// acquisisco il file di conf (SE presente)
|
|
string iobManConfPath = Path.Combine(item.BasePath, "IOB-MAN", "CONF", "IOB-MAN-CONFIG.json");
|
|
Dictionary<string, string> IobList = new Dictionary<string, string>();
|
|
if (File.Exists(iobManConfPath))
|
|
{
|
|
string manConf = File.ReadAllText(iobManConfPath);
|
|
if (!string.IsNullOrEmpty(manConf))
|
|
{
|
|
var iobManConf = JsonConvert.DeserializeObject<IobManConfig>(manConf);
|
|
if (iobManConf != null)
|
|
{
|
|
IobList = iobManConf.ListIOB;
|
|
}
|
|
}
|
|
}
|
|
// 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)
|
|
{
|
|
int numImp = 1;
|
|
string codApp = Path.GetFileName(currDir);
|
|
// cerco da conf se ci siano + client process previsti... CABLATO x IOB-WIN x ora...
|
|
if (sPattern.Contains("IOB-"))
|
|
{
|
|
string appName = $"{codApp.Replace(".exe", "")}";
|
|
numImp = IobList.Where(x => x.Value.Equals(appName)).Count();
|
|
}
|
|
var currRelDto = ExeGetRelease(fileFound, item.UpdateEnabled, numImp);
|
|
if (currRelDto != null)
|
|
{
|
|
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";
|
|
|
|
/// <summary>
|
|
/// CodImpiego
|
|
/// </summary>
|
|
private string CodImpiego { get; set; } = "";
|
|
|
|
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";
|
|
|
|
/// <summary>
|
|
/// Path file salvataggio LicenceInfo
|
|
/// </summary>
|
|
private string LicInfoPath
|
|
{
|
|
get => Path.Combine(DataDir, LIName);
|
|
//get => Path.Combine(ApplicationDeployment.CurrentDeployment.DataDirectory, LSName);
|
|
}
|
|
|
|
private string LIName { get; set; } = "LicInfo.json";
|
|
|
|
private string LSName { get; set; } = "LastStatus.json";
|
|
|
|
private SubLicManager SLicManager { get; set; } = new SubLicManager();
|
|
|
|
/// <summary>
|
|
/// Path file salvataggio status
|
|
/// </summary>
|
|
private string StatusPath
|
|
{
|
|
get => Path.Combine(DataDir, 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">path applicazione locale</param>
|
|
/// <param name="canInstall">abilitazione update applicativo</param>
|
|
/// <param name="numImp"># impieghi allocati</param>
|
|
/// <returns></returns>
|
|
private ReleaseDTO? ExeGetRelease(string filePath, bool canInstall, int numImp)
|
|
{
|
|
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,
|
|
NumImp = numImp
|
|
};
|
|
}
|
|
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 = 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, int numImp)
|
|
{
|
|
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 = CodImpiego,
|
|
AppKey = CurrPatrolCont.AppKey,
|
|
VersMin = currVers,
|
|
NumImp = numImp
|
|
};
|
|
// 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
|
|
{
|
|
Log.Error($"Errore in ricezione REST services GetRemoteRel 01 | statusCode{currResp.StatusCode} | content: {currResp.Content}");
|
|
}
|
|
}
|
|
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;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Log.Error($"Errore in ricezione REST services GetRemoteRel 02 | statusCode{currResp.StatusCode} | content: {currResp.Content}");
|
|
}
|
|
}
|
|
}
|
|
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)
|
|
{
|
|
CurrAssembly = System.Reflection.Assembly.GetEntryAssembly().GetName();
|
|
AppDir = appDir;
|
|
DataDir = dataDir;
|
|
ConfName = confName;
|
|
CodImpiego = SLicManager.CodImpiego();
|
|
// 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>
|
|
/// Processa il file ini (se esistente) cercando file licenza e se lo trova restituisce il nome del file...
|
|
/// </summary>
|
|
/// <param name="iniPath">File ini da processare</param>
|
|
/// <param name="maxLines">max num di linee da verificare</param>
|
|
/// <returns></returns>
|
|
private string LicSearchFileName(string iniPath, int maxLines = 20)
|
|
{
|
|
string answ = "";
|
|
string licToken = "Licence=";
|
|
if (File.Exists(iniPath))
|
|
{
|
|
try
|
|
{
|
|
using (StreamReader reader = new StreamReader(iniPath))
|
|
{
|
|
for (int i = 0; i < maxLines; i++)
|
|
{
|
|
if (reader.EndOfStream)
|
|
break;
|
|
|
|
var line = reader.ReadLine();
|
|
if (!string.IsNullOrEmpty(line))
|
|
{
|
|
if (line.Contains(licToken))
|
|
{
|
|
answ = line.Replace(licToken, "").Trim();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Log.Error($"Error during LicSearchFileName: {Environment.NewLine}{ex}");
|
|
}
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <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))
|
|
{
|
|
bool needSave = rawData.IndexOf("CodImpiego") > 0;
|
|
CurrPatrolCont = JsonConvert.DeserializeObject<PatrolSettings>(rawData) ?? new PatrolSettings();
|
|
// verifico se ci sia la chiave x cercare EgwACC, altrimenti la aggiungo
|
|
var recEgwACC = CurrPatrolCont.TargetList.FirstOrDefault(x => x.ApplicationType == CoreEnum.AppType.EgwACC);
|
|
if (!rawData.Contains("EgwACC") || recEgwACC == null)
|
|
{
|
|
// aggiungo record e segno di dover salvare
|
|
recEgwACC = new ControlTarget()
|
|
{
|
|
Idx = CurrPatrolCont.TargetList.Count + 1,
|
|
ApplicationType = CoreEnum.AppType.EgwACC,
|
|
BasePath = "C:\\Steamware",
|
|
IsEnabled = true,
|
|
SearchPattern = "EgwControlCenterApp.exe",
|
|
UpdateEnabled = true
|
|
};
|
|
CurrPatrolCont.TargetList.Add(recEgwACC);
|
|
needSave = true;
|
|
}
|
|
// imposto il veto dalla conf...
|
|
AutoRefreshVeto = TimeSpan.FromMinutes(CurrPatrolCont.VetoCheckMinutes);
|
|
// se il file raw contenesse la key "CodImpiego" sovrascrivo...
|
|
if (needSave)
|
|
{
|
|
SaveConfig();
|
|
}
|
|
}
|
|
}
|
|
// 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>();
|
|
}
|
|
}
|
|
// cerco se presente file licInfo e lo ricarico...
|
|
if (File.Exists(LicInfoPath))
|
|
{
|
|
var rawData = File.ReadAllText(LicInfoPath);
|
|
if (!string.IsNullOrEmpty(rawData))
|
|
{
|
|
LicenceFilesDict = JsonConvert.DeserializeObject<Dictionary<string, string>>(rawData) ?? new Dictionary<string, string>();
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Effettua salvataggio obj status
|
|
/// </summary>
|
|
private void SaveLicDict()
|
|
{
|
|
var rawData = JsonConvert.SerializeObject(LicenceFilesDict, Formatting.Indented);
|
|
if (rawData != null && rawData.Length > 2)
|
|
{
|
|
File.WriteAllText(LicInfoPath, rawData);
|
|
}
|
|
}
|
|
|
|
/// <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();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Metodo effettivo invio post info sul task ASYNC
|
|
/// </summary>
|
|
/// <param name="devName"></param>
|
|
/// <param name="taskRes"></param
|
|
/// <param name="action"></param>
|
|
/// <returns></returns>
|
|
private async Task<string> TaskPostInfoAsync(string devName, Dictionary<string, string> taskRes, string action)
|
|
{
|
|
string answ = "";
|
|
try
|
|
{
|
|
// preparo richiesta...
|
|
TaskResultDTO currReq = new TaskResultDTO()
|
|
{
|
|
AppKey = CurrPatrolCont.AppKey,
|
|
CodImp = CodImpiego,
|
|
MastKey = "",
|
|
DataPayload = taskRes
|
|
};
|
|
// client chiamate rest
|
|
var client = new RestClient(restOptStd);
|
|
// Chiamo il metodo!
|
|
var actReq = new RestRequest($"/api/apptask/{action}/{devName}", Method.Post);
|
|
string payload = JsonConvert.SerializeObject(currReq);
|
|
actReq.AddJsonBody(payload);
|
|
// effettuo vera chiamata
|
|
var currResp = await client.PostAsync(actReq);
|
|
if (currResp.StatusCode == System.Net.HttpStatusCode.OK && currResp.Content != null)
|
|
{
|
|
answ = $"{currResp.Content}";
|
|
}
|
|
else
|
|
{
|
|
Log.Error($"Errore in ricezione REST services TaskPostInfoAsync | action: {action} | statusCode{currResp.StatusCode} | content: {currResp.Content}");
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Error($"Eccezione in fase gestione REST services TaskPostInfoAsync | action: {action}{Environment.NewLine}{exc}");
|
|
}
|
|
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Metodo effettivo invio post info sul task SYNC
|
|
/// </summary>
|
|
/// <param name="devName"></param>
|
|
/// <param name="taskRes"></param>
|
|
/// <param name="action"></param>
|
|
/// <returns></returns>
|
|
private string TaskPostInfo(string devName, Dictionary<string, string> taskRes, string action)
|
|
{
|
|
string answ = "";
|
|
try
|
|
{
|
|
// preparo richiesta...
|
|
TaskResultDTO currReq = new TaskResultDTO()
|
|
{
|
|
AppKey = CurrPatrolCont.AppKey,
|
|
CodImp = CodImpiego,
|
|
MastKey = "",
|
|
DataPayload = taskRes
|
|
};
|
|
// client chiamate rest
|
|
var client = new RestClient(restOptStd);
|
|
// Chiamo il metodo!
|
|
var actReq = new RestRequest($"/api/apptask/{action}/{devName}", Method.Post);
|
|
string payload = JsonConvert.SerializeObject(currReq);
|
|
actReq.AddJsonBody(payload);
|
|
// effettuo vera chiamata
|
|
var currResp = client.Post(actReq);
|
|
if (currResp.StatusCode == System.Net.HttpStatusCode.OK && currResp.Content != null)
|
|
{
|
|
answ = $"{currResp.Content}";
|
|
}
|
|
else
|
|
{
|
|
Log.Error($"Errore in ricezione REST services TaskPostInfo | action: {action} | statusCode{currResp.StatusCode} | content: {currResp.Content}");
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Error($"Eccezione in fase gestione REST services TaskPostInfo | action: {action}{Environment.NewLine}{exc}");
|
|
}
|
|
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Esegue upload dello zipfile indicato per backup
|
|
/// </summary>
|
|
/// <param name="AppKey">Chiave univoca</param>
|
|
/// <param name="ZipPath">Percorso file da caricare</param>
|
|
internal async Task<bool> UploadZipfile(string AppKey, string ZipPath)
|
|
{
|
|
bool answ = false;
|
|
try
|
|
{
|
|
// client chiamate rest
|
|
var client = new RestClient(restOptStd);
|
|
// Chiamo il metodo!
|
|
var actReq = new RestRequest($"/api/apptask/zipbackup", Method.Post);
|
|
string sTrue = $"{true}";
|
|
actReq.AddParameter("AppKey", CurrPatrolCont.AppKey);
|
|
actReq.AddParameter("CodApp", CurrPatrolCont.CodApp);
|
|
actReq.AddParameter("DoUnzip", sTrue);
|
|
actReq.AddParameter("ForceApprov", sTrue);
|
|
actReq.AddParameter("CodImp", CodImpiego);
|
|
actReq.AddFile("ZipFile", ZipPath);
|
|
// effettuo vera chiamata
|
|
var currResp = await client.PostAsync<UploadResultDTO>(actReq);
|
|
if (currResp != null)
|
|
{
|
|
answ = currResp.Uploaded;
|
|
}
|
|
#if false
|
|
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;
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Error($"Eccezione in fase gestione REST services UploadZipfile{Environment.NewLine}{exc}");
|
|
}
|
|
|
|
return answ;
|
|
}
|
|
|
|
#endregion Private Methods
|
|
}
|
|
} |