public override Stream ObtenirContenu(ICab cab)
{
try
{
var request = RequêteFtp(cab.Url);
request.Method = WebRequestMethods.Ftp.DownloadFile;
Stream s;
try
{
s = OuvrirFlux(request);
return(s);
}
catch
{
// On donne une seconde chance en cas de souci réseau:
Thread.Sleep(5000);
request = RequêteFtp(cab.Url);
request.Method = WebRequestMethods.Ftp.DownloadFile;
s = OuvrirFlux(request);
return(s);
}
}
catch (Exception ex)
{
throw new Exception(
"Problème durant le téléchargement du CAB de " + cab.Codif + " n°" + cab.Numéro +
" depuis le site NMPP", ex);
}
}
private void TéléchargerCab(ICab cab, string cheminFichierCab, ITaskObserver observer)
{
observer.NotifyInfo(this,
$"Transfert du Cab depuis [{cab.Url}] vers [{cheminFichierCab}]");
TéléchargerCab(cab, cheminFichierCab);
observer.NotifyInfo(this, $"Cab [{cab.Url}] récupéré dans [{cheminFichierCab}]");
}
public override Stream ObtenirContenu(ICab cab)
{
try
{
var compte = Configuration.Comptes.FirstOrDefault(c => c.Editeur == cab.Editeur.TypeEditeur)
?? throw new ArgumentException($"Type d'éditeur inconnu pour le téléchargement du CAB de [{cab.ParutionCible.LibelléCourt}] depuis le site MLP", nameof(cab));
Stream s;
var request = RequêteUrl(compte, cab.Url);
try
{
s = OuvrirFlux(request);
return(s);
}
catch
{
// On donne une seconde chance en cas de souci réseau:
Thread.Sleep(5000);
request = RequêteUrl(compte, cab.Url);
s = OuvrirFlux(request);
return(s);
}
}
catch (Exception ex)
{
throw new Exception(
$"Problème durant le téléchargement du CAB de [{cab.ParutionCible.LibelléCourt}] depuis le site MLP", ex);
}
}
public InfosOpérationDépôt(ICab cabSource, ICab cabDestination, ICab cabExistant, EtatCabOnline étatCabOnline, IParution parutionCible)
{
_cabSource = cabSource;
_parutionCible = parutionCible;
_étatCabOnline = étatCabOnline;
_cabDestination = cabDestination;
_cabExistant = cabExistant;
}
private ICab IntégrerCabTéléchargé(ICab cab, string cheminFichierCab, ITaskObserver observer)
{
observer.NotifyInfo(this, $"Vérification et intégration du nouveau Cab téléchargé [{cheminFichierCab}]");
var newCab = IntégrerCabTéléchargé(cab, cheminFichierCab);
observer.NotifyInfo(this, $"Nouveau Cab téléchargé [{cheminFichierCab}] vérifié et intégré : [{newCab}]");
return(newCab);
}
private static void TéléchargerCab(ICab cab, string cheminFichierCab)
{
using (var input = cab.ObtenirContenu())
{
using (var output = new FileStream(cheminFichierCab, FileMode.Create))
{
input.CopyTo(output);
}
}
File.SetCreationTime(cheminFichierCab, cab.DateCréation);
}
public InfosTraitementParution(IParution parution, ICab cab, IInfosOpérationDépôt infosOpérationDépôt)
{
Parution = parution ?? throw new ArgumentNullException(nameof(parution));
Cab = cab;
InfosOpérationDépôt = infosOpérationDépôt;
if (cab != null)
{
_anomalies = cab.Anomalies.ToDictionary(a => a.Type);
}
else
{
_anomalies = new Dictionary <TypeAnomalieCab, IAnomalieCab>();
}
}
protected virtual string CheminDossierCab(ICab cab)
{
if (!_dossiersParutions.Contains(cab.ParutionCible))
{
throw new Exception(
$"Impossible de trouver le dossier de Magazines en cours pour [{cab.ParutionCible}] afin d'y déposer le Cab [{cab}]");
}
var cheminDossierCab =
(from chemin in _dossiersParutions[cab.ParutionCible]
let cheminCab = Path.Combine(chemin, _NomDossierCab)
where !String.IsNullOrWhiteSpace(cheminCab) && Directory.Exists(cheminCab)
select cheminCab).FirstOrDefault();
if (cheminDossierCab == null)
{
throw new Exception(
$"Impossible de trouver le dossier [{_NomDossierCab}] pour [{cab.ParutionCible}] afin d'y déposer le Cab [{cab}]");
}
return(cheminDossierCab);
}
private ICab IntégrerCabTéléchargé(ICab cab, string cheminFichierCab)
{
var newCab = CréerCab(new FileInfo(cheminFichierCab), cab.ParutionCible);
if (newCab == null)
{
throw new Exception(
$"Le fichier du Cab téléchargé [{cheminFichierCab}] est introuvable ou son nom n'est pas dans le bon format");
}
lock (_listeDonnéesCab)
{
var oldCab =
(from c in _listeDonnéesCab where c.ParutionCible == cab.ParutionCible select c).
FirstOrDefault();
if (oldCab != null)
{
_listeDonnéesCab.Remove(oldCab);
}
_listeDonnéesCab.Add(newCab);
}
return(newCab);
}
private static string NomFichierCab(ICab cab)
{
return
($"{cab.ParutionCible.CodeProduit}_{TypeDistributeurVersDistributeurPao(cab.Distributeur.TypeDistributeur)}_{cab.Codif}_{cab.Prix.ToString().Replace(",", ".")}_{TypePériodicitéVersPériodicitéPao(cab.Périodicité.TypePériodicité)}_{TypeQualificationRéseauVersQualificationPao(cab.Qualif.TypeQualificationRéseau)}.eps");
}
public virtual ICab Déposer(ICab cab, bool créerFichierTiff, ITaskObserver observer)
{
if (cab == null)
{
throw new ArgumentNullException(nameof(cab));
}
if (observer == null)
{
throw new ArgumentNullException(nameof(observer));
}
observer.NotifyInfo(this,
$"Début du téléchargement du Cab [{cab}] pour [{cab.ParutionCible}] depuis [{cab.Dépôt}] vers [{this}]");
if (cab.Dépôt == this)
{
observer.NotifyWarning(this,
$"Tentative de téléchargement d'un Cab vers lui-même : [{cab.Url}], opération ignorée");
return(cab);
}
string cheminDossierCab = CheminDossierCab(cab);
if (String.IsNullOrWhiteSpace(cheminDossierCab))
{
throw new Exception(
$"Impossible de trouver le dossier [{cheminDossierCab}] pour y déposer le Cab [{cab}]");
}
string nomFichierCab = NomFichierCab(cab);
string cheminFichierCab = Path.Combine(cheminDossierCab, nomFichierCab);
string nomFichierTiff = Path.GetFileNameWithoutExtension(nomFichierCab) + ".tif";
string cheminFichierTiff = Path.Combine(cheminDossierCab, nomFichierTiff);
EffacerFichiersCab(cab, cheminDossierCab, observer);
TéléchargerCab(cab, cheminFichierCab, observer);
Task conversionTask;
if (créerFichierTiff)
{
conversionTask = ConvertirVersTiffAsync(cheminFichierCab, cheminFichierTiff, observer);
}
else
{
conversionTask = null;
}
var newCab = IntégrerCabTéléchargé(cab, cheminFichierCab, observer);
if (conversionTask != null)
{
try
{
conversionTask.Wait();
}
catch (Exception exception)
{
observer.NotifyWarning(this,
$"Echec de la conversion en Tiff de [{cheminFichierCab}] vers [{cheminFichierTiff}] : {exception.DetailedMessage()}");
}
}
observer.NotifyInfo(this,
$"Fin du téléchargement du Cab [{cab}] pour [{cab.ParutionCible}] depuis [{cab.Dépôt}] vers [{this}]");
return(newCab);
}
private void EffacerFichiersCab(ICab cab, string cheminDossierCab, ITaskObserver observer)
{
observer.NotifyInfo(this, $"Effacement des anciens fichiers Cab et Tiff pour [{cab.ParutionCible}]");
EffacerFichiersCabs(cheminDossierCab);
observer.NotifyInfo(this, $"Anciens fichiers Cab et Tiff pour [{cab.ParutionCible}] effacés");
}
public ICab ClonerCab(ICab cabSource, IDépôtCab dépôtCab, string url, DateTime dateCréation)
{
return(_factoryFunc(dépôtCab, url, cabSource.Editeur, cabSource.Distributeur, cabSource.Codif,
cabSource.Numéro, cabSource.Prix, cabSource.Périodicité, cabSource.Qualif, dateCréation,
cabSource.ParutionCible));
}
public abstract Stream ObtenirContenu(ICab cab);
public override Stream ObtenirContenu(ICab cab)
{
return(new FileStream(cab.Url, FileMode.Open));
}
public void CalculerCompatbilité(ICab cab, out bool estCompatible, out IEnumerable <IAnomalieCab> anomalies)
{
Tuple <bool, IEnumerable <IAnomalieCab> > cachedValue;
if (_cache.TryGetValue(cab, out cachedValue))
{
estCompatible = cachedValue.Item1;
anomalies = cachedValue.Item2;
return;
}
estCompatible = true;
var lAnomalies = new List <IAnomalieCab>();
anomalies = lAnomalies;
if (ComparerEditeurs(cab.Editeur, cab.ParutionCible.Editeur) != 0)
{
// On note la différence d'éditeur mais ce n'est pas une incompatibilité
lAnomalies.Add(_anomalieCabFactory.CréerAnomalieCab(TypeAnomalieCab.Editeur,
cab.ParutionCible.Editeur.LibelléCourt.ToUpper(),
cab.Editeur.LibelléCourt.ToUpper(),
nécessiteAction: true,
estIncompatible: false));
}
if (ComparerCodifs(cab.Codif, cab.ParutionCible.Codif) != 0)
{
estCompatible = false;
lAnomalies.Add(_anomalieCabFactory.CréerAnomalieCab(TypeAnomalieCab.Codif,
cab.ParutionCible.Codif,
cab.Codif,
nécessiteAction: true,
estIncompatible: true));
}
if (ComparerNuméros(cab.Numéro, cab.ParutionCible.Numéro) != 0)
{
estCompatible = false;
lAnomalies.Add(_anomalieCabFactory.CréerAnomalieCab(TypeAnomalieCab.Numéro,
cab.ParutionCible.Numéro.ToString(),
cab.Numéro.ToString(),
nécessiteAction: true,
estIncompatible: true));
}
if (ComparerPrix(cab.Prix, cab.ParutionCible.Prix) != 0)
{
estCompatible = false;
lAnomalies.Add(_anomalieCabFactory.CréerAnomalieCab(TypeAnomalieCab.Prix,
(cab.ParutionCible.Prix ?? 0).ToString("C"),
(cab.Prix ?? 0).ToString("C"),
nécessiteAction: true,
estIncompatible: true));
}
if (ComparerQualifs(cab.Qualif, cab.ParutionCible.Qualif) != 0)
{
estCompatible = false;
lAnomalies.Add(_anomalieCabFactory.CréerAnomalieCab(TypeAnomalieCab.Qualification,
cab.ParutionCible.Qualif.LibelléCourt.ToUpper(),
cab.Qualif.LibelléCourt.ToUpper(),
nécessiteAction: true,
estIncompatible: true));
}
if (ComparerDistributeurs(cab.Distributeur, cab.ParutionCible.Distributeur) != 0)
{
estCompatible = false;
lAnomalies.Add(_anomalieCabFactory.CréerAnomalieCab(TypeAnomalieCab.Distributeur,
cab.ParutionCible.Distributeur.LibelléCourt.
ToUpper(),
cab.Distributeur.LibelléCourt.ToUpper(),
nécessiteAction: true,
estIncompatible: true));
}
int résultatComparaisonPériodicités = ComparerPériodicités(cab.Périodicité,
cab.ParutionCible.PériodicitéEffective);
if (résultatComparaisonPériodicités != 0)
{
// On note la différence de périodicité mais ce n'est pas une incompatibilité
lAnomalies.Add(_anomalieCabFactory.CréerAnomalieCab(TypeAnomalieCab.Périodicité,
cab.ParutionCible.Périodicité.LibelléCourt,
cab.Périodicité.LibelléCourt,
nécessiteAction: résultatComparaisonPériodicités < 0,
estIncompatible: false));
}
_cache[cab] = new Tuple <bool, IEnumerable <IAnomalieCab> >(estCompatible, lAnomalies);
}
public IInfosOpérationDépôt CréerInfosOpérationDépôt(ICab cabSource, ICab cabDestination, ICab cabExistant, EtatCabOnline étatCabOnline, IParution parutionCible)
{
return(_factoryFunc(cabSource, cabDestination, cabExistant, étatCabOnline, parutionCible));
}
