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