Samuele Locatelli
806 lines
27 KiB
C#
806 lines
27 KiB
C#
using DeviceId;
|
|
using EgwControlCenter.Core.DTO;
|
|
using EgwControlCenter.Core.Models;
|
|
using EgwCoreLib.Utils;
|
|
using Newtonsoft.Json;
|
|
using NLog;
|
|
using System.Diagnostics;
|
|
using System.IO.Compression;
|
|
using System.Reflection;
|
|
|
|
namespace EgwControlCenter.Core
|
|
{
|
|
public class AppControlService : IAppControlService
|
|
{
|
|
#region Public Constructors
|
|
|
|
public AppControlService()
|
|
{
|
|
try
|
|
{
|
|
Assembly assembly = Assembly.GetExecutingAssembly();
|
|
string startDir = Path.GetDirectoryName(assembly.Location)!;
|
|
ConfDir = startDir;
|
|
//DataDir = Environment.GetEnvironmentVariable("ClickOnce_DataDirectory") ?? startDir;
|
|
string appData = Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData);
|
|
if (string.IsNullOrEmpty(appData))
|
|
{
|
|
appData = "C:\\ProgramData";
|
|
}
|
|
DataDir = Path.Combine(appData, "EgalWare", "AppControlCenter");
|
|
Log.Trace($"appData: {appData} | EnvData: {Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData)}");
|
|
// verifico esistenza directory...
|
|
Directory.CreateDirectory(DataDir);
|
|
CurrCheck = new ReleaseChecker(ConfDir, DataDir);
|
|
Log.Trace($"Folder Setup | {ConfDir} | {DataDir}");
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Error($"Error in AppControlService.init:{Environment.NewLine}{exc}");
|
|
}
|
|
}
|
|
|
|
#endregion Public Constructors
|
|
|
|
#region Public Events
|
|
|
|
/// <summary>
|
|
/// Evento update configurazione
|
|
/// </summary>
|
|
public event Action EA_ConfigUpdated = null!;
|
|
|
|
/// <summary>
|
|
/// Evento calling a remote in corso
|
|
/// </summary>
|
|
public event Action EA_RemoteCalling = null!;
|
|
|
|
/// <summary>
|
|
/// Evento udpate status controlli
|
|
/// </summary>
|
|
public event Action EA_StatusUpdated = null!;
|
|
|
|
#endregion Public Events
|
|
|
|
#region Public Properties
|
|
|
|
public string AppKey
|
|
{
|
|
get => CurrCheck.CurrPatrolCont.AppKey;
|
|
set
|
|
{
|
|
if (CurrCheck.CurrPatrolCont.AppKey != value)
|
|
{
|
|
// verifico ammissibilità
|
|
CurrCheck.CurrPatrolCont.AppKey = value;
|
|
ReportConfigUpd();
|
|
}
|
|
}
|
|
}
|
|
|
|
private Random rnd = new Random();
|
|
|
|
/// <summary>
|
|
/// Restituisce un codice di auth temporaneo INT da impiegare x autorizzare
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public async Task<int> GetAuthPassocde()
|
|
{
|
|
int tVal = 0;
|
|
//verifico che NON ci sia una richiesta già in corso...
|
|
if (CurrEnrollData.IdReq == 0)
|
|
{
|
|
// in primis preparo dizionario dei dati da allegare alla richiesta
|
|
Dictionary<string, string> reqInfo = new Dictionary<string, string>();
|
|
// preparo dati DeviceId da allegare in coda
|
|
string deviceId = new DeviceIdBuilder()
|
|
.AddMachineName()
|
|
.AddUserName()
|
|
.AddOsVersion()
|
|
.OnWindows(windows => windows
|
|
.AddMacAddressFromWmi(excludeWireless: true, excludeNonPhysical: true)
|
|
.AddProcessorId()
|
|
.AddMotherboardSerialNumber()
|
|
.AddSystemDriveSerialNumber())
|
|
.ToString();
|
|
// aggiungo dati MachineInfo...
|
|
reqInfo = MachineDataValidator.userInfo;
|
|
foreach (var item in MachineDataValidator.netInfo)
|
|
{
|
|
if (!reqInfo.ContainsKey(item.Key))
|
|
{
|
|
reqInfo.Add(item.Key, item.Value);
|
|
}
|
|
}
|
|
// raggiungo DevideID
|
|
reqInfo.Add("DeviceID", deviceId);
|
|
|
|
// faccio la chiamata rest e salvo risposta...
|
|
CurrEnrollData = await CurrCheck.GetNewEnroll(reqInfo);
|
|
}
|
|
|
|
// risposta valida se trovo un id richeista > 0...
|
|
if (CurrEnrollData.IdReq > 0)
|
|
{
|
|
tVal = CurrEnrollData.Passcode;
|
|
}
|
|
return tVal;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Verifica se sia stato assegnato il codice licenza x una richiesta di enroll e nel caso recupera licenza e restituisce il codice da salvare in conf
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public async Task<string> CheckAssignIdxLic()
|
|
{
|
|
string tVal = "";
|
|
// verifico dati richeista enroll, altrimenti faccio refresh richiesta...
|
|
if (CurrEnrollData.IdReq == 0)
|
|
{
|
|
int newCode = await GetAuthPassocde();
|
|
}
|
|
// recupero info
|
|
EnrollRequestDTO updRec = await CurrCheck.CheckCurrEnroll();
|
|
if (updRec.IdReq > 0)
|
|
{
|
|
CurrEnrollData = updRec;
|
|
// se la licenza è valida --> procedo!
|
|
if( updRec.IdxLic>0)
|
|
{
|
|
LicenzaDTO currLic = await CurrCheck.GetEnrollLic();
|
|
// se licenza valida --> restituisco e salvo!
|
|
if(currLic.IsValid && currLic.IsActive)
|
|
{
|
|
tVal = currLic.Chiave;
|
|
}
|
|
}
|
|
}
|
|
return tVal;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Richiesta enroll corrente (se presente come file oppure nuova...)
|
|
/// </summary>
|
|
private EnrollRequestDTO CurrEnrollData
|
|
{
|
|
get => CurrCheck.CurrEnrollData;
|
|
set => CurrCheck.CurrEnrollData = value;
|
|
}
|
|
|
|
/// <summary>
|
|
/// verifica autorizzazione al canale, ovvero
|
|
/// - deve avere tutte le chiavi/registri di comunicazione
|
|
/// - CodImpiego e AppKey devono essere validate
|
|
/// </summary>
|
|
public bool ChannelAuth
|
|
{
|
|
get
|
|
{
|
|
// in primis deve avere i dati di configurazione
|
|
bool answ = CurrCheck.CurrPatrolCont.HasCommData;
|
|
if (answ)
|
|
{
|
|
// verifico CodImpiego locale sia valido
|
|
answ = CurrCheck.CurrPatrolCont.CodImpiego == SubLicManager.CodImpiego();
|
|
// verifica sia valida (scadenza a tempo da ultimo controllo) chiave auth in remoto
|
|
if (answ)
|
|
{
|
|
}
|
|
}
|
|
return answ;
|
|
}
|
|
}
|
|
|
|
public bool CloudCallActive
|
|
{
|
|
get => cloudCallActive;
|
|
set
|
|
{
|
|
if (cloudCallActive != value)
|
|
{
|
|
cloudCallActive = value;
|
|
ReportRemoteCall();
|
|
}
|
|
}
|
|
}
|
|
|
|
public string CodApp
|
|
{
|
|
get => CurrCheck.CurrPatrolCont.CodApp;
|
|
set
|
|
{
|
|
if (CurrCheck.CurrPatrolCont.CodApp != value)
|
|
{
|
|
// verifico ammissibilità
|
|
CurrCheck.CurrPatrolCont.CodApp = value;
|
|
ReportConfigUpd();
|
|
}
|
|
}
|
|
}
|
|
|
|
public string CodImpiego
|
|
{
|
|
get => CurrCheck.CurrPatrolCont.CodImpiego;
|
|
set
|
|
{
|
|
if (CurrCheck.CurrPatrolCont.CodImpiego != value)
|
|
{
|
|
// verifico ammissibilità
|
|
CurrCheck.CurrPatrolCont.CodImpiego = value;
|
|
ReportConfigUpd();
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Dir applicazione
|
|
/// </summary>
|
|
public string DataDir { get; set; } = "";
|
|
|
|
public List<VersStatusDTO> ListAppStatus
|
|
{
|
|
get => CurrCheck.ListAppStatus;
|
|
set
|
|
{
|
|
CurrCheck.ListAppStatus = value;
|
|
ReportStatusUpd();
|
|
}
|
|
}
|
|
|
|
public string MainKey
|
|
{
|
|
get => CurrCheck.CurrPatrolCont.MainKey;
|
|
set
|
|
{
|
|
if (CurrCheck.CurrPatrolCont.MainKey != value)
|
|
{
|
|
// verifico ammissibilità
|
|
CurrCheck.CurrPatrolCont.MainKey = value;
|
|
ReportConfigUpd();
|
|
}
|
|
}
|
|
}
|
|
|
|
public int RefreshPeriod
|
|
{
|
|
get => CurrCheck.CurrPatrolCont.RefreshIntSec;
|
|
set
|
|
{
|
|
if (CurrCheck.CurrPatrolCont.RefreshIntSec != value)
|
|
{
|
|
// verifico ammissibilità
|
|
CurrCheck.CurrPatrolCont.RefreshIntSec = value < refPMin ? refPMin : value > refPMax ? refPMax : value;
|
|
ReportConfigUpd();
|
|
}
|
|
}
|
|
}
|
|
|
|
public List<ControlTarget> TargetList
|
|
{
|
|
get => CurrCheck.CurrPatrolCont.TargetList;
|
|
set
|
|
{
|
|
CurrCheck.CurrPatrolCont.TargetList = value;
|
|
ReportConfigUpd();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// num minuti veto controllo COMPLETO
|
|
/// </summary>
|
|
public int VetoCheck
|
|
{
|
|
get => CurrCheck.CurrPatrolCont.VetoCheckMinutes;
|
|
set
|
|
{
|
|
if (CurrCheck.CurrPatrolCont.VetoCheckMinutes != value)
|
|
{
|
|
// verifico ammissibilità
|
|
CurrCheck.CurrPatrolCont.VetoCheckMinutes = value < vetoPMin ? vetoPMin : value > vetoPMax ? vetoPMax : value;
|
|
ReportConfigUpd();
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// num minuti veto controllo refresh
|
|
/// </summary>
|
|
public int VetoRefresh
|
|
{
|
|
get => CurrCheck.CurrPatrolCont.VetoRefreshMinutes;
|
|
}
|
|
|
|
#endregion Public Properties
|
|
|
|
#region Public Methods
|
|
|
|
public async Task<bool> CheckAttivazioni()
|
|
{
|
|
bool fatto = await CurrCheck.CheckAttivazioni();
|
|
return fatto;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Effettua un controllo completo (loacele remoto)
|
|
/// </summary>
|
|
/// <param name="doForce">se true esegue anche prima della scadenza veto</param>
|
|
public async Task DoFullCheckAsync(bool doForce)
|
|
{
|
|
DateTime adesso = DateTime.Now;
|
|
if (lastCheckDone.AddMinutes(VetoRefresh) < adesso || doForce)
|
|
{
|
|
lastCheckDone = adesso;
|
|
//se non è forzato controllo ultimo check
|
|
CloudCallActive = true;
|
|
// in primis controllo se il remote è ok sennò mi fermo...
|
|
bool remoteOk = await CurrCheck.CheckRemote();
|
|
if (remoteOk)
|
|
{
|
|
// effettua un refresh del controllo status...
|
|
bool locCheckOk = CurrCheck.UpdateLocalStatus(doForce);
|
|
bool remCheckOk = false;
|
|
bool critCheckOk = false;
|
|
if (locCheckOk)
|
|
{
|
|
remCheckOk = await CurrCheck.CheckRemoteReleases();
|
|
}
|
|
// infine effettua una verifica dello status "release critiche"
|
|
critCheckOk = await CurrCheck.CheckCriticalReport();
|
|
if (remCheckOk || critCheckOk)
|
|
{
|
|
ReportStatusUpd();
|
|
}
|
|
}
|
|
CloudCallActive = false;
|
|
}
|
|
}
|
|
|
|
/// <summary> Effettua rilettura configurazione e setup controlli... </summary
|
|
public void DoReloadConfig()
|
|
{
|
|
try
|
|
{
|
|
CurrCheck = new ReleaseChecker(ConfDir, DataDir);
|
|
Log.Trace($"Riletta config Setup | {ConfDir} | {DataDir}");
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Equals($"Eccezione in DoReloadConfig{Environment.NewLine}{exc}");
|
|
}
|
|
ReportConfigUpd();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Effettua salvataggio configurazione
|
|
/// </summary>
|
|
public void DoSaveConfig()
|
|
{
|
|
try
|
|
{
|
|
var rawData = JsonConvert.SerializeObject(CurrCheck.CurrPatrolCont, Formatting.Indented);
|
|
if (rawData != null && rawData.Length > 2)
|
|
{
|
|
File.WriteAllText(CurrCheck.ConfPath, rawData);
|
|
Log.Trace($"Effettuato salvataggio Config Setup! | {ConfDir} | {DataDir}");
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Equals($"Eccezione in DoSaveConfig{Environment.NewLine}{exc}");
|
|
}
|
|
ReportConfigUpd();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Metodo update specifico x app IobWin a step
|
|
/// </summary>
|
|
/// <param name="reqApp"></param>
|
|
/// <param name="step">Step richiesto: 1=backup conf, 2=download, 3=unzip, $=fix conf e close</param>
|
|
/// <returns></returns>
|
|
public async Task IobWinUpdateStep(VersStatusDTO reqApp, int step)
|
|
{
|
|
// eseguo step secondo richiesta...
|
|
switch (step)
|
|
{
|
|
case 1:
|
|
await IobWinDoBackup(reqApp);
|
|
break;
|
|
|
|
case 2:
|
|
await IobWinDownload(reqApp);
|
|
break;
|
|
|
|
case 3:
|
|
await IobWinUnzip(reqApp);
|
|
break;
|
|
|
|
case 4:
|
|
await IobWinRestoreConf(reqApp);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
public void ResetConf()
|
|
{
|
|
bool fatto = CurrCheck.ResetConf();
|
|
if (fatto)
|
|
{
|
|
ReportConfigUpd();
|
|
ReportStatusUpd();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Reimposta CodImpiego / AppKey da librerie Egw secondo richiesta...
|
|
/// </summary>
|
|
/// <param name="resCodImpiego"></param>
|
|
/// <param name="resAppKey"></param>
|
|
public void ResetSubLic(bool resCodImpiego, bool resAppKey)
|
|
{
|
|
if (resCodImpiego)
|
|
{
|
|
CurrCheck.CurrPatrolCont.CodImpiego = SubLicManager.CodImpiego();
|
|
}
|
|
if (resAppKey)
|
|
{
|
|
CurrCheck.CurrPatrolCont.AppKey = SubLicManager.GenKey(CodApp);
|
|
}
|
|
ReportConfigUpd();
|
|
}
|
|
|
|
#endregion Public Methods
|
|
|
|
#region Protected Fields
|
|
|
|
protected UpdateMan updateMan = new UpdateMan();
|
|
|
|
protected UpdateMan updateManAuth = new UpdateMan("SWDownloader", "viaD@nte16");
|
|
|
|
#endregion Protected Fields
|
|
|
|
#region Protected Properties
|
|
|
|
protected SubLicManager SubLicManager { get; set; } = new SubLicManager();
|
|
|
|
#endregion Protected Properties
|
|
|
|
#region Protected Methods
|
|
|
|
/// <summary>
|
|
/// Helper copia directory + contenuto
|
|
/// </summary>
|
|
/// <param name="sourceDir"></param>
|
|
/// <param name="destDir"></param>
|
|
protected void CopyDirectory(string sourceDir, string destDir)
|
|
{
|
|
// Create the destination directory if it doesn't exist
|
|
if (!Directory.Exists(destDir))
|
|
{
|
|
Directory.CreateDirectory(destDir);
|
|
}
|
|
|
|
// Copy all files
|
|
foreach (var file in Directory.GetFiles(sourceDir))
|
|
{
|
|
string destFile = Path.Combine(destDir, Path.GetFileName(file));
|
|
File.Copy(file, destFile, true);
|
|
}
|
|
|
|
// Copy all subdirectories
|
|
foreach (var dir in Directory.GetDirectories(sourceDir))
|
|
{
|
|
string destSubDir = Path.Combine(destDir, Path.GetFileName(dir));
|
|
CopyDirectory(dir, destSubDir);
|
|
}
|
|
}
|
|
|
|
#endregion Protected Methods
|
|
|
|
#region Private Fields
|
|
|
|
/// <summary>
|
|
/// Classe logger
|
|
/// </summary>
|
|
private static Logger Log = LogManager.GetCurrentClassLogger();
|
|
|
|
/// <summary>
|
|
/// Directory di backup x IobWin
|
|
/// </summary>
|
|
private string backupDir = @"C:\Steamware\backup";
|
|
|
|
/// <summary>
|
|
/// DataOra ultimo controllo effettuato
|
|
/// </summary>
|
|
private DateTime lastCheckDone = DateTime.Today.AddMonths(-1);
|
|
|
|
/// <summary>
|
|
/// Valore massimo ammesso refresh sec
|
|
/// </summary>
|
|
private int refPMax = 3600;
|
|
|
|
/// <summary>
|
|
/// Valore minimo ammesso refresh sec
|
|
/// </summary>
|
|
private int refPMin = 1;
|
|
|
|
/// <summary>
|
|
/// Directory temp di appoggio
|
|
/// </summary>
|
|
private string tempDir = @"C:\Steamware\temp";
|
|
|
|
/// <summary>
|
|
/// File segnaposto x lock fasi di update
|
|
/// </summary>
|
|
private string updFilePath = @"c:\Steamware\IOB-MAN\update.run";
|
|
|
|
/// <summary>
|
|
/// Valore massimo ammesso veto minuti
|
|
/// </summary>
|
|
private int vetoPMax = 14400;
|
|
|
|
/// <summary>
|
|
/// Valore minimo ammesso veto minuti
|
|
/// </summary>
|
|
private int vetoPMin = 30;
|
|
|
|
/// <summary>
|
|
/// Ms di attesa x uscita processo (std)
|
|
/// </summary>
|
|
private int waitForExitMsec = 250;
|
|
|
|
#endregion Private Fields
|
|
|
|
#region Private Properties
|
|
|
|
private bool cloudCallActive { get; set; } = false;
|
|
|
|
private string ConfDir { get; set; } = "";
|
|
|
|
private ReleaseChecker CurrCheck { get; set; } = null!;
|
|
|
|
#endregion Private Properties
|
|
|
|
#region Private Methods
|
|
|
|
/// <summary>
|
|
/// Elimina contenuto directory
|
|
/// </summary>
|
|
/// <param name="directoryPath"></param>
|
|
private void DeleteDirectoryContents(string directoryPath)
|
|
{
|
|
// recupero info dir
|
|
DirectoryInfo directory = new DirectoryInfo(directoryPath);
|
|
// elimina file
|
|
foreach (FileInfo file in directory.GetFiles())
|
|
{
|
|
file.Delete();
|
|
}
|
|
// elimina ulteriori directory
|
|
foreach (DirectoryInfo subDirectory in directory.GetDirectories())
|
|
{
|
|
subDirectory.Delete(true);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Effettua un force kill dato nome processo
|
|
/// </summary>
|
|
/// <param name="nomeProc"></param>
|
|
private void ForceKillByName(string nomeProc)
|
|
{
|
|
Process[] stillRunningProc = Process.GetProcessesByName(nomeProc);
|
|
if (stillRunningProc != null)
|
|
{
|
|
if (stillRunningProc.Length > 0)
|
|
{
|
|
foreach (var item in stillRunningProc)
|
|
{
|
|
try
|
|
{
|
|
Process p = Process.GetProcessById(item.Id);
|
|
{
|
|
if (!p.HasExited)
|
|
{
|
|
p.Kill();
|
|
p.WaitForExit(waitForExitMsec);
|
|
}
|
|
if (!p.HasExited)
|
|
{
|
|
Log.Error($"Process not Killed, 2nd try p.kill()");
|
|
p.Kill();
|
|
p.WaitForExit(waitForExitMsec * 2);
|
|
}
|
|
if (!p.HasExited)
|
|
{
|
|
Log.Error($"Process not Killed, 3th try p.kill()");
|
|
p.Kill();
|
|
}
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Error($"Errore in fase di kill processo da nome {exc}");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Step preliminare di backup conf e app corrente
|
|
/// </summary>
|
|
/// <param name="reqApp"></param>
|
|
/// <returns></returns>
|
|
private async Task IobWinDoBackup(VersStatusDTO reqApp)
|
|
{
|
|
// controllo di avere un file di riferimento...
|
|
string appDir = Path.GetDirectoryName(reqApp.LocalPath) ?? "";
|
|
if (!string.IsNullOrEmpty(appDir))
|
|
{
|
|
string tempZip = Path.Combine(tempDir, "FULL", reqApp.CodApp);
|
|
// step 0: inserisce i file semaforo di segnalazione update in corso
|
|
using (FileStream fs = File.Create(updFilePath))
|
|
{
|
|
// File is created and access is released when the using block ends
|
|
}
|
|
|
|
// step 1: backup configurazioni partendo da path applicazione...
|
|
string srcDir = Path.Combine(appDir, "DATA", "CONF");
|
|
string destDir = Path.Combine(backupDir, "Conf", reqApp.CodApp, "DATA", "CONF");
|
|
// se MAN uso folder "accorciata"
|
|
if (reqApp.CodApp == "IOB-MAN")
|
|
{
|
|
srcDir = Path.Combine(appDir, "CONF");
|
|
destDir = Path.Combine(backupDir, "Conf", reqApp.CodApp, "CONF");
|
|
}
|
|
CopyDirectory(srcDir, destDir);
|
|
|
|
// step 2: kill processi
|
|
ForceKillByName(reqApp.CodApp);
|
|
|
|
// step 3: backup + zip intera folder applicativo
|
|
if (Directory.Exists(tempZip))
|
|
{
|
|
Directory.Delete(tempZip, true);
|
|
}
|
|
Directory.CreateDirectory(tempZip);
|
|
CopyDirectory(appDir, tempZip);
|
|
|
|
string zipPath = Path.Combine(backupDir, "Archive", reqApp.CodApp, $"{DateTime.Now:yyyyMMdd}_{DateTime.Now:HHmmss}.zip");
|
|
if (File.Exists(zipPath))
|
|
{
|
|
File.Delete(zipPath);
|
|
}
|
|
else
|
|
{
|
|
string zipDir = Path.GetDirectoryName(zipPath) ?? "";
|
|
if (!string.IsNullOrEmpty(zipDir))
|
|
{
|
|
if (!Directory.Exists(zipDir))
|
|
{
|
|
Directory.CreateDirectory(zipDir);
|
|
}
|
|
}
|
|
}
|
|
await Task.Run(() =>
|
|
{
|
|
ZipFile.CreateFromDirectory(tempZip, zipPath);
|
|
});
|
|
}
|
|
await Task.Delay(10);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Step di download da remoto
|
|
/// </summary>
|
|
/// <param name="reqApp"></param>
|
|
/// <returns></returns>
|
|
private async Task IobWinDownload(VersStatusDTO reqApp)
|
|
{
|
|
// step 4: download // controllo di avere un file di riferimento...
|
|
string appDir = Path.GetDirectoryName(reqApp.LocalPath) ?? "";
|
|
if (!string.IsNullOrEmpty(appDir))
|
|
{
|
|
string installerDir = Path.Combine(backupDir, "installer", reqApp.CodApp);
|
|
// se il path fosse vuoto --> uso quello standard da nexus...
|
|
string urlDownload = reqApp.UrlDownload;
|
|
if (string.IsNullOrEmpty(urlDownload))
|
|
{
|
|
urlDownload = $"https://nexus.steamware.net/repository/utility/MAPO/{reqApp.CodApp}/stable/{reqApp.CodApp}.zip";
|
|
}
|
|
long size = updateMan.DownloadApp(urlDownload, installerDir, reqApp.CodApp, reqApp.VersNumLast);
|
|
// se non andata provo con auth...
|
|
if (size == 0)
|
|
{
|
|
size = updateManAuth.DownloadApp(urlDownload, installerDir, reqApp.CodApp, reqApp.VersNumLast);
|
|
}
|
|
}
|
|
await Task.Delay(10);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Step di fix backup configurazioni + unlock file update run
|
|
/// </summary>
|
|
/// <param name="reqApp"></param>
|
|
/// <returns></returns>
|
|
private async Task IobWinRestoreConf(VersStatusDTO reqApp)
|
|
{
|
|
// step 6: restore conf
|
|
string appDir = Path.GetDirectoryName(reqApp.LocalPath) ?? "";
|
|
if (!string.IsNullOrEmpty(appDir))
|
|
{
|
|
string srcDir = Path.Combine(appDir, "DATA", "CONF");
|
|
string destDir = Path.Combine(backupDir, "Conf", reqApp.CodApp, "DATA", "CONF");
|
|
// se MAN uso folder "accorciata"
|
|
if (reqApp.CodApp == "IOB-MAN")
|
|
{
|
|
srcDir = Path.Combine(appDir, "CONF");
|
|
destDir = Path.Combine(backupDir, "Conf", reqApp.CodApp, "CONF");
|
|
}
|
|
|
|
CopyDirectory(destDir, srcDir);
|
|
}
|
|
// step 7: rimozione file lock semaforo
|
|
File.Delete(updFilePath);
|
|
await Task.Delay(10);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Step di unzip file scaricato
|
|
/// </summary>
|
|
/// <param name="reqApp"></param>
|
|
/// <returns></returns>
|
|
private async Task IobWinUnzip(VersStatusDTO reqApp)
|
|
{
|
|
// step 5: unzip + overwrite
|
|
string appDir = Path.GetDirectoryName(reqApp.LocalPath) ?? "";
|
|
if (!string.IsNullOrEmpty(appDir))
|
|
{
|
|
string installerDir = Path.Combine(backupDir, "installer", reqApp.CodApp);
|
|
string srcZip = Path.Combine(installerDir, $"{reqApp.CodApp}.zip");
|
|
// svuoto la dir di destinazione preliminarmente...
|
|
DeleteDirectoryContents(appDir);
|
|
// esegue unzip
|
|
ZipFile.ExtractToDirectory(srcZip, appDir, true);
|
|
}
|
|
await Task.Delay(10);
|
|
}
|
|
|
|
private void ReportConfigUpd()
|
|
{
|
|
if (EA_ConfigUpdated != null)
|
|
{
|
|
EA_ConfigUpdated?.Invoke();
|
|
}
|
|
}
|
|
|
|
private void ReportRemoteCall()
|
|
{
|
|
if (EA_RemoteCalling != null)
|
|
{
|
|
EA_RemoteCalling?.Invoke();
|
|
}
|
|
}
|
|
|
|
private void ReportStatusUpd()
|
|
{
|
|
if (EA_StatusUpdated != null)
|
|
{
|
|
// controllo se almeno 1 app abbia update...
|
|
foreach (var item in ListAppStatus)
|
|
{
|
|
if (item.HasUpdate)
|
|
{
|
|
EA_StatusUpdated?.Invoke();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion Private Methods
|
|
|
|
}
|
|
} |