public ExecuteCommandSet(IBasicActivateItems activator, [DemandsInitialization("A single object on which you want to change a given property")] IMapsDirectlyToDatabaseTable setOn, [DemandsInitialization("Name of a property you want to change e.g. Description")] string property, [DemandsInitialization("New value to assign, this will be parsed into a valid Type if property is not a string")] string value) : base(activator) { _setOn = setOn; _property = _setOn.GetType().GetProperty(property); if (_property == null) { SetImpossible($"Unknown Property '{property}'"); } else { var picker = new CommandLineObjectPicker(new string[] { value ?? "NULL" }, activator.RepositoryLocator); if (!picker.HasArgumentOfType(0, _property.PropertyType)) { SetImpossible($"Provided value could not be converted to '{_property.PropertyType}'"); } else { NewValue = picker[0].GetValueForParameterOfType(_property.PropertyType); } } }
public int Run(IRDMPPlatformRepositoryServiceLocator repositoryLocator, IDataLoadEventListener listener, ICheckNotifier checkNotifier, GracefulCancellationToken token) { _input = new ConsoleInputManager(repositoryLocator, checkNotifier); _listener = listener; _invoker = new CommandInvoker(_input); _invoker.CommandImpossible += (s, c) => Console.WriteLine($"Command Impossible:{c.Command.ReasonCommandImpossible}"); _invoker.CommandCompleted += (s, c) => Console.WriteLine("Command Completed"); _commands = _invoker.GetSupportedCommands().ToDictionary( k => BasicCommandExecution.GetCommandName(k.Name), v => v, StringComparer.CurrentCultureIgnoreCase); _picker = _options.CommandArgs != null && _options.CommandArgs.Any() ? new CommandLineObjectPicker(_options.CommandArgs, repositoryLocator) : null; if (string.IsNullOrWhiteSpace(_options.CommandName)) { RunCommandExecutionLoop(repositoryLocator); } else { RunCommand(_options.CommandName); } return(0); }
/// <summary> /// Runs a main loop in which the user types many commands one after the other /// </summary> /// <param name="repositoryLocator"></param> private void RunCommandExecutionLoop(IRDMPPlatformRepositoryServiceLocator repositoryLocator) { //when running a command loop don't use command line arguments (shouldn't really be possible anyway) _picker = null; while (true) { Console.WriteLine("Enter Command (or 'exit')"); var command = _input.GetString("Command", _commands.Keys.ToList()); if (command.Contains(' ')) { _picker = new CommandLineObjectPicker(SplitCommandLine(command).Skip(1).ToArray(), repositoryLocator); command = command.Substring(0, command.IndexOf(' ')); } if (string.Equals(command, "exit", StringComparison.CurrentCultureIgnoreCase)) { break; } RunCommand(command); _picker = null; } }
/// <summary> /// Runs a main loop in which the user types many commands one after the other /// </summary> /// <param name="repositoryLocator"></param> private void RunCommandExecutionLoop(IRDMPPlatformRepositoryServiceLocator repositoryLocator) { //when running a command loop don't use command line arguments (shouldn't really be possible anyway) _picker = null; while (true) { Console.WriteLine("Enter Command (or 'exit')"); var command = _input.GetString(new DialogArgs { WindowTitle = "Command" }, _commands.Keys.ToList()); try { command = GetCommandAndPickerFromLine(command, out _picker, repositoryLocator); if (string.Equals(command, "exit", StringComparison.CurrentCultureIgnoreCase)) { break; } RunCommand(command); } catch (Exception ex) { Console.WriteLine(ex.Message); } _picker = null; } }
public void TestSetArgument_CatalogueArrayOf2_Valid() { var cata1 = WhenIHaveA <Catalogue>(); cata1.Name = "kapow bob"; cata1.SaveToDatabase(); var cata2 = WhenIHaveA <Catalogue>(); cata2.Name = "kapow frank"; cata2.SaveToDatabase(); //Lets also test that PipelineComponentArgument also work (not just ProcessTaskArgument) var pca = WhenIHaveA <PipelineComponentArgument>(); var pc = pca.PipelineComponent; pca.Name = "ggg"; pca.SetType(typeof(Catalogue[])); Assert.IsNull(pca.Value); var picker = new CommandLineObjectPicker(new [] { $"PipelineComponent:{pc.ID}", "ggg", $"Catalogue:kapow*" }, RepositoryLocator); Assert.DoesNotThrow(() => GetInvoker().ExecuteCommand(typeof(ExecuteCommandSetArgument), picker)); Assert.Contains(cata1, (System.Collections.ICollection)pca.GetValueAsSystemType()); Assert.Contains(cata2, (System.Collections.ICollection)pca.GetValueAsSystemType()); }
/// <summary> /// Returns the first best constructor on the <paramref name="type"/> preferring those decorated with <see cref="UseWithCommandLineAttribute"/> /// </summary> /// <param name="type"></param> /// <returns></returns> public virtual ConstructorInfo GetConstructor(Type type, CommandLineObjectPicker picker) { var constructors = type.GetConstructors(); if (constructors.Length == 0) { return(null); } ConstructorInfo[] importDecorated = null; //If we have a picker, look for a constructor that wants to run from the command line if (picker != null) { importDecorated = constructors.Where(c => Attribute.IsDefined(c, typeof(UseWithCommandLineAttribute))).ToArray(); } //otherwise look for a regular decorated constructor if (importDecorated == null || !importDecorated.Any()) { importDecorated = constructors.Where(c => Attribute.IsDefined(c, typeof(UseWithObjectConstructorAttribute))).ToArray(); } if (importDecorated.Any()) { return(importDecorated[0]); } return(constructors[0]); }
public void TestPicker_TypeYieldsEmptyArrayOfObjects() { foreach (var cat in RepositoryLocator.CatalogueRepository.GetAllObjects <Catalogue>()) { cat.DeleteInDatabase(); } Assert.IsEmpty(RepositoryLocator.CatalogueRepository.GetAllObjects <Catalogue>()); //when interpreting the string "Catalogue" for a command var picker = new CommandLineObjectPicker(new [] { "Catalogue" }, GetActivator()); //we can pick it as either a Catalogue or a collection of all the Catalogues Assert.AreEqual(typeof(Catalogue), picker.Arguments.Single().Type); Assert.IsEmpty(picker.Arguments.Single().DatabaseEntities); //when interpretting as a Type we get Catalogue Assert.IsTrue(picker.Arguments.First().HasValueOfType(typeof(Type))); Assert.AreEqual(typeof(Catalogue), picker.Arguments.Single().GetValueForParameterOfType(typeof(Type))); //if it is looking for an ienumerable of objects Assert.IsTrue(picker.Arguments.First().HasValueOfType(typeof(IMapsDirectlyToDatabaseTable[]))); Assert.IsEmpty((IMapsDirectlyToDatabaseTable[])picker.Arguments.First().GetValueForParameterOfType(typeof(IMapsDirectlyToDatabaseTable[]))); Assert.IsTrue(picker.Arguments.First().HasValueOfType(typeof(Catalogue[]))); Assert.IsEmpty(((Catalogue[])picker.Arguments.First().GetValueForParameterOfType(typeof(Catalogue[]))).ToArray()); }
public void PickTypeName() { var picker = new CommandLineObjectPicker(new [] { "Name" }, GetActivator()); Assert.IsNull(picker[0].Type); Assert.AreEqual("Name", picker[0].RawValue); }
public void PickTypeName() { var picker = new CommandLineObjectPicker(new [] { "Name" }, RepositoryLocator); Assert.IsNull(picker[0].Type); Assert.AreEqual("Name", picker[0].RawValue); }
public void TestSetArgument_CatalogueArray_SetToNull_Valid() { var cata1 = WhenIHaveA <Catalogue>(); cata1.Name = "lolzzzyy"; cata1.SaveToDatabase(); //Lets also test that PipelineComponentArgument also work (not just ProcessTaskArgument) var pca = WhenIHaveA <PipelineComponentArgument>(); var pc = pca.PipelineComponent; pca.Name = "ggg"; pca.SetType(typeof(Catalogue[])); pca.SetValue(new Catalogue[] { cata1 }); pca.SaveToDatabase(); Assert.Contains(cata1, (System.Collections.ICollection)pca.GetValueAsSystemType()); var picker = new CommandLineObjectPicker(new [] { $"PipelineComponent:{pc.ID}", "ggg", $"Null" }, GetActivator()); Assert.DoesNotThrow(() => GetInvoker().ExecuteCommand(typeof(ExecuteCommandSetArgument), picker)); Assert.IsNull(pca.GetValueAsSystemType()); }
public ExecuteCommandSetArgument(IBasicActivateItems activator, CommandLineObjectPicker picker) : base(activator) { if (picker.Arguments.Count != 3) { SetImpossible($"Wrong number of parameters supplied to command, expected 3 but got {picker.Arguments.Count}"); return; } if (!picker.HasArgumentOfType(0, typeof(IMapsDirectlyToDatabaseTable))) { SetImpossible("First parameter must be an IArgumentHost DatabaseEntity"); return; } _host = picker[0].GetValueForParameterOfType(typeof(IMapsDirectlyToDatabaseTable)) as IArgumentHost; if (_host == null) { SetImpossible("First parameter must be an IArgumentHost"); return; } var args = _host.GetAllArguments(); _arg = args.FirstOrDefault(a => a.Name.Equals(picker[1].RawValue)); if (_arg == null) { SetImpossible($"Could not find argument called '{picker[1].RawValue}' on '{_host}'. Arguments found were {string.Join(",",args.Select(a=>a.Name))}"); return; } Type argType; try { argType = _arg.GetConcreteSystemType(); } catch (Exception e) { SetImpossible("Failed to get system Type of argument:" + e); return; } if (argType == null) { SetImpossible($"Argument '{_arg.Name}' has no listed Type"); return; } if (!picker[2].HasValueOfType(argType)) { SetImpossible($"Provided value '{picker[2].RawValue}' does not match expected Type '{argType.Name}' of argument '{_arg.Name}'"); return; } _value = picker[2].GetValueForParameterOfType(argType); }
public void TestSetArgument_WrongArgCount() { var picker = new CommandLineObjectPicker(new [] { "yyy" }, GetActivator()); var cmd = new ExecuteCommandSetArgument(GetMockActivator().Object, picker); Assert.IsTrue(cmd.IsImpossible); Assert.AreEqual("Wrong number of parameters supplied to command, expected 3 but got 1", cmd.ReasonCommandImpossible); }
public void TestSetArgument_NotAHost() { var c = WhenIHaveA <Catalogue>(); var picker = new CommandLineObjectPicker(new [] { $"Catalogue:{c.ID}", "fff", "yyy" }, GetActivator()); var cmd = new ExecuteCommandSetArgument(GetMockActivator().Object, picker); Assert.IsTrue(cmd.IsImpossible); Assert.AreEqual("First parameter must be an IArgumentHost", cmd.ReasonCommandImpossible); }
public void Test_NewObjectCommand_WrongTypeArgument() { var picker = new CommandLineObjectPicker(new[] { "UnitTests" }, GetActivator()); Assert.AreEqual(typeof(UnitTests), picker[0].Type); var ex = Assert.Throws <Exception>(() => GetInvoker().ExecuteCommand(typeof(ExecuteCommandNewObject), picker)); StringAssert.StartsWith("Type must be derived from DatabaseEntity", ex.Message); }
public void Test_NewObjectCommand_MissingNameArgument() { var picker = new CommandLineObjectPicker(new[] { "Catalogue" }, GetActivator()); Assert.AreEqual(typeof(Catalogue), picker[0].Type); var ex = Assert.Throws <ArgumentException>(() => GetInvoker().ExecuteCommand(typeof(ExecuteCommandNewObject), picker)); StringAssert.StartsWith("Value needed for parameter 'name' (of type 'System.String')", ex.Message); }
public void Test_NewObjectCommand_Success() { var picker = new CommandLineObjectPicker(new[] { "Catalogue", "lolzeeeyeahyeah" }, GetActivator()); Assert.AreEqual(typeof(Catalogue), picker[0].Type); Assert.DoesNotThrow(() => GetInvoker().ExecuteCommand(typeof(ExecuteCommandNewObject), picker)); Assert.Contains("lolzeeeyeahyeah", RepositoryLocator.CatalogueRepository.GetAllObjects <Catalogue>().Select(c => c.Name).ToArray()); }
/// <summary> /// Takes a single command line e.g. "list Catalogue" and spits it into a command "list" (returned) and the arguments list (as <paramref name="picker"/>) /// </summary> /// <param name="command"></param> /// <param name="picker"></param> /// <param name="repositoryLocator"></param> /// <returns></returns> private string GetCommandAndPickerFromLine(string command, out CommandLineObjectPicker picker, IRDMPPlatformRepositoryServiceLocator repositoryLocator) { if (command.Contains(' ')) { picker = new CommandLineObjectPicker(SplitCommandLine(command).Skip(1).ToArray(), _input); return(command.Substring(0, command.IndexOf(' '))); } picker = null; return(command); }
public void TestSetArgument_NoArgumentFound() { var pt = WhenIHaveA <ProcessTask>(); var picker = new CommandLineObjectPicker(new [] { $"ProcessTask:{pt.ID}", "fff", "yyy" }, GetActivator()); var cmd = new ExecuteCommandSetArgument(GetMockActivator().Object, picker); Assert.IsTrue(cmd.IsImpossible); StringAssert.StartsWith("Could not find argument called 'fff' on ", cmd.ReasonCommandImpossible); }
public void Test_Delete_WithPicker() { var mgr = new ConsoleInputManager(RepositoryLocator, new ThrowImmediatelyCheckNotifier()); var invoker = new CommandInvoker(mgr); WhenIHaveA <Catalogue>(); var picker = new CommandLineObjectPicker(new[] { "Catalogue:*" }, RepositoryLocator); invoker.ExecuteCommand(typeof(ExecuteCommandDelete), picker); }
public void Test_PickCatalogueByID_PickTwo() { var cata1 = WhenIHaveA <Catalogue>(); var cata2 = WhenIHaveA <Catalogue>(); var picker = new CommandLineObjectPicker(new [] { $"Catalogue:{cata1.ID},{cata2.ID}" }, GetActivator()); Assert.AreEqual(2, picker[0].DatabaseEntities.Count); Assert.Contains(cata1, picker[0].DatabaseEntities); Assert.Contains(cata2, picker[0].DatabaseEntities); }
public void Test_Delete_WithPicker() { var mgr = GetActivator(); var invoker = new CommandInvoker(mgr); WhenIHaveA <Catalogue>(); var picker = new CommandLineObjectPicker(new[] { "Catalogue:*" }, mgr); invoker.ExecuteCommand(typeof(ExecuteCommandDelete), picker); }
public void Test_PickCatalogueByID_PickTwo() { var cata1 = WhenIHaveA <Catalogue>(); var cata2 = WhenIHaveA <Catalogue>(); var picker = new CommandLineObjectPicker(new [] { $"Catalogue:{cata1.ID},{cata2.ID}" }, RepositoryLocator); Assert.AreEqual(cata1, picker[0].DatabaseEntities[0]); Assert.AreEqual(cata2, picker[0].DatabaseEntities[1]); Assert.AreEqual(2, picker[0].DatabaseEntities.Count); }
public void Test_RandomGarbage_GeneratesRawValueOnly() { string str = $"Shiver me timbers"; var picker = new CommandLineObjectPicker(new [] { str }, GetActivator()); Assert.AreEqual(str, picker[0].RawValue); Assert.IsNull(picker[0].DatabaseEntities); Assert.IsNull(picker[0].Database); Assert.IsNull(picker[0].Table); Assert.IsNull(picker[0].Type); }
public void Test_PickCatalogueByTypeOnly_WithShortCode() { var cata1 = WhenIHaveA <Catalogue>(); var cata2 = WhenIHaveA <Catalogue>(); // c is short for Catalogue // so this would be the use case 'rdmp cmd list Catalogue' where user can instead write 'rdmp cmd list c' var picker = new CommandLineObjectPicker(new[] { $"c" }, GetActivator()); Assert.AreEqual(2, picker[0].DatabaseEntities.Count); Assert.Contains(cata1, picker[0].DatabaseEntities); Assert.Contains(cata2, picker[0].DatabaseEntities); }
public void Test_PickCatalogueByName_WithShortCode() { var cata1 = WhenIHaveA <Catalogue>(); var cata2 = WhenIHaveA <Catalogue>(); cata1.Name = "Biochem"; cata2.Name = "Haematology"; var picker = new CommandLineObjectPicker(new[] { $"c:*io*" }, GetActivator()); Assert.AreEqual(cata1, picker[0].DatabaseEntities[0]); Assert.AreEqual(1, picker[0].DatabaseEntities.Count); }
private CommandLineObjectPickerArgumentValue ReadLineWithAuto(PickObjectBase[] pickers, IEnumerable <string> autoComplete) { if (DisallowInput) { throw new InputDisallowedException("Value required"); } string line = ReadLineWithAuto(autoComplete); var picker = new CommandLineObjectPicker(new[] { line }, RepositoryLocator, pickers); return(picker[0]); }
public void Test_PickCatalogueByID_PickOne() { var cata = WhenIHaveA <Catalogue>(); var picker = new CommandLineObjectPicker(new [] { $"Catalogue:{cata.ID}" }, GetActivator()); Assert.AreEqual(cata, picker[0].DatabaseEntities.Single()); //specifying the same ID twice shouldn't return duplicate objects picker = new CommandLineObjectPicker(new [] { $"Catalogue:{cata.ID},{cata.ID}" }, GetActivator()); Assert.AreEqual(cata, picker[0].DatabaseEntities.Single()); }
public void Test_PickWithPropertyQuery_PeriodicityNull() { // Catalogues var c1 = WhenIHaveA <Catalogue>(); var c2 = WhenIHaveA <Catalogue>(); c1.PivotCategory_ExtractionInformation_ID = 10; c2.PivotCategory_ExtractionInformation_ID = null; var picker = new CommandLineObjectPicker(new[] { $"Catalogue?PivotCategory_ExtractionInformation_ID:null" }, GetActivator()); Assert.AreEqual(1, picker[0].DatabaseEntities.Count); Assert.Contains(c2, picker[0].DatabaseEntities); }
public void Test_PickerForWhitespace(string val) { var picker = new CommandLineObjectPicker(new [] { val }, GetActivator()); Assert.AreEqual(1, picker.Length); Assert.IsNull(picker[0].Database); Assert.IsNull(picker[0].DatabaseEntities); Assert.IsFalse(picker[0].ExplicitNull); Assert.AreEqual(val, picker[0].RawValue); Assert.IsNull(picker[0].Type); Assert.AreEqual(val, picker[0].GetValueForParameterOfType(typeof(string))); Assert.IsTrue(picker.HasArgumentOfType(0, typeof(string))); }
public void TestSetArgument_Int_Valid() { var pta = WhenIHaveA <ProcessTaskArgument>(); var pt = pta.ProcessTask; pta.Name = "fff"; pta.SetType(typeof(int)); Assert.IsNull(pta.Value); var picker = new CommandLineObjectPicker(new [] { $"ProcessTask:{pt.ID}", "fff", "5" }, GetActivator()); Assert.DoesNotThrow(() => GetInvoker().ExecuteCommand(typeof(ExecuteCommandSetArgument), picker)); Assert.AreEqual(5, pta.GetValueAsSystemType()); }