internal void SimpleCopyManager(string fileSrc, ref E_Decision previousDec, string destFile)
{
if (CancelToken.IsCancellationRequested)
{
throw new OperationCanceledException("Operation stopped");
}
if (!destFile.Contains(_WFolder))
{
throw new Exception($"[CreateFolders] Erreur la chaine '{destFile}' ne contient pas '{_WFolder}'");
}
// Création des dossiers
string destFolder = Path.GetDirectoryName(destFile);
if (!Directory.Exists(destFolder))
{
Directory.CreateDirectory(destFolder);
}
//string destFile = Path.Combine(destFolder, Path.GetFileName(fileSrc));
E_Decision?conflictDec = previousDec;
bool overwrite = false;
if (File.Exists(destFile))
{
HeTrace.Write($"[CopyHandler] Destination file exists... ", this);
if (conflictDec == E_Decision.None)
{
conflictDec = PackMe_IHM.Ask4_FileConflict(fileSrc, destFile, E_DxConfB.OverWrite | E_DxConfB.Pass | E_DxConfB.Trash);
// Mémorisation pour les futurs conflits
switch (conflictDec)
{
case E_Decision.PassAll:
case E_Decision.OverWriteAll:
case E_Decision.TrashAll:
previousDec = conflictDec == null ? E_Decision.None : (E_Decision)conflictDec;
break;
}
}
HeTrace.EndLine(conflictDec.ToString(), this);
switch (conflictDec)
{
case E_Decision.Pass:
case E_Decision.PassAll:
SetStatus(this, new StateArg($"Pass: {fileSrc}", CancelFlag));
return;
case E_Decision.OverWrite:
case E_Decision.OverWriteAll:
SetStatus(this, new StateArg($"OverWrite: {destFile}", CancelFlag));
overwrite = true;
break;
case E_Decision.Trash:
case E_Decision.TrashAll:
SetStatus(this, new StateArg($"Trash: {destFile}", CancelFlag));
OpDFiles.Trash(destFile);
break;
}
}
// --- Copie
SetStatus(this, new StateArg($"Copy {fileSrc}", CancelFlag));
SetProgress(this, new ProgressArg(0, 1, CancelFlag));
FilesFunc.Copy(fileSrc, destFile, overwrite);
SetProgress(this, new ProgressArg(1, 1, CancelFlag));
// --- Vérification des sommes
this.SetStatus(this, new StateArg($"Copy verification", CancelFlag));
//this.SetMaximum(this, 100);
//bool? res = _ObjectFiles.VerifByHash_Sync(fileSrc, destFile, () => MD5.Create());
//var res = _ObjectFiles.DeepVerif(fileSrc, destFile, () => MD5.Create());
this.SetStatus(this, new StateArg($"Check verif: {res}", CancelFlag));
//this.UpdateProgress?.Invoke(100);
}
/// <summary>
/// Function advanced
/// </summary>
/// <param name="dbPath">Chemin déjà stocké en db</param>
/// <param name="destLocation">Emplacement de destination</param>
/// <param name="mediatype">Type de media, fourni par le fichier xml
/// <remarks>(Manual, Music, Video...)</remarks>
/// </param>
/// <param name="Assignation">Définit à quelle variable on va assigner le chemin relatif calculé</param>
private bool CopySpecific(string dbPath, string destLocation, string mediatype, Func <string, string> Assignation)
{
// Normal copy, if path exists
if (File.Exists(dbPath))
{
Copy_Handler(dbPath, destLocation, mediatype);
// L'assignation permet de transmettre le résultat d'une fonction à une variable
Assignation(DxPaths.Windows.DxPath.ToRelative(Settings.Default.LBPath, dbPath));
}
else
{
// On récupère le dossier concerné par le média
PlatformFolder plafFolder = null;
foreach (PlatformFolder pFormfolder in _ZePlatform.PlatformFolders)
{
if (pFormfolder.MediaType.Equals(mediatype))
{
plafFolder = pFormfolder;
break;
}
}
//MessageBox.Show(_ZeGame.Title +" "+ zeOne.FolderPath);
// 2020 - Formatage de la chaine pour éviter les erreurs
string tosearch = _ZeGame.Title.Replace(':', '_').Replace('\'', '_');
tosearch = tosearch.Replace("__", "_");
// array of files with a part of the name
string[] files = Directory.GetFiles(plafFolder.FolderPath, $"{tosearch}*.*", System.IO.SearchOption.AllDirectories);
/*
* // case array is empty
* if (files.Length <= 0)
* {
* MessageBox.Show($"Searching for {mediatype} returned 0 results", $"Searching for {mediatype}", MessageBoxButtons.OK, MessageBoxIcon.Information);
* return false;
* }*/
#region processing on files founded
MB_ListFiles mbL = new MB_ListFiles();
mbL.Message = $"Select {mediatype} matching.\rNote: There is an automatic preselection ";
// bypass
string[] bypass = new string[] { "-", " -" };
ushort numberF = 0;
foreach (string fichier in files)
{
string filename = Path.GetFileNameWithoutExtension(fichier);
// Test if total match
if (filename.Equals(tosearch))
{
// On ajoute à la liste des checkbox
mbL.AddItem(fichier, true);
numberF++;
}
//Test if match with bypass
else
{
// On test avec chaque bypass
foreach (var b in bypass)
{
if (filename.StartsWith(tosearch + b))
{
// On ajoute à la liste des checkbox
mbL.AddItem(fichier, true);
numberF++;
break;
}
}
}
}
//if(mbL.Menu.MenuItems.Count)
#endregion
// 2020
// case array is empty or no corresponding file even with bypass
//if (files.Length <= 0 || mbL.Menu == null)
if (numberF <= 0)
{
MessageBox.Show($"Searching for {mediatype} returned {numberF} results", $"Searching for {mediatype}", MessageBoxButtons.OK, MessageBoxIcon.Information);
return(false);
}
// 2020
// Affichage de la boite de selection;
List <string> dFiles = null;
if (mbL.ShowDialog() == DialogResult.Yes)
{
dFiles = mbL.CheckedFiles;
}
// old List<string> dFiles = OPFiles.Search_Files(tosearch, plafFolder.FolderPath, System.IO.SearchOption.TopDirectoryOnly, "-", " -");
// En cas d'abandon ou de fichier non trouvé on renvoie false
if (dFiles == null || dFiles.Count == 0)
{
return(false);
}
#region
// Traitement des fichiers pour la copie
foreach (string fichier in dFiles)
{
// 2020
// Analyses du fichier
//if()
// 2020
//Recherche de fichiers déjà présents
string destFile = Path.Combine(destLocation, Path.GetFileName(fichier));
// On fait un prétest pour limiter - Le but est d'évaluer si le fichier de destination existe déjà
if (File.Exists(destFile))
//if(fichier.Equals(fichier1))
{
/*
* On teste les fichiers pour voir s'ils sont les mêmes en plus d'avoir le même nom
* - Si c'est le cas on va passer, on va passer, puisque l'intégrite est vérifiée
* - S'ils sont différents, on va proposer de renommer, passer.
*
*/
// 2020-10-16
//Normalement copy handler doit tout gérer
Copy_Handler(fichier, destLocation, mediatype);
/*
* OPFiles opF = new OPFiles()
* {
*
* };
* opF.IWriteLine += new RetourMessage(x => ITrace.WriteLine(x));
*
* // Vérification totale
* var res = opF.DeepVerif(fichier, destFile, () => MD5.Create());
*
*/
//Demande s'il n'y a pas correspondance mais fichiers similaires.
//if(res == EFileResult.NoMatch)
// test similarity
//var res = OPFiles.DeepCompare(fichier, destFile, $"Copy_{mediatype}", () => MD5.Create(), Dcs_Buttons.All, x=> ITrace.WriteLine(x));
}
else
{
FilesFunc.Copy(fichier, destFile, false);
}
//var res = OPFiles.FileNameCompare(fichier, destLocation, $"Copy_{mediatype}", Dcs_Buttons.NoStop, x => ITrace.WriteLine(x));
// CopyFile(fichier, destLocation, res);
}
Assignation(DxPaths.Windows.DxPath.ToRelative(Settings.Default.LBPath, dFiles[0]));
return(true);
#endregion
}
//
//if (resCopy) return;
//
return(false);
}
/// <summary>
/// Gère la copie en examinant la totale similitude des fichiers
/// </summary>
/// <param name="srcFile"></param>
/// <param name="destLocation"></param>
/// <param name="mediatype"></param>
private bool Copy_Handler(string srcFile, string destLocation, string mediatype)
{
// 2020
// Test de la similitude en profondeur
//FilesFunc.Check4Crash();
OPFiles neoOPF = new OPFiles()
{
};
neoOPF.IWrite += new RetourMessage((x) => ITrace.BeginLine(x));
neoOPF.IWriteLine += new RetourMessage((x) => ITrace.WriteLine(x));
// Booleen pour déterminer si l'on écrase ou pas
bool overW = false;
// Vérification en profondeur
// Annulé EOPResult res = OPFiles.Copy_DeepVMode(dbPath, destLocation, $"Copy_{mediatype}", () => MD5.Create(), Dcs_Buttons.NoStop, x => ITrace.WriteLine(x));
string fileName = Path.GetFileName(srcFile);
string destFile = Path.Combine(destLocation, fileName);
EFileResult verif = neoOPF.DeepVerif(srcFile, destFile, () => MD5.Create());
bool copyRes = false; // Stocke le résultat de la copie
switch (verif)
{
case EFileResult.DifferentSize:
case EFileResult.DifferentHash:
// Check selon les résultats de ce qu'il faut faire
// Demande à l'utilisateur
// EDestDecision res = MB_Decision.Show($"Copy_Handler: {Lang.Dest_File_Exists}, { Lang.Replace_Question} ?", $"{Lang.Alert} - Copy_Handler", destination: destLocation, buttons: Dcs_Buttons.All);
EDestDecision res = MB_Decision.Show($"Copy_Handler: {Lang.Dest_File_Exists}, { Lang.Replace_Question} ?", $"{Lang.Alert} - Copy_Handler", source: srcFile, destination: destFile, buttons: Dcs_Buttons.All);
// On passe si l'utilisateur ne veut pas écraser ou renommer
/*if (res == EDestDecision.Pass || res == EDestDecision.PassAll)
* return;
*/
// On utilise une fonction de traitement sur le fichier de destination (renommer, envoyer à la poubelle)
neoOPF.DestFileAction(res, destFile);
// Selon le résultat de la boite on copie ou non le fichier
bool?overwrite = Handle_Copy(srcFile, ref destFile, res);
if (overwrite != null)
{
copyRes = FilesFunc.Copy(srcFile, destFile, (bool)overwrite);
}
break;
// Gère si la source a une taille 0 (entre autre)
case EFileResult.Source_Error:
break;
case EFileResult.Destination_Error:
case EFileResult.NoMatch:
ITrace.WriteLine($"PackMe: Copy of '{fileName}'");
copyRes = FilesFunc.Copy(srcFile, destFile, false);
break;
default:
ITrace.WriteLine($"PackMe: Copy of '{fileName}' avoided");
break;
}
return(copyRes);
// 2020
//2020 EOPResult res = OPFiles.FileNameCompare(dbPath, destLocation, $"Copy_{mediatype}", Dcs_Buttons.NoStop, x => ITrace.WriteLine(x));
// assignation du chemin relatif à la variable
// return CopyFile(dbPath, destLocation, res);
}
/// <summary>
/// Copie les roms, regroupe les fichiers sur les images
/// </summary>
/// <param name="dbPath"></param>
/// <param name="destLocation"></param>
/// <returns></returns>
private bool CopyRoms(string dbPath, string destLocation)
{
/*
* On part du principe que le dossier rom DOIT être rempli
*/
if (_zBackGame.ApplicationPath.Length <= 0)
{
return(false);
}
string extRom = Path.GetExtension(_zBackGame.ApplicationPath);
// si aucune extension on ne pack pas le fichier
if (extRom.Length <= 0)
{
return(false);
}
try
{
// résultat pour définir si on copie ou pas
EOPResult res;
// Traitement dans le cas d'un fichier cue
if (extRom.Equals(".cue", StringComparison.OrdinalIgnoreCase))
{
//Lecture du fichier cue
Cue_Scrapper cuecont = new Cue_Scrapper(_zBackGame.ApplicationPath);
//Folder containing files
string sourceFold = Path.GetDirectoryName(_zBackGame.ApplicationPath);
// Copie de tous les fichiers
// Fonctionne avec le nom du fichier
foreach (string fileName in cuecont.Files)
{
// Donne le lien complet vers le fichier
string source = Path.Combine(sourceFold, fileName);
/*18/10/2020
* // Hardlink
* // string destination = Path.Combine(destLocation, fileName);
*
*
* // 2020 Todo
* // Test if already copied
*
*
* res = OPFiles.FileNameCompare(source, destLocation, $"Copy_Rom", Dcs_Buttons.NoStop, x => ITrace.WriteLine(x));
*
* // Copy
* // 2020
* /*
* CopyFile(source, destLocation, res);
*/
/*18 / 10 / 2020
* FilesFunc.Copy(source, Path.Combine(des, res);
*/
// 18/10/2020
// 2020 remplacement
string destFile = Path.Combine(destLocation, fileName);
// On fait un prétest pour limiter - Le but est d'évaluer si le fichier de destination existe déjà
if (File.Exists(destFile))
//if(fichier.Equals(fichier1))
{
/*
*
*
* /*
* On teste les fichiers pour voir s'ils sont les mêmes en plus d'avoir le même nom
* - Si c'est le cas on va passer, on va passer, puisque l'intégrite est vérifiée
* - S'ils sont différents, on va proposer de renommer, passer.
*
*/
// 2020-10-16
//Normalement copy handler doit tout gérer
/* Copy_Handler(fichier, destLocation, mediatype);
*
*
*
* /*
* OPFiles opF = new OPFiles()
* {
*
* };
* opF.IWriteLine += new RetourMessage(x => ITrace.WriteLine(x));
*
* // Vérification totale
* var res = opF.DeepVerif(fichier, destFile, () => MD5.Create());
*
*/
//Demande s'il n'y a pas correspondance mais fichiers similaires.
//if(res == EFileResult.NoMatch)
// test similarity
//var res = OPFiles.DeepCompare(fichier, destFile, $"Copy_{mediatype}", () => MD5.Create(), Dcs_Buttons.All, x=> ITrace.WriteLine(x));
}
else
{
FilesFunc.Copy(source, destFile, false);
}
//2020
}
// return true;
}
// Traitement dans tous les cas (si c'est un cue on en a aussi besoin)
/*else
* /*{*/
//2020/18/10 res = OPFiles.FileNameCompare(dbPath, destLocation, $"Copy_Rom", Dcs_Buttons.NoStop, x => ITrace.WriteLine(x));
_zBackGame.ApplicationPath = DxPaths.Windows.DxPath.ToRelative(Settings.Default.LBPath, dbPath);
//TODO voir peut être si présence avant de copier ?
// On copie le fichier donné dans la base
// Copy handler ne peut fonctionner que si on lui file un fichier source et un ficher destination à analyser
return(Copy_Handler(dbPath, destLocation, "Rom"));
/*
* return CopyFile(dbPath, destLocation, res);
*/
//return true;
// }
}
catch (Exception exc)
{
return(false);
}
}
