/// <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; }