public override void Execute(List <CommandParameter> parameters) { var path = GetStringParameterValue(parameters, CommandPathParameter.Name); var name = GetStringParameterValue(parameters, CommandNameParameter.Name); var description = GetStringParameterValue(parameters, CommandDescriptionParameter.Name); if (StoredDataService.ExistsTemplate(name)) { throw new TemplateNameRepeatedException(); } if (!FileService.ExistsDirectory(path)) { throw new PathNotFoundException(path); } if (!FileService.ExistsTemplateConfigFile(path)) { throw new TemplateConfigFileNotFoundException(path); } if (!StringFormats.IsValidLogicalName(name)) { throw new InvalidStringFormatException("Name can only contains alphanumeric characters"); } StoredDataService.AddTemplate(path, name, description); Log($"Template stored!"); }
public override void Execute(List <CommandParameter> parameters) { var name = GetStringParameterValue(parameters, CommandNameParameter.Name); if (!StoredDataService.ExistsTemplate(name)) { throw new TemplateNotFoundException(); } StoredDataService.DeleteTemplate(name); Log($"Template deleted!"); }
private List <CommandBase> SearchCommandAndAlias(InputRequest inputRequest) { var commands = Commands.Where(k => k.CommandName.ToLowerInvariant() == inputRequest.CommandName) .ToList(); if (commands.Count == 0 && inputRequest.CommandName.Length > MandatoryCommandSufix.Length) { var aliasName = inputRequest.CommandName.Substring(0, inputRequest.CommandName.Length - MandatoryCommandSufix.Length); var isAlias = StoredDataService.ExistsAlias(aliasName); if (isAlias) { var commandName = StoredDataService.GetAliasedCommand(aliasName); commands = Commands.Where(k => k.GetInvocationCommandName() == commandName) .ToList(); } } return(commands); }
public override void Execute(List <CommandParameter> parameters) { var commandName = GetStringParameterValue(parameters, CommandNameParameter.Name); var aliasName = GetStringParameterValue(parameters, CommandAliasParameter.Name); var commandAliased = RegisteredCommands .FirstOrDefault(k => k.GetInvocationCommandName() == commandName); if (commandAliased == null) { throw new CommandNotFoundException(commandName); } if (StoredDataService.ExistsAlias(aliasName)) { throw new AliasRepeatedException(aliasName); } StoredDataService.AddAlias(commandName, aliasName); Log($"Alias stored!"); }
static void Main(string[] args) { //var argsV2 = StringFormats.StringToParams(string.Join(" ", args)); _loggerService = new LoggerService(); _loggerService.Log("###### INITIALIZED DYNAMICS CLI ######"); LogRecievedArgs(args); bool isRecursive = args.Any(k => k.Length > 0 && k.First() == '\"'); var argsV2 = isRecursive ? StringFormats.StringToParams(string.Join(" ", args)) : args; LogProcessedArgs(argsV2); var storedData = StoredDataManager.GetStoredData(); _loggerService = new LoggerService(); IRegistryService registryService = new RegistryService(); ICryptoService cryptoService = new CryptoService(registryService); IStoredDataService storedDataService = new StoredDataService(storedData, cryptoService); commandManager = new CommandManager(_loggerService, storedDataService, cryptoService); commandManager.OnLog += CommandManager_OnLog; RegisterCommands(storedDataService, registryService, cryptoService); try { var inputCommand = new InputRequest(argsV2); commandManager.ExecuteInputRequest(inputCommand); } catch (PathNotFoundException ex) { ExceptionManager.RaiseException(_loggerService, $"Path '{ex.Message}' does not exists"); } catch (Exception ex) { ExceptionManager.RaiseException(_loggerService, $"Throwed uncatched exception: {ex.ToString()}"); } }
public override void Execute(List <CommandParameter> parameters) { string path = string.Empty; if (IsParamOk(parameters, CommandNameParameter.Name)) { var templateName = GetStringParameterValue(parameters, CommandNameParameter.Name); path = StoredDataService.GetTemplatePath(templateName); } else { var regardingPath = GetStringParameterValue(parameters, CommandPathParameter.Name); if (FileService.IsFile(regardingPath)) { path = FileService.GetFilePath(regardingPath); } else { path = regardingPath; } } if (!FileService.ExistsDirectory(path)) { throw new PathNotFoundException(path); } if (!FileService.ExistsTemplateConfigFile(path)) { throw new TemplateConfigFileNotFoundException(path); } var templateConfig = ExceptionInLine.Run <DDTemplateConfig>( () => { return(FileService.GetTemplateConfig(path)); }, (ex) => { throw new InvalidTemplateConfigFileException(ex.Message); }); if (templateConfig == null) { throw new InvalidTemplateConfigFileException(); } var destinationPathRequest = GetStringParameterValue(parameters, DestinationPathParameter.Name); var destinationPath = string.Empty; if (string.IsNullOrEmpty(destinationPathRequest)) { Log($"Set up for template '{templateConfig.TemplateName}'"); Log($"Type destination folder:"); destinationPath = ConsoleService.ReadLine(); } else { destinationPath = destinationPathRequest; } var valuesRequest = GetStringParameterValue(parameters, ValuesParameter.Name); if (string.IsNullOrEmpty(valuesRequest)) { Log($"Complete the paris for replace in the base project"); foreach (var pair in templateConfig.ReplacePairs) { Log($"\t{pair.ReplaceDescription}: (Old value = {pair.OldValue})"); var value = ConsoleService.ReadLine(); var replacedPair = new ReplacePairValue(pair, value); UserTemplateSetupReplaceStrings.Add(replacedPair); } } else { UserTemplateSetupReplaceStrings.AddRange(valuesRequest.Split(';').Select(k => { if (k.IndexOf("=") == -1) { throw new Exception("Invalid pair param=value"); } var keyValue = k.Split('='); var key = keyValue[0]; var value = keyValue[1]; if (string.IsNullOrEmpty(key) || string.IsNullOrEmpty(value)) { throw new Exception("Invalid pair param=value"); } var pair = templateConfig.ReplacePairs.FirstOrDefault(l => l.OldValue == key); if (pair == null) { throw new Exception($"Param '{key}' is not defined in the template.json"); } return(new ReplacePairValue(pair, value)); })); } var absoluteDestionPath = FileService.GetAbsoluteCurrentPath(destinationPath); Log($"The template will be cloned at '{absoluteDestionPath}'"); if (!FileService.ExistsDirectory(absoluteDestionPath)) { FileService.CreateDirectory(absoluteDestionPath, true); } Log($"Cloning files..."); var clonedFiles = FileService.CloneDirectory(path, absoluteDestionPath, templateConfig.IgnorePathPatterns); Log(clonedFiles.ToDisplayList($"Cloned {clonedFiles.Count} files:", "", false)); foreach (var replaceString in UserTemplateSetupReplaceStrings) { Log($"Applying replacemene of string '{replaceString.ReplacedPair.OldValue}'->'{replaceString.Value}'. Apply for directories:{replaceString.ReplacedPair.ApplyForDirectories}, Apply for file names:{replaceString.ReplacedPair.ApplyForFileNames}, Apply for directories:{replaceString.ReplacedPair.ApplyForFileContents}"); var oldValue = replaceString.ReplacedPair.OldValue; var newValue = replaceString.Value; var rootPath = absoluteDestionPath; var pattern = replaceString.ReplacedPair.ApplyForFilePattern; if (replaceString.ReplacedPair.ApplyForDirectories) { FileService.ReplaceAllSubDirectoriesName(rootPath, oldValue, newValue); } if (replaceString.ReplacedPair.ApplyForFileNames) { FileService.ReplaceAllFilesName(rootPath, oldValue, newValue); } if (replaceString.ReplacedPair.ApplyForFileContents) { FileService.ReplaceFilesContents(rootPath, oldValue, newValue, pattern); } } }
public void ExecuteInputRequest(InputRequest inputRequest, List <string> consoleInputs = null) { List <CommandBase> commands = SearchCommandAndAlias(inputRequest); if (commands.Count > 1) { throw new DuplicateCommandException(commands.Select(k => k.GetInvocationCommandName()).ToList()); } if (commands.Count == 0) { throw new CommandNotFoundException($"{inputRequest.CommandNamespace}.{inputRequest.CommandName} is not registered"); } var command = commands[0]; var commandsParameters = new List <CommandParameter>(); if (command.CommandParametersDefinition.Where(k => k.Name != "help").Count() == 1 && inputRequest.InputParameters.Count == 1 && inputRequest.InputParameters[0].IsOnlyOne) { var targetCommandParameter = command.CommandParametersDefinition.FirstOrDefault(k => k.Name != "help"); var parameter = GetParsedCommandParameter( command, targetCommandParameter, inputRequest.InputParameters[0]); commandsParameters.Add(parameter); } else { foreach (var parameterDefinition in command.CommandParametersDefinition) { var itemInput = GetImputParameterFromRequest(inputRequest, parameterDefinition); if (itemInput != null) { var parameter = GetParsedCommandParameter(command, parameterDefinition, itemInput); commandsParameters.Add(parameter); } } } if (command.CanExecute(commandsParameters) || command.IsHelpCommand(commandsParameters)) { _parameterManager.OnReplacedEncrypted += _parameterManager_OnReplacedEncrypted; _parameterManager.OnReplacedAutoIncrement += _parameterManager_OnReplacedAutoIncrement; try { ExecuteCommand(command, commandsParameters, consoleInputs); if (command.CommandName != "ShowComandsHistoryCommand") { StoredDataService.AddCommandToHistorical(new HistoricalCommand(inputRequest)); } } catch (Exception) { throw; } finally { _parameterManager.OnReplacedEncrypted -= _parameterManager_OnReplacedEncrypted; _parameterManager.OnReplacedAutoIncrement -= _parameterManager_OnReplacedAutoIncrement; if (ExecutionMode == ExecutionModeTypes.Single) { StoredDataService.UpdateAutoIncrements(this._autoincrementParametersReplaced); } } } else { throw new InvalidParamsException("Cannot execute this command with this parameters"); } }
static void Main(string[] args) { _loggerService = new LoggerService(); _loggerService.Log("###### INITIALIZED CLI ######"); LogRecievedArgs(args); bool isRecursive = args.Any(k => k.Length > 0 && k.First() == '\"'); var argsV2 = isRecursive ? StringFormats.StringToParams(string.Join(" ", args)) : args; LogProcessedArgs(argsV2); var storedData = StoredDataManager.GetStoredData(); IRegistryService registryService = new RegistryService(); ICryptoService cryptoService = new CryptoService(registryService); IStoredDataService storedDataService = new StoredDataService(storedData, cryptoService); commandManager = new CommandManager(_loggerService, storedDataService, cryptoService); commandManager.OnLog += CommandManager_OnLog; RegisterCommands(storedDataService, registryService, cryptoService); try { var inputCommand = new InputRequest(argsV2); commandManager.ExecuteInputRequest(inputCommand); } catch (DuplicateCommandException ex) { ExceptionManager.RaiseException(_loggerService, $"Found {ex.Commands.Count} commands with the same name in different namespaces. In this case is necessary use the namespace for execute it. Commands: {string.Join(",", ex.Commands.ToArray())}"); } catch (CommandNotFoundException) { ExceptionManager.RaiseException(_loggerService, $"Command not found. Use 'help' for check the available commands"); } catch (InvalidParamsException) { ExceptionManager.RaiseException(_loggerService, $"This command cannot be executed with this combination of parameters"); } catch (InvalidParamNameException ex) { ExceptionManager.RaiseException(_loggerService, $"Invalid parameter name '{ex.Message}'"); } catch (NotArgumentsException) { ExceptionManager.RaiseException(_loggerService, $"Check all the params with 'help' command"); } catch (NotValidCommandNameException ex) { ExceptionManager.RaiseException(_loggerService, $"Invalid command name '{ex.Message}'"); } catch (AliasRepeatedException ex) { ExceptionManager.RaiseException(_loggerService, $"Alias '{ex.Message}' is already used"); } catch (AliasNotFoundException ex) { ExceptionManager.RaiseException(_loggerService, $"Alias '{ex.Message}' is not registered"); } catch (ParameterRepeatedException ex) { ExceptionManager.RaiseException(_loggerService, $"Parameter '{ex.Message}' is already used"); } catch (ParameterNotFoundException ex) { ExceptionManager.RaiseException(_loggerService, $"Parameter '{ex.Message}' is not registered"); } catch (InvalidParamException ex) { ExceptionManager.RaiseException(_loggerService, $"Cannot resolver parameter {ex.Message}"); } catch (PathNotFoundException ex) { ExceptionManager.RaiseException(_loggerService, $"Path '{ex.Message}' does not exists"); } catch (TemplateConfigFileNotFoundException) { ExceptionManager.RaiseException(_loggerService, $"Can't find '{Definitions.TemplateConfigFilename}' file in path"); } catch (InvalidTemplateConfigFileException ex) { ExceptionManager.RaiseException(_loggerService, $"Config file '{Definitions.TemplateConfigFilename}' is invalid. Error parsing: {ex.Message}"); } catch (InvalidStringFormatException ex) { ExceptionManager.RaiseException(_loggerService, $"Invalid string format. {ex.Message}"); } catch (TemplateNameRepeatedException) { ExceptionManager.RaiseException(_loggerService, $"Template name repeated"); } catch (TemplateNotFoundException) { ExceptionManager.RaiseException(_loggerService, $"Can't find any template with this name"); } catch (RepositoryNotFoundException) { ExceptionManager.RaiseException(_loggerService, $"Can't find any repository with this name"); } catch (PipelineConfigFileNotFoundException) { ExceptionManager.RaiseException(_loggerService, $"Can't find '{Definitions.PipelineConfigFilename}' file in path"); } catch (InvalidPipelineConfigFileException ex) { ExceptionManager.RaiseException(_loggerService, $"Config file '{Definitions.PipelineConfigFilename}' is invalid. Error parsing: {ex.Message}"); } catch (PipelineNameRepeatedException) { ExceptionManager.RaiseException(_loggerService, $"Pipeline name repeated"); } catch (PipelineNotFoundException) { ExceptionManager.RaiseException(_loggerService, $"Can't find any pipeline with this name"); } catch (Exception ex) { ExceptionManager.RaiseException(_loggerService, $"Throwed uncatched exception: {ex.ToString()}"); } finally { _loggerService.Log("###### FINISHED! ######"); } }