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(); }