private void DownloadAndInstall(string url, string filename, string mod_name = null) { var src = Path.Combine(DOWNLOAD_FOLDER, filename); if (!File.Exists(src)) { var state = DownloadDispatcher.ResolveArchive(url); state.Download(new Archive() { Name = "Unknown" }, src); } if (!Directory.Exists(utils.DownloadsFolder)) { Directory.CreateDirectory(utils.DownloadsFolder); } File.Copy(src, Path.Combine(utils.DownloadsFolder, filename)); if (mod_name == null) { FileExtractor.ExtractAll(src, utils.MO2Folder); } else { FileExtractor.ExtractAll(src, Path.Combine(utils.ModsFolder, mod_name)); } }
private void DownloadAndInstall(Game game, int modid, string mod_name) { utils.AddMod(mod_name); var client = new NexusApiClient(); var file = client.GetModFiles(game, modid).First(f => f.is_primary); var src = Path.Combine(DOWNLOAD_FOLDER, file.file_name); var ini = string.Join("\n", new List <string> { "[General]", $"gameName={GameRegistry.Games[game].MO2ArchiveName}", $"modID={modid}", $"fileID={file.file_id}" }); if (!File.Exists(file.file_name)) { var state = DownloadDispatcher.ResolveArchive(ini.LoadIniString()); state.Download(src); } if (!Directory.Exists(utils.DownloadsFolder)) { Directory.CreateDirectory(utils.DownloadsFolder); } var dest = Path.Combine(utils.DownloadsFolder, file.file_name); File.Copy(src, dest); FileExtractor.ExtractAll(src, Path.Combine(utils.ModsFolder, mod_name)); File.WriteAllText(dest + ".meta", ini); }
private void ClearExplorerSource() { this.ExplorerViewModel?.ClearFileSystemTree(); FileExtractor.CleanUpExtractedTemporaryFiles(); NotifyExplorerSourceCleared(); }
/// <summary> /// Add a path to a url file to parse. /// </summary> public void AddUrlFile(string path) { _lock.Take(); // has the extractor been setup? if (_fileExtractor == null) { // no, create an extractor of urls Extract extract = new ExtractUrl( new ActionSet <string, Crawler>(ParseControl.OnUrl), new ArrayRig <Protocol>(ParseControl.Protocols)); // start a file extractor for the files with the url extractor _fileExtractor = new FileExtractor(new ArrayRig <string>(new [] { path }), extract); _fileExtractor.OnFile = new ActionSet <string>(OnCompleteUrlFile); _fileExtractor.Run(); } else { // yes, add the file to the extractor _fileExtractor.AddFile(path); } _lock.Release(); }
public Action Stage(IEnumerable <VirtualFile> files) { var grouped = files.SelectMany(f => f.FilesInPath) .Distinct() .Where(f => f.ParentArchive != null) .GroupBy(f => f.ParentArchive) .OrderBy(f => f.Key == null ? 0 : f.Key.Paths.Length) .ToList(); List <string> Paths = new List <string>(); foreach (var group in grouped) { var tmp_path = Path.Combine(_stagedRoot, Guid.NewGuid().ToString()); FileExtractor.ExtractAll(group.Key.StagedPath, tmp_path); Paths.Add(tmp_path); foreach (var file in group) { file._stagedPath = Path.Combine(tmp_path, file.Paths[group.Key.Paths.Length]); } } return(() => { Paths.Do(p => { if (Directory.Exists(p)) { DeleteDirectory(p); } }); }); }
public async Task <bool> transferFiles(string d3path, string bfgpath, int scaling) { await Task.Run(() => { exporter = new FileExtractorImpl(d3path + "/pak000.pk4"); foreach (string key in Paths.paths.Keys) { string currentPath = bfgpath + "/" + key; Directory.CreateDirectory(currentPath); Directory.SetCurrentDirectory(currentPath); if (key.Equals("maps/game")) { File.WriteAllText(currentPath + "/erebus3.map", Resources.erebus3); File.WriteAllText(currentPath + "/erebus4.map", Resources.erebus4); File.WriteAllText(currentPath + "/phobos2.map", Resources.phobos2); continue; } if (Paths.paths[key][0].EndsWith(".gui")) { exporter.extractFiles(Paths.paths[key][0], "guis", currentPath, scaling); continue; } foreach (string path in Paths.paths[key]) { exporter.extractFiles(path, key, currentPath, scaling); } } }); return(true); }
void Client_DownloadFileCompleted(object sender, AsyncCompletedEventArgs e) { if (e.Cancelled) { this.toolStripStatusLabel1.Text = Properties.Resources.Downloadcanceled; resetUI(); } else if (e.Error != null) { this.toolStripProgressBar1.Visible = false; this.toolStripStatusLabel1.Text = e.Error.Message; resetUI(); } else { string fileName = e.UserState.ToString(); if (fileName.StartsWith(DICTIONARY_FOLDER)) { FileExtractor.ExtractCompressedFile(fileName.Substring(DICTIONARY_FOLDER.Length), Path.Combine(baseDir, DICTIONARY_FOLDER)); } else { FileExtractor.ExtractCompressedFile(fileName.Substring(TESS_DATA.Length), Path.Combine(baseDir, TESS_DATA)); numberOfDownloads++; } if (--numOfConcurrentTasks <= 0) { this.toolStripStatusLabel1.Text = Properties.Resources.Downloadcompleted; this.toolStripProgressBar1.Visible = false; resetUI(); } } }
public static void ExportBinary(PackedFile CurrentPackedFile, string _exportDirectory) { string extractTo = null; // TODO: Add support for ModManager //extractTo = ModManager.Instance.CurrentModSet ? ModManager.Instance.CurrentModDirectory : null; if (extractTo == null) { DirectoryDialog dialog = new DirectoryDialog { Description = "Please point to folder to extract to", SelectedPath = String.IsNullOrEmpty(_exportDirectory) ? System.IO.Path.GetDirectoryName(System.Diagnostics.Process.GetCurrentProcess().MainModule.FileName) : _exportDirectory }; extractTo = dialog.ShowDialog() == System.Windows.Forms.DialogResult.OK ? dialog.SelectedPath : null; _exportDirectory = dialog.SelectedPath; } if (!string.IsNullOrEmpty(extractTo)) { List <PackedFile> files = new List <PackedFile>(); files.Add(CurrentPackedFile); FileExtractor extractor = new FileExtractor(extractTo); extractor.ExtractFiles(files); MessageBox.Show(string.Format("File exported as binary.")); } }
public void Extract() { const string targetPath = "e:\\temp\\gitlab"; const string filePath = "e:\\temp\\gitlab\\temp.zip"; FileExtractor.Extract(filePath, targetPath); }
private async Task Setup() { Console.WriteLine(Program.Configuration.serverCorePath); var download = await _artifactsService.Download(_artifactsService.artifacts.First().Value, Program.Configuration.serverCorePath); Console.WriteLine("UnZip - Citizen"); FileExtractor.Zip(download, Program.Configuration.serverCorePath); Console.WriteLine("Finish !"); }
private void UpdateArchive(VirtualFile f) { if (!f.IsStaged) { throw new InvalidDataException("Can't analyze an unstaged file"); } var tmp_dir = Path.Combine(_stagedRoot, Guid.NewGuid().ToString()); Utils.Status($"Extracting Archive {Path.GetFileName(f.StagedPath)}"); FileExtractor.ExtractAll(f.StagedPath, tmp_dir); Utils.Status($"Updating Archive {Path.GetFileName(f.StagedPath)}"); var entries = Directory.EnumerateFiles(tmp_dir, "*", SearchOption.AllDirectories) .Select(path => path.RelativeTo(tmp_dir)); var new_files = entries.Select(e => { var new_path = new string[f.Paths.Length + 1]; f.Paths.CopyTo(new_path, 0); new_path[f.Paths.Length] = e; var nf = new VirtualFile { Paths = new_path }; nf._stagedPath = Path.Combine(tmp_dir, e); Add(nf); return(nf); }).ToList(); // Analyze them new_files.PMap(file => { Utils.Status($"Analyzing {Path.GetFileName(file.StagedPath)}"); file.Analyze(); }); // Recurse into any archives in this archive new_files.Where(file => file.IsArchive).Do(file => UpdateArchive(file)); f.FinishedIndexing = true; if (!_isSyncing) { SyncToDisk(); } Utils.Status("Cleaning Directory"); DeleteDirectory(tmp_dir); }
public static async Task Unpack(UnpackerConfig config) { using (var initialUnpack = new InitialUnpack(config.InputUnityFile, config.WorkingDir, config.Logger)) { await initialUnpack.StartAsync(); var fileScanner = new FileScanner(config.WorkingDir, config.OutputDir, config.Logger); var scannedFiles = await fileScanner.StartAsync(); using (var fileExtractor = new FileExtractor(config.WorkingDir, scannedFiles, config.Logger)) { await fileExtractor.StartAsync(); } } }
/// <summary> /// We bundle the cef libs inside the .exe, we need to extract them before loading any wpf code that requires them /// </summary> private static async Task ExtractLibs() { if (File.Exists("cefglue.7z") && File.Exists("libcef.dll")) { return; } using (var fs = File.OpenWrite("cefglue.7z")) using (var rs = Assembly.GetExecutingAssembly().GetManifestResourceStream("Wabbajack.Lib.LibCefHelpers.cefglue.7z")) { rs.CopyTo(fs); Utils.Log("Extracting libCef files"); } using (var wq = new WorkQueue(1)) { await FileExtractor.ExtractAll(wq, "cefglue.7z", "."); } }
/// <summary> /// We bundle the cef libs inside the .exe, we need to extract them before loading any wpf code that requires them /// </summary> private static void ExtractLibs() { if (File.Exists("cefsharp.7z") && File.Exists("libcef.dll")) { return; } using (var fs = File.Open("cefsharp.7z", System.IO.FileMode.Create)) using (var rs = Assembly.GetExecutingAssembly().GetManifestResourceStream("Wabbajack.Lib.LibCefHelpers.cefsharp.7z")) { rs.CopyTo(fs); Utils.Log("Extracting libCef files"); } using (var wq = new WorkQueue(1)) { FileExtractor.ExtractAll(wq, "cefsharp.7z", ".").Wait(); } }
private void btnBegin_Click(object sender, EventArgs e) { if (btnBegin.Text == "Cancel") { Log("User cancelled process...stopping as soon as possible"); FileExtractor.CancelAsync(); btnBegin.Enabled = false; return; } if (!inputFiles.Any()) { return; } EnableDisable(false); btnConverter.Visible = false; btnBegin.Text = "Cancel"; toolTip1.SetToolTip(btnBegin, "Click to cancel extracting process"); FileExtractor.RunWorkerAsync(); }
public async Task ExtractFiles_WithManifestItemsInContentDirectory_ReturnsFiles() { var zip = new Mock <IZip>(); var content = Encoding.ASCII.GetBytes("test"); var manifestItems = new[] { new ManifestItem(string.Empty, "chapter1.xml", string.Empty, ContentType.Unknown), }; var opf = await XmlStructureFile.LoadFromTextAsync("content/opf.opf", "<Doc />"); zip.Setup(x => x.GetFileContent("content/chapter1.xml")).Returns(content); var testee = new FileExtractor(); var result = (await testee.ExtractFiles(opf, manifestItems, zip.Object)).Single(); Assert.AreEqual(content, result.Content); Assert.AreEqual("chapter1.xml", result.Name); Assert.AreEqual("content/chapter1.xml", result.Path); }
private IFileSystemItemModel CreateFileSystemTreeItemModel(IFileSystemItemModel parentFileSystemItem, FileSystemInfo pathInfo) { IFileSystemItemModel fileSystemTreeElement = parentFileSystemItem.CreateModel(); fileSystemTreeElement.ParentFileSystemItem = parentFileSystemItem; fileSystemTreeElement.Info = pathInfo; fileSystemTreeElement.DisplayName = pathInfo.Name; fileSystemTreeElement.IsDirectory = pathInfo is DirectoryInfo; fileSystemTreeElement.IsArchive = !fileSystemTreeElement.IsDirectory && FileExtractor.FileIsArchive(fileSystemTreeElement.Info as FileInfo); fileSystemTreeElement.IsSystem = pathInfo.Attributes.HasFlag(FileAttributes.System); fileSystemTreeElement.IsHidden = pathInfo.Attributes.HasFlag(FileAttributes.Hidden); fileSystemTreeElement.IsDrive = pathInfo is DirectoryInfo directoryInfo && directoryInfo.Root.FullName.Equals( directoryInfo.FullName, StringComparison.OrdinalIgnoreCase); return(fileSystemTreeElement); }
private async Task DownloadAndInstall(string url, string filename, string mod_name = null) { var src = Path.Combine(DOWNLOAD_FOLDER, filename); if (!File.Exists(src)) { var state = DownloadDispatcher.ResolveArchive(url); await state.Download(new Archive { Name = "Unknown" }, src); } if (!Directory.Exists(utils.DownloadsFolder)) { Directory.CreateDirectory(utils.DownloadsFolder); } await Utils.CopyFileAsync(src, Path.Combine(utils.DownloadsFolder, filename)); await FileExtractor.ExtractAll(Queue, src, mod_name == null?utils.MO2Folder : Path.Combine(utils.ModsFolder, mod_name)); }
private async Task <(string Download, string ModFolder)> DownloadAndInstall(Game game, int modid, string mod_name) { utils.AddMod(mod_name); var client = await NexusApiClient.Get(); var resp = await client.GetModFiles(game, modid); var file = resp.files.FirstOrDefault(f => f.is_primary) ?? resp.files.FirstOrDefault(f => !string.IsNullOrEmpty(f.category_name)); var src = Path.Combine(DOWNLOAD_FOLDER, file.file_name); var ini = string.Join("\n", new List <string> { "[General]", $"gameName={game.MetaData().MO2ArchiveName}", $"modID={modid}", $"fileID={file.file_id}" }); if (!File.Exists(src)) { var state = (AbstractDownloadState)await DownloadDispatcher.ResolveArchive(ini.LoadIniString()); await state.Download(src); } if (!Directory.Exists(utils.DownloadsFolder)) { Directory.CreateDirectory(utils.DownloadsFolder); } var dest = Path.Combine(utils.DownloadsFolder, file.file_name); await Utils.CopyFileAsync(src, dest); var modFolder = Path.Combine(utils.ModsFolder, mod_name); await FileExtractor.ExtractAll(Queue, src, modFolder); File.WriteAllText(dest + Consts.MetaFileExtension, ini); return(dest, modFolder); }
private void CreateChildItems(int remainingFileSystemTreeEnumerationLevelCount, ref List <FileSystemTreeElement> lazyChildren) { foreach (FileSystemInfo fileSystemTreeChildInfo in (this.ElementInfo as DirectoryInfo).EnumerateFileSystemInfos( "*", SearchOption.TopDirectoryOnly)) { if (fileSystemTreeChildInfo is DirectoryInfo subdirectoryInfo) { var childDirectoryElement = new FileSystemTreeElement(this.RootFileSystemTreeElement, this, subdirectoryInfo) { HasLazyChildren = remainingFileSystemTreeEnumerationLevelCount.Equals(0) }; Application.Current.Dispatcher.Invoke( () => this.ChildFileSystemTreeElements.Add(childDirectoryElement), DispatcherPriority.Send); if (childDirectoryElement.HasLazyChildren) { lazyChildren.Add(childDirectoryElement); } else { childDirectoryElement.ReadFolderStructure(remainingFileSystemTreeEnumerationLevelCount, ref lazyChildren); } } else if (fileSystemTreeChildInfo is FileInfo fileInfo) { var fileIsArchive = FileExtractor.FileIsArchive(fileInfo); var childFileElement = new FileSystemTreeElement(this.RootFileSystemTreeElement, this, fileInfo) { IsArchive = fileIsArchive }; Application.Current.Dispatcher.Invoke( () => this.ChildFileSystemTreeElements.Add(childFileElement), DispatcherPriority.Send); } } }
static void Main(string[] args) { Console.WriteLine("Hello."); var extractor = new FileExtractor(new FileSystem()); var weather = new WeatherData(); var manager = new WeatherDataManager(extractor, weather); Console.WriteLine($"Processing the file '{AppConstants.FullFileName}'."); try { var result = manager.GetDayWithLeastChange(AppConstants.FullFileName); Console.WriteLine($"The result is: {result}."); } catch (Exception exception) { Console.WriteLine($"The application threw the following exception: {exception.Message}."); } Console.WriteLine("I hoped you enjoyed it!"); }
private void ExecuteViewFile(object sender, ExecutedRoutedEventArgs e) { if (!(e.OriginalSource is FrameworkElement frameworkElement)) { return; } if (!(frameworkElement.DataContext is FileSystemTreeElement fileSystemTreeElement) || fileSystemTreeElement.IsDirectory) { return; } // If file is a compressed archive, then try to extract to temp folder and open the destination folder ... if (FileExtractor.FileIsArchive(fileSystemTreeElement.ElementInfo as FileInfo)) { this.ExplorerViewModel.ExtractArchive(fileSystemTreeElement).ConfigureAwait(true); return; } // ... or just open the document if it's no archive but file throw new NotImplementedException(); }
private void AddFilePathInfoToExplorerTree([NotNull] FileSystemInfo pathInfo, bool isRootFolderExpanded) { var fileSystemTreeElement = new FileSystemTreeElement( this.VirtualExplorerRootDirectory, this.VirtualExplorerRootDirectory, pathInfo); fileSystemTreeElement.IsArchive = !fileSystemTreeElement.IsDirectory && FileExtractor.FileIsArchive(fileSystemTreeElement.ElementInfo as FileInfo); fileSystemTreeElement.IsSystemDirectory = DriveInfo.GetDrives().Any((driveInfo) => driveInfo.RootDirectory.FullName.Equals(fileSystemTreeElement.ElementInfo.FullName, StringComparison.OrdinalIgnoreCase)); if (fileSystemTreeElement.IsDirectory || fileSystemTreeElement.IsArchive) { List <FileSystemTreeElement> lazyFileSystemElements = fileSystemTreeElement.InitializeWithLazyTreeStructure(); // Observe top level tree directories 'IsExpanded' to show/ hide drag drop hint accordingly ObserveTopLevelDirectoryIsExpanded(fileSystemTreeElement); // Observe lazy children if (fileSystemTreeElement.IsLazyLoading) { ObserveVirtualDirectories(lazyFileSystemElements); fileSystemTreeElement.IsExpanded = isRootFolderExpanded && !fileSystemTreeElement.IsArchive; } } // Validate state including the new item that to this point is still not added to the tree UpdateFileSystemElementTreeState(fileSystemTreeElement); Application.Current.Dispatcher.Invoke( () => { FilterFileSystemTree(fileSystemTreeElement); this.VirtualExplorerRootDirectory.ChildFileSystemTreeElements.Add(fileSystemTreeElement); }, DispatcherPriority.Send); }
private void ExportData(object sender, EventArgs e) { string extractTo = ModManager.Instance.CurrentModSet ? ModManager.Instance.CurrentModDirectory : null; if (extractTo == null) { DirectoryDialog dialog = new DirectoryDialog { Description = "Please point to folder to extract to", SelectedPath = Settings.Default.LastPackDirectory }; extractTo = dialog.ShowDialog() == DialogResult.OK ? dialog.SelectedPath : null; } if (!string.IsNullOrEmpty(extractTo)) { List <PackedFile> files = new List <PackedFile>(); files.Add(CurrentPackedFile); FileExtractor extractor = new FileExtractor(null, null, extractTo) { Preprocessor = new TsvExtractionPreprocessor() }; extractor.ExtractFiles(files); MessageBox.Show(string.Format("File exported to TSV.")); } }
public FileExtractorTests() { _fileSystem = Substitute.For <IFileSystem>(); _fileExtractor = new FileExtractor(_fileSystem); }
public async Task ExtractModlist() { ExtractedModListFiles = await FileExtractor.ExtractAll(Queue, ModListArchive); }
[InlineData(Game.Fallout4, 43474)] // EM 2 Rifle public async Task BSACompressionRecompression(Game game, int modid) { var filename = await DownloadMod(game, modid); var folder = _bsaFolder.Combine(game.ToString(), modid.ToString()); await folder.DeleteDirectory(); folder.CreateDirectory(); await using var files = await FileExtractor.ExtractAll(Queue, filename); await files.MoveAllTo(folder); foreach (var bsa in folder.EnumerateFiles().Where(f => Consts.SupportedBSAs.Contains(f.Extension))) { TestContext.WriteLine($"From {bsa}"); TestContext.WriteLine("Cleaning Output Dir"); await _tempDir.DeleteDirectory(); _tempDir.CreateDirectory(); TestContext.WriteLine($"Reading {bsa}"); var tempFile = ((RelativePath)"tmp.bsa").RelativeToEntryPoint(); var size = bsa.Size; await using var a = BSADispatch.OpenRead(bsa); await a.Files.PMap(Queue, file => { var absName = _tempDir.Combine(file.Path); ViaJson(file.State); absName.Parent.CreateDirectory(); using (var fs = absName.Create()) { file.CopyDataTo(fs); } Assert.Equal(file.Size, absName.Size); }); // Check Files should be case insensitive Assert.Equal(a.Files.Count(), a.Files.Select(f => f.Path).ToHashSet().Count); Assert.Equal(a.Files.Count(), a.Files.Select(f => f.Path.ToString().ToLowerInvariant()).ToHashSet().Count); TestContext.WriteLine($"Building {bsa}"); await using (var w = ViaJson(a.State).MakeBuilder(size)) { var streams = await a.Files.PMap(Queue, async file => { var absPath = _tempDir.Combine(file.Path); var str = absPath.OpenRead(); await w.AddFile(ViaJson(file.State), str); return(str); }); await w.Build(tempFile); streams.Do(s => s.Dispose()); } TestContext.WriteLine($"Verifying {bsa}"); await using var b = BSADispatch.OpenRead(tempFile); TestContext.WriteLine($"Performing A/B tests on {bsa}"); Assert.Equal(a.State.ToJson(), b.State.ToJson()); // Check same number of files Assert.Equal(a.Files.Count(), b.Files.Count()); await a.Files.Zip(b.Files, (ai, bi) => (ai, bi)) .PMap(Queue, pair => { Assert.Equal(pair.ai.State.ToJson(), pair.bi.State.ToJson()); //Console.WriteLine($" - {pair.ai.Path}"); Assert.Equal(pair.ai.Path, pair.bi.Path); //Equal(pair.ai.Compressed, pair.bi.Compressed); Assert.Equal(pair.ai.Size, pair.bi.Size); Assert.Equal(GetData(pair.ai), GetData(pair.bi)); }); } }
private void Init() { context.InstInfo.InstallPath = context.ConvertPath(context.InstInfo.InstallPath); context.Files.ForEach(x => x.Path = context.ConvertPath(x.Key)); context.UninstallData = new UninstallData() { UninstallKey = context.AppInfo.AppName, InstallPath = context.InstInfo.InstallPath, AppName = context.AppInfo.FullName, Shortcuts = new List <string>() }; var index = 0; var fileExtractor = new FileExtractor(); fileExtractor.SetContext(context, process); commands.Add(new Cmd() { Index = index++, Command = fileExtractor }); var shortcutCreator = new ShortcutCreator(); shortcutCreator.SetContext(context, process); commands.Add(new Cmd() { Index = index++, Command = shortcutCreator }); foreach (var cmdInfo in context.Commands) { cmdInfo.ArgList = cmdInfo.ArgList?.Select(x => context.ConvertPath(context.ConvertVars(x))).ToArray() ?? new string[0]; var cmd = BaseCommand.GetCommand(cmdInfo.Target); if (cmd != null) { cmd.SetContext(context, process, cmdInfo.Name, cmdInfo.ArgList); commands.Add(new Cmd() { Index = index++, Command = cmd }); } else { commands.Add(new Cmd() { Index = index++, CmdInfo = cmdInfo }); } } var uninsCreator = new UninsCreator(); uninsCreator.SetContext(context, process); commands.Add(new Cmd() { Index = index++, Command = uninsCreator }); var registerEditor = new RegisterEditor(); registerEditor.SetContext(context, process); commands.Add(new Cmd() { Index = index++, Command = registerEditor }); process?.SetMaxValue(GetProcessValue(), ValueMin); }