public PyProcessContext(IScriptContext scriptContext,
dynamic processHandler,
ProcessFactory processFactory,
string command,
string commandArguments,
string workingDirectory,
ICommandParameters commandParameters)
{
_commandParameters = commandParameters;
_scriptContext = scriptContext;
_command = command;
_commandArguments = commandArguments;
_workingDirectory = workingDirectory;
_processFactory = processFactory;
var processContext = _processFactory.CreateProcessContext(command,
commandArguments,
workingDirectory);
_processHandler = processHandler;
processContext.OnMessage += (message) =>
{
_processHandler.OnMessage(message);
// Console.WriteLine(message);
};
processContext.OnError += (message) =>
{
_processHandler.OnError(message);
};
_processHandler.OnInit(this, _commandParameters);
_processContext = processContext;
}
private ISensorQueryTargetParameters SynthesizeParameters(ICommandParameters parameters)
{
var customParameters = parameters[Parameter.Custom];
if (customParameters.IsIEnumerable())
{
var queryParameters = new SensorQueryTargetParameters();
var any = false;
foreach (CustomParameter parameter in customParameters.ToIEnumerable())
{
any = true;
queryParameters[parameter.Name] = parameter.Value;
}
if (any)
{
return(queryParameters);
}
}
return(null);
}
public MethodCommandWrapper(MethodInfo methodInfo, IServiceProvider serviceProvider)
{
m_MethodInfo = methodInfo;
m_ServiceProvider = serviceProvider;
m_CommandParameters = serviceProvider.GetRequiredService <ICurrentCommandContextAccessor>().Context.Parameters;
m_ParametersTypes = m_MethodInfo.GetParameters().GetParametersTypes();
}
internal override async Task AddSensorInternalAsync(ICommandParameters internalParams, int index, CancellationToken token)
{
var deviceId = (int)internalParams[Parameter.Id];
int?tmpId = (int?)internalParams[Parameter.TmpId];
//If it's our first request (not the case when adding excesive values)
if (index == 0)
{
if (tmpId == null)
{
tmpId = await GetTmpIdAsync(deviceId, internalParams, token).ConfigureAwait(false);
}
internalParams[Parameter.TmpId] = tmpId.Value;
((BaseParameters)internalParams).Cookie = true;
}
await client.AddObjectInternalDefaultAsync(internalParams, token).ConfigureAwait(false);
//If it's our first request (not the case when adding excesive values)
if (index == 0)
{
var progressParameters = new AddSensorProgressParameters(deviceId, tmpId.Value, true);
var progress = await client.ObjectEngine.GetObjectAsync <AddSensorProgress>(progressParameters, token : token).ConfigureAwait(false);
await client.ValidateAddSensorProgressResultAsync(deviceId, progress, true, token).ConfigureAwait(false);
}
}
//######################################
// AddSensorInternal
//######################################
internal override void AddSensorInternal(ICommandParameters internalParams, int index, CancellationToken token)
{
var deviceId = (int)internalParams[Parameter.Id];
int?tmpId = (int?)internalParams[Parameter.TmpId];
//If it's our first request (not the case when adding excesive values)
if (index == 0)
{
if (tmpId == null)
{
tmpId = GetTmpId(deviceId, internalParams, token);
}
internalParams[Parameter.TmpId] = tmpId.Value;
((BaseParameters)internalParams).Cookie = true;
}
client.AddObjectInternalDefault(internalParams, token);
//If it's our first request (not the case when adding excesive values)
if (index == 0)
{
var progressParameters = new AddSensorProgressParameters(deviceId, tmpId.Value, true);
var progress = client.ObjectEngine.GetObject <AddSensorProgress>(progressParameters, token: token);
ResponseParser.ValidateAddSensorProgressResult(progress, true);
}
}
public PyProcessContext(IScriptContext scriptContext,
dynamic processHandler,
ProcessFactory processFactory,
string command,
string commandArguments,
string workingDirectory,
ICommandParameters commandParameters)
{
_commandParameters = commandParameters;
_scriptContext = scriptContext;
_command = command;
_commandArguments = commandArguments;
_workingDirectory = workingDirectory;
_processFactory = processFactory;
var processContext = _processFactory.CreateProcessContext(command,
commandArguments,
workingDirectory);
_processHandler = processHandler;
processContext.OnMessage += (message) =>
{
_processHandler.OnMessage(message);
// Console.WriteLine(message);
};
processContext.OnError += (message) =>
{
_processHandler.OnError(message);
};
_processHandler.OnInit(this, _commandParameters);
_processContext = processContext;
}
public void SetupPark_Throws_Exception_When_Parameters_Are_Missing(string commandAsString)
{
// arrange
Exception resultException = null;
// act
try
{
_commandParameters = _commandExtractor.ExtractFromCommandString(commandAsString);
}
catch (Exception exception)
{
if (exception.InnerException != null && exception.InnerException.GetType() == typeof(ArgumentException))
{
resultException = exception.InnerException;
}
else
{
resultException = exception;
}
}
// assert
Assert.IsInstanceOfType(resultException, typeof(ArgumentException));
}
public CommandContext(ICommandLogger logger,
ICommandParameters parameters,
ICommand command)
{
this.Logger = logger;
this.Parameters = parameters;
this.Command = command;
}
public string Execution(ICommandParameters command)
{
if (command.Name != "SetupPark" && VehicleInPark == null)
{
return("The vehicle park has not been set up");
}
switch (command.Name)
{
case "SetupPark":
return("Vehicle park created");
case "Рark":
switch (command.Parameters["type"])
{
case "car":
return(VehicleInPark.InsertCar(
new Car(command.Parameters["licensePlate"], command.Parameters["owner"],
int.Parse(command.Parameters["hours"])), int.Parse(command.Parameters["sector"]),
int.Parse(command.Parameters["place"]),
DateTime.Parse(command.Parameters["time"], null,
System.Globalization.DateTimeStyles.RoundtripKind))); //why round trip kind??
case "motorbike":
return(VehicleInPark.InsertMotorbike(
new MotorBike(command.Parameters["licensePlate"], command.Parameters["owner"],
int.Parse(command.Parameters["hours"])), int.Parse(command.Parameters["sector"]),
int.Parse(command.Parameters["place"]),
DateTime.Parse(command.Parameters["time"], null,
System.Globalization.DateTimeStyles.RoundtripKind))); //stack overflow says this
case "truck":
return(VehicleInPark.InsertTruck(
new Truck(command.Parameters["licensePlate"], command.Parameters["owner"],
int.Parse(command.Parameters["hours"])), int.Parse(command.Parameters["sector"]),
int.Parse(command.Parameters["place"]),
DateTime.Parse(command.Parameters["time"], null,
System.Globalization.DateTimeStyles.RoundtripKind))); //I wanna know
}
break;
case "Exit": return(VehicleInPark.ExitVehicle(command.Parameters["licensePlate"],
DateTime.Parse(command.Parameters["time"], null,
System.Globalization.DateTimeStyles.RoundtripKind),
decimal.Parse(command.Parameters["money"])));
case "Status": return(VehicleInPark.GetStatus());
case "FindVehicle": return(VehicleInPark.FindVehicle(command.Parameters["licensePlate"]));
case "VehiclesByOwner": return(VehicleInPark.FindVehiclesByOwner(command.Parameters["owner"]));
default: throw new IndexOutOfRangeException("Invalid command.");
}
return("");
}
public void Configure(ICommandParameters commandlineParamters)
{
_IpAddress = commandlineParamters.ParamAfterSwitch("IpAddress");
_mask = commandlineParamters.ParamAfterSwitch("Mask");
_Gateway = commandlineParamters.ParamAfterSwitch("Gateway");
_DNS = commandlineParamters.ParamAfterSwitch("DNS");
_Name = commandlineParamters.ParamAfterSwitch("Name");
_adapterName = commandlineParamters.ParamAfterSwitch("AdapterName");
}
//AddSensorInternal
internal virtual void AddSensorInternal(ICommandParameters internalParams, int index, CancellationToken token)
{
if (index == 0)
{
//Validate the sensor type
GetTmpId((int)internalParams[Parameter.Id], internalParams, token);
}
client.AddObjectInternalDefault(internalParams, token);
}
internal virtual async Task AddSensorInternalAsync(ICommandParameters internalParams, int index, CancellationToken token)
{
if (index == 0)
{
//Validate the sensor type
await GetTmpIdAsync((int)internalParams[Parameter.Id], internalParams, token).ConfigureAwait(false);
}
await client.AddObjectInternalDefaultAsync(internalParams, token).ConfigureAwait(false);
}
public PyRunner(string command, string script, string args, string workingDirectory,
ICommandParameters commandParameters)
{
this.command = command;
this.script = script;
this.args = args;
this.workingDirectory = workingDirectory;
_processFactory = new ProcessFactory();
_commandParameters = commandParameters;
}
internal string ExecuteRequest(ICommandParameters parameters, Func <HttpResponseMessage, string> responseParser = null)
{
if (parameters is IMultiTargetParameters)
{
return(ExecuteMultiRequest(p => GetPrtgUrl((ICommandParameters)p), (IMultiTargetParameters)parameters, responseParser));
}
var url = GetPrtgUrl(parameters);
var response = ExecuteRequest(url, responseParser);
return(response);
}
public void StatusReturnStatusCommand(string commandAsString)
{
//arange
//act
_result = _extractor.ExtractFromCommandString(commandAsString);
//assert
Assert.IsInstanceOfType(_result, typeof(ICommand));
Assert.AreEqual("Status", _result.Name);
Assert.AreEqual(0, _result.Parameters.Count);
}
internal async Task <PrtgResponse> ExecuteRequestAsync(ICommandParameters parameters, Func <HttpResponseMessage, Task <PrtgResponse> > responseParser = null, CancellationToken token = default(CancellationToken))
{
if (parameters is IMultiTargetParameters)
{
return(await ExecuteMultiRequestAsync(p => GetPrtgUrl((ICommandParameters)p), (IMultiTargetParameters)parameters, token, responseParser).ConfigureAwait(false));
}
var url = GetPrtgUrl(parameters);
var response = await ExecuteRequestAsync(url, token, responseParser).ConfigureAwait(false);
return(response);
}
public void SetupParkReturnsParkComand()
{
// arrange
// act
_result = _extractor.ExtractFromCommandString(Inputs.CreateDefaultPark);
// assert
Assert.IsInstanceOfType(_result, typeof(ICommand));
Assert.AreEqual("SetupPark", _result.Name);
Assert.AreEqual(3.ToString(), _result.Parameters["sectors"]);
Assert.AreEqual(5.ToString(), _result.Parameters["placesPerSector"]);
}
internal async Task <string> ExecuteRequestAsync(ICommandParameters parameters, Func <HttpResponseMessage, Task <string> > responseParser = null)
{
if (parameters is IMultiTargetParameters)
{
return(await ExecuteMultiRequestAsync(p => GetPrtgUrl((ICommandParameters)p), (IMultiTargetParameters)parameters, responseParser).ConfigureAwait(false));
}
var url = GetPrtgUrl(parameters);
var response = await ExecuteRequestAsync(url, responseParser).ConfigureAwait(false);
return(response);
}
internal PrtgResponse ExecuteRequest(ICommandParameters parameters, Func <HttpResponseMessage, PrtgResponse> responseParser = null, CancellationToken token = default(CancellationToken))
{
if (parameters is IMultiTargetParameters)
{
return(ExecuteMultiRequest(p => GetPrtgUrl((ICommandParameters)p), (IMultiTargetParameters)parameters, token, responseParser));
}
var url = GetPrtgUrl(parameters);
var response = ExecuteRequest(url, token, responseParser);
return(response);
}
protected async Task <int?> GetTmpIdAsync(int deviceId, ICommandParameters internalParams, CancellationToken token)
{
//Purposely not validating the QueryTarget for addsensor2; when adding the sensor for real we don't really need it, and
//current evidence suggestly we can simply just ignore it
var tmpIdParameters = new BeginAddSensorQueryParameters(deviceId, internalParams[Parameter.SensorType].ToString(), SynthesizeParameters(internalParams));
var tmpId = await client.GetAddSensorTmpIdAsync(tmpIdParameters, token).ConfigureAwait(false);
if (tmpId == null)
{
throw new PrtgRequestException($"Failed to add sensor for sensor type '{internalParams[Parameter.SensorType]}': type was not valid or you do not have sufficient permissions on the specified object.");
}
return(tmpId);
}
public MethodCommandWrapper(MethodInfo methodInfo, IServiceProvider serviceProvider)
{
m_MethodInfo = methodInfo ?? throw new ArgumentNullException(nameof(methodInfo));
m_ServiceProvider = serviceProvider ?? throw new ArgumentNullException(nameof(serviceProvider));
var contextAccessor = serviceProvider.GetRequiredService <ICurrentCommandContextAccessor>();
var context = contextAccessor.Context;
if (context == null)
{
throw new InvalidOperationException("contextAccessor.Context was null");
}
m_CommandParameters = context.Parameters;
m_ParametersTypes = m_MethodInfo.GetParameters().GetParametersTypes();
}
public void NullOrEmptyInputThrowsException(string commandAsString)
{
// Arrange
Exception expectedResult = null;
// Act
try
{
_result = _extractor.ExtractFromCommandString(commandAsString);
}
catch (ArgumentException exception)
{
expectedResult = exception;
}
// Assert
Assert.IsInstanceOfType(expectedResult, typeof(ArgumentException));
}
public void StatusThrowsArgumentExeption(string commandAsString)
{
// arrange
Exception expectedExeption = null;
// act
try
{
_result = _extractor.ExtractFromCommandString(commandAsString);
}
catch (ArgumentException exeption)
{
expectedExeption = exeption;
}
// assert
Assert.IsInstanceOfType(expectedExeption, typeof(ArgumentException));
}
internal PrtgResponse ExecuteRequest(ICommandParameters parameters, Func <HttpResponseMessage, PrtgResponse> responseParser = null, CancellationToken token = default(CancellationToken))
{
if (parameters == null)
{
throw new ArgumentNullException(nameof(parameters), "Parameters cannot be null.");
}
if (parameters is IMultiTargetParameters)
{
return(ExecuteMultiRequest(p => GetRequestMessage((ICommandParameters)p), (IMultiTargetParameters)parameters, token, responseParser));
}
var url = GetRequestMessage(parameters);
var response = ExecuteRequest(url, token, responseParser);
return(response);
}
public void SetupPark_Throws_Exception_With_Incorrect_Parameter_Values(string commandAsString)
{
// arrange
Exception resultException = null;
// act
try
{
_commandParameters = _commandExtractor.ExtractFromCommandString(commandAsString);
}
catch (Exception exception)
{
resultException = exception.InnerException;
}
// assert
Assert.IsInstanceOfType(resultException, typeof(ArgumentOutOfRangeException));
}
internal async Task <PrtgResponse> ExecuteRequestAsync(ICommandParameters parameters, Func <HttpResponseMessage, Task <PrtgResponse> > responseParser = null, CancellationToken token = default(CancellationToken))
{
if (parameters == null)
{
throw new ArgumentNullException(nameof(parameters), "Parameters cannot be null.");
}
if (parameters is IMultiTargetParameters)
{
return(await ExecuteMultiRequestAsync(p => GetRequestMessage((ICommandParameters)p), (IMultiTargetParameters)parameters, token, responseParser).ConfigureAwait(false));
}
var url = GetRequestMessage(parameters);
var response = await ExecuteRequestAsync(url, token, responseParser).ConfigureAwait(false);
return(response);
}
public static async Task <object[]> GetServiceOrCommandParameter(
IEnumerable <Type> types, IServiceProvider serviceProvider, ICommandParameters commandParameters)
{
object[] values = new object[types.Count()];
int commandParamIndex = 0;
for (int i = 0; i < values.Length; i++)
{
Type type = types.ElementAt(i);
// try get service
values[i] = serviceProvider.GetService(type);
// parse command parameter value if the type is not a service
if (values[i] == null)
{
values[i] = await commandParameters.GetAsync(commandParamIndex ++, type);
}
}
return(values);
}
public PyRunner(string command, string script, string args, string workingDirectory,
ICommandParameters commandParameters)
{
this.command = command;
this.script = script;
this.args = args;
this.workingDirectory = workingDirectory;
_processFactory = new ProcessFactory();
_commandParameters = commandParameters;
}
private PrtgRequestMessage GetRequestMessage(ICommandParameters parameters) => new PrtgRequestMessage(prtgClient.ConnectionDetails, parameters.Function, parameters);
public void Handle(ICommandParameters parameters)
{
Handle((CommandParameters)parameters);
}
internal static bool IsAddSensor(ICommandParameters parameters) => parameters.Function == CommandFunction.AddSensor5;
private async Task AddObjectWithExcessiveValueAsync(List <KeyValuePair <Parameter, object> > lengthLimit, ICommandParameters internalParams)
{
var limitParam = lengthLimit.First();
var limit = limitParam.Key.GetEnumAttribute <LengthLimitAttribute>().Length;
if (limitParam.Value.IsIEnumerable())
{
var list = limitParam.Value.ToIEnumerable().ToList();
var count = list.Count();
if (count > limit)
{
for (int i = 0; i < count; i += limit)
{
var thisRequest = list.Skip(i).Take(limit);
internalParams[limitParam.Key] = thisRequest;
await RequestEngine.ExecuteRequestAsync(internalParams).ConfigureAwait(false);
}
}
else
{
await RequestEngine.ExecuteRequestAsync(internalParams).ConfigureAwait(false);
}
}
else
{
throw new NotImplementedException($"Don't know how to handle {nameof(LengthLimitAttribute)} applied to value of type {limitParam.Value.GetType()}");
}
}
private PrtgUrl GetPrtgUrl(ICommandParameters parameters) => new PrtgUrl(prtgClient.ConnectionDetails, parameters.Function, parameters);
