Samuele Locatelli
c8b049be4f
- maca gestione timer autorefresh componente - manca testing finale - manca clickonce finale
460 lines
16 KiB
C#
460 lines
16 KiB
C#
using EgwControlCenter.Core.Models;
|
|
using Newtonsoft.Json;
|
|
using NLog;
|
|
using RestSharp;
|
|
using RestSharp.Serializers;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Threading.Tasks;
|
|
|
|
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, CPName);
|
|
}
|
|
|
|
#endregion Public Constructors
|
|
|
|
#region Public Properties
|
|
|
|
/// <summary>
|
|
/// Path file di conf check
|
|
/// </summary>
|
|
public string ConfPath
|
|
{
|
|
get => Path.Combine(AppDir, ConfName);
|
|
}
|
|
|
|
/// <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 versioni x i sw tracciati
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public 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 = 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;
|
|
}
|
|
|
|
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>
|
|
/// 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:
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
// aggiungo oggetto TargetStatus
|
|
}
|
|
// aggiorno obj...
|
|
ListStatus = newListStatus;
|
|
// salvo status...
|
|
SaveStatus();
|
|
fatto = true;
|
|
}
|
|
return fatto;
|
|
}
|
|
|
|
#endregion Public Methods
|
|
|
|
#region Protected Fields
|
|
|
|
protected static string apiUrl = "https://liman.egalware.com/ELM.Api/";
|
|
|
|
#endregion Protected Fields
|
|
|
|
#region Protected Properties
|
|
|
|
/// <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();
|
|
|
|
#endregion Private Fields
|
|
|
|
#region Private Properties
|
|
|
|
private string AppDir { get; set; } = "";
|
|
|
|
/// <summary>
|
|
/// Periodo minimo per autorefresh versioni default 1 gg) protected TimeSpan AutoRefreshVeto
|
|
/// { get; set; } = TimeSpan.FromDays(1);
|
|
/// </summary>
|
|
private TimeSpan AutoRefreshVeto { get; set; } = TimeSpan.FromSeconds(30);
|
|
|
|
private string ConfName { get; set; } = "";
|
|
private string CPName { get; set; } = "ConfPatrol.json";
|
|
|
|
private string DataDir { get; set; } = "";
|
|
|
|
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
|
|
|
|
private static List<ReleaseDTO> GetRemoteRel(string CodApp, string CurrVers)
|
|
{
|
|
List<ReleaseDTO> answ = new List<ReleaseDTO>();
|
|
try
|
|
{
|
|
// client chiamate rest
|
|
var client = new RestClient(apiUrl);
|
|
string rawData = "";
|
|
// Chiamo il metodo!
|
|
var checkRel = new RestRequest($"/api/Release/filt/{CodApp}?VersMin={CurrVers}", Method.Get);
|
|
// effettuo vera chiamata
|
|
var pUpd = Task.Run(async () =>
|
|
{
|
|
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;
|
|
}
|
|
}
|
|
});
|
|
pUpd.Wait();
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Error($"Eccezione in fase gestione REST services{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) < adesso)
|
|
{
|
|
answ = true;
|
|
// esco!
|
|
break;
|
|
}
|
|
}
|
|
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;
|
|
}
|
|
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>
|
|
/// 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 = "";
|
|
string versTxt = "";
|
|
string codApp = "";
|
|
// leggo una riga alla volta e cerco le chaivi
|
|
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>
|
|
/// 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
|
|
//.Where(x => x.HasUpdate())
|
|
.Select(x => new VersStatusDTO
|
|
{
|
|
CodApp = x.CodApp,
|
|
VersNumCurr = x.CurrLocal.VersNum,
|
|
VersNumLast = x.CurrRemote.VersNum,
|
|
RelTagsLast = x.CurrRemote.RelTags,
|
|
HasUpdate= x.HasUpdate()
|
|
})
|
|
.ToList();
|
|
}
|
|
|
|
#endregion Private Methods
|
|
}
|
|
} |