/// <summary>
/// Destruction
/// </summary>
/// <param name="application"></param>
/// <param name="directory"></param>
public static void DeleteDirectoryOrFile(IRemoteApplication application, IRemoteFileInfo directoryOrFile)
{
GetParentDirectory(application, directoryOrFile);
if (application == null || directoryOrFile == null)
{
return;
}
var isolatedStore = application.GetIsolatedStore();
if (isolatedStore != null)
{
string path = GetSearchPattern(application, directoryOrFile);
if (directoryOrFile.IsDirectory() == true)
{
isolatedStore.DeleteDirectory(path);
}
else
{
//TODO isolatedStore.DeleteFile(path);
}
}
}
/// <summary>
/// Construct a representation of a real remote file (or directory)
/// </summary>
/// <param name="app"></param>
/// <param name="remoteFile"></param>
private RemoteAppIsoStoreItem(RemoteApplicationEx app, IRemoteFileInfo remoteFile, IRemoteIsolatedStorageFile remoteStore, RemoteAppIsoStoreItem parent)
{
RemoteApp = app.RemoteApplication;
_remoteStore = remoteStore;
_appEx = app;
Parent = parent;
RemoteFile = remoteFile;
// if we can't get the internal object, set it back to the default, which is remoteFile itself.
// remoteFile only exposes a subset of properties, but these are better than none
RemoteFileInfo = (object)remoteFile.GetInternalRemoteFileInfo() ?? (object)remoteFile;
string name = RemoteFile.Name;
Name = Path.GetFileName(name);
// "\\Applications\\Data\\8531f2be-f4c3-4822-9fa6-bcc70c9d50a8\\Data\\IsolatedStore\\\\Shared"
_path = RemoteFile.GetRelativePath();
// Modern applications are rooted by their IsoStore object so don't need the full path
if (_path.Contains("%"))
{
_path = "";
}
if (RemoteFile.IsDirectory())
{
Children.Add(new FakeRemoteAppIsoStoreItem(this));
}
}
/// <summary>
/// Le FileInfo est-il supporté ?
/// </summary>
/// <param name="fileInfo"></param>
/// <returns></returns>
public bool CheckFileInfoIsSupported(IRemoteFileInfo fileInfo)
{
string filename = RemoteIsolatedStoreTools.GetShortName(fileInfo);
if (filename != null && filename.ToLower() == "__applicationsettings")
{
return true;
}
return this.CheckExtensions(new string[]{".txt",".csv",".tab",".xml",".settings"}, fileInfo);
}
protected ConfigurationTest(
IRemoteFileInfo remoteFileInfo,
IRemoteFileInfo remoteFileInfoNotExistAndOptional,
IRemoteFileInfo remoteFileInfoNotExitAndNotOptional,
string resultRemotAppsettings)
{
_remoteFileInfo = remoteFileInfo;
_remoteFileInfoNotExistAndOptional = remoteFileInfoNotExistAndOptional;
_remoteFileInfoNotExitAndNotOptional = remoteFileInfoNotExitAndNotOptional;
_resultRemotAppsettings = resultRemotAppsettings;
}
/// <summary>
/// Verifier les extensions
/// </summary>
/// <param name="extensions"></param>
/// <param name="fileInfo"></param>
/// <returns></returns>
protected bool CheckExtensions(string[] extensions, IRemoteFileInfo fileInfo)
{
foreach (string extension in extensions)
{
if (CheckExtension(extension, fileInfo) == true)
{
return true;
}
}
return false;
}
public static RemoteFileInfo GetInternalRemoteFileInfo(this IRemoteFileInfo wrapperRemoteFileInfo)
{
BindingFlags eFlags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
var fieldInfo = (typeof(RemoteFileInfoObject)).GetField("mRemoteFileInfo", eFlags);
if (fieldInfo != null)
{
// An exception will be thrown when referencing CoreCon 10 objects since it won't contain the field on this particular
// wrapper object (so fall through and return null)
try
{
return(fieldInfo.GetValue(wrapperRemoteFileInfo) as RemoteFileInfo);
}
catch { }
}
return(null);
}
/// <summary>
/// Creation du répertoire
/// </summary>
/// <param name="fileInfo"></param>
public static IRemoteFileInfo CreateDirectory(IRemoteApplication application, IRemoteFileInfo directoryParent, string newDirectoryName)
{
if (application == null || string.IsNullOrWhiteSpace(newDirectoryName) == true)
{
return null;
}
var isolatedStore = application.GetIsolatedStore();
if (isolatedStore != null)
{
string path = Path.Combine(GetSearchPattern(application, directoryParent), newDirectoryName);
isolatedStore.CreateDirectory(path);
return SearchRemoteFileInfo(application, directoryParent, newDirectoryName);
}
return null;
}
public static string GetRelativePath(this IRemoteFileInfo fileInfo)
{
string name = fileInfo.Name;
if (name.Contains(WP8_SEPERATOR))
{
name = name.Substring(WP8_PATH_SEPERATOR_LENGTH);
// modern applications will have an extra field which needs to be removed
if (name.Contains("%"))
{
Regex re = new Regex("\\%.*?%");
name = re.Replace(name, "");
}
return(name);
}
else
{
return(name.Substring(name.IndexOf(RELATIVE_PATH_SEPARATOR) + RELATIVE_PATH_SEPARATOR_LENGTH));
}
}
public static string GetExtension(this IRemoteFileInfo fileInfo)
{
return(Path.GetExtension(fileInfo.Name));
}
public static IConfigurationBuilder AddRemoteJsonFile(this IConfigurationBuilder builder, IRemoteFileInfo remoteFileInfo) => builder.Add(new RemoteConfigurationSource(remoteFileInfo));
/// <summary>
/// Telechargement
/// </summary>
/// <param name="application"></param>
/// <param name="directoryOrFileToDownload"></param>
/// <param name="desktopPath"></param>
public static void DownloadFileOrDirectoryFromDevice(IRemoteApplication application, IRemoteFileInfo directoryOrFileToDownload, string desktopPath, bool includeRootDirectory = true)
{
if (application == null || desktopPath == null)
{
return;
}
var isolatedStore = application.GetIsolatedStore();
if (isolatedStore != null)
{
if (directoryOrFileToDownload == null || directoryOrFileToDownload.IsDirectory() == true)
{
string searchPattern = GetSearchPattern(application, directoryOrFileToDownload);
List<IRemoteFileInfo> fileInfos = GetRemoteFileInfos(application, searchPattern, null);
desktopPath = Path.Combine(desktopPath, GetShortName(directoryOrFileToDownload));
if (includeRootDirectory == true)
{
Directory.CreateDirectory(desktopPath);
}
foreach (IRemoteFileInfo fileInfo in fileInfos)
{
if (fileInfo.IsDirectory() == true)
{
if (includeRootDirectory == false)
{
Directory.CreateDirectory(desktopPath);
}
// repertoire
DownloadFileOrDirectoryFromDevice(application, fileInfo, desktopPath, true);
}
else
{ // fichier
DownloadFileFromDevice(application, fileInfo, desktopPath);
}
}
}
else
{
// fichier
DownloadFileFromDevice(application, directoryOrFileToDownload, desktopPath);
}
}
}
/// <summary>
/// Obtenir le repertoire parent
/// </summary>
/// <param name="application"></param>
/// <param name="remoteFileInfo"></param>
/// <returns></returns>
public static IRemoteFileInfo GetParentDirectory(IRemoteApplication application, IRemoteFileInfo remoteFileInfo)
{
if (application == null || remoteFileInfo == null)
return null;
string parent = GetParentDirectoryString(application, remoteFileInfo);
string parentName = new DirectoryInfo(parent).Name;
string parentOfParent = Path.GetPathRoot(parent);
var isolatedStore = application.GetIsolatedStore();
if (isolatedStore != null)
{
var remoteFileInfos = isolatedStore.GetDirectoryListing(parentOfParent);
foreach (var r in remoteFileInfos)
{
string name = RemoteIsolatedStoreTools.GetShortName(r);
if (r.IsDirectory() && name == parentName)
{
return r;
}
}
}
return null;
}
public RemoteConfigurationSource(IRemoteFileInfo remoteFileInfo)
{
FileInfo = remoteFileInfo;
}
/// <summary>
/// Sauvegarde d'un fichier
/// </summary>
/// <param name="desktopStream"></param>
public static void SaveFile(IRemoteApplication application, IRemoteFileInfo directory, FileStream desktopStream)
{
RemoteIsolatedStoreTools.UploadFileToDevice(application, directory, desktopStream.Name);
}
/// <summary>
/// Chargement d'un fichier texte
/// </summary>
/// <param name="application"></param>
/// <param name="fileInfo"></param>
/// <param name="tempDirectory"></param>
/// <returns></returns>
public static string LoadFileText(IRemoteApplication application, IRemoteFileInfo fileInfo, string tempDirectory)
{
using (FileStream stream = LoadFile(application, fileInfo, tempDirectory))
{
using (StreamReader reader = new StreamReader(stream))
{
return reader.ReadToEnd();
}
}
}
/// <summary>
/// Chargement d'un fichier de nom FileInfo
/// </summary>
/// <returns></returns>
public static FileStream LoadFile(IRemoteApplication application, IRemoteFileInfo fileInfo, string desktopTempDirectory)
{
RemoteIsolatedStoreTools.DownloadFileFromDevice(application, fileInfo, desktopTempDirectory);
string filename = Path.Combine(desktopTempDirectory, RemoteIsolatedStoreTools.GetShortName(fileInfo));
return File.OpenRead(filename);
}
/// <summary>
/// Obtenir le nom court d'un fichier/repertoire
/// </summary>
/// <param name="remoteFileInfo"></param>
/// <returns></returns>
public static string GetShortName(IRemoteFileInfo remoteFileInfo)
{
if (remoteFileInfo != null)
{
FileInfo fileinfo = new FileInfo(remoteFileInfo.Name);
return fileinfo.Name;
}
return string.Empty;
}
/// <summary>
/// Obtenir la search pattern à partir des informations d'un fichier
/// </summary>
/// <param name="application"></param>
/// <param name="fileInfo"></param>
/// <returns></returns>
public static string GetSearchPattern(IRemoteApplication application, IRemoteFileInfo fileInfo)
{
if (fileInfo == null)
return string.Empty;
string root = GetRootPath(application).ToLower();
if (fileInfo.Name.ToLower().StartsWith(root) == true)
{
return fileInfo.Name.Substring(root.Length);
}
return null;
}
/// <summary>
/// Obtenir le parent
/// </summary>
/// <param name="application"></param>
/// <param name="remoteFileInfo"></param>
/// <returns></returns>
public static string GetParentDirectoryString(IRemoteApplication application, IRemoteFileInfo remoteFileInfo)
{
string filename = GetSearchPattern(application, remoteFileInfo);
string name = GetShortName(remoteFileInfo);
return filename.Substring(0, filename.Length - name.Length);
}
/// <summary>
/// Sauvegarde d'un fichier texte dans un repertoire temporaire puis envoi vers le device
/// </summary>
/// <param name="stream"></param>
public static void SaveFileText(IRemoteApplication application, IRemoteFileInfo directory, string tempFullFilename, string text)
{
using (FileStream stream = new FileStream(tempFullFilename, FileMode.Create))
{
using (StreamWriter writer = new StreamWriter(stream))
{
writer.Write(text);
SaveFile(application, directory, stream);
}
}
}
/// <summary>
/// Le FileInfo est-il supporté ?
/// </summary>
/// <param name="fileInfo"></param>
/// <returns></returns>
public bool CheckFileInfoIsSupported(IRemoteFileInfo fileInfo)
{
return this.CheckExtensions(new string[]{".jpg",".png",".gif",".bmp",".ico"}, fileInfo);
}
/// <summary>
/// Verifie une extension
/// </summary>
/// <param name="extension"></param>
/// <param name="fileInfo"></param>
/// <returns></returns>
protected bool CheckExtension(string extension, IRemoteFileInfo fileInfo)
{
string name = RemoteIsolatedStoreTools.GetShortName(fileInfo);
return (Path.GetExtension(name).ToLower() == extension.ToLower());
}
/// <summary>
/// Download a file
/// </summary>
/// <param name="application"></param>
/// <param name="fileToDownload"></param>
/// <param name="desktopPath"></param>
public static void DownloadFileFromDevice(IRemoteApplication application, IRemoteFileInfo fileToDownload, string desktopPath)
{
if (application == null || fileToDownload == null || desktopPath == null)
{
return;
}
if (fileToDownload.IsDirectory() == false)
{
var isolatedStore = application.GetIsolatedStore();
if (isolatedStore != null)
{
// on rajoute le nom du fichier
desktopPath = Path.Combine(desktopPath, GetShortName(fileToDownload));
string searchPattern = GetSearchPattern(application, fileToDownload);
isolatedStore.ReceiveFile(searchPattern, desktopPath, true);
}
}
}
/// <summary>
/// Constructeur
/// </summary>
/// <param name="fileInfo"></param>
public RemoteFileInfoManager(IRemoteApplication application, IRemoteFileInfo fileInfo, string tempDirectory)
{
this.RemoteFileInfo = fileInfo;
this.TempDirectory = tempDirectory;
this.RemoteApplication = application;
}
/// <summary>
/// Upload du fichier
/// </summary>
/// <param name="application"></param>
/// <param name="directoryToUpload"></param>
/// <param name="desktopfilename"></param>
public static void UploadFileToDevice(IRemoteApplication application, IRemoteFileInfo directoryToUpload, string desktopfilename)
{
if (application == null || desktopfilename == null)
{
return;
}
if (directoryToUpload == null || directoryToUpload.IsDirectory() == true)
{
var isolatedStore = application.GetIsolatedStore();
if (isolatedStore != null)
{
string searchPattern = GetSearchPattern(application, directoryToUpload);
// on rajoute le nom du fichier
string devicefilename = Path.Combine(searchPattern, new FileInfo(desktopfilename).Name);
isolatedStore.SendFile(desktopfilename, devicefilename, true);
}
}
}
/// <summary>
/// Recherche d'un IRemoteFileInfo par son nom
/// </summary>
/// <param name="application"></param>
/// <param name="directoryParent"></param>
/// <param name="nameOfFileOrDirectory"></param>
/// <returns></returns>
public static IRemoteFileInfo SearchRemoteFileInfo(IRemoteApplication application, IRemoteFileInfo directoryParent, string nameOfFileOrDirectory)
{
if (application == null || string.IsNullOrWhiteSpace(nameOfFileOrDirectory) == true)
{
return null;
}
var isolatedStore = application.GetIsolatedStore();
if (isolatedStore != null)
{
string searchPattern = GetSearchPattern(application, directoryParent);
var result = GetRemoteFileInfos(application, searchPattern, null);
return result.FirstOrDefault(r => GetShortName(r) == nameOfFileOrDirectory);
}
return null;
}
/// <summary>
/// le repertoire de nom Exist ou non
/// </summary>
/// <param name="application"></param>
/// <param name="directoryParent"></param>
/// <param name="directoryOrFilename"></param>
/// <returns></returns>
public static bool Exists(IRemoteApplication application, IRemoteFileInfo directoryParent, string directoryOrFilename)
{
if (application == null || string.IsNullOrWhiteSpace(directoryOrFilename) == true)
{
return false;
}
bool result = false;
var isolatedStore = application.GetIsolatedStore();
if (isolatedStore != null)
{
string searchPattern = GetSearchPattern(application, directoryParent);
string path = Path.Combine(searchPattern, directoryOrFilename);
result = isolatedStore.DirectoryExists(path);
if (result == false)
{
result = isolatedStore.FileExists(path);
}
}
return result;
}
/// <summary>
/// Le FileInfo est-il supporté ?
/// </summary>
/// <param name="fileInfo"></param>
/// <returns></returns>
public bool CheckFileInfoIsSupported(IRemoteFileInfo fileInfo)
{
return this.CheckExtension(".sdf", fileInfo);
}
/// <summary>
/// Upload d'un fichier ou d'un répertoire entier
/// </summary>
/// <param name="application"></param>
/// <param name="directoryOrFileToDownload"></param>
/// <param name="desktopPath"></param>
public static IRemoteFileInfo UploadFileOrDirectoryToDevice(IRemoteApplication application, IRemoteFileInfo directoryToUpload, string desktopPathOrFilename, bool includeRootDirectory = false)
{
if (application == null || desktopPathOrFilename == null)
{
return null;
}
if (directoryToUpload == null || directoryToUpload.IsDirectory() == true)
{
var isolatedStore = application.GetIsolatedStore();
if (isolatedStore != null)
{
bool isDirectory = Directory.Exists(desktopPathOrFilename);
string searchPattern = GetSearchPattern(application, directoryToUpload);
if (isDirectory == true)
{
string directoryName = new DirectoryInfo(desktopPathOrFilename).Name;
IRemoteFileInfo newDirectory = directoryToUpload;
if (includeRootDirectory == true)
{
newDirectory = CreateDirectory(application, directoryToUpload, directoryName);
}
foreach (string directory in Directory.GetDirectories(desktopPathOrFilename))
{
string desktopDirectoryPath = Path.Combine(desktopPathOrFilename, directory);
UploadFileOrDirectoryToDevice(application, newDirectory, desktopDirectoryPath, true);
}
foreach (string file in Directory.GetFiles(desktopPathOrFilename))
{
string desktopFilename = Path.Combine(desktopPathOrFilename, file);
UploadFileToDevice(application, newDirectory, desktopFilename);
}
return newDirectory;
}
else
{
// fichier
UploadFileToDevice(application, directoryToUpload, desktopPathOrFilename);
}
}
}
return null;
}
