public void EnableFeature(ChocolateyGuiConfiguration configuration) { var featureProperty = GetProperty(configuration.FeatureCommand.Name, true); var featureValue = GetPropertyValue <bool>(_appConfiguration, featureProperty); if (!featureValue) { featureProperty.SetValue(_appConfiguration, true); UpdateSettings(_appConfiguration); Logger.Warning(Resources.FeatureCommand_EnabledWarning.format_with(configuration.FeatureCommand.Name)); } else { Logger.Warning(Resources.FeatureCommand_NoChangeMessage); } }
public virtual void HandleValidation(ChocolateyGuiConfiguration configuration) { if (configuration.ConfigCommand.Command != ConfigCommandType.List && string.IsNullOrWhiteSpace(configuration.ConfigCommand.Name)) { Logger.Error(Resources.ConfigCommand_MissingNameOptionError.format_with(configuration.ConfigCommand.Command.to_string(), "--name")); Environment.Exit(-1); } if (configuration.ConfigCommand.Command == ConfigCommandType.Set && string.IsNullOrWhiteSpace(configuration.ConfigCommand.ConfigValue)) { Logger.Error(Resources.ConfigCommand_MissingValueOptionError.format_with(configuration.ConfigCommand.Command.to_string(), "--value")); Environment.Exit(-1); } }
public virtual void ConfigureArgumentParser(OptionSet optionSet, ChocolateyGuiConfiguration configuration) { optionSet .Add( "name=", Resources.ConfigCommand_NameOption, option => configuration.ConfigCommand.Name = option.remove_surrounding_quotes()) .Add( "value=", Resources.ConfigCommand_ValueOption, option => configuration.ConfigCommand.ConfigValue = option.remove_surrounding_quotes()) .Add( "g|global", Resources.GlobalOption, option => configuration.Global = option != null); }
public void ListSettings(ChocolateyGuiConfiguration configuration) { Logger.Warning(Resources.Command_SettingsTitle); Logger.Information(string.Empty); foreach (var setting in GetSettings()) { Logger.Information("{0} = {1} | {2}".format_with(setting.Key, setting.Value, setting.Description)); } Logger.Information(string.Empty); Logger.Warning(Resources.Command_FeaturesTitle); Logger.Information(string.Empty); ListFeatures(configuration); Logger.Information(string.Empty); Logger.Information(Resources.Command_UseFeatureCommandNote.format_with("chocolateyguicli feature")); }
public virtual void Run(ChocolateyGuiConfiguration config) { switch (config.FeatureCommand.Command) { case FeatureCommandType.List: _configService.ListFeatures(config); break; case FeatureCommandType.Disable: _configService.ToggleFeature(config, false); break; case FeatureCommandType.Enable: _configService.ToggleFeature(config, true); break; } }
private static void SetUpGlobalOptions(IList <string> args, ChocolateyGuiConfiguration configuration, IContainer container) { ParseArgumentsAndUpdateConfiguration( args, configuration, (option_set) => { option_set .Add( "r|limitoutput|limit-output", ChocolateyGui.Common.Properties.Resources.Command_LimitOutputOption, option => configuration.RegularOutput = option == null); }, (unparsedArgs) => { if (!string.IsNullOrWhiteSpace(configuration.CommandName)) { // save help for next menu configuration.HelpRequested = false; configuration.UnsuccessfulParsing = false; } }, () => { }, () => { var commandsLog = new StringBuilder(); var commands = container.Resolve <IEnumerable <ICommand> >(); foreach (var command in commands.or_empty_list_if_null()) { var attributes = command.GetType().GetCustomAttributes(typeof(LocalizedCommandForAttribute), false).Cast <LocalizedCommandForAttribute>(); foreach (var attribute in attributes.or_empty_list_if_null()) { commandsLog.AppendFormat(" * {0} - {1}\n", attribute.CommandName, attribute.Description); } } Bootstrapper.Logger.Information(ChocolateyGui.Common.Properties.Resources.Command_CommandsListText.format_with("chocolateyguicli")); Bootstrapper.Logger.Information(string.Empty); Bootstrapper.Logger.Warning(ChocolateyGui.Common.Properties.Resources.Command_CommandsTitle); Bootstrapper.Logger.Information(string.Empty); Bootstrapper.Logger.Information("{0}".format_with(commandsLog.ToString())); Bootstrapper.Logger.Information(ChocolateyGui.Common.Properties.Resources.Command_CommandsText.format_with("chocolateyguicli")); Bootstrapper.Logger.Information(string.Empty); Bootstrapper.Logger.Warning(ChocolateyGui.Common.Properties.Resources.Command_DefaultOptionsAndSwitches); }); }
public virtual void HelpMessage(ChocolateyGuiConfiguration configuration) { Logger.Warning(L(nameof(Resources.PurgeCommand_Title))); Logger.Information(string.Empty); Logger.Information(L(nameof(Resources.PurgeCommand_Help))); Logger.Information(string.Empty); Logger.Warning(L(nameof(Resources.Command_Usage))); Logger.Information(@" chocolateyguicli purge icons|outdated [<options/switches>] "); Logger.Warning(L(nameof(Resources.Command_Examples))); Logger.Information(@" chocolateyguicli purge icons chocolateyguicli purge outdated "); PrintExitCodeInformation(); }
public async Task UpdateChocolateyGuiFeature(ChocolateyGuiFeature feature) { var configuration = new ChocolateyGuiConfiguration(); configuration.CommandName = "feature"; configuration.FeatureCommand.Name = feature.Title; if (feature.Enabled) { configuration.FeatureCommand.Command = FeatureCommandType.Enable; await Task.Run(() => _configService.EnableFeature(configuration)); } else { configuration.FeatureCommand.Command = FeatureCommandType.Disable; await Task.Run(() => _configService.DisableFeature(configuration)); } _eventAggregator.PublishOnUIThread(new FeatureModifiedMessage()); }
public virtual void HelpMessage(ChocolateyGuiConfiguration configuration) { Logger.Warning(L(nameof(Resources.FeatureCommand_Title))); Logger.Information(string.Empty); Logger.Information(L(nameof(Resources.FeatureCommand_Help))); Logger.Information(string.Empty); Logger.Warning(L(nameof(Resources.Command_Usage))); Logger.Information(@" chocolateyguicli feature [list]|disable|enable [<options/switches>] "); Logger.Warning(L(nameof(Resources.Command_Examples))); Logger.Information(@" chocolateyguicli feature chocolateyguicli feature list chocolateyguicli feature disable -n=ShowConsoleOutput chocolateyguicli feature enable -n=ShowConsoleOutput "); PrintExitCodeInformation(); }
public void UnsetConfigValue(ChocolateyGuiConfiguration configuration) { if (configuration.Global && !Hacks.IsElevated) { // This is not allowed! Logger.Error(L(nameof(Resources.ConfigCommand_Unset_ElevatedPermissionsError))); return; } var chosenAppConfiguration = GetChosenAppConfiguration(configuration.Global); var configProperty = GetProperty(configuration.ConfigCommand.Name, false); configProperty.SetValue(chosenAppConfiguration, string.Empty); UpdateSettings(chosenAppConfiguration, configuration.Global); // since the update happened successfully, update the effective configuration configProperty.SetValue(EffectiveAppConfiguration, string.Empty); Logger.Warning(L(nameof(Resources.ConfigCommand_Unset), configuration.ConfigCommand.Name)); }
public virtual void Run(ChocolateyGuiConfiguration config) { switch (config.ConfigCommand.Command) { case ConfigCommandType.List: _configService.ListSettings(config); break; case ConfigCommandType.Get: _configService.GetConfigValue(config); break; case ConfigCommandType.Set: _configService.SetConfigValue(config); break; case ConfigCommandType.Unset: _configService.UnsetConfigValue(config); break; } }
public async Task UpdateChocolateyGuiFeature(ChocolateyGuiFeature feature) { // When the flow direction gets changed, this results in the feature // being null some times immediately. As such, if the feature is null // then just return so we don't encounter an exception. if (feature == null) { return; } var configuration = new ChocolateyGuiConfiguration(); configuration.CommandName = "feature"; configuration.FeatureCommand.Name = feature.Title; if (feature.Enabled) { configuration.FeatureCommand.Command = FeatureCommandType.Enable; await Task.Run(() => _configService.ToggleFeature(configuration, true)); } else { configuration.FeatureCommand.Command = FeatureCommandType.Disable; await Task.Run(() => _configService.ToggleFeature(configuration, false)); } _eventAggregator.PublishOnUIThread(new FeatureModifiedMessage()); if (feature.Title == "ShowAggregatedSourceView") { await _eventAggregator.PublishOnUIThreadAsync(new SourcesUpdatedMessage()); } if (feature.Title == "DefaultToDarkMode") { ThemeAssist.BundledTheme.IsLightTheme = !feature.Enabled; ThemeAssist.BundledTheme.ToggleTheme.Execute(null); } }
public virtual void HelpMessage(ChocolateyGuiConfiguration configuration) { Logger.Warning(Resources.ConfigCommand_Title); Logger.Information(string.Empty); Logger.Information(Resources.ConfigCommand_Help); Logger.Information(string.Empty); Logger.Warning(Resources.Command_Usage); Logger.Information(@" chocolateyguicli config [list]|get|set|unset [<options/switches>] "); Logger.Warning(Resources.Command_Examples); Logger.Information(@" chocolateyguicli config chocolateyguicli config list chocolateyguicli config get outdatedPackagesCacheDurationInMinutes chocolateyguicli config get --name outdatedPackagesCacheDurationInMinutes chocolateyguicli config set outdatedPackagesCacheDurationInMinutes 60 chocolateyguicli config set --name outdatedPackagesCacheDurationInMinutes --value 60 chocolateyguicli config unset outdatedPackagesCacheDurationInMinutes chocolateyguicli config unset --name outdatedPackagesCacheDurationInMinutes "); PrintExitCodeInformation(); }
public virtual void HandleAdditionalArgumentParsing(IList <string> unparsedArguments, ChocolateyGuiConfiguration configuration) { configuration.Input = string.Join(" ", unparsedArguments); if (unparsedArguments.Count > 1) { Logger.Error(L(nameof(Resources.FeatureCommand_SingleFeatureError))); Environment.Exit(-1); } var command = FeatureCommandType.Unknown; var unparsedCommand = unparsedArguments.DefaultIfEmpty(string.Empty).FirstOrDefault(); Enum.TryParse(unparsedCommand, true, out command); if (command == FeatureCommandType.Unknown) { if (!string.IsNullOrWhiteSpace(unparsedCommand)) { Logger.Warning(L(nameof(Resources.FeatureCommand_UnknownCommandError), unparsedCommand, "list")); } command = FeatureCommandType.List; } configuration.FeatureCommand.Command = command; }
public virtual void HandleAdditionalArgumentParsing(IList <string> unparsedArguments, ChocolateyGuiConfiguration configuration) { configuration.Input = string.Join(" ", unparsedArguments); var command = ConfigCommandType.Unknown; var unparsedCommand = unparsedArguments.DefaultIfEmpty(string.Empty).FirstOrDefault().to_string().Replace("-", string.Empty); Enum.TryParse(unparsedCommand, true, out command); if (command == ConfigCommandType.Unknown) { if (!string.IsNullOrWhiteSpace(unparsedCommand)) { Logger.Warning(Resources.ConfigCommand_UnknownCommandError.format_with(unparsedCommand, "list")); } command = ConfigCommandType.List; } configuration.ConfigCommand.Command = command; if ((configuration.ConfigCommand.Command == ConfigCommandType.List || !string.IsNullOrWhiteSpace(configuration.ConfigCommand.Name)) && unparsedArguments.Count > 1) { Logger.Error(Resources.ConfigCommand_SingleConfigError); Environment.Exit(-1); } if (string.IsNullOrWhiteSpace(configuration.ConfigCommand.Name) && unparsedArguments.Count >= 2) { configuration.ConfigCommand.Name = unparsedArguments[1]; } if (string.IsNullOrWhiteSpace(configuration.ConfigCommand.ConfigValue) && unparsedArguments.Count >= 3) { configuration.ConfigCommand.ConfigValue = unparsedArguments[2]; } }
public virtual void ConfigureArgumentParser(OptionSet optionSet, ChocolateyGuiConfiguration configuration) { // There are no additional options for this command currently }
public virtual void HandleAdditionalArgumentParsing(IList <string> unparsedArguments, ChocolateyGuiConfiguration configuration) { configuration.Input = string.Join(" ", unparsedArguments); if (unparsedArguments.Count > 1) { Environment.Exit(-1); } var command = PurgeCommandType.Unknown; var unparsedCommand = unparsedArguments.DefaultIfEmpty(string.Empty).FirstOrDefault(); Enum.TryParse(unparsedCommand, true, out command); configuration.PurgeCommand.Command = command; }
public static void Main(string[] args) { AddAssemblyResolver(); Bootstrapper.Configure(); var commandName = string.Empty; IList <string> commandArgs = new List <string>(); // shift the first arg off int count = 0; foreach (var arg in args) { if (count == 0) { count += 1; continue; } commandArgs.Add(arg); } var configuration = new ChocolateyGuiConfiguration(); SetUpGlobalOptions(args, configuration, Bootstrapper.Container); SetEnvironmentOptions(configuration); if (configuration.RegularOutput) { #if DEBUG Bootstrapper.Logger.Information("{0} v{1} (DEBUG BUILD)".format_with("Chocolatey GUI", configuration.Information.ChocolateyGuiProductVersion)); #else Bootstrapper.Logger.Information("{0} v{1}".format_with("Chocolatey GUI", configuration.Information.ChocolateyGuiProductVersion)); #endif if (args.Length == 0) { Bootstrapper.Logger.Information(ChocolateyGui.Common.Properties.Resources.Command_CommandsText.format_with("chocolateyguicli")); } } var runner = new GenericRunner(); runner.Run(configuration, Bootstrapper.Container, command => { ParseArgumentsAndUpdateConfiguration( commandArgs, configuration, (optionSet) => command.ConfigureArgumentParser(optionSet, configuration), (unparsedArgs) => { command.HandleAdditionalArgumentParsing(unparsedArgs, configuration); }, () => { Bootstrapper.Logger.Debug("Performing validation checks..."); command.HandleValidation(configuration); }, () => command.HelpMessage(configuration)); }); }
private static void ParseArgumentsAndUpdateConfiguration( ICollection <string> args, ChocolateyGuiConfiguration configuration, Action <OptionSet> setOptions, Action <IList <string> > afterParse, Action validateConfiguration, Action helpMessage) { IList <string> unparsedArguments = new List <string>(); // add help only once if (_optionSet.Count == 0) { _optionSet .Add( "?|help|h", ChocolateyGui.Common.Properties.Resources.Command_HelpOption, option => configuration.HelpRequested = option != null); } if (setOptions != null) { setOptions(_optionSet); } try { unparsedArguments = _optionSet.Parse(args); } catch (OptionException) { ShowHelp(_optionSet, helpMessage); configuration.UnsuccessfulParsing = true; } // the command argument if (string.IsNullOrWhiteSpace(configuration.CommandName) && unparsedArguments.Contains(args.FirstOrDefault())) { var commandName = args.FirstOrDefault(); if (!Regex.IsMatch(commandName, @"^[-\/+]")) { configuration.CommandName = commandName; } else if (commandName.is_equal_to("-v") || commandName.is_equal_to("--version")) { // skip help menu } else { configuration.HelpRequested = true; configuration.UnsuccessfulParsing = true; } } if (afterParse != null) { afterParse(unparsedArguments); } if (configuration.HelpRequested) { ShowHelp(_optionSet, helpMessage); } else { if (validateConfiguration != null) { validateConfiguration(); } } }
private static void SetEnvironmentOptions(ChocolateyGuiConfiguration config) { config.Information.ChocolateyGuiVersion = VersionInformation.get_current_assembly_version(Assembly.GetCallingAssembly()); config.Information.ChocolateyGuiProductVersion = VersionInformation.get_current_informational_version(Assembly.GetCallingAssembly()); config.Information.FullName = Assembly.GetExecutingAssembly().FullName; }
public static void Main(string[] args) { try { AddAssemblyResolver(); Bootstrapper.Configure(); var commandName = string.Empty; IList <string> commandArgs = new List <string>(); // shift the first arg off int count = 0; foreach (var arg in args) { if (count == 0) { count += 1; continue; } commandArgs.Add(arg); } var configuration = new ChocolateyGuiConfiguration(); SetUpGlobalOptions(args, configuration, Bootstrapper.Container); SetEnvironmentOptions(configuration); if (configuration.RegularOutput) { #if DEBUG Bootstrapper.Logger.Warning(" (DEBUG BUILD)".format_with("Chocolatey GUI", configuration.Information.DisplayVersion)); #else Bootstrapper.Logger.Warning("{0}".format_with(configuration.Information.DisplayVersion)); #endif if (args.Length == 0) { Bootstrapper.Logger.Information(ChocolateyGui.Common.Properties.Resources.Command_CommandsText.format_with("chocolateyguicli")); } } var runner = new GenericRunner(); runner.Run(configuration, Bootstrapper.Container, command => { ParseArgumentsAndUpdateConfiguration( commandArgs, configuration, (optionSet) => command.ConfigureArgumentParser(optionSet, configuration), (unparsedArgs) => { command.HandleAdditionalArgumentParsing(unparsedArgs, configuration); }, () => { Bootstrapper.Logger.Debug("Performing validation checks..."); command.HandleValidation(configuration); }, () => command.HelpMessage(configuration)); }); } catch (Exception ex) { Bootstrapper.Logger.Error(ex.Message); } finally { Log.CloseAndFlush(); if (Bootstrapper.Container != null) { if (Bootstrapper.Container.IsRegisteredWithName <LiteDatabase>(Bootstrapper.GlobalConfigurationDatabaseName)) { var globalDatabase = Bootstrapper.Container.ResolveNamed <LiteDatabase>(Bootstrapper.GlobalConfigurationDatabaseName); globalDatabase.Dispose(); } if (Bootstrapper.Container.IsRegisteredWithName <LiteDatabase>(Bootstrapper.UserConfigurationDatabaseName)) { var userDatabase = Bootstrapper.Container.ResolveNamed <LiteDatabase>(Bootstrapper.UserConfigurationDatabaseName); userDatabase.Dispose(); } Bootstrapper.Container.Dispose(); } } }