public IExecutable ManageCommand(string[] inputArgs)
{
IExecutable command = null;
string commandType = inputArgs[0];
switch (commandType)
{
case "create":
command = new CreateCommand(this.Engine, inputArgs[1], int.Parse(inputArgs[2]), int.Parse(inputArgs[3]),
(BehaviorTypes)Enum.Parse(typeof(BehaviorTypes), inputArgs[4]), (AttackTypes)Enum.Parse(typeof(AttackTypes), inputArgs[5]));
break;
case "attack":
command = new AttackCommand(this.Engine, inputArgs[1], inputArgs[2]);
break;
case "pass":
command = new PassCommand();
break;
case "status":
command = new StatusCommand(this.Engine);
break;
case "drop":
command = new DropCommand();
break;
}
return command;
}
public IExecutable ManageCommand(string[] inputArgs)
{
IExecutable command = null;
string commandType = inputArgs[0];
switch (commandType)
{
case "create":
command = new CreateCommand(this.Engine, inputArgs[1], int.Parse(inputArgs[2]), int.Parse(inputArgs[3]),
(BehaviorTypes)Enum.Parse(typeof(BehaviorTypes), inputArgs[4]), (AttackTypes)Enum.Parse(typeof(AttackTypes), inputArgs[5]));
break;
case "attack":
command = new AttackCommand(this.Engine, inputArgs[1], inputArgs[2]);
break;
case "pass":
command = new PassCommand();
break;
case "status":
command = new StatusCommand(this.Engine);
break;
case "drop":
command = new DropCommand();
break;
}
return(command);
}
/// <summary>
/// Ajouter un Status en base
/// </summary>
/// <param name="e">Status à ajouter</param>
/// <returns></returns>
public int AddStatus(Status s)
{
// TODO : ajouter des contrôles sur le produit (exemple : vérification de champ, etc.)
StatusCommand sc = new StatusCommand(_context);
return(sc.Add(s));
}
internal GameController(EmailCommand emailService,
TimeLeftCommand timerService,
InsertCodeCommand codeService,
CheckRadioCommand checkRadioCommand,
DefragCommand defragCommand,
StatusCommand statusCommand,
CleanCacheCommand cleanCacheCommand)
{
SetupEmailService(emailService);
_timerService = timerService;
_codeService = codeService;
_radioService = checkRadioCommand;
_defragCommand = defragCommand;
_statusCommand = statusCommand;
_cleanCacheCommand = cleanCacheCommand;
_codeService.OnSuccesfullDelayCode += StartTimer;
DeadHandSettings = new DeadHandSettings()
{
MotherboardTemperature = 80,
MemoryCacheUsedPercentage = 20,
DiskFragmentationPercentage = 10
};
_deadHandMaintenanceTimer = new Timer(_rng.Next(2, 4) * 60 * 1000);
_deadHandMaintenanceTimer.Elapsed += _deadHandMaintenanceTimer_Elapsed;
_deadHandMaintenanceTimer.Start();
_defragCommand.CurrentSettings = DeadHandSettings;
_statusCommand.CurrentSettings = DeadHandSettings;
_cleanCacheCommand.CurrentSettings = DeadHandSettings;
CreateTimeline();
}
/// <summary>
/// Modifier un Status en base
/// </summary>
/// <param name="e">Status à modifier</param>
public void UpdateStatus(Status s)
{
// TODO : ajouter des contrôles sur le produit (exemple : vérification de champ, etc.)
StatusCommand sc = new StatusCommand(_context);
sc.Update(s);
}
public BasicMetaCommandResult ProcessResponce(BasicResponce rsp)
{
if (_step == 0)
{
_step = 1;
var cmd = new StatusCommand(_degree, 1200);
return(new BasicMetaCommandResult(MetaCommandAction.Command, cmd));
}
if (rsp == null)
{
return(new BasicMetaCommandResult(MetaCommandAction.Idle));
}
var scanResponce = rsp as StatusResponce;
if (scanResponce != null)
{
_scanResult[scanResponce.Degree] = scanResponce.DistanceToObstacle;
}
if (_step == 1 && _degree < MaxDegree)
{
_degree += 1;
var cmd = new StatusCommand(_degree, 50);
return(new BasicMetaCommandResult(MetaCommandAction.Command, cmd));
}
return(new BasicMetaCommandResult(MetaCommandAction.Done));
}
public static void Status(StatusCommand o)
{
// Check if the status window is already showing.
foreach (Process existingProcess in Process.GetProcessesByName(Process.GetCurrentProcess().ProcessName).Where(p => p.Id != Process.GetCurrentProcess().Id))
{
// Get the process's command-line args to see if it was run with the "status" flag.
ManagementObjectSearcher managementObjectSearcher = new ManagementObjectSearcher(@"root/cimv2", $"select CommandLine from Win32_Process where ProcessId = '{existingProcess.Id}'");
foreach (var ws4wInstance in managementObjectSearcher.Get().OfType <ManagementObject>())
{
if (ws4wInstance.GetPropertyValue("CommandLine")?.ToString() is { } commandLine)
{
int substringIndex = commandLine.LastIndexOf('"') + 2;
string arguments = substringIndex <= commandLine.Length ? commandLine.Substring(commandLine.LastIndexOf('"') + 2) : string.Empty;
if (arguments == typeof(StatusCommand).GetVerb())
{
SetForegroundWindow(existingProcess.MainWindowHandle);
Environment.Exit(0);
}
}
}
}
// Otherwise, show the status window.
new ServerStatusPrerequisite().Show();
}
private async void buttonStatus_Click(object sender, EventArgs e)
{
var cardReader = new XFS4IoTClient.ClientConnection(new Uri($"{textBoxCardReader.Text}"));
try
{
await cardReader.ConnectAsync();
}
catch (Exception)
{
return;
}
var statusCmd = new StatusCommand(Guid.NewGuid().ToString(), new StatusCommand.PayloadData(CommandTimeout));
textBoxCommand.Text = statusCmd.Serialise();
await cardReader.SendCommandAsync(statusCmd);
textBoxResponse.Text = string.Empty;
textBoxEvent.Text = string.Empty;
object cmdResponse = await cardReader.ReceiveMessageAsync();
if (cmdResponse is StatusCompletion response)
{
textBoxResponse.Text = response.Serialise();
textBoxStDevice.Text = response.Payload.Common.Device.ToString();
textBoxStMedia.Text = response.Payload.CardReader.Media.ToString();
}
}
public IExecutable ManageCommand(string inputArgs)
{
IExecutable command = null;
string commandType = inputArgs;
switch (commandType)
{
case "top":
command = new StatusCommand(this.Engine);
break;
case "restart":
command = new RestartCommand(this.Engine);
break;
case "turn":
command = new TurnCommand(this.Engine);
break;
case "exit":
command = new EndCommand(this.Engine);
break;
default:
this.Engine.Writer.WriteLine("\nError! Invalid command\n");
break;
}
return command;
}
/// <summary>
/// Create the command object that will be used to act on the repository.
/// </summary>
/// <returns>The command object that will be used to act on the
/// repository.</returns>
/// <exception cref="Exception">TODO: Make a more specific exception</exception>
/// <exception cref="NotImplementedException">If the command argument
/// is not implemented currently. TODO: Implement the argument.</exception>
public override ICommand CreateCommand()
{
DirectoryInfo dir =
new DirectoryInfo(Path.Combine(Directory.GetCurrentDirectory(), "CVS"));
StatusCommand statusCommand;
this.localDirectory = Directory.GetCurrentDirectory();
try {
this.repository = Repository.Load(dir).FileContents;
this.CvsRoot = new CvsRoot(Root.Load(dir).FileContents);
} catch (NullReferenceException) {
this.InvalidRepository();
} catch (CvsFileNotFoundException) {
this.InvalidRepository();
} catch (ICSharpCode.SharpCvsLib.Exceptions.CvsRootParseException) {
this.InvalidRepository();
}
CurrentWorkingDirectory = new WorkingDirectory(this.CvsRoot,
localDirectory, this.repository);
// Create new command object
statusCommand = new StatusCommand(CurrentWorkingDirectory);
statusCommand.Folders = this.GetCurrentDirectory(new DirectoryInfo(localDirectory));
this.ParseOptions(statusCommand, this.Args);
return(statusCommand);
}
public virtual void ProcessStatusCommand(StatusCommand cmd)
{
this.Session.AppendResponse(
new ServerStatusResponse(cmd.Tag,
ServerStatusResponseType.NO,
"STATUS State Error")
);
}
public virtual void RetrieveServerStatus()
{
var command = new StatusCommand(_connection);
command.Execute();
Assert.IsTrue(command.Result.Success);
Assert.IsTrue(command.Result.StatusInfo.Count > 0);
Assert.IsNotNull(command.Result.StatusInfo[0].Name);
Assert.IsNotNull(command.Result.StatusInfo[0].Value);
}
private List <string> SensorCommands(int sensorId)
{
var commands = new List <string>();
commands.Add(StreamReadingsCommand.Create(15000));
commands.Add(SleepCommand.Create(1000));
commands.Add(StatusCommand.Create());
return(commands);
}
public virtual void RetrieveServerStatus()
{
var command = new StatusCommand(_connection);
command.Execute();
Assert.IsTrue(command.Result.Success);
Assert.IsTrue(command.Result.StatusInfo.Count > 0);
Assert.IsNotNull(command.Result.StatusInfo[0].Name);
Assert.IsNotNull(command.Result.StatusInfo[0].Value);
}
public void Create()
{
var log = A.Fake <ILogger>();
var radio = A.Fake <IRadio>();
var output = A.Fake <Action <string> >();
var command = new StatusCommand(log, output, radio);
Assert.NotNull(command);
}
public void CheckName()
{
var log = A.Fake <ILogger>();
var radio = A.Fake <IRadio>();
var output = A.Fake <Action <string> >();
var command = new StatusCommand(log, output, radio);
Assert.Contains(string.Empty, command.Name);
Assert.Contains("Show status of radio", command.Description);
}
public void senMessenger(StatusCommand command)
{
if (IO_COM_Port.IsOpen)
{
IO_COM_Port.WriteLine(command.ToString());
}
else
{
Global.ICOP_messenger("Serial port is not connected.");
}
}
public void Refresh()
{
var command = new StatusCommand();
foreach (var portState in this.PortState.Values)
{
var output = Wrapper.Run(command.Arguments(portState.Port));
var statusOutput = command.Parse(output);
PortState[portState.Port].Enabled = statusOutput.Enabled;
}
}
public async Task Execute()
{
var log = A.Fake <ILogger>();
var radio = A.Fake <IRadio>();
var output = A.Fake <Action <string> >();
var command = new StatusCommand(log, output, radio);
var result = await command.Execute(new string[0]);
A.CallTo(() => radio.Status()).MustHaveHappened();
Assert.Equal(CommandResult.OK, result);
}
public string ExecuteCommand(string commandArguments)
{
var commandName = commandArguments.Substring(0, commandArguments.IndexOf(' '));
var commandParameters = new JavaScriptSerializer()
.Deserialize<Dictionary<string, string>>(
commandArguments.Substring(commandArguments.IndexOf(' ') + 1));
if (commandName != "SetupPark" && this.VehiclePark == null)
{
return "The vehicle park has not been set up";
}
ICommand command = null;
switch (commandName)
{
case "SetupPark":
command = new SetupParkCommand(commandName, commandParameters, this.VehiclePark);
break;
case "Park":
command = new ParkCommand(commandName, commandParameters, this.VehiclePark);
break;
case "Exit":
command = new ExitCommand(commandName, commandParameters, this.VehiclePark);
break;
case "Status":
command = new StatusCommand(commandName, commandParameters, this.VehiclePark);
break;
case "FindVehicle":
command = new FindVehicleCommand(commandName, commandParameters, this.VehiclePark);
break;
case "VehiclesByOwner":
command = new VehiclesByOwner(commandName, commandParameters, this.VehiclePark);
break;
default:
throw new InvalidOperationException("Invalid command.");
}
var commandOutput = string.Empty;
if (commandName == "SetupPark")
{
this.VehiclePark = command.Execute() as IVehiclePark;
commandOutput = "Vehicle park created";
}
else
{
commandOutput = command.Execute() as string;
}
return commandOutput;
}
public async Task <int> Execute(string[] args)
{
var rootCommand = new RootCommand("Party: A Virt-A-Mate package manager")
{
HelpCommand.CreateCommand(_renderer, _config, _controllerFactory),
SearchCommand.CreateCommand(_renderer, _config, _controllerFactory),
GetCommand.CreateCommand(_renderer, _config, _controllerFactory),
ShowCommand.CreateCommand(_renderer, _config, _controllerFactory),
StatusCommand.CreateCommand(_renderer, _config, _controllerFactory),
UpgradeCommand.CreateCommand(_renderer, _config, _controllerFactory),
PublishCommand.CreateCommand(_renderer, _config, _controllerFactory),
CleanCommand.CreateCommand(_renderer, _config, _controllerFactory),
};
// For CoreRT:
rootCommand.Name = Path.GetFileName(Environment.GetCommandLineArgs().FirstOrDefault()) ?? "party.exe";
Exception exc = null;
var parser = new CommandLineBuilder(rootCommand)
.UseVersionOption()
.UseHelp()
#if DEBUG
.UseParseDirective()
.UseDebugDirective()
#endif
.UseSuggestDirective()
// .RegisterWithDotnetSuggest()
.UseTypoCorrections()
.UseParseErrorReporting()
.UseExceptionHandler((e, ctx) => exc = e)
.CancelOnProcessTermination()
.Build();
_renderer.WriteLine("Party, a Virt-A-Mate package manager, is still in it's early stages. Please file any issue or ideas at https://github.com/vam-community/vam-party/issues", ConsoleColor.Green);
try
{
await parser.InvokeAsync(args, _renderer);
}
catch (Exception e)
{
exc = e;
}
if (exc != null)
{
return(HandleError(exc));
}
return(0);
}
/// <summary>
/// Parse the command line options/ arguments and populate the command
/// object with the arguments.
/// </summary>
/// <param name="upOptions">A string value that holds the command
/// line options the user has selected.</param>
/// <exception cref="NotImplementedException">If the command argument
/// is not implemented currently. TODO: Implement the argument.</exception>
private void ParseOptions(StatusCommand command, string[] options)
{
int currentOptionIndex = 0;
while (currentOptionIndex < options.Length)
{
string currentOption = options[currentOptionIndex];
switch (currentOption)
{
case "-v":
command.Verbose = true;
break;
case "-l":
command.LocalOnly = true;
break;
case "-R":
command.Recursive = true;
break;
case "-q":
command.Terse = true;
break;
case "-x":
command.CvsNt2Output = true;
break;
case "-X":
command.Cvs1Output = true;
break;
default:
// if a switch is passed in that we don't know about
// then throw an exception
if (currentOption.StartsWith("-"))
{
throw new NotSupportedException(
string.Format("Unknown option specified: {0}", currentOption));
}
// otherwise the parameter is probably a file or module name, ignore
break;
}
}
this.ParseFiles(options);
}
public void Execute_ShouldReturn_Success_WhenTraverseDependencies_Succeeds()
{
var algorithm = Container.Resolve <IDependencyVisitorAlgorithm>();
algorithm.Arrange(a => a.TraverseDependencies(Arg.IsAny <IVisitor>(), Arg.AnyString))
.DoInstead((IVisitor visitor, string directory) =>
{
visitor.ReturnCode = ReturnCode.Success;
});
var options = new StatusSubOptions();
var instance = new StatusCommand(options);
var code = instance.Execute();
Assert.AreEqual(ReturnCode.Success, code, "Invalid Return Code");
}
public void StatusCommandTest()
{
GameObject mockGo = new GameObject();
Locator.Scheduler = mockGo.AddComponent <TurnScheduler>();
Entity actor = new Entity(new Status())
{
Name = "TEST_ENTITY"
};
StatusDefinition momentum = StatusDefinition.statuses["Status_Momentum"];
StatusCommand cmd = new StatusCommand(null, actor, momentum, 300, 1);
CommandResult result = cmd.Execute();
Assert.True(Status.IsAffectedBy(actor, momentum));
Assert.True(result == CommandResult.Succeeded);
}
public void Run()
{
IExecutable command = null;
string line = reader.ReadLine();
while (line != "drop")
{
string[] tokens = line.Split();
switch (tokens[0])
{
case "create":
command = new CreateCommand(
db,
tokens[1],
int.Parse(tokens[2]),
int.Parse(tokens[3]),
tokens[4],
tokens[5]);
break;
case "pass":
command = new PassCommand(db);
break;
case "status":
command = new StatusCommand(db);
break;
case "attack":
default:
throw new NotImplementedException("Uncnoun command.");
}
try
{
this.writer.Print(command.Execute());
}
catch (Exception e)
{
this.writer.Print(e.Message);
}
finally
{
line = reader.ReadLine();
}
}
}
public Task ChangeState(StatusCommand status)
{
if (_statusMatrix[this.Status] == status.Status)
{
Status = status.Status;
}
return(_asyncCollector.AddAsync(new SignalRMessage()
{
Target = "newStatus",
Arguments = new[] { new
{
Name = Entity.Current.EntityKey,
Status = (int)this.Status
} }
}));
}
private string GetServerStatus()
{
StringBuilder sb = new StringBuilder();
using (TcpConnection connection = new TcpConnection(Host, Port))
{
StatusCommand status = new StatusCommand(connection);
status.Execute();
sb.Append("<table border=1 style='border-collapse: collapse;' cellpadding='5'><tr><th>Name</th><th>Value</th></tr>");
foreach (StatusInfo statusInfo in status.Result.StatusInfo)
{
sb.AppendFormat("<tr><td>{0}</td><td>{1}</td></tr>", statusInfo.Name, statusInfo.Value);
}
sb.Append("</table>");
}
return(sb.ToString());
}
private static void UpdateDatesInternal()
{
Console.WriteLine("Updating dates...");
StatusCommand statusCommand = _git.Status();
Status status = statusCommand.Call();
_changedFiles = status.GetModified();
if (_changedFiles.Count == 0)
{
Console.WriteLine("No files to commit");
Environment.Exit(0);
}
foreach (string filename in _changedFiles)
{
StringBuilder stringBuilder = new StringBuilder();
string filePath = _currentDirectory + @"\" + filename;
using (StreamReader streamReader = new StreamReader(filePath))
{
string currentLine;
while (streamReader.Peek() >= 0)
{
currentLine = streamReader.ReadLine();
if (currentLine.Contains(_dateText))
{
currentLine = _dateText + @": " + DateTime.Today.ToString("d");
}
stringBuilder.AppendLine(currentLine);
}
}
using (StreamWriter streamWriter = new StreamWriter(filePath))
{
streamWriter.Write(stringBuilder.ToString());
}
}
}
public StatusSubcommand()
{
Name = "status";
Description = "git status";
OnExecute(() =>
{
var command = new StatusCommand();
bool isDirty = command.Execute(PathValueOrDefault);
if (!Quiet)
{
Console.WriteLine(isDirty ? "Repository has changes" : "Repository has no changes");
}
return(isDirty
? 1
: 0);
});
}
public ICommand ParseCommand(string input)
{
string[] data = input.Split();
ICommand command = null;
switch (data[0])
{
case "Job":
string jobName = data[1];
int workHoursRequired = int.Parse(data[2]);
string employeeName = data[3];
IEmployee employee = this.employeeRepository.GetEmployeeByName(employeeName);
command = new CreateJobCommand(jobName, workHoursRequired, employee);
break;
case nameof(StandardEmployee):
case nameof(PartTimeEmployee):
string employeeToCreateName = data[1];
command = new CreateEmployeeCommand(data[0], employeeToCreateName);
break;
case "Pass":
command = new PassWeekCommand();
break;
case "Status":
command = new StatusCommand();
break;
case "End":
command = new EndCommand();
break;
}
InjectFields(command);
return(command);
}
public static bool WaitForStatus(CommandSender sender, MountState stat, int timeout)
{
//Wait for a certain status to be obtained for a specified number of seconds
int t = timeout * 4;
while (t > 0)
{
var s = new StatusCommand(sender).Execute();
if (s != stat)
{
Thread.Sleep(250);
t -= 1;
}
else
{
break;
}
}
return(t > 0);
}
public IExecutable ManageCommand(string[] inputArgs)
{
IExecutable command = null;
switch (inputArgs[0])
{
case "build":
command = new BuildCommand(inputArgs[1], this.Engine);
break;
case "skip":
command = new SkipCommand();
break;
case "empire-status":
command = new StatusCommand(this.Engine);
break;
case "armistice":
command = new EndCommand();
break;
}
return command;
}
public BasicMetaCommandResult ProcessResponce(BasicResponce rsp)
{
if (rsp == null)
{
Console.WriteLine("Sending status");
var cmd = new StatusCommand(Degree, 200);
return(new BasicMetaCommandResult(MetaCommandAction.Command, cmd));
}
Console.WriteLine("Received command");
var status = rsp as StatusResponce;
if (status == null)
{
Console.WriteLine("Idle");
return(new BasicMetaCommandResult(MetaCommandAction.Idle));
}
if (status.DistanceToObstacle < MinDistance && _direction == MoveDirection.Forward)
{
return(MoveBackward());
}
if (status.DistanceToObstacle >= MinDistance && _direction == MoveDirection.Backwards)
{
return(MoveForward());
}
if (_direction == MoveDirection.Stopped)
{
Console.WriteLine("Stopped.Moving forward");
return(MoveForward());
}
return(new BasicMetaCommandResult(MetaCommandAction.Idle));
}
public ICommand DispatchCommand(string commandName, string[] arguments)
{
ICommand command = null;
switch (commandName)
{
case "CreateCore":
command = new CreateCoreCommand(this.NuclearPowerPlant, (CoreType)Enum.Parse(typeof(CoreType), arguments[0]), this.NuclearPowerPlant.NextCoreName, int.Parse(arguments[1]));
break;
case "RemoveCore":
command = new RemoveCoreCommand(this.NuclearPowerPlant, arguments[0]);
break;
case "SelectCore":
command = new SelectCommand(this.NuclearPowerPlant, arguments[0]);
break;
case "AttachFragment":
command = new AttachFragmentCommand(this.NuclearPowerPlant, (FragmentType)Enum.Parse(typeof(FragmentType), arguments[0]), arguments[1], int.Parse(arguments[2]));
break;
case "DetachFragment":
command = new DetachFragmentCommand(this.NuclearPowerPlant);
break;
case "Status":
command = new StatusCommand(this.NuclearPowerPlant);
break;
case "System Shutdown":
break;
}
return(command);
}
public List<byte> CommandToByteList(StatusCommand cmd, byte n)
{
List<byte> result = new List<byte>();
result.AddRange(GetCommandBytes(Convert.ToInt32(cmd)));
result.Add(n);
return result;
}
VersionInfo[] GetDirectoryVersionInfo(FilePath localDirectory, IEnumerable<FilePath> localFileNames, bool getRemoteStatus, bool recursive)
{
List<VersionInfo> versions = new List<VersionInfo> ();
HashSet<FilePath> existingFiles = new HashSet<FilePath> ();
HashSet<FilePath> nonVersionedMissingFiles = new HashSet<FilePath> ();
if (localFileNames != null) {
var localFiles = new List<FilePath> ();
var arev = new MercurialRevision (this, "");
foreach (var p in localFileNames) {
if (Directory.Exists (p)) {
if (recursive)
versions.AddRange (GetDirectoryVersionInfo (p, getRemoteStatus, true));
else
versions.Add (new VersionInfo (p, "", true, VersionStatus.Versioned, arev, VersionStatus.Versioned, null));
}
else {
localFiles.Add (p);
if (File.Exists (p))
existingFiles.Add (p.CanonicalPath);
else
nonVersionedMissingFiles.Add (p.CanonicalPath);
}
}
// No files to check, we are done
if (localFiles.Count == 0)
return versions.ToArray ();
localFileNames = localFiles;
} else {
CollectFiles (existingFiles, localDirectory, recursive);
}
MercurialRevision rev;
var headCommit = RootRepository.Tip ();
if (headCommit != null)
rev = new MercurialRevision (this, headCommit.Hash);
else
rev = null;
IEnumerable<string> paths;
if (localFileNames == null) {
if (recursive)
paths = new [] { (string) localDirectory };
else
paths = Directory.GetFiles (localDirectory);
} else {
paths = localFileNames.Select (f => (string)f);
}
paths = paths.Select (f => ToMercurialPath (f));
var statcmd = new StatusCommand ();
foreach (var p in paths) statcmd.AddArgument (p);
var status = RootRepository.Status (statcmd);
HashSet<string> added = new HashSet<string> ();
Action<IEnumerable<FileStatus>, VersionStatus> AddFiles = delegate(IEnumerable<FileStatus> files, VersionStatus fstatus) {
foreach (FileStatus file in files) {
if (!added.Add (file.Path))
continue;
FilePath statFile = FromMercurialPath (file.Path);
existingFiles.Remove (statFile.CanonicalPath);
nonVersionedMissingFiles.Remove (statFile.CanonicalPath);
versions.Add (new VersionInfo (statFile, "", false, fstatus, rev, VersionStatus.Versioned, null));
}
};
AddFiles (status.Where (fs => fs.State == FileState.Added), VersionStatus.Versioned | VersionStatus.ScheduledAdd);
AddFiles (status.Where (fs => fs.State == FileState.Modified), VersionStatus.Versioned | VersionStatus.Modified);
AddFiles (status.Where (fs => fs.State == FileState.Removed), VersionStatus.Versioned | VersionStatus.ScheduledDelete);
AddFiles (status.Where (fs => fs.State == FileState.Missing), VersionStatus.Versioned | VersionStatus.ScheduledDelete);
// mercurial-FIXME: how can I get conflicts?
//AddFiles (status.GetConflicting (), VersionStatus.Versioned | VersionStatus.Conflicted);
AddFiles (status.Where (fs => fs.State == FileState.Unknown), VersionStatus.Unversioned);
// Existing files for which hg did not report an status are supposed to be tracked
foreach (FilePath file in existingFiles) {
VersionInfo vi = new VersionInfo (file, "", false, VersionStatus.Versioned, rev, VersionStatus.Versioned, null);
versions.Add (vi);
}
// Non existing files for which hg did not report an status are unversioned
foreach (FilePath file in nonVersionedMissingFiles)
versions.Add (VersionInfo.CreateUnversioned (file, false));
return versions.ToArray ();
}
private string GetServerStatus()
{
StringBuilder sb = new StringBuilder();
using (TcpConnection connection = new TcpConnection(Host, Port))
{
StatusCommand status = new StatusCommand(connection);
status.Execute();
sb.Append("<table border=1 style='border-collapse: collapse;' cellpadding='5'><tr><th>Name</th><th>Value</th></tr>");
foreach (StatusInfo statusInfo in status.Result.StatusInfo)
{
sb.AppendFormat("<tr><td>{0}</td><td>{1}</td></tr>", statusInfo.Name, statusInfo.Value);
}
sb.Append("</table>");
}
return sb.ToString();
}
public static Command Parse(string input)
{
string[] values = input.Split(' ');
if (!values.Any())
{
throw new ArgumentException("No command specified.");
}
// command should be first
if (!Enum.TryParse(values[0].ToPascalCase(), out CommandType type))
{
throw new ArgumentException($"Invalid command {values[0]}");
}
if (type == CommandType.Undefined)
{
throw new ArgumentException($"Invalid command {type}");
}
string[] args = values.Skip(1).ToArray();
Command command = null;
switch (type)
{
case CommandType.End:
{
command = new EndCommand();
break;
}
case CommandType.Flag:
{
command = new FlagCommand();
Dictionary <string, object> requiredArgs = command.GetRequiredArguments();
if (args.Length != requiredArgs.Count)
{
throw new ArgumentException($"Command type {type} requires {requiredArgs.Count} arguments.");
}
if (!int.TryParse(args[0], out int x))
{
throw new ArgumentException($"Parameter {CommandKeys.XPosition} must be an integer.");
}
if (!int.TryParse(args[1], out int y))
{
throw new ArgumentException($"Parameter {CommandKeys.YPosition} must be an integer.");
}
requiredArgs[CommandKeys.XPosition] = x;
requiredArgs[CommandKeys.YPosition] = y;
command.Build(requiredArgs);
break;
}
case CommandType.Help:
{
command = new HelpCommand();
Dictionary <string, object> requiredArgs = command.GetRequiredArguments();
if (args.Length > 0)
{
if (args.Length > 1)
{
throw new ArgumentException($"Command type {type} requires 1 or 0 arguments.");
}
if (!Enum.TryParse(args[0].ToPascalCase(), out CommandType commandType))
{
throw new ArgumentException($"Invalid command type {args[0]}");
}
requiredArgs[CommandKeys.CommandName] = commandType;
command.Build(requiredArgs);
}
break;
}
case CommandType.New:
{
command = new NewCommand();
Dictionary <string, object> requiredArgs = command.GetRequiredArguments();
if (args.Length != requiredArgs.Count)
{
throw new ArgumentException($"Command type {type} requires {requiredArgs.Count} arguments.");
}
if (!int.TryParse(args[0], out int x))
{
throw new ArgumentException($"Parameter {CommandKeys.XLength} must be an integer.");
}
if (!int.TryParse(args[1], out int y))
{
throw new ArgumentException($"Parameter {CommandKeys.YLength} must be an integer.");
}
if (!int.TryParse(args[2], out int b))
{
throw new ArgumentException($"Parameter {CommandKeys.Bombs} must be an integer.");
}
requiredArgs[CommandKeys.XLength] = x;
requiredArgs[CommandKeys.YLength] = y;
requiredArgs[CommandKeys.Bombs] = b;
command.Build(requiredArgs);
break;
}
case CommandType.Open:
{
command = new OpenCommand();
Dictionary <string, object> requiredArgs = command.GetRequiredArguments();
if (args.Length != requiredArgs.Count)
{
throw new ArgumentException($"Command type {type} requires {requiredArgs.Count} arguments.");
}
if (!int.TryParse(args[0], out int x))
{
throw new ArgumentException($"Parameter {CommandKeys.XPosition} must be an integer.");
}
if (!int.TryParse(args[1], out int y))
{
throw new ArgumentException($"Parameter {CommandKeys.YPosition} must be an integer.");
}
requiredArgs[CommandKeys.XPosition] = x;
requiredArgs[CommandKeys.YPosition] = y;
command.Build(requiredArgs);
break;
}
case CommandType.Quit:
{
command = new QuitCommand();
Dictionary <string, object> requiredArgs = command.GetRequiredArguments();
break;
}
case CommandType.Unflag:
{
command = new UnflagCommand();
Dictionary <string, object> requiredArgs = command.GetRequiredArguments();
if (args.Length != requiredArgs.Count)
{
throw new ArgumentException($"Command type {type} requires {requiredArgs.Count} arguments.");
}
if (!int.TryParse(args[0], out int x))
{
throw new ArgumentException($"Parameter {CommandKeys.XPosition} must be an integer.");
}
if (!int.TryParse(args[1], out int y))
{
throw new ArgumentException($"Parameter {CommandKeys.YPosition} must be an integer.");
}
requiredArgs[CommandKeys.XPosition] = x;
requiredArgs[CommandKeys.YPosition] = y;
command.Build(requiredArgs);
break;
}
case CommandType.Status:
{
command = new StatusCommand();
Dictionary <string, object> requiredArgs = command.GetRequiredArguments();
if (args.Length != requiredArgs.Count)
{
throw new ArgumentException($"Command type {type} requires {requiredArgs.Count} arguments.");
}
if (!int.TryParse(args[0], out int x))
{
throw new ArgumentException($"Parameter {CommandKeys.XPosition} must be an integer.");
}
if (!int.TryParse(args[1], out int y))
{
throw new ArgumentException($"Parameter {CommandKeys.YPosition} must be an integer.");
}
requiredArgs[CommandKeys.XPosition] = x;
requiredArgs[CommandKeys.YPosition] = y;
command.Build(requiredArgs);
break;
}
}
return(command);
}
public override void ProcessStatusCommand(StatusCommand cmd)
{
MailBox mailbox = store.GetMailbox(cmd.MailBox);
if (mailbox == null)
{
this.Session.AppendResponse(
new ServerStatusResponse(
cmd.Tag,
ServerStatusResponseType.NO,
"STATUS fail. Mailbox not found.")
);
return;
}
StatusResponse response = new StatusResponse(mailbox.Path);
foreach (var item in cmd.StatusDataItems)
{
switch (item)
{
case StatusCommand.StatusItem.MESSAGES:
response.StatusItems.Add(
new StatusResponseItem(
StatusCommand.StatusItem.MESSAGES, mailbox.Exist.ToString()
));
break;
case StatusCommand.StatusItem.RECENT:
response.StatusItems.Add(
new StatusResponseItem(
StatusCommand.StatusItem.RECENT, mailbox.Recent.ToString()
));
break;
case StatusCommand.StatusItem.UIDVALIDITY:
response.StatusItems.Add(
new StatusResponseItem(
StatusCommand.StatusItem.UIDVALIDITY, mailbox.UidValidity.ToString()
));
break;
case StatusCommand.StatusItem.UIDNEXT:
response.StatusItems.Add(
new StatusResponseItem(
StatusCommand.StatusItem.UIDNEXT, mailbox.UidNext.ToString()
));
break;
case StatusCommand.StatusItem.UNSEEN:
response.StatusItems.Add(
new StatusResponseItem(
StatusCommand.StatusItem.UNSEEN, store.GetUnseenMailCount(mailbox).ToString()
));
break;
default:
break;
}
}
this.Session.AppendResponse(response);
this.Session.AppendResponse(
new ServerStatusResponse(cmd.Tag, ServerStatusResponseType.OK, "STATUS completed")
);
}
