public Task <int> Execute()
{
return(ConsoleTask.ExecuteAsync(this, async(console) =>
{
console.WriteLine("Connecting to innovator...");
var conn = await this.GetConnection().ConfigureAwait(false);
var processor = new InstallProcessor(conn);
console.WriteLine("Reading the install package...");
var script = default(InstallScript);
if (Path.GetExtension(InputFile) == ".innpkg")
{
using (var pkg = InnovatorPackage.Load(InputFile))
script = pkg.Read();
}
else
{
var pkg = new ManifestFolder(InputFile);
var doc = pkg.Read(out var title);
script = await processor.ConvertManifestXml(doc, title).ConfigureAwait(false);
}
console.Write("Installing package `{0}`...", script.Title);
using (var prog = console.Progress())
{
var tcs = new TaskCompletionSource <int>();
processor.ProgressChanged += (s, e) => prog.Report(e.Progress / 100.0);
processor.ErrorRaised += (s, e) =>
{
tcs.TrySetException(e.Exception);
e.RecoveryOption = RecoveryOption.Abort;
};
processor.ActionComplete += (s, e) =>
{
if (e.Exception == null)
{
tcs.TrySetResult(0);
}
else
{
tcs.TrySetException(e.Exception);
}
};
await processor.Initialize(script).ConfigureAwait(false);
processor.Install();
await tcs.Task.ConfigureAwait(false);
}
console.WriteLine("Done.");
}));
}
public Task <int> Execute()
{
return(ConsoleTask.ExecuteAsync(this, async(console) =>
{
foreach (var file in GetMatchingFiles(InputFile))
{
console.Write("Generating doc for ");
console.WriteLine(file);
var metadata = PackageMetadataProvider.FromFile(file);
var outputPath = Output.Replace("*", CleanFileName(metadata.Title));
var writer = new DocumentationWriter();
var extension = Path.GetExtension(outputPath).ToUpperInvariant().TrimStart('.');
switch (extension)
{
case "PUML":
case "TXT":
writer.Format = DiagramFormat.PlantUml;
writer.Output = DocumentOutput.Diagram;
break;
case "SVG":
case "PNG":
writer.Format = (DiagramFormat)Enum.Parse(typeof(DiagramFormat), extension, true);
writer.Output = DocumentOutput.Diagram;
break;
case "MD":
writer.Format = DiagramFormat.PlantUml;
writer.Output = DocumentOutput.Markdown;
break;
}
try
{
using (var stream = File.OpenWrite(outputPath))
await writer.WriteAsync(metadata, stream);
}
catch (Exception ex)
{
console.WriteLine("Error documenting " + file);
console.WriteLine(ex.ToString());
}
}
}));
}
public Task <int> Execute(ILogger logger)
{
return(ConsoleTask.ExecuteAsync(this, async(console) =>
{
console.WriteLine("Connecting to innovator...");
var conn = await GetConnection().ConfigureAwait(false);
console.WriteLine("Reading input...");
var stream = string.IsNullOrEmpty(InputFile) ? console.ReadInput() : new FileStream(InputFile, FileMode.Open, FileAccess.Read);
var cmd = default(Command);
if (string.IsNullOrEmpty(SoapAction))
{
var input = conn.AmlContext.FromXml(stream);
cmd = new Command(input);
if (input.Items().Count() > 1)
{
cmd.WithAction(CommandAction.ApplyAML);
}
}
else
{
cmd = new Command(stream.AsString());
}
console.WriteLine("Calling action...");
var result = (await conn.ApplyAsync(cmd, true, false).ConfigureAwait(false)).AssertNoError();
console.WriteLine("Writing output...");
using (var output = string.IsNullOrEmpty(Output) ? Console.Out : new StreamWriter(Output))
using (var xml = XmlWriter.Create(output))
{
result.ToAml(xml);
}
}, console =>
{
if (string.IsNullOrEmpty(Output))
{
console.LogWriter = string.IsNullOrEmpty(LogFile) ? null : new StreamWriter(LogFile);
}
}));
}
public Task <int> Execute()
{
return(ConsoleTask.ExecuteAsync(this, async(console) =>
{
console.WriteLine("Connecting to innovator...");
var conn = await this.GetConnection().ConfigureAwait(false);
var processor = new ExportProcessor(conn);
var refsToExport = default(List <ItemReference>);
var checkDependencies = true;
console.Write("Identifying items to export... ");
if (this.InputFile?.EndsWith(".innpkg", StringComparison.OrdinalIgnoreCase) == true ||
this.InputFile?.EndsWith(".mf", StringComparison.OrdinalIgnoreCase) == true)
{
var exportScript = InnovatorPackage.Load(this.InputFile).Read();
refsToExport = exportScript.Lines
.Where(l => l.Type == InstallType.Create)
.Select(l => l.Reference)
.Distinct()
.ToList();
}
else
{
var exportQuery = XElement.Parse("<AML><Item type='*' /></AML>");
if (!string.IsNullOrEmpty(this.InputFile))
{
exportQuery = XElement.Load(this.InputFile);
}
var firstItem = exportQuery.XPathSelectElement("//Item[1]");
if (firstItem == null)
{
throw new Exception("No item nodes could be found");
}
var items = default(IEnumerable <XElement>);
if (firstItem.Parent == null)
{
items = new[] { firstItem }
}
;
else
{
items = firstItem.Parent.Elements("Item");
}
var version = await conn.FetchVersion(true).ConfigureAwait(false);
var types = ExportAllType.Types.Where(t => t.Applies(version)).ToList();
var queries = GetQueryies(items, types).ToList();
checkDependencies = items.All(e => e.Attribute("type")?.Value != "*");
using (var prog = console.Progress())
{
var toExport = await SharedUtils.TaskPool(30, (l, m) => prog.Report(l / 100.0), queries
.Select(q =>
{
var aml = new XElement(q);
var levels = aml.Attribute("levels");
if (levels != null)
{
levels.Remove();
}
return (Func <Task <QueryAndResult> >)(() => conn.ApplyAsync(aml, true, false)
.ToTask()
.ContinueWith(t => new QueryAndResult()
{
Query = q,
Result = t.Result
}));
})
.ToArray());
refsToExport = toExport.SelectMany(r =>
{
var refs = r.Result.Items()
.Select(i => ItemReference.FromFullItem(i, true))
.ToList();
var levels = (int?)r.Query.Attribute("levels");
if (levels.HasValue)
{
foreach (var iRef in refs)
{
iRef.Levels = levels.Value;
}
}
return refs;
})
.ToList();
}
}
console.WriteLine("Done.");
var script = new InstallScript
{
ExportUri = new Uri(Url),
ExportDb = Database,
Lines = Enumerable.Empty <InstallItem>(),
Title = Title ?? System.IO.Path.GetFileNameWithoutExtension(Output),
Creator = Author ?? Username,
Website = string.IsNullOrEmpty(Website) ? null : new Uri(Website),
Description = Description,
Created = DateTime.Now,
Modified = DateTime.Now
};
console.Write("Exporting metadata... ");
using (var prog = console.Progress())
{
processor.ProgressChanged += (s, e) => prog.Report(e.Progress / 100.0);
processor.ActionComplete += (s, e) =>
{
if (e.Exception != null)
{
throw new AggregateException(e.Exception);
}
};
await processor.Export(script, refsToExport, checkDependencies);
}
console.WriteLine("Done.");
WritePackage(console, script, Output, MultipleDirectories, CleanOutput);
}));
}
public Task <int> Execute()
{
return(ConsoleTask.ExecuteAsync(this, async(console) =>
{
console.WriteLine("Connecting to innovator...");
var conn = await this.GetConnection().ConfigureAwait(false);
var processor = new ExportProcessor(conn);
var refsToExport = default(List <ItemReference>);
var checkDependencies = true;
if (string.IsNullOrEmpty(this.InputFile))
{
var version = await conn.FetchVersion(true).ConfigureAwait(false);
var types = ExportAllType.Types.Where(t => t.Applies(version)).ToList();
console.Write("Identifying all metadata items... ");
using (var prog = console.Progress())
{
var toExport = await SharedUtils.TaskPool(30, (l, m) => prog.Report(l / 100.0), types
.Select(t => (Func <Task <IReadOnlyResult> >)(() => conn.ApplyAsync(t.ToString(), true, false).ToTask()))
.ToArray());
refsToExport = toExport.SelectMany(r => r.Items())
.Select(i => ItemReference.FromFullItem(i, true))
.ToList();
}
console.WriteLine("Done.");
checkDependencies = false;
}
else
{
throw new NotSupportedException("Input package is not supported");
}
var script = new InstallScript
{
ExportUri = new Uri(Url),
ExportDb = Database,
Lines = Enumerable.Empty <InstallItem>(),
Title = Title ?? System.IO.Path.GetFileNameWithoutExtension(Output),
Creator = Author ?? Username,
Website = string.IsNullOrEmpty(Website) ? null : new Uri(Website),
Description = Description,
Created = DateTime.Now,
Modified = DateTime.Now
};
console.Write("Exporting metadata... ");
using (var prog = console.Progress())
{
processor.ProgressChanged += (s, e) => prog.Report(e.Progress / 100.0);
processor.ActionComplete += (s, e) =>
{
if (e.Exception != null)
{
throw new AggregateException(e.Exception);
}
};
await processor.Export(script, refsToExport, checkDependencies);
}
console.WriteLine("Done.");
WritePackage(console, script, Output, MultipleDirectories, CleanOutput);
}));
}
