/// <summary>
/// Entrypoint of application
/// </summary>
/// <param name="args">Application arguments</param>
private static void Main(string[] args)
{
PathHelper.Init(Resources.LibraryBasePath);
NuGetHelper.Init(Resources.ApiKey, Resources.FeedUrl);
while (true)
{
Console.WriteLine("Please paste the escaped code of the snippet...");
var input = GetInputFromConsole();
if (!string.IsNullOrWhiteSpace(input))
{
Console.WriteLine("Please enter the name of the snippet...");
var name = GetInputFromConsole();
Console.WriteLine("Please enter the version of the snippet...");
var version = GetInputFromConsole();
Console.WriteLine("Please enter the author of the snippet...");
var author = GetInputFromConsole();
var snippet = new Snippet(input, name, version, author);
var libraryPath = DotnetCliHelper.CreateTempLibrary(snippet.Id);
if (libraryPath == null)
{
Console.WriteLine($"Failed to create class library {snippet.Id}...");
return;
}
Console.WriteLine($"Created class library {snippet.Id}...");
var codeFilePath = DotnetCliHelper.AddClassToTempLibrary(snippet);
Console.WriteLine($"Created file {codeFilePath}...");
var packagePath = NuGetHelper.CreateNuGetPackage(libraryPath, snippet);
if (packagePath == null)
{
Console.WriteLine("Failed to create package...");
return;
}
Console.WriteLine("NuGet package created...");
var published = NuGetHelper.PublishNuGetPackage(packagePath);
if (!published)
{
Console.WriteLine("Failed to publish package...");
return;
}
Console.WriteLine("NuGet package published...");
}
}
}
public static void TryNugetRestore(List <Dep> modulesToUpdate, ModuleBuilder builder)
{
Log.Debug("Restoring NuGet packages");
ConsoleWriter.ResetProgress();
try
{
var nugetRunCommand = NuGetHelper.GetNugetRunCommand();
if (nugetRunCommand == null)
{
return;
}
var uniqueDeps = modulesToUpdate.GroupBy(d => d.Name).Select(g => g.First()).ToList();
Parallel.ForEach(uniqueDeps, Helper.ParallelOptions, dep =>
{
ConsoleWriter.WriteProgress($"{dep.Name,-30} nuget restoring");
builder.NugetRestore(dep, nugetRunCommand);
ConsoleWriter.SaveToProcessedModules(dep.Name);
});
}
catch (AggregateException ae)
{
Log.Error(ae.Flatten().InnerExceptions.First());
}
catch (Exception e)
{
Log.Error(e);
}
Log.Debug("OK NuGet packages restored");
ConsoleWriter.ResetProgress();
}
public async System.Threading.Tasks.Task ManageMigrationsAsync(string outputPath, Project project)
{
await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
try
{
if (string.IsNullOrEmpty(outputPath))
{
throw new ArgumentException(outputPath, nameof(outputPath));
}
if (project == null)
{
throw new ArgumentNullException(nameof(project));
}
if (project.Properties.Item("TargetFrameworkMoniker") == null)
{
EnvDteHelper.ShowError(SharedLocale.SelectedProjectTypeNoTargetFrameworkMoniker);
return;
}
if (!project.IsNetCore30OrHigher())
{
EnvDteHelper.ShowError($"{SharedLocale.SupportedFramework}: {project.Properties.Item("TargetFrameworkMoniker").Value}");
return;
}
var result = await project.ContainsEfCoreDesignReferenceAsync();
if (string.IsNullOrEmpty(result.Item2))
{
EnvDteHelper.ShowError(SharedLocale.EFCoreVersionNotFound);
return;
}
if (!result.Item1)
{
if (!Version.TryParse(result.Item2, out Version version))
{
EnvDteHelper.ShowError(string.Format(MigrationsLocale.CannotSupportVersion, version));
return;
}
var nugetHelper = new NuGetHelper();
nugetHelper.InstallPackage("Microsoft.EntityFrameworkCore.Design", project, version);
EnvDteHelper.ShowError(string.Format(SharedLocale.InstallingEfCoreDesignPackage, version));
return;
}
var migrationsDialog = _package.GetView <IMigrationOptionsDialog>();
migrationsDialog.UseProjectForMigration(project)
.UseOutputPath(outputPath);
migrationsDialog.ShowAndAwaitUserResponse(true);
}
catch (Exception exception)
{
_package.LogError(new List <string>(), exception);
}
}
public static void Main(string[] args)
{
CreateWebHostBuilder(args).Build().Run();
PathHelper.Init(Resources.LibraryBasePath);
NuGetHelper.Init(Resources.ApiKey, Resources.FeedUrl);
}
public async System.Threading.Tasks.Task ManageMigrationsAsync(string outputPath, Project project)
{
try
{
if (string.IsNullOrEmpty(outputPath))
{
throw new ArgumentException(outputPath, nameof(outputPath));
}
if (project == null)
{
throw new ArgumentNullException(nameof(project));
}
if (project.Properties.Item("TargetFrameworkMoniker") == null)
{
EnvDteHelper.ShowError("The selected project type has no TargetFrameworkMoniker");
return;
}
if (!project.IsNetCore30OrHigher())
{
EnvDteHelper.ShowError("Only .NET Core 3.0+ projects are supported - TargetFrameworkMoniker: " + project.Properties.Item("TargetFrameworkMoniker").Value);
return;
}
var outputFolder = Path.GetDirectoryName(outputPath);
var result = await project.ContainsEfCoreDesignReferenceAsync();
if (string.IsNullOrEmpty(result.Item2))
{
EnvDteHelper.ShowError("EF Core 3.1 or later not found in project");
return;
}
if (!result.Item1)
{
if (!Version.TryParse(result.Item2, out Version version))
{
EnvDteHelper.ShowError($"Cannot support version {version}, notice that previews are not supported.");
return;
}
var nugetHelper = new NuGetHelper();
nugetHelper.InstallPackage("Microsoft.EntityFrameworkCore.Design", project, version);
EnvDteHelper.ShowError($"Installing EFCore.Design version {version}, please retry the command");
return;
}
var migrationsDialog = _package.GetView <IMigrationOptionsDialog>();
migrationsDialog.UseProjectForMigration(project)
.UseOutputPath(outputPath);
migrationsDialog.ShowAndAwaitUserResponse(true);
}
catch (Exception exception)
{
_package.LogError(new List <string>(), exception);
}
}
public static void TryNugetRestore(List <Dep> modulesToUpdate, ModuleBuilder builder)
{
Log.LogDebug("Restoring NuGet packages");
ConsoleWriter.ResetProgress();
try
{
var nugetRunCommand = NuGetHelper.GetNugetRunCommand();
if (nugetRunCommand == null)
{
return;
}
var deps = modulesToUpdate.GroupBy(d => d.Name).ToList();
Parallel.ForEach(deps, Helper.ParallelOptions, group =>
{
ConsoleWriter.WriteProgress($"{group.Key,-30} nuget restoring");
builder.NugetRestore(group.Key, group.Select(d => d.Configuration).ToList(), nugetRunCommand);
ConsoleWriter.SaveToProcessedModules(group.Key);
});
}
catch (AggregateException ae)
{
Log.LogError(ae.Flatten().InnerExceptions.First(), ae.Flatten().InnerExceptions.First().Message);
}
catch (Exception e)
{
Log.LogError(e, e.Message);
}
Log.LogDebug("OK NuGet packages restored");
ConsoleWriter.ResetProgress();
}
public async Task InitializeAsync()
{
var logger = new TestLogger();
try
{
// Restore the Analyzer packages that have been added to `for_analyzer_formatter/analyzer_project/analyzer_project.csproj`
var exitCode = await NuGetHelper.PerformRestore(s_analyzerProjectFilePath, TestOutputHelper);
Assert.Equal(0, exitCode);
// Load the analyzer_project into a MSBuildWorkspace.
var workspacePath = Path.Combine(TestProjectsPathHelper.GetProjectsDirectory(), s_analyzerProjectFilePath);
MSBuildRegistrar.RegisterInstance(logger);
var analyzerWorkspace = await MSBuildWorkspaceLoader.LoadAsync(workspacePath, WorkspaceType.Project, createBinaryLog : false, logWorkspaceWarnings : true, logger, CancellationToken.None);
// From this project we can get valid AnalyzerReferences to add to our test project.
_analyzerReferencesProject = analyzerWorkspace.CurrentSolution.Projects.Single();
}
catch
{
TestOutputHelper.WriteLine(logger.GetLog());
throw;
}
}
public async Task TestQueryNuGetAsync01Async()
{
var nugetApiHelper = new NuGetHelper(new RemoteFile());
var results = await nugetApiHelper.QueryNuGetAsync(httpClient, "dec");
Assert.True(results.Count > 300);
}
public async Task TestGetAllQueryUrisAsync01Async()
{
var nugetApiHelper = new NuGetHelper(new RemoteFile());
var results = await nugetApiHelper.GetAllQueryUrisAsync(httpClient, "template", 20);
Assert.NotEmpty(results);
}
public NugetHelperTest()
{
var service = new ServiceCollection();
service.AddHttpClient();
service.AddSingleton <CodeGeneratorConfig>();
service.AddSingleton <NuGetHelper>();
_nuGetHelper = service.BuildServiceProvider().GetService <NuGetHelper>();
}
public void NuGetHelper_ArgChecks()
{
var loggerMock = new Mock <ILogger>().Object;
Exceptions.Expect <ArgumentNullException>(() => NuGetHelper.TryInstallPackage(null, loggerMock, new ProjectMock("123"), "123"));
Exceptions.Expect <ArgumentNullException>(() => NuGetHelper.TryInstallPackage(CreateServiceProvider(), null, new ProjectMock("123"), "123"));
Exceptions.Expect <ArgumentNullException>(() => NuGetHelper.TryInstallPackage(CreateServiceProvider(), loggerMock, null, "123"));
Exceptions.Expect <ArgumentNullException>(() => NuGetHelper.TryInstallPackage(CreateServiceProvider(), loggerMock, new ProjectMock("123"), null));
}
/// <summary>
/// Determine the NuGet package sources configured for the current project and create clients for them.
/// </summary>
/// <param name="cancellationToken">
/// An optional <see cref="CancellationToken"/> that can be used to cancel the operation.
/// </param>
/// <returns>
/// <c>true</c>, if the package sources were loaded; otherwise, <c>false</c>.
/// </returns>
public virtual async Task <bool> ConfigurePackageSources(CancellationToken cancellationToken = default(CancellationToken))
{
try
{
_configuredPackageSources.Clear();
_autoCompleteResources.Clear();
bool includeLocalSources = Workspace.Configuration.NuGet.IncludeLocalSources;
_configuredPackageSources.AddRange(
NuGetHelper.GetWorkspacePackageSources(ProjectFile.Directory.FullName)
.Where(
packageSource => packageSource.IsHttp || (includeLocalSources && packageSource.TrySourceAsUri?.Scheme == Uri.UriSchemeFile)
)
);
Log.Information("{PackageSourceCount} package sources configured for project {ProjectFile}.",
_configuredPackageSources.Count,
VSCodeDocumentUri.GetFileSystemPath(DocumentUri)
);
foreach (PackageSource packageSource in _configuredPackageSources)
{
if (packageSource.IsMachineWide)
{
Log.Information(" Globally-configured package source {PackageSourceName} (v{PackageSourceProtocolVersion}) => {PackageSourceUri}",
packageSource.Name,
packageSource.ProtocolVersion,
packageSource.SourceUri
);
}
else
{
Log.Information(" Locally-configured package source {PackageSourceName} (v{PackageSourceProtocolVersion}) => {PackageSourceUri}",
packageSource.Name,
packageSource.ProtocolVersion,
packageSource.SourceUri
);
}
}
_autoCompleteResources.AddRange(
await NuGetHelper.GetAutoCompleteResources(_configuredPackageSources, cancellationToken)
);
return(true);
}
catch (Exception packageSourceLoadError)
{
Log.Error(packageSourceLoadError, "Error configuring NuGet package sources for MSBuild project '{ProjectFileName}'.", ProjectFile.FullName);
return(false);
}
}
public void NuGetHelper_SuccessfulCalls()
{
// Arrange
var package = new PackageName(Guid.NewGuid().ToString("N"), new SemanticVersion("1.0"));
var availablePackages = new[] { package };
ConfigurableServiceProvider sp = CreateServiceProvider();
sp.RegisterService(typeof(SComponentModel), ConfigurableComponentModel.CreateWithExports(MefTestHelpers.CreateExport <IVsPackageInstaller>(new ConfigurablePackageInstaller(availablePackages, simulateInstallerException: false))), replaceExisting: true);
// Act + Assert
NuGetHelper.TryInstallPackage(sp, new ProjectMock("prj"), package.Id, package.Version.ToNormalizedString()).Should().BeTrue("The package is expected to be installed successfully");
}
public async Task <string> GetNuGetPackage(string templatePackName, string?version = null, NuGetVersion?minimumVersion = null, ILogger?logger = null)
{
logger = logger ?? NullLogger.Instance;
NuGetHelper nuGetHelper = new NuGetHelper(_packageLocation, logger);
try
{
logger.LogDebug($"[NuGet Package Manager] Trying to get semaphore.");
await semaphore.WaitAsync().ConfigureAwait(false);
logger.LogDebug($"[NuGet Package Manager] Semaphore acquired.");
if (_installedPackages.TryGetValue(templatePackName, out string?packagePath))
{
return(packagePath);
}
for (int retry = 0; retry < 5; retry++)
{
try
{
logger.LogDebug($"[NuGet Package Manager][attempt: {retry + 1}] Downloading package {templatePackName}, minimum version: {minimumVersion?.ToNormalizedString()}");
string downloadedPackage = await nuGetHelper.DownloadPackageAsync(
templatePackName,
version : version,
additionalSources : new [] { NuGetOrgFeed },
minimumVersion : minimumVersion).ConfigureAwait(false);
_installedPackages[templatePackName] = downloadedPackage;
logger.LogDebug($"[NuGet Package Manager][attempt: {retry + 1}] The package {templatePackName} was successfully downloaded.");
return(downloadedPackage);
}
catch (Exception ex)
{
logger.LogError($"[NuGet Package Manager] Download failed: package {templatePackName}, details: {ex}");
//retry failed download
}
logger.LogDebug($"[NuGet Package Manager][attempt: {retry + 1}] Will wait for 1 sec before re-attempt.");
await Task.Delay(1000).ConfigureAwait(false);
logger.LogDebug($"[NuGet Package Manager][attempt: {retry + 1}] Waiting over.");
}
logger.LogError($"[NuGet Package Manager] Failed to download {templatePackName} after 5 retries.");
throw new Exception($"Failed to download {templatePackName} after 5 retries");
}
finally
{
logger.LogDebug($"[NuGet Package Manager] Releasing semaphore.");
semaphore.Release();
logger.LogDebug($"[NuGet Package Manager] Semaphore released.");
}
}
public ModuleService(IModuleRepository repository, IMapper mapper, IClassRepository classRepository, IPropertyRepository propertyRepository, IEnumRepository enumRepository, IEnumItemRepository enumItemRepository, IModelPropertyRepository modelPropertyRepository, IClassMethodRepository classMethodRepository, CodeGeneratorDbContext dbContext, NuGetHelper nugetHelper, IConfigProvider configProvider)
{
_repository = repository;
_mapper = mapper;
_classRepository = classRepository;
_propertyRepository = propertyRepository;
_enumRepository = enumRepository;
_enumItemRepository = enumItemRepository;
_modelPropertyRepository = modelPropertyRepository;
_classMethodRepository = classMethodRepository;
_dbContext = dbContext;
_nugetHelper = nugetHelper;
_configProvider = configProvider;
}
public async Task UpsertPackageAsync(ILocalPackage package)
{
Console.WriteLine("Upserting package " + package.PublishName + " version " + package.Version + " to remote package repository.");
var basePath = Path.Combine(
package.FolderPath,
package.PublishName + "." + package.Version);
await NuGetHelper.PublishAsync(
basePath + ".nupkg",
_nuGetSettings.ApiKey);
package.PublishUrl = $"https://www.nuget.org/packages/{package.PublishName}/{package.Version}";
}
public async void InstallDgmlNuget(Project project)
{
_package.Dte2.StatusBar.Text = "Installing DbContext Dgml extension package";
var nuGetHelper = new NuGetHelper();
await nuGetHelper.InstallPackageAsync("ErikEJ.EntityFrameworkCore.DgmlBuilder", project);
_package.Dte2.StatusBar.Text = "Dgml package installed";
var path = Path.GetTempFileName() + ".txt";
File.WriteAllText(path, GetReadme(), Encoding.UTF8);
var window = _package.Dte2.ItemOperations.OpenFile(path);
window.Document.Activate();
}
public FormProject(FormType formType, DTE dte, string entityName = null)
{
InitializeComponent();
DTE = dte;
EntityName = entityName;
FormType = formType;
cboCrmVersion.DataSource = NuGetHelper.GetMicrosoftCrmSdkCoreAssembliesPackages();
cboNetVersion.DataSource = new List <string> {
"v4.5.2", "v4.6.2"
};
LoadDefault();
}
public async Task NoFilesFormattedInAnalyzersSolution_WhenNotFixingAnalyzers()
{
var restoreExitCode = await NuGetHelper.PerformRestore(s_analyzersSolutionFilePath, _output);
Assert.Equal(0, restoreExitCode);
await TestFormatWorkspaceAsync(
s_analyzersSolutionFilePath,
include : EmptyFilesList,
exclude : EmptyFilesList,
includeGenerated : false,
expectedExitCode : 0,
expectedFilesFormatted : 0,
expectedFileCount : 7,
fixCategory : FixCategory.Whitespace);
}
private async Task DownloadPackage(bool force, bool usePre)
{
Logger.Log($"Installing package \"{m_PackageId}\"...");
var nuGetPackageManager = NuGetHelper.GetNuGetPackageManager();
var oldIdentity = await nuGetPackageManager.GetLatestPackageIdentityAsync(m_PackageId);
if (!force && oldIdentity != null)
{
Logger.LogWarning($"Package \"{m_PackageId}\" is already installed, skipping. Use \"openmod install -f\" to install anyway.");
return;
}
var package = await nuGetPackageManager.QueryPackageExactAsync(m_PackageId, null, usePre);
if (package?.Identity == null)
{
Logger.LogError($"Downloading has failed for {m_PackageId}: {NuGetInstallCode.PackageOrVersionNotFound}");
return;
}
if (oldIdentity?.Version == package.Identity.Version && package.Identity.HasVersion)
{
Logger.LogError($"Latest version of {package.Identity.Id} is already installed.");
return;
}
var identity = package.Identity;
var installResult = await nuGetPackageManager.InstallAsync(identity, usePre);
var isInstalled = installResult.Code == NuGetInstallCode.Success || installResult.Code == NuGetInstallCode.NoUpdatesFound;
if (isInstalled)
{
m_PackageDirectory = Path.Combine(OpenModInstallerPlugin.Instance.OpenModManager.WorkingDirectory,
"packages",
identity.ToString());
Logger.Log($"Finished downloading \"{m_PackageId}\".");
}
else
{
Logger.Log($"Downloading has failed for {m_PackageId}: {installResult.Code}");
}
Logger.Log($"Installed package \"{m_PackageId}\"@{identity.Version}.");
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
else
{
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseMvc();
PathHelper.Init("/Users/Olivier/Desktop/temp");
NuGetHelper.Init(NuGetCredentials.Key, NuGetCredentials.FeedUrl);
}
public async Task FilesFormattedInCodeStyleSolutionFilter_WhenFixingCodeStyleWarnings()
{
var restoreExitCode = await NuGetHelper.PerformRestore(s_codeStyleSolutionFilterFilePath, _output);
Assert.Equal(0, restoreExitCode);
await TestFormatWorkspaceAsync(
s_codeStyleSolutionFilterFilePath,
include : EmptyFilesList,
exclude : EmptyFilesList,
includeGenerated : false,
expectedExitCode : 0,
expectedFilesFormatted : 1,
expectedFileCount : 3,
fixCategory : FixCategory.Whitespace | FixCategory.CodeStyle,
codeStyleSeverity : DiagnosticSeverity.Warning);
}
public async System.Threading.Tasks.Task InstallDgmlNugetAsync(Project project)
{
await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
_package.Dte2.StatusBar.Text = DgmlLocale.InstallingPackage;
var nuGetHelper = new NuGetHelper();
await nuGetHelper.InstallPackageAsync("ErikEJ.EntityFrameworkCore.DgmlBuilder", project);
_package.Dte2.StatusBar.Text = DgmlLocale.PackageInstalled;
var path = Path.GetTempFileName() + ".txt";
File.WriteAllText(path, GetReadme(), Encoding.UTF8);
var window = _package.Dte2.ItemOperations.OpenFile(path);
window.Document.Activate();
Telemetry.TrackEvent("PowerTools.InstallDgmlNuget");
}
private static async System.Threading.Tasks.Task InstallNuGetPackagesAsync(Project project, bool onlyGenerate, Tuple <bool, string> containsEfCoreReference, ReverseEngineerOptions options, bool forceEdit)
{
var nuGetHelper = new NuGetHelper();
if (options.InstallNuGetPackage && (!onlyGenerate || forceEdit) &&
await project.IsNetCore31OrHigherAsync() &&
containsEfCoreReference != null)
{
await VS.StatusBar.ShowMessageAsync(ReverseEngineerLocale.InstallingEFCoreProviderPackage);
await nuGetHelper.InstallPackageAsync(containsEfCoreReference.Item2, project);
}
if (options.Tables.Any(t => t.ObjectType == ObjectType.Procedure) &&
AdvancedOptions.Instance.DiscoverMultipleResultSets)
{
await nuGetHelper.InstallPackageAsync("Dapper", project);
}
}
public void OnClick(Window mainWindow, Instance instance)
{
if (instance == null)
{
WindowHelper.ShowMessage("Choose an instance first");
return;
}
var product = instance.Product;
Assert.IsNotNull(product, $"The {instance.ProductFullName} distributive is not available in local repository. You need to get it first.");
var version = product.Version + "." + product.Update;
var args = new[]
{
version,
instance.Name,
instance.WebRootPath
};
var dir = Environment.ExpandEnvironmentVariables("%APPDATA%\\Sitecore\\PatchCreator");
if (!Directory.Exists(dir))
{
Directory.CreateDirectory(dir);
}
File.WriteAllLines(Path.Combine(dir, "args.txt"), args);
CoreApp.RunApp("iexplore", $"http://dl.sitecore.net/updater/pc/PatchCreator.application");
NuGetHelper.UpdateSettings();
NuGetHelper.GeneratePackages(new FileInfo(product.PackagePath));
foreach (var module in instance.Modules)
{
NuGetHelper.GeneratePackages(new FileInfo(module.PackagePath));
}
}
public async System.Threading.Tasks.Task InstallDgmlNugetAsync(Project project)
{
await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
await VS.StatusBar.ShowMessageAsync(DgmlLocale.InstallingPackage);
var nuGetHelper = new NuGetHelper();
await nuGetHelper.InstallPackageAsync("ErikEJ.EntityFrameworkCore.DgmlBuilder", project);
await VS.StatusBar.ShowMessageAsync(DgmlLocale.PackageInstalled);
var path = Path.GetTempFileName() + ".txt";
File.WriteAllText(path, GetReadme(), Encoding.UTF8);
var window = await VS.Documents.OpenAsync(path);
await window.WindowFrame.ShowAsync();
Telemetry.TrackEvent("PowerTools.InstallDgmlNuget");
}
public void NuGetHelper_HandleFailures()
{
// Arrange
var sp = CreateServiceProvider();
var testLogger = new TestLogger();
// Case 1: No MEF service
// Act + Assert
using (new AssertIgnoreScope()) // Missing MEF service
{
NuGetHelper.TryInstallPackage(sp, testLogger, new ProjectMock("prj"), "pcg").Should().BeFalse("No MEF service should be resulted with a false returned value");
}
testLogger.AssertOutputStrings(0);
// Case 2: Exception from the service
sp.RegisterService(typeof(SComponentModel), ConfigurableComponentModel.CreateWithExports(MefTestHelpers.CreateExport <IVsPackageInstaller>(new ConfigurablePackageInstaller(simulateInstallerException: true))), replaceExisting: true);
// Act + Assert
NuGetHelper.TryInstallPackage(sp, testLogger, new ProjectMock("prj"), "pcg").Should().BeFalse("Non critical exception should result with a false returned value");
testLogger.AssertOutputStrings(1);
}
public void OnClick(Window mainWindow, Instance instance)
{
Assert.ArgumentNotNull(mainWindow, nameof(mainWindow));
var nugetFolderPath = NuGetHelper.NuGetFolderPath;
Action longRunningTask = delegate
{
if (!Directory.Exists(nugetFolderPath))
{
Directory.CreateDirectory(nugetFolderPath);
}
NuGetHelper.UpdateSettings(nugetFolderPath);
if (InstanceMode)
{
var product = instance.Product;
Assert.IsNotNull(product, $"The {instance.ProductFullName} distributive is not available in local repository. You need to get it first.");
NuGetHelper.GeneratePackages(new FileInfo(product.PackagePath));
var modules = instance.Modules;
foreach (var module in modules)
{
NuGetHelper.GeneratePackages(new FileInfo(module.PackagePath));
}
}
else
{
NuGetHelper.GeneratePackages(ProfileManager.Profile.LocalRepository, nugetFolderPath);
}
};
var content = $"The SC.* NuGet packages are now being generated in the {nugetFolderPath} directory for all Sitecore versions that exist in the local repository. Read more: {Link}";
WindowHelper.LongRunningTask(longRunningTask, "Generating NuGet Packages", mainWindow, null, content, true);
}
public static bool Handle(JObject jsonObject)
{
var url = (string)jsonObject["repository"]["html_url"];
var name = (string)jsonObject["repository"]["name"];
var description = (string)jsonObject["repository"]["description"];
var author = (string)jsonObject["repository"]["owner"]["name"];
var pushed = (long)jsonObject["repository"]["pushed_at"];
Console.WriteLine($"Received webhook for {name}");
var path = GitHelper.CloneRepository(url, (string)jsonObject["repository"]["master_branch"]);
var packagePath = NuGetHelper.CreateNuGetPackage(path, name, $"1.0.0-{pushed}", description, author);
bool success = NuGetHelper.PublishNuGetPackage(packagePath);
if (success)
{
Console.WriteLine($"Published package for {name}...");
}
return(success);
}
public void NuGetHelper_HandleFailures()
{
// Setup
ConfigurableServiceProvider sp = CreateServiceProvider();
var outputWindow = new ConfigurableVsOutputWindow();
var outputPane = outputWindow.GetOrCreateSonarLintPane();
sp.RegisterService(typeof(SVsOutputWindow), outputWindow);
// Case 1: No MEF service
// Act + Verify
using (new AssertIgnoreScope()) // Missing MEF service
{
Assert.IsFalse(NuGetHelper.TryInstallPackage(sp, new ProjectMock("prj"), "pcg"), "No MEF service should be resulted with a false returned value");
}
outputPane.AssertOutputStrings(0);
// Case 2: Exception from the service
sp.RegisterService(typeof(SComponentModel), ConfigurableComponentModel.CreateWithExports(MefTestHelpers.CreateExport <IVsPackageInstaller>(new ConfigurablePackageInstaller(simulateInstallerException: true))), replaceExisting: true);
// Act + Verify
Assert.IsFalse(NuGetHelper.TryInstallPackage(sp, new ProjectMock("prj"), "pcg"), "Non critical exception should result with a false returned value");
outputPane.AssertOutputStrings(1);
}
