public Runner(ISemanticVersioning versioning, IPackageReader reader, INuGetFactory nugetFactory, IArguments arguments)
{
_versioning = versioning;
_nugetFactory = nugetFactory;
_packageReader = reader;
_arguments = arguments;
}
static Extract()
{
_texReader = TexReader.Default;
_texJsonInfoGenerator = new TexJsonInfoGenerator();
_texToImageConverter = new TexToImageConverter();
_packageReader = new PackageReader();
}
public PhotoProcessor(IArchiveParser archiveParser,
IPackageReader packageReader,
IIdentifierProvider identifierProvider,
IPhotoResizer photoResizer,
IPhotoStorage photoStorage)
{
this.archiveParser = archiveParser;
this.packageReader = packageReader;
this.identifierProvider = identifierProvider;
this.photoResizer = photoResizer;
this.photoStorage = photoStorage;
}
static Extract()
{
var texHeaderReader = new TexHeaderReader();
var texMipmapDecompressor = new TexMipmapDecompressor();
var texMipmapReader = new TexMipmapReader(texMipmapDecompressor);
var texMipmapContainerReader = new TexMipmapContainerReader(texMipmapReader);
_texReader = new TexReader(texHeaderReader, texMipmapContainerReader);
_texJsonInfoGenerator = new TexJsonInfoGenerator();
_packageReader = new PackageReader();
}
private static Yield Create_Helper(Plug dekiApi, int relto, string reltopath, IPackageReader packager, Result<ImportManager> result) {
Result<XDoc> manifestResult;
yield return manifestResult = packager.ReadManifest(new Result<XDoc>());
Result<Importer> importerResult;
if(string.IsNullOrEmpty(reltopath)) {
yield return importerResult = Importer.CreateAsync(dekiApi, manifestResult.Value, relto, new Result<Importer>());
} else {
yield return importerResult = Importer.CreateAsync(dekiApi, manifestResult.Value, reltopath, new Result<Importer>());
}
result.Return(new ImportManager(importerResult.Value, packager));
yield break;
}
/// <summary>
/// Initializes a new instance of the <see cref="OpenDocumentImporter"/> class.
/// </summary>
public OpenDocumentImporter(IPackageReader packageReader)
{
_packageReader = packageReader;
_importError = new List <AODLWarning>();
_supportedExtensions = new List <DocumentSupportInfo>
{
new DocumentSupportInfo(".odt", DocumentTypes.TextDocument),
new DocumentSupportInfo(".ods", DocumentTypes.SpreadsheetDocument)
};
_author = "Lars Behrmann, [email protected]";
_infoUrl = "http://AODL.OpenDocument4all.com";
_description = "This the standard importer of the OpenDocument library AODL.";
}
public PackageManifest GetManifest(PackageKey key, NuGet.Frameworks.NuGetFramework projectFramework)
{
if (key.Framework != null)
{
var fullPath = Path.Combine(RootPath, key.GetFileName());
if (!File.Exists(fullPath))
{
throw new FileNotFoundException("package not found");
}
using (IPackageReader reader = _packageReaderFactory.Get(RepositoryType.Pundit, File.OpenRead(fullPath)))
return(reader.ReadManifest());
}
// From here on, we resolve packages that come from a NuGet package and therefore, have no FW
var filePattern = key.GetNoFrameworkFileName();
var results = new DirectoryInfo(RootPath).GetFiles(filePattern).ToArray();
if (results.Length == 0)
{
return(null);
}
var matches = 0;
foreach (var info in results)
{
var tempKey = PackageExtensions.GetPackageKeyFromFileName(info.Name);
var nearestFw = NuGet.Frameworks.NuGetFrameworkUtility.GetNearest(new[] { new FakedFrameworkGroup(tempKey.Framework) }, projectFramework);
if (nearestFw.TargetFramework.GetShortFolderName() == tempKey.Framework)
{
matches++;
}
}
if (matches != 1)
{
throw new NotSupportedException("Error, 0 or more than 1 package found matching the framework.");
}
using (IPackageReader reader = _packageReaderFactory.Get(RepositoryType.Pundit, File.OpenRead(results[0].FullName)))
return(reader.ReadManifest());
}
public static Result<ImportManager> CreateAsync(Plug dekiApi, string reltopath, IPackageReader packager, Result<ImportManager> result) {
return Coroutine.Invoke(Create_Helper, dekiApi, 0, reltopath, packager, result);
}
public static Result<ImportManager> CreateAsync(Plug dekiApi, int relto, IPackageReader packager, Result<ImportManager> result) {
return Coroutine.Invoke(Create_Helper, dekiApi, relto, (string)null, packager, result);
}
private static Yield Create_Helper(Plug dekiApi, int relto, string reltopath, IPackageReader packager, Result <ImportManager> result)
{
Result <XDoc> manifestResult;
yield return(manifestResult = packager.ReadManifest(new Result <XDoc>()));
Result <Importer> importerResult;
if (string.IsNullOrEmpty(reltopath))
{
yield return(importerResult = Importer.CreateAsync(dekiApi, manifestResult.Value, relto, new Result <Importer>()));
}
else
{
yield return(importerResult = Importer.CreateAsync(dekiApi, manifestResult.Value, reltopath, new Result <Importer>()));
}
result.Return(new ImportManager(importerResult.Value, packager));
yield break;
}
public static Result <ImportManager> CreateAsync(Plug dekiApi, string reltopath, IPackageReader packager, Result <ImportManager> result)
{
return(Coroutine.Invoke(Create_Helper, dekiApi, 0, reltopath, packager, result));
}
//--- Constructors ---
public ImportManager(Importer importer, IPackageReader packager)
{
MaxRetries = DEFAULT_RETRIES;
_importer = importer;
_packager = packager;
}
protected override void EstablishContext()
{
packageReader = new EdFiPackageReader(null);
}
static Info()
{
_reader = new PackageReader();
}
/// <summary>
/// Constructs package reader object
/// </summary>
/// <param name="reader">Reader to use when reading package (will use default if null)</param>
/// <param name="fileIO">Writer to use when reading package (will use default if null)</param>
public PackageController(IPackageReader reader = null, IFileIO fileIO = null)
{
this.reader = reader ?? new PackageReader();
this.fileIO = fileIO ?? new FileIO();
}
public PackageReaderFile(string path, IPackageReader packageReader)
{
_path = path;
_packageReader = packageReader;
}
//--- Constructors ---
public ImportManager(Importer importer, IPackageReader packager) {
MaxRetries = DEFAULT_RETRIES;
_importer = importer;
_packager = packager;
}
public static Result <ImportManager> CreateAsync(Plug dekiApi, int relto, IPackageReader packager, Result <ImportManager> result)
{
return(Coroutine.Invoke(Create_Helper, dekiApi, relto, (string)null, packager, result));
}
