/// <summary> /// ctor is responsible for parsing the file /// </summary> protected FileImporter(WebLibraryDetail web_library_detail, string fileName) { Entries = new List <BibTeXEntry>(); ImportLibrary = web_library_detail; ExportFileName = fileName; _exportDirectory = Path.GetDirectoryName(fileName); }
public static void Export(Library library, List <PDFDocument> pdf_documents) { FeatureTrackingManager.Instance.UseFeature(Features.Library_Export); // Get the directory string initial_directory = null; if (null == initial_directory) { initial_directory = Path.GetDirectoryName(ConfigurationManager.Instance.ConfigurationRecord.System_LastLibraryExportFolder); } if (null == initial_directory) { initial_directory = Environment.GetFolderPath(Environment.SpecialFolder.Desktop); } using (FolderBrowserDialog dlg = new FolderBrowserDialog { Description = "Please select the folder to which you wish to export your entire Qiqqa library.", SelectedPath = initial_directory, ShowNewFolderButton = true }) { if (dlg.ShowDialog() == DialogResult.OK) { // Remember the filename for next time string base_path = dlg.SelectedPath; ConfigurationManager.Instance.ConfigurationRecord.System_LastLibraryExportFolder = base_path; ConfigurationManager.Instance.ConfigurationRecord_Bindable.NotifyPropertyChanged(() => ConfigurationManager.Instance.ConfigurationRecord.System_LastLibraryExportFolder); SafeThreadPool.QueueUserWorkItem(o => Export(library, pdf_documents, base_path)); } } }
private static string ConvertNormalFilenameToZoteroFilename(string bibtex_base_filename, string filename) { string bibtex_base_path = Path.GetDirectoryName(bibtex_base_filename); string file = Path.GetFileName(filename); string path = filename; /// Try shrink it to a relative path if (path.StartsWith(bibtex_base_path)) { path = path.Substring(bibtex_base_path.Length + 1); } else { Logging.Warn("Unable to convert path to Zotero form: {0}", path); } // Replace the slashes path = path.Replace('\\', '/'); // Concatenate string export_string = "" + file + ":" + path + ":" + "application/pdf"; return(export_string); }
/// <summary> /// ctor is responsible for parsing the file /// </summary> protected FileImporter(Library library, string fileName) { Entries = new List <BibTeXEntry>(); ImportLibrary = library; ExportFileName = fileName; _exportDirectory = Path.GetDirectoryName(fileName); }
public IntranetLibraryDB(string base_path) { this.base_path = base_path; library_path = IntranetLibraryTools.GetLibraryMetadataPath(base_path); // Copy a library into place... if (!File.Exists(library_path)) { Logging.Warn("Intranet Library metadata db does not exist so copying the template to {0}", library_path); string library_metadata_template_path = Path.GetFullPath(Path.Combine(ConfigurationManager.Instance.StartupDirectoryForQiqqa, @"DocumentLibrary/IntranetLibraryStuff/IntranetLibrary.Metadata.Template.s3db")); if (!File.Exists(library_metadata_template_path)) { throw new Exception($"Sync template file '{library_metadata_template_path}' does not exist!"); } string basedir = Path.GetDirectoryName(library_path); if (!Directory.Exists(basedir)) { throw new Exception($"Sync target directory '{basedir}' for Qiqqa database '{library_path}' does not exist!"); } try { File.Copy(library_metadata_template_path, library_path); } catch (Exception ex) { Logging.Error(ex, "Error 0x{2:08X}: Failed to write the sync template '{0}' to sync target directory '{1}'", library_metadata_template_path, basedir, ex.HResult); throw; } } }
public static void Export(WebLibraryDetail web_library_detail, List <PDFDocument> pdf_documents) { FeatureTrackingManager.Instance.UseFeature(Features.Library_Export); // Get the directory string initial_directory = null; if (null == initial_directory) { initial_directory = Path.GetDirectoryName(ConfigurationManager.Instance.ConfigurationRecord.System_LastLibraryExportFolder); } if (null == initial_directory) { initial_directory = Environment.GetFolderPath(Environment.SpecialFolder.Desktop); } using (CommonOpenFileDialog dialog = new CommonOpenFileDialog()) { dialog.IsFolderPicker = true; dialog.Title = "Please select the folder to which you wish to export your entire Qiqqa library."; dialog.DefaultDirectory = initial_directory; CommonFileDialogResult result = dialog.ShowDialog(); if (result == CommonFileDialogResult.Ok) { // Remember the filename for next time string base_path = dialog.FileName; ConfigurationManager.Instance.ConfigurationRecord.System_LastLibraryExportFolder = base_path; ConfigurationManager.Instance.ConfigurationRecord_Bindable.NotifyPropertyChanged(nameof(ConfigurationManager.Instance.ConfigurationRecord.System_LastLibraryExportFolder)); SafeThreadPool.QueueUserWorkItem(o => Export(web_library_detail, pdf_documents, base_path)); } } }
/// <summary> /// Saves settings to location specified /// </summary> /// <param name="path">Path to settings file</param> public void Save(string path) { try { if (!Directory.Exists(Path.GetDirectoryName(path))) { Directory.CreateDirectory(Path.GetDirectoryName(path)); } lock (this) { // Create temp file in case save crashes using (FileStream stream = File.OpenWrite(path + "~")) using (XmlWriter xmlStream = XmlWriter.Create(stream, new XmlWriterSettings { Indent = true })) { if (xmlStream == null) { return; } XmlSerializer serializer = new XmlSerializer(typeof(SerializableDictionary)); serializer.Serialize(xmlStream, this); } File.Copy(path + "~", path, true); Utils.DeleteFile(path + "~"); } } catch (Exception ex) { logger.Log <Exception>(LogLevel.Error, "Failed to load settings", ex); } }
private void ChooseCSLFile(CSLFileSource csl_file_source) { OpenFileDialog dialog = new OpenFileDialog(); dialog.Filter = "CSL style files|*.csl" + "|" + "All files|*.*"; dialog.CheckFileExists = true; dialog.Multiselect = false; string filename = null; string directory = null; // Decide what we want to use as the CSL file location if (CSLFileSource.TEXTBOX == csl_file_source) { try { CorrectStyleFilenameForNewDirectoryLocation(); directory = Path.GetDirectoryName(ConfigurationManager.Instance.ConfigurationRecord.InCite_LastStyleFile); filename = Path.GetFileName(ConfigurationManager.Instance.ConfigurationRecord.InCite_LastStyleFile); // If the directory no longer exists, kill our memory of it. We will pick the default directory again. if (!Directory.Exists(directory)) { directory = null; } } catch { } } if (null == directory) { directory = PDFDocumentCitingTools.BASE_STYLE_DIRECTORY; } // Set the dialog defaults dialog.FileName = filename; dialog.InitialDirectory = directory; // Get the user response if (true == dialog.ShowDialog()) { ConfigurationManager.Instance.ConfigurationRecord.InCite_LastStyleFile = dialog.FileName; ConfigurationManager.Instance.ConfigurationRecord_Bindable.NotifyPropertyChanged(() => ConfigurationManager.Instance.ConfigurationRecord.InCite_LastStyleFile); // Check if it is a dependent style string style_xml_filename = ConfigurationManager.Instance.ConfigurationRecord.InCite_LastStyleFile; string root_style_filename = DependentStyleDetector.GetRootStyleFilename(style_xml_filename); if (root_style_filename != style_xml_filename) { if (null != root_style_filename) { MessageBoxes.Info("This style is dependent on another style, so InCite will be using this file instead:\n" + root_style_filename); } else { MessageBoxes.Info("This style is dependent on another style that is not available on your computer. Please download it before proceeding."); } } } }
public void WriteMasterList() { Logging.Info("+WriteMasterList"); string filename_temp = Path.GetTempFileName(); Utilities.LockPerfTimer l1_clk = Utilities.LockPerfChecker.Start(); lock (locker) { l1_clk.LockPerfTimerStop(); FlushAllWords_LOCK(); PurgeAllWords_LOCK(); using (FileStream fs = File.Open(filename_temp, FileMode.Create)) { Headers headers = new Headers(); // First the documents { headers.documents = new List <DocumentMapHeader>(); foreach (var pair in fingerprint_to_document_ids) { DocumentMapHeader header = new DocumentMapHeader { Fingerprint = pair.Key, DocumentId = pair.Value }; headers.documents.Add(header); } } // Then the words { headers.words = new List <WordMapHeader>(); foreach (WordInWordIndex word_in_word_index in word_in_word_indexes) { WordMapHeader header = new WordMapHeader { Word = word_in_word_index.Word, WordId = word_in_word_index.WordId, DocCount = word_in_word_index.DocumentCount }; headers.words.Add(header); } } Serializer.Serialize <Headers>(fs, headers); } } Logging.Info("-WriteMasterList"); // Move the temp file over the library filename Directory.CreateDirectory(Path.GetDirectoryName(GetFilename_MasterList())); FileTools.MoveSafelyWithOverwriting(filename_temp, GetFilename_MasterList()); // Write the version of the index File.WriteAllText(VersionFilename, INDEX_VERSION); }
public void SaveTempLocaleTable(string locale, LocaleTable locale_table) { string filename = GetFilenameForTempLocale(locale); Directory.CreateDirectory(Path.GetDirectoryName(filename)); locale_table.Save(filename); Logging.Info("Saved locale {0}", locale); }
public async Task TestUpdating() { var profile = utils.AddProfile(); var mod = utils.AddMod(); var unchanged = utils.AddModFile(mod, @"Data\scripts\unchanged.pex", 10); var deleted = utils.AddModFile(mod, @"Data\scripts\deleted.pex", 10); var modified = utils.AddModFile(mod, @"Data\scripts\modified.pex", 10); utils.Configure(); utils.AddManualDownload( new Dictionary <string, byte[]> { { "/baz/unchanged.pex", File.ReadAllBytes(unchanged) }, { "/baz/deleted.pex", File.ReadAllBytes(deleted) }, { "/baz/modified.pex", File.ReadAllBytes(modified) }, }); await CompileAndInstall(profile); utils.VerifyInstalledFile(mod, @"Data\scripts\unchanged.pex"); utils.VerifyInstalledFile(mod, @"Data\scripts\deleted.pex"); utils.VerifyInstalledFile(mod, @"Data\scripts\modified.pex"); var unchanged_path = utils.PathOfInstalledFile(mod, @"Data\scripts\unchanged.pex"); var deleted_path = utils.PathOfInstalledFile(mod, @"Data\scripts\deleted.pex"); var modified_path = utils.PathOfInstalledFile(mod, @"Data\scripts\modified.pex"); var extra_path = utils.PathOfInstalledFile(mod, @"something_i_made.foo"); File.WriteAllText(extra_path, "bleh"); var extra_folder = Path.Combine(Path.GetDirectoryName(utils.PathOfInstalledFile(mod, @"something_i_made.foo")), "folder_i_made"); Directory.CreateDirectory(extra_folder); Assert.IsTrue(Directory.Exists(extra_folder)); var unchanged_modified = File.GetLastWriteTime(unchanged_path); var modified_modified = File.GetLastWriteTime(modified_path); File.WriteAllText(modified_path, "random data"); File.Delete(deleted_path); Assert.IsTrue(File.Exists(extra_path)); await CompileAndInstall(profile); utils.VerifyInstalledFile(mod, @"Data\scripts\unchanged.pex"); utils.VerifyInstalledFile(mod, @"Data\scripts\deleted.pex"); utils.VerifyInstalledFile(mod, @"Data\scripts\modified.pex"); Assert.AreEqual(unchanged_modified, File.GetLastWriteTime(unchanged_path)); Assert.AreNotEqual(modified_modified, File.GetLastWriteTime(modified_path)); Assert.IsFalse(File.Exists(extra_path)); Assert.IsFalse(Directory.Exists(extra_folder)); }
/// <summary> /// Saves settings to location specified /// </summary> /// <param name="path">Path to settings file</param> public void Save(string path) { using (var mutex = new Mutex(false, mutexId)) { bool hasHandle = false; try { try { hasHandle = mutex.WaitOne(5000, false); if (hasHandle == false) { logger.Info("Timeout waiting for exclusive access to save app settings."); return; } } catch (AbandonedMutexException) { // The mutex was abandoned in another process, // it will still get acquired hasHandle = true; } // Perform work here. if (!Directory.Exists(Path.GetDirectoryName(path))) { Directory.CreateDirectory(Path.GetDirectoryName(path)); } // Create temp file in case save crashes using (FileStream stream = File.OpenWrite(path + "~")) using (XmlWriter xmlStream = XmlWriter.Create(stream, new XmlWriterSettings { Indent = true })) { if (xmlStream == null) { return; } XmlSerializer serializer = new XmlSerializer(typeof(SerializableDictionary)); serializer.Serialize(xmlStream, this); } File.Copy(path + "~", path, true); Utils.DeleteFile(path + "~"); } catch (Exception ex) { logger.Log <Exception>(LogLevel.Error, "Failed to save app settings: " + ex.Message, ex); } finally { if (hasHandle) { mutex.ReleaseMutex(); } } } }
public ZoteroImporter(Library library, string filename) : base(library, filename) { FeatureTrackingManager.Instance.UseFeature(Features.Library_ImportFromZotero); // For Zotero export, the files all live under \Files, // e.g. if export is c:\temp\bla.bib, a file might be c:\temp\files\20\foo.pdf _importBasePath = Path.GetDirectoryName(filename); }
internal static string GetRootStyleFilename(string style_xml_filename) { string parent_filename; string parent_url; if (IsDependentStyle(style_xml_filename, out parent_filename, out parent_url)) { // Check that we have the dependent style - if we don't prompt to download it string full_parent_filename = Path.GetFullPath(Path.Combine(Path.GetDirectoryName(style_xml_filename), parent_filename)); if (!File.Exists(full_parent_filename)) { string message = String.Format( "Can't find parent style for this dependent style" + "\n\n" + "Your style depends on a parent style named {0}, which needs to be saved in the same directory.\n\n" + "It appears to be available from {1}.\n" + "Shall we try to download it automatically? If you choose NO, Qiqqa will open the website for you so you can download it manually.", parent_filename, parent_url ); if (MessageBoxes.AskQuestion(message)) { try { using (MemoryStream ms = UrlDownloader.DownloadWithBlocking(parent_url)) { File.WriteAllBytes(full_parent_filename, ms.ToArray()); } } catch (UnauthorizedAccessException ex) { Logging.Error(ex, "You don't seem to have permission to write the new style to the directory '{0}'.\nPlease copy the original style file '{1}' to a folder where you can write (perhaps alongside your Word document), and try again.", full_parent_filename, style_xml_filename); MessageBoxes.Warn("You don't seem to have permission to write the new style to the directory '{0}'.\nPlease copy the original style file '{1}' to a folder where you can write (perhaps alongside your Word document), and try again.", full_parent_filename, style_xml_filename); } } else { MainWindowServiceDispatcher.Instance.OpenUrlInBrowser(parent_url, true); } } // Check again if the parent file exists, and if it does, recurse the dependency check if (File.Exists(full_parent_filename)) { return(GetRootStyleFilename(full_parent_filename)); } else { // We need the parent style, but haven't managed to download it, so return nothing... return(null); } } else // Not a dependent style, so use this filename { return(style_xml_filename); } }
internal string StorePageTextGroup(int page, string source_filename) { string filename = MakeFilename_TextGroup(page); Directory.CreateDirectory(Path.GetDirectoryName(filename)); File.Copy(source_filename, filename, true); File.Delete(source_filename); return(filename); }
internal void StorePageTextSingle(int page, string source_filename) { string filename = MakeFilename_TextSingle(page); Directory.CreateDirectory(Path.GetDirectoryName(filename)); File.Copy(source_filename, filename, true); File.Delete(source_filename); OnPageTextAvailable?.Invoke(page, page); }
public override void OpenFile(OpenFileArgs args) { string tempFolder = Path.Combine(Utils.GetTempFolder(), "dnGREP-Archive", Utils.GetHash(args.SearchResult.FileNameReal)); string innerFileName = args.SearchResult.FileNameDisplayed.Substring(args.SearchResult.FileNameReal.Length).TrimStart(Path.DirectorySeparatorChar); string filePath = Path.Combine(tempFolder, innerFileName); if (!File.Exists(filePath)) { // use the directory name to also include folders within the archive string directory = Path.GetDirectoryName(filePath); if (!Directory.Exists(directory)) { Directory.CreateDirectory(directory); } string zipFile = args.SearchResult.FileNameReal; if (zipFile.Length > 260 && !zipFile.StartsWith(@"\\?\")) { zipFile = @"\\?\" + zipFile; } using (SevenZipExtractor extractor = new SevenZipExtractor(zipFile)) { if (extractor.ArchiveFileData.Where(r => r.FileName == innerFileName && !r.IsDirectory).Any()) { using (FileStream stream = File.Open(filePath, FileMode.Create, FileAccess.Write, FileShare.None)) { try { extractor.ExtractFile(innerFileName, stream); } catch { args.UseBaseEngine = true; } } } } } if (Utils.IsPdfFile(filePath) || Utils.IsWordFile(filePath) || Utils.IsExcelFile(filePath)) { args.UseCustomEditor = false; } GrepSearchResult newResult = new GrepSearchResult { FileNameReal = args.SearchResult.FileNameReal, FileNameDisplayed = args.SearchResult.FileNameDisplayed }; OpenFileArgs newArgs = new OpenFileArgs(newResult, args.Pattern, args.LineNumber, args.FirstMatch, args.ColumnNumber, args.UseCustomEditor, args.CustomEditor, args.CustomEditorArgs); newArgs.SearchResult.FileNameDisplayed = filePath; Utils.OpenFile(newArgs); }
static VirtualFileSystem() { VFS = new VirtualFileSystem(); var entry = Assembly.GetEntryAssembly(); if (entry != null && !string.IsNullOrEmpty(entry.Location)) { RootFolder = Path.GetDirectoryName(Assembly.GetEntryAssembly().Location); _stagedRoot = Path.Combine(RootFolder, "vfs_staged_files"); } }
public static void SaveObject(string filename, object obj) { // Make sure the path exists string pathname = Path.GetDirectoryName(filename); Directory.CreateDirectory(pathname); using (FileStream fs = File.OpenWrite(filename)) { SaveObject(fs, obj); } }
internal static void DaemonPut(Library library, string fingerprint) { string filename_full = PDFDocumentFileLocations.DocumentPath(library, fingerprint, "pdf"); string filename_short = Path.GetFileName(filename_full); string pdf_path = IntranetLibraryTools.GetLibraryPDFPath(library.WebLibraryDetail.IntranetPath, filename_short); DirectoryTools.CreateDirectory(Path.GetDirectoryName(pdf_path)); Logging.Info("+Copying up {0}", fingerprint); File.Copy(filename_full, pdf_path); Logging.Info("-Copying up {0}", fingerprint); }
/// <summary> /// Adds a file to the given mod with a given path in the mod. Fills it with random data unless /// random_fill == 0; /// </summary> /// <param name="mod_name"></param> /// <param name="path"></param> /// <param name="random_fill"></param> /// <returns></returns> public string AddModFile(string mod_name, string path, int random_fill = 128) { byte[] bytes = new byte[0]; if (random_fill != 0) { bytes = new byte[random_fill]; RNG.NextBytes(bytes); } var full_path = Path.Combine(ModsFolder, mod_name, path); Directory.CreateDirectory(Path.GetDirectoryName(full_path)); File.WriteAllBytes(full_path, bytes); return(full_path); }
public void Dispose() { // if long path, delete folder from the top of the long path string folder = destinationFolder; while (folder.Contains("aaaaaaaaaaaaaaaaaaaa")) { folder = Path.GetDirectoryName(folder); } if (Directory.Exists(folder)) { Utils.DeleteFolder(folder); } }
private bool CheckHidden(FileFilter filter, string fileName, List <string> hiddenDirectories) { if (!filter.IncludeHidden && hiddenDirectories.Count > 0) { string path = Path.GetDirectoryName(fileName); foreach (var dir in hiddenDirectories) { if (path.Contains(dir)) { return(false); } } } return(true); }
/// </summary> // Iterates through each file entry within the supplied tar, // extracting them to the nominated folder. /// </summary> public static void ExtractTarByEntry(TarInputStream tarIn, string targetDir) { TarEntry tarEntry; while ((tarEntry = tarIn.GetNextEntry()) != null) { // Converts the unix forward slashes in the filenames to windows backslashes string name = tarEntry.Name.Replace('/', Path.DirectorySeparatorChar); // Remove any root e.g. '\' because a PathRooted filename defeats Path.Combine if (Path.IsPathRooted(name)) { name = name.Substring(System.IO.Path.GetPathRoot(name).Length); } // Apply further name transformations here as necessary string outName = Path.Combine(targetDir, name); string directoryName = Path.GetDirectoryName(outName); try { if (tarEntry.IsDirectory) { Directory.CreateDirectory(outName); continue; } // Does nothing if directory exists Directory.CreateDirectory(directoryName); try { using (var outStr = File.Open(outName, FileMode.Create)) { tarIn.CopyEntryContents(outStr); } // Set the modification date/time. This approach seems to solve timezone issues. DateTime myDt = DateTime.SpecifyKind(tarEntry.ModTime, DateTimeKind.Utc); File.SetLastWriteTime(outName, myDt); } catch (NotSupportedException) { Console.WriteLine($"[!] invalid file name: {outName}"); } catch (PathTooLongException) { Console.WriteLine($"[!] file name too long?! {outName}"); } } catch (NotSupportedException) { Console.WriteLine($"[!] invalid directory name: {directoryName}"); } } }
private static void DoDirectCopy(string vmBackupPath, string snapshotPath, int volumePathLength, string vmPath) { var srcPath = Path.Combine(snapshotPath, vmPath.Substring(volumePathLength)); if (Directory.Exists(srcPath)) { foreach (var srcChildPath in Directory.GetFileSystemEntries(srcPath)) { var srcChildPathRel = srcChildPath.Substring(snapshotPath.EndsWith(Path.PathSeparator.ToString(), StringComparison.CurrentCultureIgnoreCase) ? snapshotPath.Length : snapshotPath.Length + 1); var childPath = Path.Combine(vmPath.Substring(0, volumePathLength), srcChildPathRel); DoDirectCopy(vmBackupPath, snapshotPath, volumePathLength, childPath); } } else if (File.Exists(srcPath)) { var outputName = Path.Combine(vmBackupPath, vmPath.Substring(volumePathLength)); using (var s = File.OpenRead(srcPath)) { var folder = Path.GetDirectoryName(outputName); if (!Directory.Exists(folder)) { Directory.CreateDirectory(folder); } using (var ns = File.Create(outputName)) { s.CopyTo(ns); } } } else { var lowerPath = srcPath.ToLowerInvariant(); var isIgnorable = lowerPath.EndsWith(".avhdx") || lowerPath.EndsWith(".vmrs") || lowerPath.EndsWith(".bin") || lowerPath.EndsWith(".vsv"); if (!isIgnorable) { throw new Exception($"Entry \"{srcPath}\" not found in snapshot"); } } }
internal void StorePageTextGroup(int page, int TEXT_PAGES_PER_GROUP, string source_filename) { string filename = MakeFilename_TextGroup(page); Directory.CreateDirectory(Path.GetDirectoryName(filename)); File.Copy(source_filename, filename, true); File.Delete(source_filename); if (null != OnPageTextAvailable) { int page_range_start = ((page - 1) / TEXT_PAGES_PER_GROUP) * TEXT_PAGES_PER_GROUP + 1; int page_range_end = page_range_start + TEXT_PAGES_PER_GROUP - 1; page_range_end = Math.Min(page_range_end, PageCount); OnPageTextAvailable?.Invoke(page_range_start, page_range_end); } }
public string ExtractToTempFile(GrepSearchResult searchResult) { string tempFolder = Path.Combine(Utils.GetTempFolder(), "dnGREP-Archive", Utils.GetHash(searchResult.FileNameReal)); string innerFileName = searchResult.FileNameDisplayed.Substring(searchResult.FileNameReal.Length).TrimStart(Path.DirectorySeparatorChar); string filePath = Path.Combine(tempFolder, innerFileName); if (!File.Exists(filePath)) { // use the directory name to also include folders within the archive string directory = Path.GetDirectoryName(filePath); if (!Directory.Exists(directory)) { Directory.CreateDirectory(directory); } string zipFile = searchResult.FileNameReal; if (zipFile.Length > 260 && !zipFile.StartsWith(@"\\?\")) { zipFile = @"\\?\" + zipFile; } using (SevenZipExtractor extractor = new SevenZipExtractor(zipFile)) { if (extractor.ArchiveFileData.Where(r => r.FileName == innerFileName && !r.IsDirectory).Any()) { using (FileStream stream = File.Open(filePath, FileMode.Create, FileAccess.Write, FileShare.None)) { try { extractor.ExtractFile(innerFileName, stream); } catch (Exception ex) { logger.Log <Exception>(LogLevel.Error, string.Format("Failed extract file {0} from archive '{1}'", innerFileName, searchResult.FileNameReal), ex); } } } } } return(filePath); }
public static string ExtractToTempFile(GrepSearchResult searchResult) { if (searchResult == null) { throw new ArgumentNullException(nameof(searchResult)); } string tempFolder = Path.Combine(Utils.GetTempFolder(), "dnGREP-Archive", Utils.GetHash(searchResult.FileNameReal)); string[] parts = searchResult.FileNameDisplayed.Split(new char[] { '/' }, StringSplitOptions.RemoveEmptyEntries); if (!searchResult.FileNameDisplayed.Contains(ArchiveSeparator) || parts.Length < 2) { return(string.Empty); } string innerFileName = parts.Last(); string[] intermediateFiles = parts.Skip(1).Take(parts.Length - 2).ToArray(); string filePath = Path.Combine(tempFolder, innerFileName); if (!File.Exists(filePath)) { // use the directory name to also include folders within the archive string directory = Path.GetDirectoryName(filePath); if (!Directory.Exists(directory)) { Directory.CreateDirectory(directory); } string zipFile = searchResult.FileNameReal; if (zipFile.Length > 260 && !zipFile.StartsWith(@"\\?\", StringComparison.InvariantCulture)) { zipFile = @"\\?\" + zipFile; } using (FileStream input = File.Open(zipFile, FileMode.Open, FileAccess.Read, FileShare.ReadWrite)) { ExtractToTempFile(input, filePath, searchResult.FileNameReal, innerFileName, intermediateFiles); } } return(filePath); }
internal static void DaemonGet(Library library, string fingerprint) { string filename_full = PDFDocumentFileLocations.DocumentPath(library, fingerprint, "pdf"); string filename_short = Path.GetFileName(filename_full); string pdf_path = IntranetLibraryTools.GetLibraryPDFPath(library.WebLibraryDetail.IntranetPath, filename_short); DirectoryTools.CreateDirectory(Path.GetDirectoryName(filename_full)); Logging.Info("+Copying down {0}", fingerprint); File.Copy(pdf_path, filename_full); Logging.Info("-Copying down {0}", fingerprint); // Write the audit if (true) { string audit_filename = IntranetLibraryTools.GetLibraryAuditFilename(library.WebLibraryDetail.IntranetPath); string audit_directory = Path.GetDirectoryName(audit_filename); if (Directory.Exists(audit_directory)) { string audit_data = String.Format( "{0}\t{1}\t{2}\t{3}\t{4}\t{5}\r\n" , DateTime.UtcNow.ToString("yyyyMMdd.hhmmss") , ConfigurationManager.Instance.ConfigurationRecord.Account_Username , ConfigurationManager.Instance.ConfigurationRecord.Account_Nickname , Environment.UserName , filename_short , pdf_path ); try { File.AppendAllText(audit_filename, audit_data); } catch (Exception ex) { Logging.Warn(ex, "Unable to write intranet sync audit data."); } } } }
public void RegenFolderRecords() { _folders = _files.GroupBy(f => Path.GetDirectoryName(f.Path.ToLowerInvariant())) .Select(f => new FolderRecordBuilder(this, f.Key, f.ToList())) .OrderBy(f => f._hash) .ToList(); var lnk = _files.Where(f => f.Path.EndsWith(".lnk")).FirstOrDefault(); foreach (var folder in _folders) { foreach (var file in folder._files) { file._folder = folder; } } _files = (from folder in _folders from file in folder._files orderby folder._hash, file._hash select file).ToList(); }