/// <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 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);
}
}
/// <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);
}
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_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;
}
/// <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);
}
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();
}
/// <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);
}
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(this RarArchiveEntry entry, string destinationPath,
ExtractOptions options = ExtractOptions.Overwrite)
{
entry.WriteToDirectory(destinationPath, new NullRarExtractionListener(), options);
}
/// <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();
}
