public void HelpCommand4() { var factory = new CommandFactory(); var command = factory.Create(new[] {"help", "foo"}); Assert.AreEqual(typeof(HelpCommand), command.GetType()); Assert.AreEqual(OutputFor(command), OutputFor(new HelpCommand(factory.Registry, "foo"))); }
private void CheckAgentUpdater() { try { var minAgentUpdater = new CommandFactory().CreateCommand(Utilities.Commands.ensureminagentupdater.ToString()); var result = minAgentUpdater.Execute(string.Empty); if (result.ExitCode == "1") { var sb = new StringBuilder(); if (result.Error != null) { foreach (var error in result.Error) { sb.AppendLine(error); } } throw new Exception(sb.ToString()); } } catch (Exception ex) { _logger.Log(string.Format("Error checking the min version of the updater and updating: {0}", ex)); } }
private static void Main(string[] args) { try { // foreach (var option in Options.Create(args)) // { // Console.WriteLine(option); // } // Console.WriteLine(new string('-', 64)); // Console.WriteLine(); var factory = new CommandFactory {Default = new DefaultCommand()}; factory.Register<FooCommand>(); factory.Register<BarCommand>(); factory.Register<FastCommand>(); var command = factory.Create(args); command.Execute(); // var options = new ObjectParser().Parse<TestAppOptions>(args); // Console.WriteLine(options); } catch (Exception e) { Console.WriteLine(e); } }
public void HelpCommand() { var factory = new CommandFactory(); var command = factory.Create(new string[] {}); Assert.AreEqual(typeof(HelpCommand), command.GetType()); Assert.AreEqual(OutputFor(command), OutputFor(new HelpCommand())); }
public void run() { var routes = Container.Current.get_a<RoutingTable>(); var factory = new CommandFactory(); routes.add(factory.match<Home>("Home.do")); routes.add(factory.match<Index>("Index.do")); }
/// <summary> /// Initializes the <see cref="FlatSquares.Terminal.Module.CommandProcess"/> class. /// </summary> public static void Initialize() { ConfigurationLoader.Initialize(); Modules = ModuleLoader.GetModules(); History = new CommandHistory(); Factory = new CommandFactory(); }
private async void SelectRepoButtonClick(object sender, RoutedEventArgs e) { using (var dialog = new CommonOpenFileDialog()) { dialog.IsFolderPicker = true; if (dialog.ShowDialog() == CommonFileDialogResult.Ok) { commandFactory = new CommandFactory(resultCommandMapper, dialog.FileName); var statusCommand = commandFactory.GetCommand<StatusResult>(); statusCommand.Execute(); if (statusCommand.Result.ExecutionResult == ExecutionResult.NoRepository) { commandFactory = null; MessageBox.Show("The selected file contains no git repository.", "Error!", MessageBoxButton.OK); } else { currentBranch.Text = "Current branch: " + statusCommand.Result.CurrentBranch; } await ListNormalCommits(); } } }
public void Init() { var mockedCommandFactory = new Mock<CommandFactory>(); var mockedICommandExecutable = new Mock<ICommandExecutable>(); this.commandFactory = mockedCommandFactory.Object; this.engine = mockedICommandExecutable.Object; }
public void should_create_a_dependency_tree_for_kmsactivate() { var factory = new CommandFactory(); foreach (var name in Enum.GetNames(typeof(Utilities.Commands))) { factory.CreateCommand(name); } }
public GameEngine(IPrinter printer, IReader inputReader, CommandFactory commandFactory, Validator validator, Game game) { this.Scoreboard = Scoreboard.Instance; this.Printer = printer; this.InputReader = inputReader; this.CommandFactory = commandFactory; this.Validator = validator; this.Game = game; }
public void AmbiguousMatchCommand() { var registry = new CommandRegistry(); registry.Register(new BarCommand()); registry.Register(new BazCommand()); var factory = new CommandFactory(registry); var command = factory.Create(new[] {"ba"}); Assert.That(command, Is.InstanceOf(typeof(AmbiguousMatchCommand))); }
public void SetCommandWithError() { using (var connection = new ConnectionMock("set foo 1\r\n3\r\n", "-ERR Get off\r\n")) { var f = new CommandFactory(new NormalCommandExecutor(connection)); RedisCommand command = f.Set("foo", "3"); command.Exec(); } }
public DriveBrowser(CommandFactory command_factory) { InitializeComponent(); ux_open_file_button.bind_to( command_factory.create_from(new ShowContentsOfATextFile( @"C:\github\nbdn_2009_august_orlando\store\readme.txt", richTextBox1))); }
// git rev-parse --show-toplevel Shows base dir of the repo // git log --pretty=format: --name-only --diff-filter=A All files that ever existed in the repository // git log --oneline -- <path/file> Get all commits a file is part of public MainWindow() { InitializeComponent(); // The version command does not need a repository path var versionCommand = new CommandFactory(resultCommandMapper, "").GetCommand<VersionResult>(); versionCommand.Execute(); Title += " (Git-Version: " + versionCommand.Result + ")"; }
/// <summary> /// Executes play command and starts the game. /// </summary> public override void Execute() { var wordSelector = new WordSelectorFromFile(); var player = new Player(); var commandFactory = new CommandFactory(); var game = new HangmanGame(this.UI, new PlayerInitializationState(), wordSelector, player, commandFactory); game.StartGame(); }
/// <summary> /// Initializes a new instance of the <see cref="HangmanGame"/> class. /// </summary> /// <param name="ui">Used to draw on console</param> /// <param name="state">Holds different states while game is running</param> /// <param name="wordselector">Select words from .txt file</param> /// <param name="player">Holds information for user</param> /// <param name="commandCreator">Returns command from user</param> public HangmanGame(IUI ui, State state, WordSelectorFromFile wordselector, IPlayer player, CommandFactory commandCreator) { this.WordSelect = wordselector; this.Scores = ScoreBoard.Instance; this.State = state; this.Player = player; this.UI = ui; this.CommandFactory = commandCreator; }
public HttpOptionsBuilder WithCommandFactory(Func<IHttpOptionsContext, CommandFactory> resolver) { Guard.EnsureNotNull(resolver, nameof(resolver)); commandFactory = resolver(this); Guard.EnsureNotNull(commandFactory, nameof(commandFactory)); return this; }
static void Main(string[] args) { var commandText = args[0]; var commandFactory = new CommandFactory(); var command = commandFactory.CreateCommand(commandText); command.Execute(); }
public static void Main(string[] args) { ConfigureLog4net(); WriteVanityBanner(); using (MachineContainer container = new MachineContainer()) { container.Initialize(); container.PrepareForServices(); ContainerRegistrationHelper helper = new ContainerRegistrationHelper(container); helper.AddServiceCollectionsFrom(typeof(PartstoreServices).Assembly); container.Start(); IoC.Container = container; CommandLineParser parser = new CommandLineParser(); parser.ParseCommandLine(args); string commandName = "help"; if (parser.OrphanedArguments.Count > 0) { commandName = parser.OrphanedArguments[0].Value; parser.OrphanedArguments.RemoveAt(0); } CommandFactory commandFactory = new CommandFactory(container); commandFactory.AddCommand<ShowCommand>("show"); commandFactory.AddCommand<UnpackageCommand>("unpackage"); commandFactory.AddCommand<AddDependencyCommand>("add"); commandFactory.AddCommand<AddNewVersionCommand>("publish"); commandFactory.AddCommand<AddNewVersionCommand>("archive"); commandFactory.AddCommand<SeachRepositoryCommand>("search"); commandFactory.AddCommand<RefreshCommand>("refresh"); commandFactory.AddCommand<ConfigureCommand>("config"); commandFactory.AddCommand<HelpCommand>("help"); ICommand command = commandFactory.CreateCommand(commandName); CommandLineOptionBinder bind = new CommandLineOptionBinder(parser, command); bind.Required<AddDependencyCommand>(x => x.ProjectName, bind.Named("project"), bind.Named("p"), bind.First()); bind.Optional<AddDependencyCommand>(x => x.RepositoryName, bind.Named("repository"), bind.Named("r")); bind.Optional<AddNewVersionCommand>(x => x.RepositoryName, bind.Named("repository"), bind.Named("r")); bind.Optional<AddNewVersionCommand>(x => x.Tags, bind.Named("tags"), bind.Named("t")); if (bind.HasErrors) { foreach (BindingError error in bind.Errors) { Console.WriteLine(error); } return; } command.Run(); Console.WriteLine(); } }
public void GetCommandWithNormalResult() { using (var connection = new ConnectionMock("GET foo\r\n", "+baz\r\n")) { var f = new CommandFactory(new NormalCommandExecutor(connection)); var command = f.Get("foo"); command.Exec(); Assert.That(Encoding.ASCII.GetString(command.Result), Is.EqualTo("baz")); } }
public void SetCommandWithNormalResult() { using (var connection = new ConnectionMock("SET foo 1_3_", "+OK\r\n")) { var f = new CommandFactory(new NormalCommandExecutor(connection)); RedisCommand command = f.Set("foo", "3"); command.Exec(); connection.Verify(); } }
private void Init() { if( m_instance == null ){ m_instance = this; DontDestroyOnLoad(this.gameObject); } else{ Destroy(this.gameObject); } }
public void HangmanEngineIsCreatedAndFactoryIsPartOfIt() { var factory = new CommandFactory(); var engine = new HangmanEngine(new ConsolePrinter(), new ConsoleReader(), factory, new Validator(), new HangmanGame(new WordInitializer())); var testFactoryReference = engine.CommandFactory; Assert.AreSame(factory, testFactoryReference); }
internal HttpOptions(string commandPath, ICommandRegistry commandRegistry, IHandlerFactory handlerFactory, ICommandNameResolver commandNameResolver, CommandFactory commandFactory, CommandPipeline commandPipeline) : base(commandRegistry, handlerFactory, commandPipeline) { Guard.EnsureNotNullOrWhitespace(commandPath, nameof(commandPath)); Guard.EnsureNotNull(commandNameResolver, nameof(commandNameResolver)); Guard.EnsureNotNull(commandFactory, nameof(commandFactory)); CommandPath = commandPath; CommandNameResolver = commandNameResolver; CommandFactory = commandFactory; }
public void CreateCommand_DuplicateValidCommandStrings_ReturnsNullCommandOnSecondInstantiation() { string commandString = "<LF255F255F255>"; CommandFactory factory = new CommandFactory(); ICommand command = factory.CreateCommand(commandString); Assert.IsNotInstanceOf(typeof(NullCommand), command, "Valid string inputted, should return a non-null command"); command = factory.CreateCommand(commandString); Assert.IsInstanceOf(typeof(NullCommand), command); }
public void OutputForAmbiguousMatchCommand() { var registry = new CommandRegistry(); registry.Register(new BarCommand()); registry.Register(new BazCommand()); var factory = new CommandFactory(registry); var command = factory.Create(new[] {"ba"}); var output = OutputFor(command); Assert.That(output, Is.StringContaining("Multiple commands start with 'ba':")); Assert.That(output, Is.StringContaining(" bar")); Assert.That(output, Is.StringContaining(" baz")); }
public void MultiGet(Func<IRedisConnection, IComandExecutor> ef) { using (var conn = RedisConnection.Connect("localhost", 6379)) { var f = new CommandFactory(ef(conn)); f.Set("foo1", "bar").Exec(); f.Set("foo2", "baz").Exec(); var cmd = f.MultiGet("foo1", "foo2"); var strings = cmd.ExecAndReturn().Select(q => Str(q)).ToArray(); Assert.That(strings, Is.EqualTo(new[] { "bar", "baz" })); } }
public void CreateCommand_DifferentValidMovementCommandStrings_ReturnsTwoMovementCommands() { string commandString = "<LF255F255F255>"; string commandString2 = "<LF200F200F200>"; CommandFactory factory = new CommandFactory(); ICommand command = factory.CreateCommand(commandString); Assert.IsInstanceOf(typeof(MovementCommand), command); command = factory.CreateCommand(commandString2); Assert.IsInstanceOf(typeof(MovementCommand), command); }
public void CreateCommand_DifferentValidCameraCommandStrings_ReturnsTwoCameraCommands() { string commandString = "<C1O>"; string commandString2 = "<C1F>"; CommandFactory factory = new CommandFactory(); ICommand command = factory.CreateCommand(commandString); Assert.IsInstanceOf(typeof(CameraCommand), command); command = factory.CreateCommand(commandString2); Assert.IsInstanceOf(typeof(CameraCommand), command); }
public ViewModelContext( ClassifierDictionary availableClassifiers, CommandFactory commandFactory, MessageSystem messageSystem) { Requires(availableClassifiers != null); Requires(messageSystem != null); Classifiers = availableClassifiers; MessageSystem = messageSystem; ViewModelFactory = new ViewModelFactory(this); CommandFactory = commandFactory; }
public void TestBucketCommandMissingExpetedParams() { string input = "b 6 4"; CommandEntity command = CommandFactory.GetCommand(input); }
public void TestBucketCommandZeroWidth() { string input = "b 0 -2 o"; CommandEntity command = CommandFactory.GetCommand(input); }
public CommandFactoryTests() { _factory = new CommandFactory(); _commmand = new MockCommand(); }
public string Execute(string commandName, params string[] commandParams) { var command = CommandFactory.CreateCommand(commandName); return(command.Execute(this.resController, commandParams)); }
internal CommandProcessorBase CreateCommandProcessor(ExecutionContext executionContext, CommandFactory commandFactory, bool addToHistory, CommandOrigin origin) { CommandProcessorBase base2; string str2; HelpCategory category; if (!this.IsScript) { if (this._useLocalScope.HasValue && !this._useLocalScope.Value) { switch (executionContext.LanguageMode) { case PSLanguageMode.RestrictedLanguage: case PSLanguageMode.NoLanguage: throw new RuntimeException(StringUtil.Format(RunspaceStrings.UseLocalScopeNotAllowed, new object[] { "UseLocalScope", PSLanguageMode.RestrictedLanguage.ToString(), PSLanguageMode.NoLanguage.ToString() })); } } base2 = commandFactory.CreateCommand(this.CommandText, origin, this._useLocalScope); } else { if (executionContext.LanguageMode == PSLanguageMode.NoLanguage) { throw InterpreterError.NewInterpreterException(this.CommandText, typeof(ParseException), null, "ScriptsNotAllowed", ParserStrings.ScriptsNotAllowed, new object[0]); } ScriptBlock function = executionContext.Engine.ParseScriptBlock(this.CommandText, addToHistory); switch (executionContext.LanguageMode) { case PSLanguageMode.FullLanguage: case PSLanguageMode.ConstrainedLanguage: break; case PSLanguageMode.RestrictedLanguage: function.CheckRestrictedLanguage(null, null, false); break; default: throw new InvalidOperationException("Invalid langage mode was set when building a ScriptCommandProcessor"); } if (function.UsesCmdletBinding) { FunctionInfo scriptCommandInfo = new FunctionInfo("", function, executionContext); bool? nullable = this._useLocalScope; base2 = new CommandProcessor(scriptCommandInfo, executionContext, nullable.HasValue ? nullable.GetValueOrDefault() : false, false, executionContext.EngineSessionState); } else { bool?nullable2 = this._useLocalScope; base2 = new DlrScriptCommandProcessor(function, executionContext, nullable2.HasValue ? nullable2.GetValueOrDefault() : false, CommandOrigin.Runspace, executionContext.EngineSessionState); } } CommandParameterCollection parameters = this.Parameters; if (parameters != null) { bool forNativeCommand = base2 is NativeCommandProcessor; foreach (CommandParameter parameter in parameters) { CommandParameterInternal internal2 = CommandParameter.ToCommandParameterInternal(parameter, forNativeCommand); base2.AddParameter(internal2); } } if (base2.IsHelpRequested(out str2, out category)) { base2 = CommandProcessorBase.CreateGetHelpCommandProcessor(executionContext, str2, category); } this.SetMergeSettingsOnCommandProcessor(base2); return(base2); }
public CommandInterpreter(IServiceProvider service) { this.serviceProvider = service; this.factory = new CommandFactory(); }
public void InvalidTypeGetCommands() { var actual = CommandFactory.GetCommands("WieldThing"); Assert.Empty(actual); }
public void GetCommands(string type, List <string> commands) { var actual = CommandFactory.GetCommands(type).ToList(); Assert.Equal(commands, actual); }
public void CreateInvalidType() { var actual = CommandFactory.CreateCommand("SomeDevice", "Snapshot"); Assert.Null(actual); }
public void CreateInvalidOperation(string type, string operation) { var actual = CommandFactory.CreateCommand(type, operation); Assert.Null(actual); }
public void TestBucketCommandUnexpectedParam() { string input = "b 6 10 o z"; CommandEntity command = CommandFactory.GetCommand(input); }
public void TestBucketCommandInvalidXYParamType() { string input = "b 10 y o"; CommandEntity command = CommandFactory.GetCommand(input); }
private static void Startup() { SimpleIoc container = new SimpleIoc(); container.Register <ServiceMessageBus>(); container.Register <IServiceMessageBus>(() => container.GetInstance <ServiceMessageBus>()); container.Register <IServiceMessageBusRegister>(() => container.GetInstance <ServiceMessageBus>()); container.Register <ILogService, DebugLogService>(); container.Register <IInputParseService, InputParseService>(); container.Register <IInputEvaluationService, InputEvaluationService>(); container.Register <IEnvironmentService, EnvironmentService>(); container.Register <ISettingService, SettingService>(); container.Register <ICommandManagementService, SingletonCommandManagementService>(); container.Register <IResultProcessingService, ResultProcessingService>(); container.Register <IMarkdownService, MarkdownService>(); container.Register <IConsoleRenderService, ConsoleMarkdownRenderService>(); container.Register <ConsoleViewService>(); container.Register <IViewService>(() => container.GetInstance <ConsoleViewService>()); container.Register <IPromptableViewService>(() => container.GetInstance <ConsoleViewService>()); // PowerShell Fallback container.Register <IPowerShellResultBuilder, PowerShellResultMarkdownBuilder>(); container.Register <IFallbackService, PowerShellFallbackService>(); // Core commands container.Register <CurrentDirectoryCommand>(); container.Register <TexoCommand>(); container.Register <HelpCommand>(); container.Register <ClearCommand>(); // Simple commands container.Register <ReferenceCheckCommand>(); container.Register <CommandLineCommand>(); // File manager container.Register <ISerialisationService, JsonSerialisationService>(); container.Register <IStageService, StageService>(); container.Register <IStashService, StashService>(); container.Register <FileManagerCommand>(); // Nuget manager container.Register <IProjectManagementService, ProjectManagementService>(); container.Register <IPackageManagementService, PackageManagementService>(); container.Register <IConfigManagementService, ConfigManagementService>(); container.Register <ISourceManagementService, SourceManagementService>(); container.Register <IManagementService, ManagementService>(); container.Register <Commands.NugetManager.Stage.IStageService, Commands.NugetManager.Stage.StageService>(); container.Register <NugetManagerCommand>(); CommandFactory commandFactory = new CommandFactory(); container.Register <ITexoFactory <object, string> >(() => commandFactory); commandFactory.Register(CommandKeys.CURRENT_DIRECTORY, () => container.GetInstance <CurrentDirectoryCommand>()); commandFactory.Register(CommandKeys.TEXO, () => container.GetInstance <TexoCommand>()); commandFactory.Register(CommandKeys.HELP, container.GetInstance <HelpCommand>); commandFactory.Register(CommandKeys.CLEAR, container.GetInstance <ClearCommand>); commandFactory.Register(ReferenceCheckConstants.REF_CHECK, () => container.GetInstance <ReferenceCheckCommand>()); commandFactory.Register("command-line", () => container.GetInstance <CommandLineCommand>()); commandFactory.Register("file-manager", () => container.GetInstance <FileManagerCommand>()); commandFactory.Register("nuget-manager", () => container.GetInstance <NugetManagerCommand>()); ServiceMessageBus messageBus = container.GetInstance <ServiceMessageBus>(); var engineBuilder = new TexoEngineBuilder(messageBus, messageBus) .WithLogService(container.GetInstance <ILogService>()) .WithInputParseService(container.GetInstance <IInputParseService>()) .WithInputEvaluationService(container.GetInstance <IInputEvaluationService>()) .WithEnvironmentService(container.GetInstance <IEnvironmentService>()) .WithSettingService(container.GetInstance <ISettingService>()) .WithCommandManagementService(container.GetInstance <ICommandManagementService>()) .WithResultProcessingService(container.GetInstance <IResultProcessingService>()) .WithFallbackService(container.GetInstance <IFallbackService>()); var locator = engineBuilder.GetServiceLocator(); container.Register(locator.ActionProvider); container.Register(locator.ActionRegister); engine = engineBuilder.Build(commandFactory, container.GetInstance <IViewService>()); var config = TexoConfiguration.CreateDefault().ToBuilder(); config.Runtime.Commands.Add(ReferenceCheckCommand.BuildConfiguration()); config.Runtime.Commands.Add(CommandLineCommand.BuildConfiguration()); config.Runtime.Commands.Add(FileManagerBuilder.BuildCommand()); config.Runtime.Commands.Add(NugetManagerBuilder.BuildCommand()); engine.Initialise(config.ToImmutable()); }
public async Task <IActionResult> EditBooking(EditBookingViewModel editBookingViewModel) { IActionResult authenticationResult = await AuthenticateUserLogin(false); if (authenticationResult != null) { return(authenticationResult); } bool bookingValid = ValidateBooking(editBookingViewModel); if (bookingValid) { List <Equipment> chosenEquipmentList = new List <Equipment>(); List <Booking> coincidingBookings = (List <Booking>) await CommandFactory.CreateCommand(CommandFactory.CHECK_FOR_COINCIDING_BOOKINGS, editBookingViewModel.StartDate, editBookingViewModel.EndDate, DbContext).Execute(); for (int i = 0; i < coincidingBookings.Count; i++) { if (coincidingBookings[i].Id == editBookingViewModel.BookingId) { coincidingBookings.RemoveAt(i); break; } } if (coincidingBookings.Count > 0) { foreach (Booking coincidingBooking in coincidingBookings) { if (editBookingViewModel.VehicleId == coincidingBooking.Vehicle.Id) { ViewData["ChosenVehicle"] = await GetChosenVehicle(editBookingViewModel.VehicleId); ModelState.AddModelError("", "The vehicle is not available for the period of your booking. The latest you can book this vehicle until is " + coincidingBooking.StartDate.AddDays(-1).ToString("dd/MM/yyyy")); return(View(editBookingViewModel)); } } foreach (EquipmentCheckboxSelectViewModel equipmentCheckbox in editBookingViewModel.ChosenEquipmentList) { if (equipmentCheckbox.CheckboxAnswer == true) { Equipment tempEquipment = new Equipment(); tempEquipment.Id = equipmentCheckbox.Id; tempEquipment.Name = equipmentCheckbox.Name; bool equipmentAvailable = (bool)await CommandFactory.CreateCommand(CommandFactory.CHECK_EQUIPMENT_AVAILABILITY, coincidingBookings, tempEquipment, DbContext).Execute(); if (equipmentAvailable == true) { chosenEquipmentList.Add(tempEquipment); } else { errorString = "A " + equipmentCheckbox.Name + " is not available for the period of your booking. Please select a different booking period, or continue without this equipment item."; ModelState.AddModelError("", errorString); return(View(editBookingViewModel)); } } } } Booking booking = ConvertViewModelToBooking(editBookingViewModel); if (booking == null) { errorString = "Something went wrong, please try again."; ModelState.AddModelError("", errorString); return(View(editBookingViewModel)); } int bookingUpdated = (int)await CommandFactory.CreateCommand(CommandFactory.UPDATE_BOOKING, booking, chosenEquipmentList, DbContext).Execute(); if (bookingUpdated >= 1) { TempData["successmessage"] = "Booking Updated Successfully."; return(RedirectToAction("Index", "Home")); } else { errorString = "Something went wrong, please try again."; ModelState.AddModelError("", errorString); return(View(editBookingViewModel)); } } return(View(editBookingViewModel)); }
public void SetCommandFactory(CommandFactory factory) { this.CommandFactory = factory; }
public async Task <IActionResult> CollectBooking(CollectBookingViewModel collectBookingViewModel) { //Check the user is an admin. IActionResult authenticationResult = await AuthenticateUserLogin(true); if (authenticationResult != null) { return(authenticationResult); } //get the full booking record int bookingId = collectBookingViewModel.BookingId; Booking userBooking = (Booking)await CommandFactory.CreateCommand(CommandFactory.GET_BOOKING, bookingId, DbContext).Execute(); //Create a unique folder path based on the booking users name and license number, then upload the file to that folder. string folderPath = GenerateUserBasedFolderPath(userBooking.User); string uploadedFilePath = await UploadIdentificationFile(collectBookingViewModel.AdditionalIdentificationImage, folderPath); if (uploadedFilePath.Equals("uploadFailed")) { errorString = "Something went wrong, please try again."; ModelState.AddModelError("", errorString); return(View()); } else { //Update the bookee's user data with the file path for the identification image. userBooking.User.IdentificationFolderSource = uploadedFilePath; int userUpdated = (int)await CommandFactory.CreateCommand(CommandFactory.UPDATE_USER, userBooking.User, DbContext, _userManager).Execute(); if (userUpdated < 1) { errorString = "Something went wrong, please try again."; ModelState.AddModelError("", errorString); return(View()); } } //Check if the user's license is still valid, or whether it has been reported as lost, stolen or suspended bool userLicenseInvalid; try { userLicenseInvalid = await CheckIfUserLicenseValid(userBooking.User); } catch (Exception e) { TempData["errormessage"] = e.Message; return(View()); } //If the user's license is valid, then we check whether they have previously committed insurance fraud. if (!userLicenseInvalid) { bool userCommittedInsuranceFraud; try { userCommittedInsuranceFraud = await CheckIfUserCommittedInsuranceFraud(userBooking.User); } catch (Exception e) { TempData["errormessage"] = e.Message; return(View()); } //If the user committed insurance fraud, then alert the admin and delete the booking. if (userCommittedInsuranceFraud) { int bookingDeleted = (int)await CommandFactory.CreateCommand(CommandFactory.DELETE_BOOKING, bookingId, DbContext).Execute(); errorString = "This booking can not be collected: The person who made this booking has previously made a fraudulent insurance claim. This booking has been deleted."; TempData["errormessage"] = errorString; return(RedirectToAction("Index", "Home")); } else { int bookingCollected = (int)await CommandFactory.CreateCommand(CommandFactory.COLLECT_BOOKING, bookingId, DbContext).Execute(); if (bookingCollected < 1) { errorString = "Something went wrong, please try again."; ModelState.AddModelError("", errorString); return(View()); } TempData["successmessage"] = "Booking Marked As Collected!"; return(RedirectToAction("Index", "Home")); } } else { //Put the files into collection ready to email to the DVLA FormFileCollection fileCollection = new FormFileCollection(); fileCollection.Add(collectBookingViewModel.DrivingLicenseImageBack); fileCollection.Add(collectBookingViewModel.DrivingLicenseImageFront); fileCollection.Add(collectBookingViewModel.PersonCollectingImage); fileCollection.Add(collectBookingViewModel.AdditionalIdentificationImage); //Send the email to the DVLA and then delete the booking and inform the admin. await CommandFactory.CreateCommand(CommandFactory.SEND_EMAIL, fileCollection, userBooking.User).Execute(); int bookingDeleted = (int)await CommandFactory.CreateCommand(CommandFactory.DELETE_BOOKING, bookingId, DbContext).Execute(); errorString = "This booking can not be collected: The license associated with this booking is currently invalidated by the DVLA. The DVLA have been informed and this booking has been deleted."; TempData["errormessage"] = errorString; return(RedirectToAction("Index", "Home")); } }
public void ShouldDeletePackagesFolder([Frozen] Mock <IFileSystem> fileSystem, CommandFactory factory) { // Arrange var args = new ScriptCsArgs { Clean = true }; fileSystem.Setup(i => i.DirectoryExists(It.Is <string>(x => x.Contains(Constants.PackagesFolder)))).Returns(true); fileSystem.Setup(i => i.GetWorkingDirectory(It.IsAny <string>())).Returns("c:\\"); // Act factory.CreateCommand(args, new string[0]).Execute(); // Assert fileSystem.Verify(i => i.DirectoryExists(It.Is <string>(x => x.Contains(Constants.PackagesFolder))), Times.Once()); fileSystem.Verify(i => i.DeleteDirectory(It.Is <string>(x => x.Contains(Constants.PackagesFolder))), Times.Once()); }
public async Task <Vehicle> GetChosenVehicle(long vehicleId) { return((Vehicle)await CommandFactory.CreateCommand(CommandFactory.GET_VEHICLE, vehicleId, DbContext).Execute()); }
public CommandInterpreter(IRepository repository, IUnitFactory unitFactory) { this.repository = repository; this.unitFactory = unitFactory; this.commandFactory = new CommandFactory(); }
public async Task <IActionResult> BookVehicle(BookVehicleViewModel bookVehicleViewModel) { IActionResult authenticationResult = await AuthenticateUserLogin(false); if (authenticationResult != null) { return(authenticationResult); } bool bookingValid = ValidateBooking(bookVehicleViewModel); if (bookingValid) { List <Equipment> chosenEquipmentList = new List <Equipment>(); List <Booking> coincidingBookings = (List <Booking>) await CommandFactory.CreateCommand(CommandFactory.CHECK_FOR_COINCIDING_BOOKINGS, bookVehicleViewModel.StartDate, bookVehicleViewModel.EndDate, DbContext).Execute(); if (coincidingBookings.Count > 0) { foreach (Booking coincidingBooking in coincidingBookings) { if (bookVehicleViewModel.ChosenVehicleId == coincidingBooking.Vehicle.Id) { ViewData["ChosenVehicle"] = await GetChosenVehicle(bookVehicleViewModel.ChosenVehicleId); ModelState.AddModelError("", "The vehicle is not available for the period of your booking. It is booked between " + coincidingBooking.StartDate.AddDays(-1).ToString("dd/MM/yyyy") + " and " + coincidingBooking.EndDate.AddDays(-1).ToString("dd/MM/yyyy")); return(View(bookVehicleViewModel)); } } foreach (EquipmentCheckboxSelectViewModel equipmentCheckbox in bookVehicleViewModel.ChosenEquipmentList) { if (equipmentCheckbox.CheckboxAnswer == true) { Equipment tempEquipment = new Equipment(); tempEquipment.Id = equipmentCheckbox.Id; tempEquipment.Name = equipmentCheckbox.Name; bool equipmentAvailable = (bool)await CommandFactory.CreateCommand(CommandFactory.CHECK_EQUIPMENT_AVAILABILITY, coincidingBookings, tempEquipment, DbContext).Execute(); if (equipmentAvailable == true) { chosenEquipmentList.Add(tempEquipment); } else { ViewData["ChosenVehicle"] = await GetChosenVehicle(bookVehicleViewModel.ChosenVehicleId); errorString = equipmentCheckbox.Name + " is not available for the period of your booking. Please select a different booking period, or continue without this equipment item."; ModelState.AddModelError("", errorString); return(View(bookVehicleViewModel)); } } } } Booking newBooking = ConvertViewModelToBooking(bookVehicleViewModel); int bookingAdded = (int)await CommandFactory.CreateCommand(CommandFactory.ADD_BOOKING, newBooking, chosenEquipmentList, DbContext).Execute(); if (bookingAdded >= 1) { TempData["successmessage"] = "Booking successfully created!"; return(RedirectToAction("Index", "Home")); } else { ViewData["ChosenVehicle"] = await GetChosenVehicle(VehicleId); errorString = "Something went wrong, please try again."; ModelState.AddModelError("", errorString); return(View(bookVehicleViewModel)); } } ViewData["ChosenVehicle"] = await GetChosenVehicle(VehicleId); return(View(bookVehicleViewModel)); }
public TouchEffectButtonPage() { Command = CommandFactory.Create(() => DisplayAlert("Command executed ", null, "OK")); InitializeComponent(); }
public TouchEffectCollectionViewPage() { InitializeComponent(); LongPressCommand = CommandFactory.Create(() => DisplayAlert("Long Press", null, "OK")); }
public void TestBucketCommandNegativeY() { string input = "b 5 -2 o"; CommandEntity command = CommandFactory.GetCommand(input); }
public void TestBucketCommandZeroHeight() { string input = "b 6 0 o"; CommandEntity command = CommandFactory.GetCommand(input); }
/// <inheritdoc /> #pragma warning disable CA1506 // TODO: Decomplexify public async Task <IInstance> CreateInstance(IBridgeRegistrar bridgeRegistrar, Models.Instance metadata) { // Create the ioManager for the instance var instanceIoManager = new ResolvingIOManager(ioManager, metadata.Path); // various other ioManagers var repoIoManager = new ResolvingIOManager(instanceIoManager, "Repository"); var byondIOManager = new ResolvingIOManager(instanceIoManager, "Byond"); var gameIoManager = new ResolvingIOManager(instanceIoManager, "Game"); var diagnosticsIOManager = new ResolvingIOManager(instanceIoManager, "Diagnostics"); var configurationIoManager = new ResolvingIOManager(instanceIoManager, "Configuration"); var configuration = new StaticFiles.Configuration( configurationIoManager, synchronousIOManager, symlinkFactory, processExecutor, postWriteHandler, platformIdentifier, fileTransferService, loggerFactory.CreateLogger <StaticFiles.Configuration>()); var eventConsumer = new EventConsumer(configuration); var repoManager = new RepositoryManager( repositoryFactory, repositoryCommands, repoIoManager, eventConsumer, gitRemoteFeaturesFactory, loggerFactory.CreateLogger <Repository.Repository>(), loggerFactory.CreateLogger <RepositoryManager>()); try { var byond = new ByondManager(byondIOManager, byondInstaller, eventConsumer, loggerFactory.CreateLogger <ByondManager>()); var commandFactory = new CommandFactory(assemblyInformationProvider, byond, repoManager, databaseContextFactory, metadata); var chatManager = chatFactory.CreateChatManager(instanceIoManager, commandFactory, metadata.ChatSettings); try { var sessionControllerFactory = new SessionControllerFactory( processExecutor, byond, topicClientFactory, cryptographySuite, assemblyInformationProvider, gameIoManager, chatManager, networkPromptReaper, platformIdentifier, bridgeRegistrar, serverPortProvider, loggerFactory, loggerFactory.CreateLogger <SessionControllerFactory>(), metadata); var dmbFactory = new DmbFactory( databaseContextFactory, gameIoManager, remoteDeploymentManagerFactory, loggerFactory.CreateLogger <DmbFactory>(), metadata); try { var reattachInfoHandler = new SessionPersistor( databaseContextFactory, dmbFactory, processExecutor, loggerFactory.CreateLogger <SessionPersistor>(), metadata); var watchdog = watchdogFactory.CreateWatchdog( chatManager, dmbFactory, reattachInfoHandler, sessionControllerFactory, gameIoManager, diagnosticsIOManager, eventConsumer, remoteDeploymentManagerFactory, metadata, metadata.DreamDaemonSettings); eventConsumer.SetWatchdog(watchdog); commandFactory.SetWatchdog(watchdog); try { Instance instance = null; var dreamMaker = new DreamMaker( byond, gameIoManager, configuration, sessionControllerFactory, eventConsumer, chatManager, processExecutor, dmbFactory, repoManager, remoteDeploymentManagerFactory, loggerFactory.CreateLogger <DreamMaker>(), metadata); instance = new Instance( metadata, repoManager, byond, dreamMaker, watchdog, chatManager, configuration, dmbFactory, jobManager, eventConsumer, remoteDeploymentManagerFactory, loggerFactory.CreateLogger <Instance>()); return(instance); } catch { await watchdog.DisposeAsync().ConfigureAwait(false); throw; } } catch { dmbFactory.Dispose(); throw; } } catch { await chatManager.DisposeAsync().ConfigureAwait(false); throw; } } catch { repoManager.Dispose(); throw; } }
/// <inheritdoc /> public IInstance CreateInstance(Models.Instance metadata) { //Create the ioManager for the instance var instanceIoManager = new ResolvingIOManager(ioManager, metadata.Path); //various other ioManagers var repoIoManager = new ResolvingIOManager(instanceIoManager, "Repository"); var byondIOManager = new ResolvingIOManager(instanceIoManager, "Byond"); var gameIoManager = new ResolvingIOManager(instanceIoManager, "Game"); var configurationIoManager = new ResolvingIOManager(instanceIoManager, "Configuration"); var configuration = new StaticFiles.Configuration(configurationIoManager, synchronousIOManager, symlinkFactory, processExecutor, postWriteHandler, loggerFactory.CreateLogger <StaticFiles.Configuration>()); var eventConsumer = new EventConsumer(configuration); var dmbFactory = new DmbFactory(databaseContextFactory, gameIoManager, loggerFactory.CreateLogger <DmbFactory>(), metadata.CloneMetadata()); try { var repoManager = new RepositoryManager(metadata.RepositorySettings, repoIoManager, eventConsumer, credentialsProvider, loggerFactory.CreateLogger <Repository.Repository>(), loggerFactory.CreateLogger <RepositoryManager>()); try { var byond = new ByondManager(byondIOManager, byondInstaller, eventConsumer, loggerFactory.CreateLogger <ByondManager>()); var commandFactory = new CommandFactory(application, byond, repoManager, databaseContextFactory, metadata); var chat = chatFactory.CreateChat(instanceIoManager, commandFactory, metadata.ChatSettings); try { var sessionControllerFactory = new SessionControllerFactory(processExecutor, byond, byondTopicSender, cryptographySuite, application, gameIoManager, chat, networkPromptReaper, loggerFactory, metadata.CloneMetadata()); var reattachInfoHandler = new ReattachInfoHandler(databaseContextFactory, dmbFactory, loggerFactory.CreateLogger <ReattachInfoHandler>(), metadata.CloneMetadata()); var watchdog = watchdogFactory.CreateWatchdog(chat, dmbFactory, reattachInfoHandler, configuration, sessionControllerFactory, metadata.CloneMetadata(), metadata.DreamDaemonSettings); eventConsumer.SetWatchdog(watchdog); commandFactory.SetWatchdog(watchdog); try { var dreamMaker = new DreamMaker(byond, gameIoManager, configuration, sessionControllerFactory, dmbFactory, application, eventConsumer, chat, processExecutor, watchdog, loggerFactory.CreateLogger <DreamMaker>()); return(new Instance(metadata.CloneMetadata(), repoManager, byond, dreamMaker, watchdog, chat, configuration, dmbFactory, databaseContextFactory, dmbFactory, jobManager, eventConsumer, loggerFactory.CreateLogger <Instance>())); } catch { watchdog.Dispose(); throw; } } catch { chat.Dispose(); throw; } } catch { repoManager.Dispose(); throw; } } catch { dmbFactory.Dispose(); throw; } }
internal string CreateGroupBySqlString(CommandFactory factory, bool isFullName, CreateSqlState state) { return(_fieldInfo.CreateSqlString(factory, isFullName, state)); }
public void LogoutCommand_Run_HandlesLogoutRequest_ReceivedThroughRedirectBinding() { var request = new Saml2LogoutRequest() { DestinationUrl = new Uri("http://sp.example.com/path/AuthServices/logout"), Issuer = new EntityId("https://idp.example.com"), SigningCertificate = SignedXmlHelper.TestCert, NameId = new Saml2NameIdentifier("NameId"), SessionIndex = "SessionID", }; var bindResult = Saml2Binding.Get(Saml2BindingType.HttpRedirect) .Bind(request); var httpRequest = new HttpRequestData("GET", bindResult.Location); var options = StubFactory.CreateOptions(); options.SPOptions.ServiceCertificates.Add(SignedXmlHelper.TestCert); CommandResult notifiedCommandResult = null; options.Notifications.LogoutCommandResultCreated = cr => { notifiedCommandResult = cr; }; // We're using unbind to verify the created message and UnBind // expects the issuer to be a known Idp for signature validation. // Add a dummy with the right issuer name and key. var dummyIdp = new IdentityProvider(options.SPOptions.EntityId, options.SPOptions); dummyIdp.SigningKeys.AddConfiguredKey(SignedXmlHelper.TestCert); options.IdentityProviders.Add(dummyIdp); var actual = CommandFactory.GetCommand(CommandFactory.LogoutCommandName) .Run(httpRequest, options); var expected = new CommandResult() { HttpStatusCode = HttpStatusCode.SeeOther, TerminateLocalSession = true // Deliberately not comparing Location }; HttpUtility.ParseQueryString(actual.Location.Query)["Signature"] .Should().NotBeNull("LogoutResponse should be signed"); actual.ShouldBeEquivalentTo(expected, opt => opt.Excluding(cr => cr.Location)); actual.Should().BeSameAs(notifiedCommandResult); var actualUnbindResult = Saml2Binding.Get(Saml2BindingType.HttpRedirect) .Unbind(new HttpRequestData("GET", actual.Location), options); var actualMessage = actualUnbindResult.Data; var expectedMessage = XmlHelpers.FromString( $@"<samlp:LogoutResponse xmlns:samlp=""urn:oasis:names:tc:SAML:2.0:protocol"" xmlns=""urn:oasis:names:tc:SAML:2.0:assertion"" Destination=""https://idp.example.com/logout"" Version=""2.0""> <Issuer>{options.SPOptions.EntityId.Id}</Issuer> <samlp:Status> <samlp:StatusCode Value=""urn:oasis:names:tc:SAML:2.0:status:Success""/> </samlp:Status> </samlp:LogoutResponse>").DocumentElement; // Set generated attributes to actual values. expectedMessage.SetAttribute("ID", actualMessage.GetAttribute("ID")); expectedMessage.SetAttribute("IssueInstant", actualMessage.GetAttribute("IssueInstant")); expectedMessage.SetAttribute("InResponseTo", request.Id.Value); actualMessage.Should().BeEquivalentTo(expectedMessage); actualUnbindResult.RelayState.Should().Be(request.RelayState); actualUnbindResult.TrustLevel.Should().Be(TrustLevel.Signature); }
public void ProcessGroupMessage(GroupMessageReceivedContext context) { CommandFactory.Process(new CommandContext(context.FromQq, context.FromGroup, context.Message, CommandFactory.QueryCommandNs)); }
public void TestBucketCommandInvalidColourChar() { string input = "b 10 2 oo"; CommandEntity command = CommandFactory.GetCommand(input); }