public InstallationDialog(SearchResult item)
: base(item.PackageId, width: 80, height: 12)
{
var cancel = new Button(3, 14, "Cancel")
{
Clicked = () => Application.RequestStop()
};
var install = new Button(10, 14, "Install")
{
Clicked = () =>
{
var resultText = new TextView
{
Text = "Installing...",
ReadOnly = true,
Height = 15
};
var resultDialog = new Dialog(
"Install package",
width: 80,
height: 30,
new Button("Ok")
{
Clicked = () => Application.RequestStop()
});
resultDialog.Add(resultText);
Application.MainLoop.Invoke(async() =>
{
var dotnet = new Dotnet();
var result = await dotnet.AddPackage(item.PackageId, item.Version);
resultText.Text = string.Join("\n", result.Output);
});
Application.Run(resultDialog);
Application.RequestStop();
}
};
var details = $"Downloads: {FormatDownloads(item.TotalDownloads)}\n";
details += $"Tags: {string.Join(", ", item.Tags)}\n";
details += $"\n";
details += $"Description:\n";
details += item.Description;
var text = new TextView
{
Text = details,
ReadOnly = true,
Height = 5
};
AddButton(cancel);
AddButton(install);
Add(text);
}
private void ConfigureDefaultProps(ITaskSession taskSession)
{
taskSession.SetBuildVersion(new Version(1, 0, 0, 0));
taskSession.SetDotnetExecutable(Dotnet.FindDotnetExecutable());
var isWindows = RuntimeInformation.IsOSPlatform(OSPlatform.Windows);
OSPlatform platform;
if (!isWindows)
{
var isLinux = RuntimeInformation.IsOSPlatform(OSPlatform.Linux);
platform = isLinux ? OSPlatform.Linux : OSPlatform.OSX;
}
else
{
platform = OSPlatform.Windows;
}
taskSession.SetOSPlatform(platform);
taskSession.SetNodeExecutablePath(IOExtensions.GetNodePath());
taskSession.SetProfileFolder(IOExtensions.GetUserProfileFolder());
taskSession.SetNpmPath(IOExtensions.GetNpmPath());
taskSession.SetBuildDir("build");
taskSession.SetOutputDir("output");
taskSession.SetProductRootDir(".");
if (isWindows)
{
// do windows specific tasks
}
}
protected override async Task StartAsync(AspNetCoreContext ctx, CancellationToken token)
{
var info = await Dotnet.RunAsync(ctx, token, ctx.Urls);
ctx.ProcessId = info.Pid;
ctx.Output = info.Output;
}
private static ITemplateEngineHost CreateHost(bool emitTimings)
{
var preferences = new Dictionary <string, string>
{
{ "prefs:language", "C#" }
};
try
{
string versionString = Dotnet.Version().CaptureStdOut().Execute().StdOut;
if (!string.IsNullOrWhiteSpace(versionString))
{
preferences["dotnet-cli-version"] = versionString.Trim();
}
}
catch
{ }
DefaultTemplateEngineHost host = new DefaultTemplateEngineHost(HostIdentifier, HostVersion, CultureInfo.CurrentCulture.Name, preferences, new[] { "dotnetcli" });
if (emitTimings)
{
host.OnLogTiming = (label, duration, depth) =>
{
string indent = string.Join("", Enumerable.Repeat(" ", depth));
Console.WriteLine($"{indent} {label} {duration.TotalMilliseconds}");
};
}
return(host);
}
private static void AddProjectReference(DotnetProject project, DotnetProject refProject)
{
Dotnet.AddProjectToProjectReference(project.Path + project.Name, refProject.Path + refProject.Name)
.ForwardStdOut()
.ForwardStdErr()
.Execute();
}
private static void AddProjectsToSolutionReference(DotnetSolution solution, IReadOnlyList <string> projectPaths)
{
Dotnet.AddProjectsToSolution($"{solution.Path}{solution.Name}.sln", projectPaths)
.ForwardStdOut()
.ForwardStdErr()
.Execute();
}
public async Task <IEnumerable <MetadataReference> > AddPackage(string packageName, string packageVersion)
{
var package = await _lazyPackage.ValueAsync();
var currentWorkspace = await package.CreateRoslynWorkspaceForRunAsync(new Budget());
var currentRefs = new HashSet <string>(
currentWorkspace.CurrentSolution.Projects.First().MetadataReferences
.Select(m => m.Display));
var dotnet = new Dotnet(package.Directory);
var result = await dotnet.AddPackage(packageName, packageVersion);
if (result.ExitCode != 0)
{
return(Array.Empty <MetadataReference>());
}
var newWorkspace = await package.CreateRoslynWorkspaceForRunAsync(new Budget());
var newRefs = new HashSet <MetadataReference>(newWorkspace.CurrentSolution.Projects.First().MetadataReferences);
var resultRefs = newRefs.Where(n => !currentRefs.Contains(n.Display));
return(resultRefs);
}
private async Task <IPackage> TryInstallAndLocateTool(PackageDescriptor packageDesciptor)
{
var dotnet = new Dotnet();
var installationResult = await dotnet.ToolInstall(
packageDesciptor.Name,
_workingDirectory.GetFullyQualifiedRoot(),
_addSource?.ToString());
if (installationResult.ExitCode != 0)
{
Logger <LocalToolInstallingPackageDiscoveryStrategy> .Log.Warning($"Tool not installed: {packageDesciptor.Name}");
return(null);
}
var tool = PackageTool.TryCreateFromDirectory(packageDesciptor.Name, _workingDirectory);
if (tool != null)
{
return(await CreatePackage(packageDesciptor, tool));
}
return(null);
}
public async Task Pack_project_blazor_contents()
{
var asset = await Create.NetstandardWorkspaceCopy();
var packageName = Path.GetFileNameWithoutExtension(asset.Directory.GetFiles("*.csproj").First().Name);
var console = new TestConsole();
await PackCommand.Do(new PackOptions(asset.Directory, enableBlazor : true), console);
asset.Directory
.GetFiles()
.Should()
.Contain(f => f.Name.Contains("nupkg"));
var dotnet = new Dotnet(asset.Directory);
var result = await dotnet.ToolInstall(packageName, asset.Directory, asset.Directory);
var exe = Path.Combine(asset.Directory.FullName, packageName);
var tool = new WorkspaceServer.WorkspaceFeatures.PackageTool(packageName, asset.Directory);
await tool.Prepare();
var projectDirectory = await tool.LocateProjects();
var subDirectories = projectDirectory.GetDirectories();
subDirectories.Should().Contain(d => d.Name == "packTarget");
subDirectories.Should().Contain(d => d.Name == $"runner-{packageName}");
}
private async Task <PackageBuilder> TryInstallAndLocateTool(PackageDescriptor packageDesciptor, Budget budget)
{
var dotnet = new Dotnet();
var installationResult = await dotnet.ToolInstall(
packageDesciptor.Name,
_workingDirectory,
_addSource?.ToString());
if (installationResult.ExitCode != 0)
{
Logger <LocalToolInstallingPackageDiscoveryStrategy> .Log.Warning($"Tool not installed: {packageDesciptor.Name}");
return(null);
}
var tool = await _locator.LocatePackageAsync(packageDesciptor.Name, budget);
if (tool != null)
{
return(CreatePackageBuilder(packageDesciptor, tool));
}
return(null);
}
public async Task <PackageRestoreResult> Restore()
{
WriteProjectFile();
var dotnet = new Dotnet(Directory);
var result = await dotnet.Execute("msbuild -restore /t:WriteNugetAssemblyPaths");
var resolvedReferences =
GetResolvedReferences()
.Values
.ToArray();
if (result.ExitCode != 0)
{
return(new PackageRestoreResult(
succeeded: false,
requestedPackages: _packageReferences.Values,
errors: result.Output.Concat(result.Error).ToArray()));
}
else
{
return(new PackageRestoreResult(
succeeded: true,
requestedPackages: _packageReferences.Values,
resolvedReferences: resolvedReferences));
}
}
private void InstallRemotePackages(IEnumerable <Package> packages, IList <string> nuGetSources)
{
const string packageRef = @" <PackageReference Include=""{0}"" Version=""{1}"" />";
const string projectFile = @"<Project ToolsVersion=""15.0"" Sdk=""Microsoft.NET.Sdk"">
<PropertyGroup>
<TargetFrameworks>netcoreapp1.0</TargetFrameworks>
</PropertyGroup>
<ItemGroup>
<PackageReference Remove=""Microsoft.NETCore.App"" />
{0}
</ItemGroup>
</Project>";
_paths.CreateDirectory(_paths.User.ScratchDir);
string proj = Path.Combine(_paths.User.ScratchDir, "restore.csproj");
StringBuilder references = new StringBuilder();
foreach (Package pkg in packages)
{
references.AppendLine(string.Format(packageRef, pkg.Name, pkg.Version));
}
string content = string.Format(projectFile, references.ToString());
_paths.WriteAllText(proj, content);
_paths.CreateDirectory(_paths.User.Packages);
string restored = Path.Combine(_paths.User.ScratchDir, "Packages");
int additionalSlots = nuGetSources?.Count * 2 ?? 0;
string[] restoreArgs = new string[3 + additionalSlots];
restoreArgs[0] = proj;
restoreArgs[1] = "--packages";
restoreArgs[2] = restored;
if (nuGetSources != null)
{
for (int i = 0; i < nuGetSources.Count; ++i)
{
restoreArgs[3 + 2 * i] = "--source";
restoreArgs[4 + 2 * i] = nuGetSources[i];
}
}
Dotnet.Restore(restoreArgs).ForwardStdOut().ForwardStdErr().Execute();
List <string> newLocalPackages = new List <string>();
foreach (string packagePath in _paths.EnumerateFiles(restored, "*.nupkg", SearchOption.AllDirectories))
{
string path = Path.Combine(_paths.User.Packages, Path.GetFileName(packagePath));
_paths.Copy(packagePath, path);
newLocalPackages.Add(path);
}
_paths.DeleteDirectory(_paths.User.ScratchDir);
InstallLocalPackages(newLocalPackages);
}
public async Task Pack_project_blazor_contents()
{
var asset = await Create.NetstandardWorkspaceCopy();
var packageName = Path.GetFileNameWithoutExtension(asset.Directory.GetFiles("*.csproj").First().Name);
var console = new TestConsole();
await PackCommand.Do(new PackOptions(asset.Directory, enableWasm : true), console);
asset.Directory
.GetFiles()
.Should()
.Contain(f => f.Name.Contains("nupkg"));
var dotnet = new Dotnet(asset.Directory);
var result = await dotnet.ToolInstall(packageName, asset.Directory, new PackageSource(asset.Directory.FullName));
var exe = Path.Combine(asset.Directory.FullName, packageName);
var tool = WorkspaceServer.WorkspaceFeatures.PackageTool.TryCreateFromDirectory(packageName, new FileSystemDirectoryAccessor(asset.Directory));
await tool.Prepare();
var wasmDirectory = await tool.LocateWasmAsset();
wasmDirectory.Should().NotBeNull();
}
public async Task <PackageRestoreResult> Restore()
{
WriteProjectFile();
var dotnet = new Dotnet(Directory);
var commandLine = "msbuild -restore /t:WriteNugetAssemblyPaths";
#if DEBUG
commandLine += " /bl";
#endif
var result = await dotnet.Execute(commandLine);
if (result.ExitCode != 0)
{
return(new PackageRestoreResult(
succeeded: false,
requestedPackages: _requestedPackageReferences.Values,
errors: result.Output.Concat(result.Error).ToArray()));
}
else
{
ReadResolvedReferencesFromBuildOutput();
return(new PackageRestoreResult(
succeeded: true,
requestedPackages: _requestedPackageReferences.Values,
resolvedReferences: _resolvedPackageReferences.Values.ToList()));
}
}
public async Task <AddReferenceResult> AddPackage(string packageName, string packageVersion = null)
{
var package = await _lazyPackage.ValueAsync();
var currentWorkspace = await package.CreateRoslynWorkspaceForRunAsync(new Budget());
var currentRefs = new HashSet <string>(
currentWorkspace.CurrentSolution.Projects.First().MetadataReferences
.Select(m => m.Display));
var dotnet = new Dotnet(package.Directory);
var result = await dotnet.AddPackage(packageName, packageVersion);
if (result.ExitCode != 0)
{
return(new AddReferenceResult(succeeded: false, detailedErrors: result.DetailedErrors));
}
var newWorkspace = await package.CreateRoslynWorkspaceForRunAsync(new Budget());
var newRefs = new HashSet <MetadataReference>(newWorkspace.CurrentSolution.Projects.First().MetadataReferences);
return(new AddReferenceResult(succeeded: true, newRefs
.Where(n => !currentRefs.Contains(n.Display))
.ToArray(),
installedVersion: result.InstalledVersion));
}
private async Task MakeBlazorProject(DirectoryInfo directory, Budget budget)
{
var dotnet = new Dotnet(directory);
var root = directory.FullName;
AddRootNamespaceAndBlazorLinkerDirective();
DeleteUnusedFilesFromTemplate(root);
AddEmbeddedResourceContentToProject(root);
UpdateFileText(root, Path.Combine("wwwroot", "index.html"), "/LocalCodeRunner/blazor-console", $"/LocalCodeRunner/{_name}");
foreach (var packageId in _addPackages)
{
await dotnet.AddPackage(packageId);
}
await dotnet.AddPackage("System.CommandLine.Experimental", "0.3.0-alpha.19317.1");
var result = await dotnet.Build("-o runtime /bl", budget : budget);
var stuff = string.Concat(string.Join("\n", result.Output), (string.Join("\n", result.Error)));
result.ThrowOnFailure(stuff);
void AddRootNamespaceAndBlazorLinkerDirective()
{
UpdateFileText(root, "MLS.Blazor.csproj", "</PropertyGroup>",
@"</PropertyGroup>
<PropertyGroup>
<RootNamespace>MLS.Blazor</RootNamespace>
</PropertyGroup>
<ItemGroup>
<BlazorLinkerDescriptor Include=""Linker.xml"" />
</ItemGroup>");
}
}
public bool Process(IEngineEnvironmentSettings settings, IPostAction actionConfig, ICreationResult templateCreationResult, string outputBasePath)
{
if (templateCreationResult.PrimaryOutputs.Count == 0)
{
settings.Host.LogMessage(LocalizableStrings.NoPrimaryOutputsToRestore);
return(true);
}
bool allSucceeded = true;
foreach (ICreationPath output in templateCreationResult.PrimaryOutputs)
{
string pathToRestore = !string.IsNullOrEmpty(outputBasePath) ? Path.Combine(outputBasePath, output.Path) : output.Path;
Dotnet restoreCommand = Dotnet.Restore(pathToRestore);
restoreCommand.CaptureStdOut();
restoreCommand.CaptureStdErr();
settings.Host.LogMessage(string.Format(LocalizableStrings.RunningDotnetRestoreOn, pathToRestore));
Dotnet.Result commandResult = restoreCommand.Execute();
if (commandResult.ExitCode != 0)
{
settings.Host.LogMessage(LocalizableStrings.RestoreFailed);
settings.Host.LogMessage(string.Format(LocalizableStrings.CommandOutput, commandResult.StdOut + Environment.NewLine + Environment.NewLine + commandResult.StdErr));
settings.Host.LogMessage(string.Empty);
allSucceeded = false;
}
else
{
settings.Host.LogMessage(LocalizableStrings.RestoreSucceeded);
}
}
return(allSucceeded);
}
private async Task <IPackage> TryInstallAndLocateTool(PackageDescriptor packageDesciptor)
{
var dotnet = new Dotnet();
var installationResult = await dotnet.ToolInstall(
packageDesciptor.Name,
_workingDirectory,
_addSource,
new Budget());
if (installationResult.ExitCode != 0)
{
Logger <LocalToolInstallingPackageDiscoveryStrategy> .Log.Warning($"Tool not installed: {packageDesciptor.Name}");
return(null);
}
var tool = new PackageTool(packageDesciptor.Name, _workingDirectory);
if (tool.Exists)
{
return(await CreatePackage(packageDesciptor, tool));
}
return(null);
}
private static ITemplateEngineHost CreateHost(string hostIdentifier, string hostVersion)
{
var preferences = new Dictionary <string, string>
{
{ "prefs:language", "C#" }
};
try
{
string versionString = Dotnet.Version().CaptureStdOut().Execute().StdOut;
if (!string.IsNullOrWhiteSpace(versionString))
{
preferences["dotnet-cli-version"] = versionString.Trim();
}
}
catch
{ }
var builtIns = new AssemblyComponentCatalog(new[]
{
typeof(RunnableProjectGenerator).GetTypeInfo().Assembly, // for assembly: Microsoft.TemplateEngine.Orchestrator.RunnableProjects
typeof(NupkgInstallUnitDescriptorFactory).GetTypeInfo().Assembly, // for assembly: Microsoft.TemplateEngine.Edge
typeof(DotnetRestorePostActionProcessor).GetTypeInfo().Assembly, // for assembly: Microsoft.TemplateEngine.Cli
typeof(NupkgUpdater).GetTypeInfo().Assembly // for assembly: Microsoft.TemplateSearch.Common
});
return(new DefaultTemplateEngineHost(hostIdentifier, hostVersion, CultureInfo.CurrentCulture.Name, preferences, builtIns, new[] { "dotnetcli" }));
}
public async Task When_the_template_is_installed_verify_works()
{
var baseDirectory = Create.EmptyWorkspace().Directory;
var outputDirectory = baseDirectory.CreateSubdirectory("outputTemplate");
await InstallTemplateAndCreateProject(baseDirectory, outputDirectory);
var dotnet = new Dotnet(outputDirectory);
//The template targets 3.0 hence verify should run against 3.0 and not 2.1.503 used in the solution directory
await dotnet.New("global.json", "--sdk-version 3.0.100-preview6-012264");
var console = new TestConsole();
var directoryAccessor = new FileSystemDirectoryAccessor(outputDirectory);
var resultCode = await VerifyCommand.Do(
new VerifyOptions(outputDirectory),
console,
() => directoryAccessor,
PackageRegistry.CreateForTryMode(outputDirectory));
console.Out
.ToString()
.EnforceLF()
.Trim()
.Should()
.Match(
$"{outputDirectory}{Path.DirectorySeparatorChar}Readme.md*Line *:*{outputDirectory}{Path.DirectorySeparatorChar}Program.cs (in project {outputDirectory}{Path.DirectorySeparatorChar}{outputDirectory.Name}.csproj)*".EnforceLF());
resultCode.Should().Be(0);
}
private static ITemplateEngineHost CreateHost()
{
var preferences = new Dictionary<string, string>
{
{ "prefs:language", "C#" }
};
try
{
string versionString = Dotnet.Version().CaptureStdOut().Execute().StdOut;
if (!string.IsNullOrWhiteSpace(versionString))
{
preferences["dotnet-cli-version"] = versionString.Trim();
}
}
catch
{ }
var builtIns = new AssemblyComponentCatalog(new[]
{
typeof(RunnableProjectGenerator).GetTypeInfo().Assembly,
typeof(ConditionalConfig).GetTypeInfo().Assembly,
typeof(NupkgInstallUnitDescriptorFactory).GetTypeInfo().Assembly
});
return new DefaultTemplateEngineHost(HostIdentifier, HostVersion, CultureInfo.CurrentCulture.Name, preferences, builtIns, new[] { "dotnetcli" });
}
public virtual async Task Initialize(
DirectoryInfo directory,
Budget budget = null)
{
budget = budget ?? new Budget();
var dotnet = new Dotnet(directory);
// TODO : workaround to make build work, it requires
var result = await dotnet.New("globaljson", "--sdk-version 3.1.300");
result.ThrowOnFailure($"Error creating global.json in {directory.FullName}");
var gbFile = directory.GetFiles("global.json").Single();
var gj = JObject.Parse(File.ReadAllText(gbFile.FullName));
gj["sdk"]["rollForward"] = "latestMinor";
File.WriteAllText(gbFile.FullName, gj.ToString(Formatting.Indented));
result = await dotnet
.New(Template,
args : $"--name \"{ProjectName}\" --language \"{Language}\" --output \"{directory.FullName}\"");
result.ThrowOnFailure($"Error initializing in {directory.FullName}");
if (afterCreate != null)
{
await afterCreate(directory, budget);
}
}
private static void RestoreSolution(DotnetSolution solution)
{
Dotnet.Restore($"{solution.Path}{solution.Name}.sln")
.ForwardStdOut()
.ForwardStdErr()
.Execute();
}
static void Main(string[] args)
{
Console.WriteLine("Hello World!");
OlderTwentyOne oto = new OlderTwentyOne();
Dotnet dn = new Dotnet();
}
public virtual async Task Build()
{
await WriteAssemblyInformationFile();
await WriteVersionPropsFile();
await(await Dotnet.Tool()).Run("build", SlnFile,
"--configuration", this.Configuration);
}
public virtual async Task CodeCoverage()
{
await Build();
await(await Dotnet.Tool()).Run("test", SlnFile, "--no-build",
"--collect:Code Coverage"
);
}
public async Task <AddNugetResult> AddPackage(
string packageName,
string packageVersion = null,
string restoreSources = null)
{
var requestedPackage = new NugetPackageReference(packageName, packageVersion, restoreSources);
if (!String.IsNullOrEmpty(packageName) && _nugetPackageReferences.TryGetValue(requestedPackage, out var _))
{
return(new AddNugetPackageResult(false, requestedPackage));
}
_nugetPackageReferences.Add(requestedPackage, null);
WriteProjectFile();
var dotnet = new Dotnet(Directory);
var result = await dotnet.Execute("msbuild -restore /t:WriteNugetAssemblyPaths");
if (result.ExitCode != 0)
{
if (string.IsNullOrEmpty(packageName) && string.IsNullOrEmpty(restoreSources))
{
return(new AddNugetRestoreSourcesResult(
succeeded: false,
requestedPackage,
errors: result.Output.Concat(result.Error).ToArray()));
}
else
{
return(new AddNugetPackageResult(
succeeded: false,
requestedPackage,
errors: result.Output.Concat(result.Error).ToArray()));
}
}
var addedReferences =
GetResolvedNugetReferences()
.Values
.ToArray();
if (string.IsNullOrEmpty(packageName) && !string.IsNullOrEmpty(restoreSources))
{
return(new AddNugetRestoreSourcesResult(
succeeded: true,
requestedPackage: requestedPackage,
addedReferences: addedReferences));
}
else
{
return(new AddNugetPackageResult(
succeeded: true,
requestedPackage: requestedPackage,
addedReferences: addedReferences));
}
}
public static async Task <FileInfo> CreateExtensionNupkg(
DirectoryInfo projectDir,
string code,
string packageName,
string packageVersion,
params FileInfo[] filesToEmbed)
{
var msbuildFragment = GenerateEmbeddedResourceFragment(filesToEmbed);
var extensionCode = filesToEmbed?.Length == 0 ? ExtensionCs(code) : FileProviderExtensionCs(code);
projectDir.Populate(
extensionCode,
("Extension.csproj", $@"
<Project Sdk=""Microsoft.NET.Sdk"">
<PropertyGroup>
<TargetFramework>net5.0</TargetFramework>
<IsPackable>true</IsPackable>
<PackageId>{packageName}</PackageId>
<PackageVersion>{packageVersion}</PackageVersion>
<AssemblyName>{packageName}</AssemblyName>
</PropertyGroup>
<ItemGroup>
<None Include=""$(OutputPath)/{packageName}.dll"" Pack=""true"" PackagePath=""interactive-extensions/dotnet"" />
</ItemGroup>
{msbuildFragment}
<ItemGroup>
<Reference Include=""Microsoft.DotNet.Interactive"">
<HintPath>{_microsoftDotNetInteractiveDllPath}</HintPath>
</Reference>
</ItemGroup>
</Project>
"),
("global.json", @"{
""sdk"": {
""version"": ""5.0.100"",
""rollForward"": ""latestMinor""
}
}
")
);
var dotnet = new Dotnet(projectDir);
var pack = await dotnet.Pack(projectDir.FullName);
pack.ThrowOnFailure();
return(projectDir
.GetFiles("*.nupkg", SearchOption.AllDirectories)
.Single());
}
public virtual async Task Test()
{
await Build();
await(await Dotnet.Tool()).Run("test",
SlnFile,
"--no-build",
"--configuration", Configuration
);
}
public static async Task <string> Do(PackOptions options, IConsole console)
{
console.Out.WriteLine($"Creating package-tool from {options.PackTarget.FullName}");
using (var disposableDirectory = DisposableDirectory.Create())
{
var temp = disposableDirectory.Directory;
var temp_projects = temp.CreateSubdirectory("projects");
var name = options.PackageName;
var temp_projects_build = temp_projects.CreateSubdirectory("build");
options.PackTarget.CopyTo(temp_projects_build);
if (options.EnableWasm)
{
string runnerDirectoryName = $"wasm";
var temp_projects_wasm = temp_projects.CreateSubdirectory(runnerDirectoryName);
var temp_mlsblazor = temp.CreateSubdirectory("MLS.Blazor");
await AddBlazorProject(temp_mlsblazor, GetProjectFile(temp_projects_build), name, temp_projects_wasm);
}
var temp_toolproject = temp.CreateSubdirectory("project");
var archivePath = Path.Combine(temp_toolproject.FullName, "package.zip");
ZipFile.CreateFromDirectory(temp_projects.FullName, archivePath, CompressionLevel.Fastest, includeBaseDirectory: false);
console.Out.WriteLine(archivePath);
var projectFilePath = Path.Combine(temp_toolproject.FullName, "package-tool.csproj");
var contentFilePath = Path.Combine(temp_toolproject.FullName, "program.cs");
await File.WriteAllTextAsync(
projectFilePath,
typeof(Program).ReadManifestResource("MLS.Agent.MLS.PackageTool.csproj"));
await File.WriteAllTextAsync(contentFilePath, typeof(Program).ReadManifestResource("MLS.Agent.Program.cs"));
var dotnet = new Dotnet(temp_toolproject);
var result = await dotnet.Build();
result.ThrowOnFailure("Failed to build intermediate project.");
var versionArg = "";
if (!string.IsNullOrEmpty(options.Version))
{
versionArg = $"/p:PackageVersion={options.Version}";
}
result = await dotnet.Pack($@"/p:PackageId=""{name}"" /p:ToolCommandName=""{name}"" {versionArg} ""{projectFilePath}"" -o ""{options.OutputDirectory.FullName}""");
result.ThrowOnFailure("Package build failed.");
return(name);
}
}
