/// <summary> /// Extract to specific directory, retaining filename /// </summary> public static void WriteToDirectory(this RarArchiveEntry entry, string destinationDirectory, IRarExtractionListener listener, ExtractOptions options = ExtractOptions.Overwrite) { string destinationFileName = string.Empty; string file = Path.GetFileName(entry.FilePath); if (options.HasFlag(ExtractOptions.ExtractFullPath)) { string folder = Path.GetDirectoryName(entry.FilePath); destinationDirectory = Path.Combine(destinationDirectory, folder); destinationFileName = Path.Combine(destinationDirectory, file); } else { destinationFileName = Path.Combine(destinationDirectory, file); } if (!Directory.Exists(destinationDirectory)) { Directory.CreateDirectory(destinationDirectory); } entry.WriteToFile(destinationFileName, listener, options); }
/// <summary> /// Extract to specific directory, retaining filename /// </summary> public static void WriteToDirectory(this IArchiveEntry entry, string destinationDirectory, ExtractOptions options = ExtractOptions.Overwrite) { string destinationFileName; string file = Path.GetFileName(entry.Key); if (options.HasFlag(ExtractOptions.ExtractFullPath)) { string folder = Path.GetDirectoryName(entry.Key); string destdir = Path.Combine(destinationDirectory, folder); if (!Directory.Exists(destdir)) { Directory.CreateDirectory(destdir); } destinationFileName = Path.Combine(destdir, file); } else { destinationFileName = Path.Combine(destinationDirectory, file); } if (!entry.IsDirectory) { entry.WriteToFile(destinationFileName, options); } }
/// <summary> /// Extract to specific directory, retaining filename /// </summary> public static void WriteEntryToDirectory(this IReader reader, string destinationDirectory, ExtractOptions options = ExtractOptions.Overwrite) { string destinationFileName = string.Empty; string file = Path.GetFileName(reader.Entry.Key); if (options.HasFlag(ExtractOptions.ExtractFullPath)) { string folder = Path.GetDirectoryName(reader.Entry.Key); string destdir = Path.Combine(destinationDirectory, folder); if (!Directory.Exists(destdir)) { Directory.CreateDirectory(destdir); } destinationFileName = Path.Combine(destdir, file); } else { destinationFileName = Path.Combine(destinationDirectory, file); } if (!reader.Entry.IsDirectory) { reader.WriteEntryToFile(destinationFileName, options); } else if (options.HasFlag(ExtractOptions.ExtractFullPath) && !Directory.Exists(destinationFileName)) { Directory.CreateDirectory(destinationFileName); } }
/// <summary> /// Extract to specific directory, retaining filename /// </summary> public static void WriteToDirectory(this IArchive archive, string destinationDirectory, ExtractOptions options = ExtractOptions.Overwrite) { foreach (IArchiveEntry entry in archive.Entries.Where(x => !x.IsDirectory)) { entry.WriteToDirectory(destinationDirectory, options); } }
/// <summary> /// Extract all remaining unread entries to specific directory, retaining filename /// </summary> public static void WriteAllToDirectory(this IReader reader, string destinationDirectory, ExtractOptions options = ExtractOptions.Overwrite) { while (reader.MoveToNextEntry()) { reader.WriteEntryToDirectory(destinationDirectory, options); } }
/// <summary> /// Extract to specific file /// </summary> public static void WriteToFile(this IArchiveEntry entry, string destinationFileName, ExtractOptions options = ExtractOptions.Overwrite) { if (entry.IsDirectory) { return; } FileMode fm = FileMode.Create; if (!options_HasFlag(options,ExtractOptions.Overwrite)) { fm = FileMode.CreateNew; } using (FileStream fs = File.Open(destinationFileName, fm)) { //entry.WriteTo(fs); IArchiveEntryExtensions.WriteTo(entry, fs); } if (options_HasFlag(options,ExtractOptions.PreserveFileTime) || options_HasFlag(options,ExtractOptions.PreserveAttributes)) { // update file time to original packed time FileInfo nf = new FileInfo(destinationFileName); if (nf.Exists) { if (options_HasFlag(options,ExtractOptions.PreserveAttributes)) { if (entry.CreatedTime.HasValue) { nf.CreationTime = entry.CreatedTime.Value; } if (entry.LastModifiedTime.HasValue) { nf.LastWriteTime = entry.LastModifiedTime.Value; } if (entry.LastAccessedTime.HasValue) { nf.LastAccessTime = entry.CreatedTime.Value; } } if (options_HasFlag(options,ExtractOptions.PreserveAttributes)) { if (entry.Attrib.HasValue) { nf.Attributes = (FileAttributes)System.Enum.ToObject(typeof(FileAttributes), entry.Attrib.Value); } } } } }
/// <summary> /// Extract to specific file /// </summary> public static void WriteEntryToFile(this RarReader reader, string destinationFileName, ExtractOptions options = ExtractOptions.Overwrite) { FileMode fm = FileMode.Create; if (!options.HasFlag(ExtractOptions.Overwrite)) { fm = FileMode.CreateNew; } using (FileStream fs = File.Open(destinationFileName, fm)) { reader.WriteEntryTo(fs); } }
/// <summary> /// Extract to specific file /// </summary> public static void WriteToFile(this RarArchiveEntry entry, string destinationFileName, IRarExtractionListener listener, ExtractOptions options = ExtractOptions.Overwrite) { FileMode fm = FileMode.Create; if (!options.HasFlag(ExtractOptions.Overwrite)) { fm = FileMode.CreateNew; } using (FileStream fs = File.Open(destinationFileName, fm)) { entry.WriteTo(fs, listener); } }
/// <summary> /// Extract to specific file /// </summary> public static void WriteToFile(this IArchiveEntry entry, string destinationFileName, ExtractOptions options = ExtractOptions.Overwrite) { FileMode fm = FileMode.Create; if (!options.HasFlag(ExtractOptions.Overwrite)) { fm = FileMode.CreateNew; } using (FileStream fs = File.Open(destinationFileName, fm)) { entry.WriteTo(fs); } entry.PreserveExtractionOptions(destinationFileName, options); }
/// <summary> /// Extract to specific file /// </summary> public static void WriteEntryToFile(this IReader reader, string destinationFileName, ExtractOptions options = ExtractOptions.Overwrite) { FileMode fm = FileMode.Create; if (!options.HasFlag(ExtractOptions.Overwrite)) { fm = FileMode.CreateNew; } using (FileStream fs = File.Open(destinationFileName, fm)) { reader.WriteEntryTo(fs); //using (Stream s = reader.OpenEntryStream()) //{ // s.TransferTo(fs); //} } }
/// <summary> /// Extract to specific file /// </summary> public static void WriteToFile(this IArchiveEntry entry, string destinationFileName, ExtractOptions options = ExtractOptions.Overwrite) { if (entry.IsDirectory) { return; } FileMode fm = FileMode.Create; if (!options.HasFlag(ExtractOptions.Overwrite)) { fm = FileMode.CreateNew; } using (FileStream fs = File.Open(destinationFileName, fm)) { entry.WriteTo(fs); } }
public void ExtractData( [Parameter("Path to the generated data extract file")] string dataFile, [Parameter("Path to the extract log file; if not specified, defaults to same path " + "and name as extract file.", DefaultValue = null)] string logFile, [Parameter("The scenario to include in the extract")] string scenario, [Parameter("The year to include in the extract")] string year, [Parameter("The period(s) to include in the extract", Alias = "Period")] IEnumerable <string> periods, [Parameter("The entities to include in the extract", Alias = "Entity")] IEnumerable <string> entities, [Parameter("The accounts to include in the extract", Alias = "Account")] IEnumerable <string> accounts, ExtractOptions options, Metadata metadata) { options["Scenario"] = metadata["Scenario"].GetId(scenario); options["Year"] = metadata["Year"].GetId(year); var entityList = metadata["Entity"].GetMembers(entities); options["Entity Subset"] = entityList.MemberIds; options["Parent Subset"] = entityList.ParentIds; options["Period Subset"] = metadata["Period"].GetMembers(periods).MemberIds; options["Account Subset"] = metadata["Account"].GetMembers(accounts).MemberIds; if (logFile == null || logFile == "") { logFile = Path.ChangeExtension(dataFile, ".log"); } // Ensure dataFile and logFile are writeable locations FileUtilities.EnsureFileWriteable(dataFile); FileUtilities.EnsureFileWriteable(logFile); HFM.Try("Extracting data", () => HsvcDataLoad.Extract(dataFile, logFile)); }
public ValidateLocalizableExtractor(ExtractOptions options) { _repository = options.SourceDirectory; _extractorMode = options.ExtractorMode; switch (options.ExtractorMode) { case ExtractorMode.Commit: _extractorParameter = options.CommitSha; break; case ExtractorMode.TagName: _extractorParameter = options.TagName; break; default: _extractorParameter = string.Empty; break; } }
private void DoExtract(object o) { DisableButton(); ExtractOptions options = (ExtractOptions)o; SetProgressBarSettings(0, 100, 1, ProgressBarStyle.Marquee); SetText("Opening packfile..."); using (Stream stream = File.OpenRead(options.Source)) { var packfile = Packfile.FromStream(stream, Path.GetExtension(options.Source) == ".str2_pc"); string filename = Path.GetFileName(options.Source); string outputDir = Path.Combine(options.Destination, filename); if (File.Exists(outputDir)) { outputDir = Path.Combine(options.Destination, "extracted-" + filename); } Directory.CreateDirectory(outputDir); SetProgressBarSettings(0, packfile.Files.Count, 1, ProgressBarStyle.Continuous); SetText("Extracting {0}...", filename); foreach (IPackfileEntry entry in packfile.Files) { using (Stream outputStream = File.Create(Path.Combine(outputDir, entry.Name))) { using (Stream inputStream = entry.GetStream()) { inputStream.CopyTo(outputStream); } outputStream.Flush(); } Step(); } } SetText("Finished!"); EnableButton(); }
public void ExtractApiTest_UnsupportedFormat() { var testFile = TestFiles.Json; var options = new ExtractOptions { FileInfo = testFile.ToFileInfo(), SearchCriteria = new SearchCriteria { TagOptions = new TagOptions { PossibleName = "Tag" } } }; var request = new ExtractRequest(options); var ex = Assert.Throws <ApiException>(() => { MetadataApi.Extract(request); }); Assert.AreEqual($"The specified file '{testFile.FullName}' has type which is not currently supported.", ex.Message); }
public static void Run() { var configuration = new Configuration(Common.MyAppSid, Common.MyAppKey); var apiInstance = new MetadataApi(configuration); try { var fileInfo = new FileInfo { FilePath = "documents/input.docx", StorageName = Common.MyStorage }; var options = new ExtractOptions { FileInfo = fileInfo }; var request = new ExtractRequest(options); var response = apiInstance.Extract(request); foreach (var property in response.MetadataTree.InnerPackages[0].PackageProperties) { Console.WriteLine($"Property: {property.Name}. Value: {property.Value}"); if (property.Tags == null) { continue; } foreach (var tag in property.Tags) { Console.WriteLine($"Property tag: {tag.Category} {tag.Name} "); } } } catch (Exception e) { Console.WriteLine("Exception while calling MetadataApi: " + e.Message); } }
private void ExtractPbp(string srcPbp, ProcessOptions processOptions, CancellationToken cancellationToken) { var info = new ExtractOptions() { SourcePbp = srcPbp, OutputPath = processOptions.OutputPath, DiscName = "- Disc {0}", Discs = processOptions.Discs, CreateCuesheet = true, CheckIfFileExists = processOptions.CheckIfFileExists, FileNameFormat = processOptions.FileNameFormat, GetGameInfo = (gameId) => { var game = GetGameEntry(gameId, srcPbp, false); if (game == null) { return(null); } return(new GameInfo() { GameID = game.ScannerID, GameName = game.GameName, Title = game.SaveDescription, MainGameID = game.SaveFolderName, Region = game.Format }); } }; var popstation = new Popstation.Popstation { ActionIfFileExists = _eventHandler.ActionIfFileExists, Notify = _notifier.Notify, TempFiles = tempFiles }; popstation.Extract(info, cancellationToken); }
public void ExtractLocalizableItems(ExtractOptions options) { if (CanOverwriteDirectory(options.DestinationDirectory)) { Stopwatch stopwatch = new Stopwatch(); stopwatch.Start(); var validator = new ValidateLocalizableExtractor(options); var extractor = new LocalizableItemsExtractor(options.SourceDirectory, options.DestinationDirectory, cultures, validator); Console.WriteLine("\nExtract vsix"); extractor.ExtractVsix(); Console.WriteLine("Extract project templates"); extractor.ExtractProjectTemplates(); Console.WriteLine("Extract command templates"); extractor.ExtractCommandTemplates(); Console.WriteLine("Extract template pages"); extractor.ExtractTemplatePages(); Console.WriteLine("Extract template features"); extractor.ExtractTemplateFeatures(); Console.WriteLine("Extract project types"); extractor.ExtractWtsProjectTypes(); Console.WriteLine("Extract project frameworks"); extractor.ExtractWtsFrameworks(); Console.WriteLine("Extract resources"); extractor.ExtractResourceFiles(); Console.WriteLine("End"); stopwatch.Stop(); TimeSpan ts = stopwatch.Elapsed; Console.WriteLine(string.Format("{0:00}:{1:00}:{2:00}.{3:00}", ts.Hours, ts.Minutes, ts.Seconds, ts.Milliseconds / 10)); } }
internal static void PreserveExtractionOptions(this IEntry entry, string destinationFileName, ExtractOptions options) { if (options.HasFlag(ExtractOptions.PreserveFileTime) || options.HasFlag(ExtractOptions.PreserveAttributes)) { FileInfo nf = new FileInfo(destinationFileName); if (!nf.Exists) { return; } // update file time to original packed time if (options.HasFlag(ExtractOptions.PreserveFileTime)) { if (entry.CreatedTime.HasValue) { nf.CreationTime = entry.CreatedTime.Value; } if (entry.LastModifiedTime.HasValue) { nf.LastWriteTime = entry.LastModifiedTime.Value; } if (entry.LastAccessedTime.HasValue) { nf.LastAccessTime = entry.LastAccessedTime.Value; } } if (options.HasFlag(ExtractOptions.PreserveAttributes)) { if (entry.Attrib.HasValue) { nf.Attributes = (FileAttributes)System.Enum.ToObject(typeof(FileAttributes), entry.Attrib.Value); } } } }
public void ExtractApiTest_PossibleTagName() { var options = new ExtractOptions { FileInfo = TestFiles.Docx.ToFileInfo(), SearchCriteria = new SearchCriteria { TagOptions = new TagOptions { PossibleName = "creator" } } }; var request = new ExtractRequest(options); var result = MetadataApi.Extract(request); Assert.IsNotNull(result); Assert.IsNotEmpty(result.Properties); Assert.IsTrue(result.Properties.Any(x => x.Tags.Any(t => t.Name.Contains("Creator")))); }
public void ExtractApiTest_PropertyName() { var options = new ExtractOptions { FileInfo = TestFiles.Docx.ToFileInfo(), SearchCriteria = new SearchCriteria { NameOptions = new NameOptions { Value = "Date" } } }; var request = new ExtractRequest(options); var result = MetadataApi.Extract(request); Assert.IsNotNull(result); Assert.IsNotEmpty(result.Properties); Assert.IsTrue(result.Properties.Any(x => x.Name.Contains("Date"))); }
/// <summary> /// Extract to specific directory, retaining filename /// </summary> public static void WriteToDirectory(this IArchiveEntry entry, string destinationDirectory, ExtractOptions options = ExtractOptions.Overwrite) { string destinationFileName; string file = Path.GetFileName(entry.Key); if (options.HasFlag(ExtractOptions.ExtractFullPath)) { string folder = Path.GetDirectoryName(entry.Key); string destdir = Path.Combine(destinationDirectory, folder); if (!Directory.Exists(destdir)) { Directory.CreateDirectory(destdir); } destinationFileName = Path.Combine(destdir, file); } else { destinationFileName = Path.Combine(destinationDirectory, file); } entry.WriteToFile(destinationFileName, options); }
public void ExtractApiTest_PropertyValue() { var options = new ExtractOptions { FileInfo = TestFiles.Docx.ToFileInfo(), SearchCriteria = new SearchCriteria { ValueOptions = new ValueOptions { Value = "Microsoft Office Word", Type = "String" } } }; var request = new ExtractRequest(options); var result = MetadataApi.Extract(request); Assert.IsNotNull(result); Assert.IsNotEmpty(result.Properties); Assert.IsTrue(result.Properties.Any(x => x.Name.StartsWith("NameOfApplication", StringComparison.OrdinalIgnoreCase))); }
public void ExtractMetadata( [Parameter("Path to the generated metadata extract file")] string metadataFile, [Parameter("Path to the extract log file; if not specified, defaults to same path " + "and name as extract file.", DefaultValue = null)] string logFile, ExtractOptions options) { if (logFile == null || logFile == "") { logFile = Path.ChangeExtension(metadataFile, ".log"); } // TODO: Display options etc _log.FineFormat(" Metadata file: {0}", metadataFile); _log.FineFormat(" Log file: {0}", logFile); // Ensure extractFile and logFile are writeable locations FileUtilities.EnsureFileWriteable(metadataFile); FileUtilities.EnsureFileWriteable(logFile); HFM.Try("Extracting metadata", () => HsvMetadataLoad.Extract(metadataFile, logFile)); }
private bool update_Unzip(string filename, string tagetpath) { try { ExtractOptions option = ExtractOptions.None; //option = ExtractOptions.None; //option = ExtractOptions.ExtractFullPath; var archive = ArchiveFactory.Open(filename); foreach (var entry in archive.Entries) { if (!entry.IsDirectory) { entry.WriteToDirectory(tagetpath, option | ExtractOptions.Overwrite); } } archive.Dispose(); } catch { return(false); } return(true); }
public void ExtractApiTest_IncorrectTag() { var options = new ExtractOptions { FileInfo = TestFiles.Docx.ToFileInfo(), SearchCriteria = new SearchCriteria { TagOptions = new TagOptions { ExactTag = new Tag { Name = "wrong", Category = "Wrong" } } } }; var request = new ExtractRequest(options); var ex = Assert.Throws <ApiException>(() => { MetadataApi.Extract(request); }); Assert.AreEqual("The specified tag was not found or has incorrect format.", ex.Message); }
/// <summary> /// Extract to specific directory, retaining filename /// </summary> public static void WriteEntryToDirectory(this RarReader reader, string destinationDirectory, ExtractOptions options = ExtractOptions.Overwrite) { string destinationFileName = string.Empty; string file = Path.GetFileName(reader.Entry.FilePath); if (options.HasFlag(ExtractOptions.ExtractFullPath)) { string folder = Path.GetDirectoryName(reader.Entry.FilePath); string destdir = Path.Combine(destinationDirectory, folder); if (!Directory.Exists(destdir)) { Directory.CreateDirectory(destdir); } destinationFileName = Path.Combine(destdir, file); } else { destinationFileName = Path.Combine(destinationDirectory, file); } reader.WriteEntryToFile(destinationFileName, options); }
/// <summary> /// Initializes a new instance of the <see cref="ExtractRequest"/> class. /// </summary> /// <param name="options">Extract options.</param> public ExtractRequest(ExtractOptions options) { this.options = options; }
/// <summary> /// Extract to specific file /// </summary> public static void WriteToFile(this RarArchiveEntry entry, string destinationFileName, ExtractOptions options = ExtractOptions.Overwrite) { entry.WriteToFile(destinationFileName, new NullRarExtractionListener(), options); }
/// <summary> /// Extract to specific directory, retaining filename /// </summary> public static void WriteToDirectory(this RarArchiveEntry entry, string destinationPath, ExtractOptions options = ExtractOptions.Overwrite) { entry.WriteToDirectory(destinationPath, new NullRarExtractionListener(), options); }
private static object RunAndReturnExitCode(ExtractOptions options) { try { var fileLoader = new FileLoader(options.Input); var fileType = fileLoader.GetFileType(); switch (fileType) { case FileType.TOC31_VOL: case FileType.TOC31_ISO: foreach (var(stream, fileName) in fileLoader.GetStreams()) { using (stream) { var volume = new Volume(stream); volume.ReadVolume(); var logWriter = options.Verbose ? new ConsoleWriter() : null; using (var btree = new BTree(volume, logWriter)) { // Output check if (string.IsNullOrEmpty(options.Output)) { FileAttributes attr = File.GetAttributes(options.Input); if ((attr & FileAttributes.Directory) == FileAttributes.Directory) { DirectoryInfo parentDir = Directory.GetParent(options.Input); options.Output = Path.Combine(parentDir.FullName, "extracted"); } else { var folder = Path.GetDirectoryName(options.Input); options.Output = Path.Combine(folder, "extracted"); } } Console.WriteLine($"Extracting files from {fileName}..."); btree.ExtractAllFiles(options.Output, volName: fileName, overwrite: options.Overwrite); } } } return(0); case FileType.TOC22_VOL: case FileType.TOC22_ISO: Console.WriteLine("There are other tools that can handle extraction of this type of VOLs. Please use those (for example the one made by pez2k)."); return(0); case FileType.GTPSP_VOL: case FileType.GTPSP_ISO: Console.WriteLine("Gran Turismo PSP versions aren't supported by this tool. Wait for the next one ;)"); return(0); case FileType.UNKNOWN: default: Console.WriteLine("Unknown game type."); return(0); } } catch (ArgumentException aex) { Console.WriteLine(aex.Message); return(1); } catch (InvalidFileSystemException fsex) { Console.WriteLine(fsex.Message); return(1); } catch (Exception ex) { Console.WriteLine(ex); return(1); } }
public static void WriteToDirectory(string sourceArchive, string destinationDirectory, IRarExtractionListener listener, ExtractOptions options = ExtractOptions.Overwrite) { RarArchive archive = RarArchive.Open(sourceArchive); foreach (RarArchiveEntry entry in archive.Entries) { entry.WriteToDirectory(destinationDirectory, listener, options); } }
/// <summary> /// Extract to specific directory, retaining filename /// </summary> public static void WriteToDirectory(string sourceArchive, string destinationPath, ExtractOptions options = ExtractOptions.Overwrite) { WriteToDirectory(sourceArchive, destinationPath, new NullRarExtractionListener(), options); }
public void Extract(string directory, ExtractOptions options, string password) { EnsureNotDisposed(); Archive.ExtractFile(FileName, directory, options, password); }
private static bool options_HasFlag(ExtractOptions options, ExtractOptions extractOptions) { return (options&extractOptions)==extractOptions; }
static void Main(string[] args) { var extractOptions = new ExtractOptions(); var compareOptions = new CompareOptions(); var parser = new CommandLineParser(); if (args.Length > 0) { if (args[0] == "extract") { if (parser.ParseArguments(args, extractOptions)) { extractOptions.RootDirectory = extractOptions.RootDirectory ?? Environment.CurrentDirectory; Console.Out.WriteLine(""); Console.Out.WriteLine("Extracting entries from:"); Console.Out.WriteLine("\"" + extractOptions.RootDirectory + "\""); Console.Out.WriteLine("Extensions: " + string.Join(", ", extractOptions.Extensions)); Console.Out.WriteLine("Exclude patterns: " + string.Join(", ", extractOptions.ExcludePatterns)); Console.Out.WriteLine(); Console.Out.WriteLine("Saving texts to: " + extractOptions.TargetFile); var extractor = new CStyleLanguageTextExtractor(); extractor.MarkerLanguage = extractOptions.DefaultLanguage; extractor.SourceFiles = new SourceFileList( extractOptions.RootDirectory, extractOptions.Extensions, extractOptions.ExcludePatterns).GetFiles(); var target = new XmlTextSource(); target.Put(extractor.Get().Select(x => new LocalizedTextState { Text = x, Status = LocalizedTextStatus.New }), TextMergeOptions.KeepUnused); target.Document.Save(extractOptions.TargetFile); return; } } else if (args[0] == "compare") { if (parser.ParseArguments(args, compareOptions)) { Console.WriteLine(); var texts = new TextSourceAggregator(); using (texts.BeginUpdate()) { foreach (var file in compareOptions.Files) { texts.Sources.Add(new PrioritizedTextSource(new XmlTextSource(XDocument.Load(file)), 1)); } } var comparer = new LanguageComparer(texts); var result = comparer.Compare( compareOptions.SourceLanguage, compareOptions.TargetLanguage); Console.WriteLine(result.Success ? "OK - The text(s) defines the same keys for the languages" : "The two languages differ"); Console.Out.WriteLine(); foreach (var text in result.MissingTexts) { Console.Out.WriteLine("Missing\t" + text.Key); } foreach (var text in result.UnmatchedTexts) { Console.Out.WriteLine("Unmatched\t" + text.Key); } return; } } } Console.WriteLine(); Console.WriteLine("Usage: "); Console.WriteLine(); Console.WriteLine("Localization.exe extract"); WriteHelp(extractOptions); Console.WriteLine(); Console.WriteLine("Localization.exe compare"); WriteHelp(compareOptions); Console.WriteLine(); }
private static bool options_HasFlag(ExtractOptions options, ExtractOptions extractOptions) { return((options & extractOptions) == extractOptions); }
public static void WriteToDirectory(this IArchiveEntry entry, string destinationDirectory, ExtractOptions options = 1) { string destinationFileName = string.Empty; string fileName = Path.GetFileName(entry.FilePath); if (!options.HasFlag(ExtractOptions.ExtractFullPath)) { destinationFileName = Path.Combine(destinationDirectory, fileName); } else { string directoryName = Path.GetDirectoryName(entry.FilePath); string path = Path.Combine(destinationDirectory, directoryName); if (!Directory.Exists(path)) { Directory.CreateDirectory(path); } destinationFileName = Path.Combine(path, fileName); } entry.WriteToFile(destinationFileName, options); }
private void BeginExtract(string source, string destination) { var options = new ExtractOptions(source, destination); ParameterizedThreadStart pts = new ParameterizedThreadStart(DoExtract); Thread t = new Thread(pts); t.Start(options); }
public static void WriteToFile(this IArchiveEntry entry, string destinationFileName, ExtractOptions options = 1) { if (!entry.IsDirectory) { FileMode create = FileMode.Create; if (!options.HasFlag(ExtractOptions.Overwrite)) { create = FileMode.CreateNew; } using (FileStream stream = File.Open(destinationFileName, create)) { entry.WriteTo(stream); } } }
public static int Execute(ExtractOptions opts) { Console.WriteLine("In the execute command"); return(0); }
/// <summary> /// Extract to specific directory, retaining filename /// </summary> public static void WriteToDirectory(string sourceArchive, string destinationDirectory, ExtractOptions options = ExtractOptions.Overwrite) { using (IArchive archive = Open(sourceArchive)) { foreach (IArchiveEntry entry in archive.Entries) { entry.WriteToDirectory(destinationDirectory, options); } } }
static void UnpackArchive(IAbsoluteDirectoryPath outputFolder, bool overwrite, IArchive archive, ExtractOptions options) { foreach (var p in archive.Entries.Where(entry => entry.IsDirectory) .Select(entry => outputFolder.GetChildDirectoryWithName(entry.Key))) p.MakeSurePathExists(); foreach (var entry in archive.Entries.Where(entry => !entry.IsDirectory)) { if (overwrite) options = options | ExtractOptions.Overwrite; if (!overwrite) { if (!outputFolder.GetChildFileWithName(entry.Key).Exists) entry.WriteToDirectory(outputFolder.ToString(), options); } else entry.WriteToDirectory(outputFolder.ToString(), options); } }
static void Main(string[] args) { var extractOptions = new ExtractOptions(); var compareOptions = new CompareOptions(); var parser = new CommandLineParser(); if( args.Length > 0 ) { if (args[0] == "extract") { if (parser.ParseArguments(args, extractOptions)) { extractOptions.RootDirectory = extractOptions.RootDirectory ?? Environment.CurrentDirectory; Console.Out.WriteLine(""); Console.Out.WriteLine("Extracting entries from:"); Console.Out.WriteLine("\"" + extractOptions.RootDirectory + "\""); Console.Out.WriteLine("Extensions: " + string.Join(", ", extractOptions.Extensions)); Console.Out.WriteLine("Exclude patterns: " + string.Join(", ", extractOptions.ExcludePatterns)); Console.Out.WriteLine(); Console.Out.WriteLine("Saving texts to: " + extractOptions.TargetFile); var extractor = new CStyleLanguageTextExtractor(); extractor.MarkerLanguage = extractOptions.DefaultLanguage; extractor.SourceFiles = new SourceFileList( extractOptions.RootDirectory, extractOptions.Extensions, extractOptions.ExcludePatterns).GetFiles(); var target = new XmlTextSource(); target.Put(extractor.Get().Select(x => new LocalizedTextState { Text = x, Status = LocalizedTextStatus.New }), TextMergeOptions.KeepUnused); target.Document.Save(extractOptions.TargetFile); return; } } else if (args[0] == "compare") { if (parser.ParseArguments(args, compareOptions)) { Console.WriteLine(); var texts = new TextSourceAggregator(); using (texts.BeginUpdate()) { foreach (var file in compareOptions.Files) { texts.Sources.Add(new PrioritizedTextSource(new XmlTextSource(XDocument.Load(file)), 1)); } } var comparer = new LanguageComparer(texts); var result = comparer.Compare( compareOptions.SourceLanguage, compareOptions.TargetLanguage); Console.WriteLine(result.Success ? "OK - The text(s) defines the same keys for the languages" : "The two languages differ"); Console.Out.WriteLine(); foreach (var text in result.MissingTexts) { Console.Out.WriteLine("Missing\t" + text.Key); } foreach (var text in result.UnmatchedTexts) { Console.Out.WriteLine("Unmatched\t" + text.Key); } return; } } } Console.WriteLine(); Console.WriteLine("Usage: "); Console.WriteLine(); Console.WriteLine("Localization.exe extract"); WriteHelp(extractOptions); Console.WriteLine(); Console.WriteLine("Localization.exe compare"); WriteHelp(compareOptions); Console.WriteLine(); }
public FormExtractColRegExp(DynamicColumnType type, string json, Dictionary <string, int> noteDocumentcolum) { _noteDocumentColumn = noteDocumentcolum; InitializeComponent(); formType = type; if (formType == DynamicColumnType.FreeText) { rbMultipleValues.Visible = true; chbAddToPrevious.Visible = true; } else if (formType == DynamicColumnType.DateTime) { lbFormat.Visible = true; txtFormat.Visible = true; } rbFirstInstance.Checked = true; //Create object from json if (String.IsNullOrEmpty(json)) { extractObj = new ExtractOptions(); } else { extractObj = Newtonsoft.Json.JsonConvert.DeserializeObject <ExtractOptions>(json); chbExtract.Checked = extractObj.Extract; numericOrder.Value = extractObj.Order; if (extractObj.InstanceNo == 1) { rbFirstInstance.Checked = true; } else if (extractObj.InstanceNo == 2) { rbLastInstance.Checked = true; } else if (extractObj.InstanceNo == 3) { rbNthInstance.Checked = true; numericNthInstnce.Value = (decimal)extractObj.NthInstaceNumber; } else if (extractObj.InstanceNo == 4) { rbMultipleValues.Checked = true; } if (formType == DynamicColumnType.FreeText) { chbAddToPrevious.Checked = extractObj.AddToPrevious ?? false; } else if (formType == DynamicColumnType.DateTime) { txtFormat.Text = extractObj.DateTimeFormat; } } comboDocument.Items.AddRange(_noteDocumentColumn.Keys.ToArray()); comboDocument.SelectedIndex = 0; foreach (var item in comboDocument.Items) { if (_noteDocumentColumn[item.ToString()] == extractObj.NoteTextColumn) { comboDocument.SelectedItem = item; } } UpdateEnableState(); }