public async Task <Package> GetByVersionAndIdAsync(string id, string version, bool isPrerelease)
{
using (await Lock.ReadLockAsync())
{
var choco = Lets.GetChocolatey().SetCustomLogging(new SerilogLogger(Logger, _progressService));
choco.Set(
config =>
{
config.CommandName = "list";
config.Input = id;
config.ListCommand.Exact = true;
config.Version = version;
config.QuietOutput = true;
config.RegularOutput = false;
#if !DEBUG
config.Verbose = false;
#endif // DEBUG
});
var chocoConfig = choco.GetConfiguration();
var nugetLogger = choco.Container().GetInstance <NuGet.ILogger>();
var semvar = new SemanticVersion(version);
var nugetPackage = (NugetList.GetPackages(chocoConfig, nugetLogger) as IQueryable <IPackage>).FirstOrDefault(p => p.Version == semvar);
if (nugetPackage == null)
{
throw new Exception("No Package Found");
}
return(GetMappedPackage(choco, new PackageResult(nugetPackage, null, chocoConfig.Sources), _mapper));
}
}
public async Task <PackageOperationResult> UnpinPackage(string id, string version)
{
using (await Lock.WriteLockAsync())
{
var choco = Lets.GetChocolatey().SetCustomLogging(new SerilogLogger(Logger, _progressService));
choco.Set(
config =>
{
config.CommandName = "pin";
config.PinCommand.Command = PinCommandType.remove;
config.PinCommand.Name = id;
config.Version = version;
});
try
{
await choco.RunAsync();
}
catch (Exception ex)
{
return(new PackageOperationResult {
Successful = false, Exception = ex
});
}
return(PackageOperationResult.SuccessfulCached);
}
}
protected override async void OnStartup(object sender, StartupEventArgs e)
{
try
{
// Do not remove! Load Chocolatey once so all config gets set
// properly for future calls
var choco = Lets.GetChocolatey();
Mapper.Initialize(config =>
{
config.CreateMap <Package, IPackageViewModel>().ConstructUsing(rc => Container.Resolve <IPackageViewModel>());
});
var packageService = Container.Resolve <IChocolateyService>();
var features = await packageService.GetFeatures();
var backgroundFeature = features.FirstOrDefault(feature => string.Equals(feature.Name, "useBackgroundService", StringComparison.OrdinalIgnoreCase));
var elevationProvider = Elevation.Instance;
elevationProvider.IsBackgroundRunning = backgroundFeature?.Enabled ?? false;
var splashScreen = Container.Resolve <ISplashScreenService>();
splashScreen.Close(TimeSpan.FromMilliseconds(300));
DisplayRootViewFor <ShellViewModel>();
}
catch (Exception ex)
{
MessageBox.Show(string.Format(Resources.Fatal_Startup_Error_Formatted, ex.Message));
Logger.Fatal(ex, Resources.Fatal_Startup_Error);
await OnExitAsync();
}
}
public async Task <IReadOnlyList <Tuple <string, SemanticVersion> > > GetOutdatedPackages(bool includePrerelease = false, string packageName = null)
{
using (await Lock.ReadLockAsync())
{
var choco = Lets.GetChocolatey().SetCustomLogging(new SerilogLogger(Logger, _progressService));
choco.Set(
config =>
{
config.CommandName = "outdated";
config.PackageNames = packageName ?? ApplicationParameters.AllPackages;
config.UpgradeCommand.NotifyOnlyAvailableUpgrades = true;
config.RegularOutput = false;
config.QuietOutput = true;
config.Prerelease = false;
});
var chocoConfig = choco.GetConfiguration();
var nugetService = choco.Container().GetInstance <INugetService>();
var packages = await Task.Run(() => nugetService.upgrade_noop(chocoConfig, null));
var results = packages
.Where(p => !p.Value.Inconclusive)
.Select(p => Tuple.Create(p.Value.Package.Id, p.Value.Package.Version.ToNormalizedString()))
.ToArray();
var parsed = results.Select(result => Tuple.Create(result.Item1, new SemanticVersion(result.Item2)));
return(parsed.ToList());
}
}
public async Task <bool> RemoveSource(string id)
{
using (await Lock.WriteLockAsync())
{
var chocoConfig = await GetConfigFile();
var sources = chocoConfig.Sources.Select(_mapper.Map <ChocolateySource>).ToList();
if (sources.All(source => source.Id != id))
{
return(false);
}
var choco = Lets.GetChocolatey().SetCustomLogging(new SerilogLogger(Logger, _progressService));
choco.Set(
config =>
{
config.CommandName = "source";
config.SourceCommand.Command = SourceCommandType.remove;
config.SourceCommand.Name = id;
});
await choco.RunAsync();
return(true);
}
}
private async Task <List <Result> > ChocolateyResults(Action <ChocolateyConfiguration> propConfig, int count, Func <ActionContext, PackageResult, bool> action)
{
List <Result> results = new List <Result>();
IEnumerable <PackageResult> packages = Lets.GetChocolatey().Set(propConfig).List <PackageResult>().Take(count);
foreach (var package in packages)
{
var iconUrlString = package.Package.IconUrl.ToString();
string iconPath;
if (string.IsNullOrEmpty(iconUrlString))
{
iconPath = context.CurrentPluginMetadata.IcoPath;
}
else
{
var extension = iconUrlString.Substring(iconUrlString.LastIndexOf('.'));
iconPath = tempPath + package.Name + package.Version + extension;
if ((!File.Exists(iconPath) && extension != ".svg") || (extension == ".svg" && !File.Exists(iconPath.Replace(extension, ".png"))))
{
using (var client = new HttpClient())
try
{
using (var stream = await client.GetStreamAsync(package.Package.IconUrl))
if (extension != ".svg")
{
using (var fileStream = new FileStream(iconPath, FileMode.CreateNew))
await stream.CopyToAsync(fileStream);
}
else
{
SvgDocument.Open <SvgDocument>(stream).Draw().Save(iconPath = iconPath.Replace(extension, ".png"));
}
}
catch (HttpRequestException)
{
iconPath = context.CurrentPluginMetadata.IcoPath;
}
}
else if (extension == ".svg")
{
iconPath = iconPath.Replace(extension, ".png");
}
}
results.Add(new Result
{
Title = package.Package.Title,
SubTitle = $"{package.Version} - {package.Package.Summary}",
IcoPath = iconPath,
ContextData = package,
Action = c => action(c, package)
});
}
return(results);
}
private async Task <ConfigFileSettings> GetConfigFile()
{
var choco = Lets.GetChocolatey();
var xmlService = choco.Container().GetInstance <IXmlService>();
var config =
await Task.Run(
() => xmlService.deserialize <ConfigFileSettings>(ApplicationParameters.GlobalConfigFileLocation));
return(config);
}
private void SetDefaults()
{
var choco = Lets.GetChocolatey();
var config = choco.GetConfiguration();
DownloadChecksumType = "md5";
DownloadChecksumType64bit = "md5";
ExecutionTimeoutInSeconds = config.CommandExecutionTimeoutSeconds;
CacheLocation = config.CacheLocation;
LogFile = config.AdditionalLogFileLocation;
}
#pragma warning disable SA1401 // Fields must be private
#pragma warning restore SA1401 // Fields must be private
public ChocolateyService(IMapper mapper, IProgressService progressService, IChocolateyConfigSettingsService configSettingsService, IXmlService xmlService, IFileSystem fileSystem, IConfigService configService)
{
_mapper = mapper;
_progressService = progressService;
_configSettingsService = configSettingsService;
_xmlService = xmlService;
_fileSystem = fileSystem;
_configService = configService;
_choco = Lets.GetChocolatey().SetCustomLogging(new SerilogLogger(Logger, _progressService));
_localAppDataPath = _fileSystem.combine_paths(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData, Environment.SpecialFolderOption.DoNotVerify), "Chocolatey GUI");
}
// This can take a while with many packages
private static int GetOutdatedCount()
{
GetChocolatey chocolatey = Lets.GetChocolatey();
chocolatey.SetCustomLogging(new chocolatey.infrastructure.logging.NullLog());
chocolatey.Set(c => { c.CommandName = "outdated"; c.PackageNames = ApplicationParameters.AllPackages; });
INugetService nuget = chocolatey.Container().GetInstance <INugetService>();
ConcurrentDictionary <string, PackageResult> upgradeResults = nuget.upgrade_noop(chocolatey.GetConfiguration(), null);
return(upgradeResults.Values.Count((v) => { return !v.Inconclusive; }));
}
public async Task <PackageOperationResult> InstallPackage(
string id,
string version = null,
Uri source = null,
bool force = false)
{
using (await Lock.WriteLockAsync())
{
var logger = new SerilogLogger(Logger, _progressService);
var choco = Lets.GetChocolatey().SetCustomLogging(logger);
choco.Set(
config =>
{
config.CommandName = CommandNameType.install.ToString();
config.PackageNames = id;
config.Features.UsePackageExitCodes = false;
if (version != null)
{
config.Version = version.ToString();
}
if (source != null)
{
config.Sources = source.ToString();
}
if (force)
{
config.Force = true;
}
});
Action <LogMessage> grabErrors;
var errors = GetErrors(out grabErrors);
using (logger.Intercept(grabErrors))
{
await choco.RunAsync();
if (Environment.ExitCode != 0)
{
Environment.ExitCode = 0;
return(new PackageOperationResult {
Successful = false, Messages = errors.ToArray()
});
}
return(PackageOperationResult.SuccessfulCached);
}
}
}
protected override void Load(ContainerBuilder builder)
{
// Register Providers
builder.RegisterType <VersionNumberProvider>().As <IVersionNumberProvider>().SingleInstance();
builder.RegisterType <ChocolateyConfigurationProvider>().As <IChocolateyConfigurationProvider>().SingleInstance();
builder.RegisterType <DotNetFileSystem>().As <chocolatey.infrastructure.filesystem.IFileSystem>().SingleInstance();
var choco = Lets.GetChocolatey();
builder.RegisterInstance(choco.Container().GetInstance <IChocolateyConfigSettingsService>())
.As <IChocolateyConfigSettingsService>().SingleInstance();
builder.RegisterInstance(choco.Container().GetInstance <IXmlService>())
.As <IXmlService>().SingleInstance();
builder.RegisterType <ChocolateyGuiCacheService>().As <IChocolateyGuiCacheService>().SingleInstance();
try
{
var userDatabase = new LiteDatabase($"filename={Path.Combine(Bootstrapper.LocalAppDataPath, "data.db")};upgrade=true");
var globalDatabase = Hacks.IsElevated
? new LiteDatabase($"filename={Path.Combine(Bootstrapper.AppDataPath, "Config", "data.db")};upgrade=true")
: new LiteDatabase($"filename={Path.Combine(Bootstrapper.AppDataPath, "Config", "data.db")};upgrade=true;readonly=true");
var configService = new ConfigService(globalDatabase, userDatabase);
configService.SetEffectiveConfiguration();
builder.RegisterInstance(configService).As <IConfigService>().SingleInstance();
builder.RegisterInstance(new LiteDBFileStorageService(userDatabase)).As <IFileStorageService>().SingleInstance();
// Since there are two instances of LiteDB, they are added as named instances, so that they can be retrieved when required
builder.RegisterInstance(userDatabase).As <LiteDatabase>().SingleInstance().Named <LiteDatabase>(Bootstrapper.UserConfigurationDatabaseName);
builder.RegisterInstance(globalDatabase).As <LiteDatabase>().SingleInstance().Named <LiteDatabase>(Bootstrapper.GlobalConfigurationDatabaseName);
}
catch (IOException ex)
{
Bootstrapper.Logger.Error(ex, Resources.Error_DatabaseAccessCli);
Environment.Exit(-1);
}
// Services
builder.RegisterType <VersionService>().As <IVersionService>().SingleInstance();
// Commands
// These are using Named registrations to aid with the "finding" of these components
// within the Container. As suggested in this Stack Overflow question:
// https://stackoverflow.com/questions/4999000/replace-registration-in-autofac
builder.RegisterType <FeatureCommand>().As <ICommand>().SingleInstance().Named <ICommand>(FeatureCommandName);
builder.RegisterType <ConfigCommand>().As <ICommand>().SingleInstance().Named <ICommand>(ConfigCommandName);
builder.RegisterType <PurgeCommand>().As <ICommand>().SingleInstance().Named <ICommand>(PurgeCommandName);
}
public async Task AddSource(ChocolateySource source)
{
using (await Lock.WriteLockAsync())
{
var choco = Lets.GetChocolatey().SetCustomLogging(new SerilogLogger(Logger, _progressService));
choco.Set(
config =>
{
config.CommandName = "source";
config.SourceCommand.Command = SourceCommandType.add;
config.SourceCommand.Name = source.Id;
config.Sources = source.Value;
config.SourceCommand.Username = source.UserName;
config.SourceCommand.Password = source.Password;
config.SourceCommand.Certificate = source.Certificate;
config.SourceCommand.CertificatePassword = source.CertificatePassword;
config.SourceCommand.Priority = source.Priority;
config.SourceCommand.BypassProxy = source.BypassProxy;
config.SourceCommand.AllowSelfService = source.AllowSelfService;
config.SourceCommand.VisibleToAdminsOnly = source.VisibleToAdminsOnly;
});
await choco.RunAsync();
if (source.Disabled)
{
choco.Set(
config =>
{
config.CommandName = "source";
config.SourceCommand.Command = SourceCommandType.disable;
config.SourceCommand.Name = source.Id;
});
await choco.RunAsync();
}
else
{
choco.Set(
config =>
{
config.CommandName = "source";
config.SourceCommand.Command = SourceCommandType.enable;
config.SourceCommand.Name = source.Id;
});
await choco.RunAsync();
}
}
}
public async Task SetFeature(ChocolateyFeature feature)
{
using (await Lock.WriteLockAsync())
{
var choco = Lets.GetChocolatey().SetCustomLogging(new SerilogLogger(Logger, _progressService));
choco.Set(
config =>
{
config.CommandName = "feature";
config.FeatureCommand.Command = feature.Enabled ? FeatureCommandType.enable : FeatureCommandType.disable;
config.FeatureCommand.Name = feature.Name;
});
await choco.RunAsync();
}
}
public async Task SetSetting(ChocolateySetting setting)
{
using (await Lock.WriteLockAsync())
{
var choco = Lets.GetChocolatey().SetCustomLogging(new SerilogLogger(Logger, _progressService));
choco.Set(
config =>
{
config.CommandName = "config";
config.ConfigCommand.Command = ConfigCommandType.set;
config.ConfigCommand.Name = setting.Key;
config.ConfigCommand.ConfigValue = setting.Value;
});
await choco.RunAsync();
}
}
public async Task <PackageOperationResult> UpdatePackage(string id, Uri source = null)
{
using (await Lock.WriteLockAsync())
{
var logger = new SerilogLogger(Logger, _progressService);
var choco = Lets.GetChocolatey().SetCustomLogging(logger);
choco.Set(
config =>
{
config.CommandName = CommandNameType.upgrade.ToString();
config.PackageNames = id;
config.Features.UsePackageExitCodes = false;
});
return(await RunCommand(choco, logger));
}
}
public async Task <IEnumerable <Package> > GetInstalledPackages()
{
using (await Lock.ReadLockAsync())
{
var choco = Lets.GetChocolatey().SetCustomLogging(new SerilogLogger(Logger, _progressService));
choco.Set(
config =>
{
config.CommandName = CommandNameType.list.ToString();
config.ListCommand.LocalOnly = true;
});
return((await choco.ListAsync <PackageResult>())
.Select(package => GetMappedPackage(choco, package, _mapper, true))
.ToArray());
}
}
public async Task <PackageOperationResult> UninstallPackage(string id, string version, bool force = false)
{
using (await Lock.WriteLockAsync())
{
var logger = new SerilogLogger(Logger, _progressService);
var choco = Lets.GetChocolatey().SetCustomLogging(logger);
choco.Set(
config =>
{
config.CommandName = CommandNameType.uninstall.ToString();
config.PackageNames = id;
config.Features.UsePackageExitCodes = false;
if (version != null)
{
config.Version = version.ToString();
}
});
return(await RunCommand(choco, logger));
}
}
public async Task <PackageResults> Search(string query, PackageSearchOptions options)
{
using (await Lock.ReadLockAsync())
{
var choco = Lets.GetChocolatey().SetCustomLogging(new SerilogLogger(Logger, _progressService));
choco.Set(
config =>
{
config.CommandName = CommandNameType.list.ToString();
config.Input = query;
config.AllVersions = options.IncludeAllVersions;
config.ListCommand.Page = options.CurrentPage;
config.ListCommand.PageSize = options.PageSize;
if (string.IsNullOrWhiteSpace(query) || !string.IsNullOrWhiteSpace(options.SortColumn))
{
config.ListCommand.OrderByPopularity = string.IsNullOrWhiteSpace(options.SortColumn) ||
options.SortColumn == "DownloadCount";
}
config.ListCommand.Exact = options.MatchQuery;
if (!string.IsNullOrWhiteSpace(options.Source))
{
config.Sources = options.Source;
}
#if !DEBUG
config.Verbose = false;
#endif // DEBUG
});
var packages =
(await choco.ListAsync <PackageResult>()).Select(
pckge => GetMappedPackage(choco, pckge, _mapper));
return(new PackageResults
{
Packages = packages.ToArray(),
TotalCount = await Task.Run(() => choco.ListCount())
});
}
}
protected override void Load(ContainerBuilder builder)
{
// Register Providers
builder.RegisterType <VersionNumberProvider>().As <IVersionNumberProvider>().SingleInstance();
builder.RegisterType <ChocolateyConfigurationProvider>().As <IChocolateyConfigurationProvider>().SingleInstance();
builder.RegisterType <DotNetFileSystem>().As <chocolatey.infrastructure.filesystem.IFileSystem>().SingleInstance();
var choco = Lets.GetChocolatey();
builder.RegisterInstance(choco.Container().GetInstance <IChocolateyConfigSettingsService>())
.As <IChocolateyConfigSettingsService>().SingleInstance();
builder.RegisterInstance(choco.Container().GetInstance <IXmlService>())
.As <IXmlService>().SingleInstance();
builder.RegisterType <LiteDBFileStorageService>().As <IFileStorageService>().SingleInstance();
builder.RegisterType <ConfigService>().As <IConfigService>().SingleInstance();
builder.RegisterType <ChocolateyGuiCacheService>().As <IChocolateyGuiCacheService>().SingleInstance();
try
{
var database = new LiteDatabase($"filename={Path.Combine(Bootstrapper.LocalAppDataPath, "data.db")};upgrade=true");
builder.Register(c => database).SingleInstance();
}
catch (IOException ex)
{
Bootstrapper.Logger.Error(ex, Resources.Error_DatabaseAccessCli);
Environment.Exit(-1);
}
// Commands
// These are using Named registrations to aid with the "finding" of these components
// within the Container. As suggested in this Stack Overflow question:
// https://stackoverflow.com/questions/4999000/replace-registration-in-autofac
builder.RegisterType <FeatureCommand>().As <ICommand>().SingleInstance().Named <ICommand>(ApplicationParameters.FeatureCommandName);
builder.RegisterType <ConfigCommand>().As <ICommand>().SingleInstance().Named <ICommand>(ApplicationParameters.ConfigCommandName);
builder.RegisterType <PurgeCommand>().As <ICommand>().SingleInstance().Named <ICommand>(ApplicationParameters.PurgeCommandName);
}
public async Task <PackageOperationResult> InstallPackage(
string id,
string version = null,
Uri source = null,
bool force = false,
AdvancedInstall advancedInstallOptions = null)
{
using (await Lock.WriteLockAsync())
{
var logger = new SerilogLogger(Logger, _progressService);
var choco = Lets.GetChocolatey(initializeLogging: false).SetCustomLogging(logger, logExistingMessages: false, addToExistingLoggers: true);
choco.Set(
config =>
{
config.CommandName = CommandNameType.install.ToString();
config.PackageNames = id;
config.Features.UsePackageExitCodes = false;
if (version != null)
{
config.Version = version.ToString();
}
if (source != null)
{
config.Sources = source.ToString();
}
if (force)
{
config.Force = true;
}
if (advancedInstallOptions != null)
{
config.InstallArguments = advancedInstallOptions.InstallArguments;
config.PackageParameters = advancedInstallOptions.PackageParameters;
config.CommandExecutionTimeoutSeconds = advancedInstallOptions.ExecutionTimeoutInSeconds;
if (!string.IsNullOrEmpty(advancedInstallOptions.LogFile))
{
config.AdditionalLogFileLocation = advancedInstallOptions.LogFile;
}
config.Prerelease = advancedInstallOptions.PreRelease;
config.ForceX86 = advancedInstallOptions.Forcex86;
config.OverrideArguments = advancedInstallOptions.OverrideArguments;
config.NotSilent = advancedInstallOptions.NotSilent;
config.ApplyInstallArgumentsToDependencies = advancedInstallOptions.ApplyInstallArgumentsToDependencies;
config.ApplyPackageParametersToDependencies = advancedInstallOptions.ApplyPackageParametersToDependencies;
config.AllowDowngrade = advancedInstallOptions.AllowDowngrade;
config.AllowMultipleVersions = advancedInstallOptions.AllowMultipleVersions;
config.IgnoreDependencies = advancedInstallOptions.IgnoreDependencies;
config.ForceDependencies = advancedInstallOptions.ForceDependencies;
config.SkipPackageInstallProvider = advancedInstallOptions.SkipPowerShell;
config.Features.ChecksumFiles = !advancedInstallOptions.IgnoreChecksums;
config.Features.AllowEmptyChecksums = advancedInstallOptions.AllowEmptyChecksums;
config.Features.AllowEmptyChecksumsSecure = advancedInstallOptions.AllowEmptyChecksumsSecure;
if (advancedInstallOptions.RequireChecksums)
{
config.Features.AllowEmptyChecksums = false;
config.Features.AllowEmptyChecksumsSecure = false;
}
if (!string.IsNullOrEmpty(advancedInstallOptions.CacheLocation))
{
config.CacheLocation = advancedInstallOptions.CacheLocation;
}
config.DownloadChecksum = advancedInstallOptions.DownloadChecksum;
config.DownloadChecksum64 = advancedInstallOptions.DownloadChecksum64bit;
config.DownloadChecksumType = advancedInstallOptions.DownloadChecksumType;
config.DownloadChecksumType64 = advancedInstallOptions.DownloadChecksumType64bit;
}
});
Action <LogMessage> grabErrors;
var errors = GetErrors(out grabErrors);
using (logger.Intercept(grabErrors))
{
await choco.RunAsync();
if (Environment.ExitCode != 0)
{
Environment.ExitCode = 0;
return(new PackageOperationResult {
Successful = false, Messages = errors.ToArray()
});
}
return(PackageOperationResult.SuccessfulCached);
}
}
}
protected override void Load(ContainerBuilder builder)
{
var viewModelAssembly = typeof(ShellViewModel).Assembly;
var viewAssembly = typeof(ShellView).Assembly;
// Register Providers
builder.RegisterType <VersionNumberProvider>().As <IVersionNumberProvider>().SingleInstance();
builder.RegisterType <Elevation>().SingleInstance();
builder.RegisterType <ChocolateyConfigurationProvider>().As <IChocolateyConfigurationProvider>().SingleInstance();
builder.RegisterType <ChocolateyService>().As <IChocolateyService>().SingleInstance();
builder.RegisterType <DotNetFileSystem>().As <chocolatey.infrastructure.filesystem.IFileSystem>().SingleInstance();
builder.RegisterType <PackageArgumentsService>().As <IPackageArgumentsService>().SingleInstance();
builder.RegisterType <DefaultEncryptionUtility>().As <IEncryptionUtility>().SingleInstance();
// Register ViewModels
builder.RegisterAssemblyTypes(viewModelAssembly)
.Where(type => type.Name.EndsWith("ViewModel", StringComparison.Ordinal))
.Where(type => type.GetInterface(typeof(INotifyPropertyChanged).Name) != null)
.AsSelf()
.InstancePerDependency();
builder.RegisterType <PackageViewModel>().As <IPackageViewModel>();
var choco = Lets.GetChocolatey(initializeLogging: true);
builder.RegisterInstance(choco.Container().GetInstance <IChocolateyConfigSettingsService>())
.As <IChocolateyConfigSettingsService>().SingleInstance();
builder.RegisterInstance(choco.Container().GetInstance <IXmlService>())
.As <IXmlService>().SingleInstance();
// Register Views
builder.RegisterAssemblyTypes(viewAssembly)
.Where(type => type.Name.EndsWith("View", StringComparison.Ordinal))
.AsSelf()
.InstancePerDependency();
// Register the single window manager for this container
builder.Register <IWindowManager>(c => new WindowManager()).InstancePerLifetimeScope();
// Register the single event aggregator for this container
builder.Register <IEventAggregator>(c => new EventAggregator()).InstancePerLifetimeScope();
// Register Services
builder.RegisterType <DialogService>().As <IDialogService>().SingleInstance();
builder.RegisterType <ProgressService>().As <IProgressService>().SingleInstance();
builder.RegisterType <PersistenceService>().As <IPersistenceService>().SingleInstance();
builder.RegisterType <LiteDBFileStorageService>().As <IFileStorageService>().SingleInstance();
builder.RegisterType <ChocolateyGuiCacheService>().As <IChocolateyGuiCacheService>().SingleInstance();
builder.RegisterType <AllowedCommandsService>().As <IAllowedCommandsService>().SingleInstance();
// Register Mapper
var mapperConfiguration = new MapperConfiguration(config =>
{
config.CreateMap <IPackageViewModel, IPackageViewModel>()
.ForMember(vm => vm.IsInstalled, options => options.Ignore());
config.CreateMap <DataServicePackage, Package>()
.ForMember(dest => dest.Authors, opt => opt.MapFrom(src => src.Authors.Split(',')))
.ForMember(dest => dest.Owners, opt => opt.MapFrom(src => src.Owners.Split(',')));
config.CreateMap <IPackage, Package>();
config.CreateMap <ConfigFileFeatureSetting, ChocolateyFeature>();
config.CreateMap <ConfigFileConfigSetting, ChocolateySetting>();
config.CreateMap <ConfigFileSourceSetting, Common.Models.ChocolateySource>()
.ForMember(dest => dest.Password, opt => opt.MapFrom(src => NugetEncryptionUtility.DecryptString(src.Password)))
.ForMember(dest => dest.CertificatePassword, opt => opt.MapFrom(src => NugetEncryptionUtility.DecryptString(src.CertificatePassword)));
config.CreateMap <ChocolateySource, Common.Models.ChocolateySource>()
.ForMember(dest => dest.VisibleToAdminsOnly, opt => opt.MapFrom(src => src.VisibleToAdminOnly));
config.CreateMap <AdvancedInstallViewModel, AdvancedInstall>()
.ForMember(
dest => dest.DownloadChecksum,
opt => opt.Condition(source => !source.IgnoreChecksums))
.ForMember(
dest => dest.DownloadChecksumType,
opt => opt.Condition(source =>
!source.IgnoreChecksums && !string.IsNullOrEmpty(source.DownloadChecksum)))
.ForMember(
dest => dest.DownloadChecksum64bit,
opt => opt.Condition(source =>
Environment.Is64BitOperatingSystem &&
!source.IgnoreChecksums &&
!source.Forcex86))
.ForMember(
dest => dest.DownloadChecksumType64bit,
opt => opt.Condition(source =>
Environment.Is64BitOperatingSystem &&
!source.IgnoreChecksums &&
!source.Forcex86 &&
!string.IsNullOrEmpty(source.DownloadChecksum64bit)))
.ForMember(
dest => dest.PackageParameters,
opt => opt.Condition(source => !source.SkipPowerShell))
.ForMember(
dest => dest.InstallArguments,
opt => opt.Condition(source => !source.SkipPowerShell && !source.NotSilent));
});
builder.RegisterType <BundledThemeService>().As <IBundledThemeService>().SingleInstance();
builder.RegisterInstance(mapperConfiguration.CreateMapper()).As <IMapper>();
builder.Register(c => TranslationSource.Instance).SingleInstance();
try
{
var userDatabase = new LiteDatabase($"filename={Path.Combine(Bootstrapper.LocalAppDataPath, "data.db")};upgrade=true");
LiteDatabase globalDatabase;
if (Hacks.IsElevated)
{
globalDatabase = new LiteDatabase($"filename={Path.Combine(Bootstrapper.AppDataPath, "Config", "data.db")};upgrade=true");
}
else
{
if (!File.Exists(Path.Combine(Bootstrapper.AppDataPath, "Config", "data.db")))
{
// Since the global configuration database file doesn't exist, we must be running in a state where an administrator user
// has never run Chocolatey GUI. In this case, use null, which will mean attempts to use the global database will be ignored.
globalDatabase = null;
}
else
{
// Since this is a non-administrator user, they should only have read permissions to this database
globalDatabase = new LiteDatabase($"filename={Path.Combine(Bootstrapper.AppDataPath, "Config", "data.db")};readonly=true");
}
}
if (globalDatabase != null)
{
builder.RegisterInstance(globalDatabase).As <LiteDatabase>().SingleInstance().Named <LiteDatabase>(Bootstrapper.GlobalConfigurationDatabaseName);
}
var configService = new ConfigService(globalDatabase, userDatabase);
configService.SetEffectiveConfiguration();
var iconService = new PackageIconService(userDatabase);
builder.RegisterInstance(iconService).As <IPackageIconService>().SingleInstance();
builder.RegisterInstance(configService).As <IConfigService>().SingleInstance();
builder.RegisterInstance(new LiteDBFileStorageService(userDatabase)).As <IFileStorageService>().SingleInstance();
// Since there are two instances of LiteDB, they are added as named instances, so that they can be retrieved when required
builder.RegisterInstance(userDatabase).As <LiteDatabase>().SingleInstance().Named <LiteDatabase>(Bootstrapper.UserConfigurationDatabaseName);
}
catch (IOException ex)
{
Bootstrapper.Logger.Error(ex, TranslationSource.Instance[nameof(Resources.Error_DatabaseAccessGui)]);
throw;
}
builder.RegisterType <ImageService>().As <IImageService>().SingleInstance();
builder.RegisterType <VersionService>().As <IVersionService>().SingleInstance();
builder.RegisterType <SplashScreenService>().As <ISplashScreenService>().SingleInstance();
}
/// <summary>
/// Performs one-time initialization of the $provider.
/// </summary>
/// <param name="request">An object passed in from the CORE that contains functions that can be used to interact with the CORE and HOST</param>
public void InitializeProvider(Request request)
{
request.Debug("Entering '{0}::InitializeProvider' to set up a chocolatey with custom logging", PackageProviderName);
_chocolatey = Lets.GetChocolatey().SetCustomLogging(new RequestLogger(request));
}
protected override void Load(ContainerBuilder builder)
{
// Register Providers
builder.RegisterType <VersionNumberProvider>().As <IVersionNumberProvider>().SingleInstance();
builder.RegisterType <ChocolateyConfigurationProvider>().As <IChocolateyConfigurationProvider>().SingleInstance();
builder.RegisterType <DotNetFileSystem>().As <chocolatey.infrastructure.filesystem.IFileSystem>().SingleInstance();
var choco = Lets.GetChocolatey(initializeLogging: false);
builder.RegisterInstance(choco.Container().GetInstance <IChocolateyConfigSettingsService>())
.As <IChocolateyConfigSettingsService>().SingleInstance();
builder.RegisterInstance(choco.Container().GetInstance <IXmlService>())
.As <IXmlService>().SingleInstance();
builder.RegisterType <ChocolateyGuiCacheService>().As <IChocolateyGuiCacheService>().SingleInstance();
try
{
var userDatabase = new LiteDatabase($"filename={Path.Combine(Bootstrapper.LocalAppDataPath, "data.db")};upgrade=true");
LiteDatabase globalDatabase;
if (Hacks.IsElevated)
{
globalDatabase = new LiteDatabase($"filename={Path.Combine(Bootstrapper.AppDataPath, "Config", "data.db")};upgrade=true");
}
else
{
if (!File.Exists(Path.Combine(Bootstrapper.AppDataPath, "Config", "data.db")))
{
// Since the global configuration database file doesn't exist, we must be running in a state where an administrator user
// has never run Chocolatey GUI. In this case, use null, which will mean attempts to use the global database will be ignored.
globalDatabase = null;
}
else
{
// Since this is a non-administrator user, they should only have read permissions to this database
globalDatabase = new LiteDatabase($"filename={Path.Combine(Bootstrapper.AppDataPath, "Config", "data.db")};readonly=true");
}
}
if (globalDatabase != null)
{
builder.RegisterInstance(globalDatabase).As <LiteDatabase>().SingleInstance().Named <LiteDatabase>(Bootstrapper.GlobalConfigurationDatabaseName);
}
var configService = new ConfigService(globalDatabase, userDatabase);
configService.SetEffectiveConfiguration();
builder.RegisterInstance(configService).As <IConfigService>().SingleInstance();
builder.RegisterInstance(new LiteDBFileStorageService(userDatabase)).As <IFileStorageService>().SingleInstance();
// Since there are two instances of LiteDB, they are added as named instances, so that they can be retrieved when required
builder.RegisterInstance(userDatabase).As <LiteDatabase>().SingleInstance().Named <LiteDatabase>(Bootstrapper.UserConfigurationDatabaseName);
}
catch (IOException ex)
{
Bootstrapper.Logger.Error(ex, TranslationSource.Instance[Resources.Error_DatabaseAccessCli]);
Environment.Exit(-1);
}
// Services
builder.RegisterType <VersionService>().As <IVersionService>().SingleInstance();
// Commands
// These are using Named registrations to aid with the "finding" of these components
// within the Container. As suggested in this Stack Overflow question:
// https://stackoverflow.com/questions/4999000/replace-registration-in-autofac
builder.RegisterType <FeatureCommand>().As <ICommand>().SingleInstance().Named <ICommand>(FeatureCommandName);
builder.RegisterType <ConfigCommand>().As <ICommand>().SingleInstance().Named <ICommand>(ConfigCommandName);
builder.RegisterType <PurgeCommand>().As <ICommand>().SingleInstance().Named <ICommand>(PurgeCommandName);
}
protected override void Load(ContainerBuilder builder)
{
var viewModelAssembly = typeof(ShellViewModel).Assembly;
var viewAssembly = typeof(ShellView).Assembly;
// Register Providers
builder.RegisterType <VersionNumberProvider>().As <IVersionNumberProvider>().SingleInstance();
builder.RegisterType <Elevation>().SingleInstance();
builder.RegisterType <ChocolateyConfigurationProvider>().As <IChocolateyConfigurationProvider>().SingleInstance();
builder.RegisterType <ChocolateyService>().As <IChocolateyService>().SingleInstance();
builder.RegisterType <DotNetFileSystem>().As <chocolatey.infrastructure.filesystem.IFileSystem>().SingleInstance();
// Register ViewModels
builder.RegisterAssemblyTypes(viewModelAssembly)
.Where(type => type.Name.EndsWith("ViewModel", StringComparison.Ordinal))
.Where(type => type.GetInterface(typeof(INotifyPropertyChanged).Name) != null)
.AsSelf()
.InstancePerDependency();
builder.RegisterType <PackageViewModel>().As <IPackageViewModel>();
var choco = Lets.GetChocolatey();
builder.RegisterInstance(choco.Container().GetInstance <IChocolateyConfigSettingsService>())
.As <IChocolateyConfigSettingsService>().SingleInstance();
builder.RegisterInstance(choco.Container().GetInstance <IXmlService>())
.As <IXmlService>().SingleInstance();
// Register Views
builder.RegisterAssemblyTypes(viewAssembly)
.Where(type => type.Name.EndsWith("View", StringComparison.Ordinal))
.AsSelf()
.InstancePerDependency();
// Register the single window manager for this container
builder.Register <IWindowManager>(c => new WindowManager()).InstancePerLifetimeScope();
// Register the single event aggregator for this container
builder.Register <IEventAggregator>(c => new EventAggregator()).InstancePerLifetimeScope();
// Register Services
builder.RegisterType <ProgressService>().As <IProgressService>().SingleInstance();
builder.RegisterType <PersistenceService>().As <IPersistenceService>().SingleInstance();
builder.RegisterType <LiteDBFileStorageService>().As <IFileStorageService>().SingleInstance();
builder.RegisterType <ConfigService>().As <IConfigService>().SingleInstance();
builder.RegisterType <ChocolateyGuiCacheService>().As <IChocolateyGuiCacheService>().SingleInstance();
builder.RegisterType <AllowedCommandsService>().As <IAllowedCommandsService>().SingleInstance();
// Register Mapper
var mapperConfiguration = new MapperConfiguration(config =>
{
config.CreateMap <IPackageViewModel, IPackageViewModel>()
.ForMember(vm => vm.IsInstalled, options => options.Ignore());
config.CreateMap <DataServicePackage, Package>()
.ForMember(dest => dest.Authors, opt => opt.MapFrom(src => src.Authors.Split(',')))
.ForMember(dest => dest.Owners, opt => opt.MapFrom(src => src.Owners.Split(',')));
config.CreateMap <IPackage, Package>();
config.CreateMap <ConfigFileFeatureSetting, ChocolateyFeature>();
config.CreateMap <ConfigFileConfigSetting, ChocolateySetting>();
config.CreateMap <ConfigFileSourceSetting, Common.Models.ChocolateySource>()
.ForMember(dest => dest.Password, opt => opt.MapFrom(src => NugetEncryptionUtility.DecryptString(src.Password)))
.ForMember(dest => dest.CertificatePassword, opt => opt.MapFrom(src => NugetEncryptionUtility.DecryptString(src.CertificatePassword)));
config.CreateMap <ChocolateySource, Common.Models.ChocolateySource>()
.ForMember(dest => dest.VisibleToAdminsOnly, opt => opt.MapFrom(src => src.VisibleToAdminOnly));
});
builder.RegisterInstance(DialogCoordinator.Instance).As <IDialogCoordinator>();
builder.RegisterInstance(mapperConfiguration.CreateMapper()).As <IMapper>();
try
{
var database = new LiteDatabase($"filename={Path.Combine(Bootstrapper.LocalAppDataPath, "data.db")};upgrade=true");
builder.Register(c => database).SingleInstance();
}
catch (IOException ex)
{
Bootstrapper.Logger.Error(ex, Resources.Error_DatabaseAccessGui);
throw;
}
builder.RegisterType <ImageService>().As <IImageService>().SingleInstance();
builder.RegisterType <VersionService>().As <IVersionService>().SingleInstance();
builder.RegisterType <SplashScreenService>().As <ISplashScreenService>().SingleInstance();
}
public async Task <IReadOnlyList <OutdatedPackage> > GetOutdatedPackages(bool includePrerelease = false, string packageName = null)
{
var outdatedPackagesFile = _fileSystem.combine_paths(_localAppDataPath, "outdatedPackages.xml");
var outdatedPackagesCacheDurationInMinutesSetting = _configService.GetAppConfiguration().OutdatedPackagesCacheDurationInMinutes;
int outdatedPackagesCacheDurationInMinutes = 0;
if (!string.IsNullOrWhiteSpace(outdatedPackagesCacheDurationInMinutesSetting))
{
int.TryParse(outdatedPackagesCacheDurationInMinutesSetting, out outdatedPackagesCacheDurationInMinutes);
}
if (_fileSystem.file_exists(outdatedPackagesFile) && (DateTime.Now - _fileSystem.get_file_modified_date(outdatedPackagesFile)).TotalMinutes < outdatedPackagesCacheDurationInMinutes)
{
return(_xmlService.deserialize <List <OutdatedPackage> >(outdatedPackagesFile));
}
else
{
var choco = Lets.GetChocolatey();
choco.Set(
config =>
{
config.CommandName = "outdated";
config.PackageNames = packageName ?? chocolatey.infrastructure.app.ApplicationParameters.AllPackages;
config.UpgradeCommand.NotifyOnlyAvailableUpgrades = true;
config.RegularOutput = false;
config.QuietOutput = true;
config.Prerelease = false;
});
var chocoConfig = choco.GetConfiguration();
// If there are no Sources configured, for example, if they are all disabled, then figuring out
// which packages are outdated can't be completed.
if (chocoConfig.Sources != null)
{
var nugetService = choco.Container().GetInstance <INugetService>();
var packages = await Task.Run(() => nugetService.upgrade_noop(chocoConfig, null));
var results = packages
.Where(p => !p.Value.Inconclusive)
.Select(p => new OutdatedPackage
{
Id = p.Value.Package.Id, VersionString = p.Value.Package.Version.ToNormalizedString()
})
.ToArray();
try
{
_xmlService.serialize(results, outdatedPackagesFile);
}
catch (Exception ex)
{
Logger.Error(ex, "Unable to serialize Outdated Packages Cache file.");
}
return(results.ToList());
}
else
{
return(new List <OutdatedPackage>());
}
}
}
public override void Because()
{
_chocolatey1 = Lets.GetChocolatey();
_chocolatey2 = Lets.GetChocolatey();
}