private static Activity CreateCommandActivity <TValue>(ITurnContext turnContext, T data, string name)
{
if (turnContext == null)
{
throw new ArgumentNullException(nameof(turnContext));
}
if (string.IsNullOrEmpty(name))
{
throw new ArgumentNullException(nameof(name));
}
var commandActivity = new Activity(type: ActivityTypes.Command);
commandActivity.Name = name;
var commandValue = new CommandValue <T>()
{
CommandId = Guid.NewGuid().ToString(),
Data = data,
};
commandActivity.Value = commandValue;
commandActivity.From = turnContext.Activity.From;
commandActivity.ReplyToId = turnContext.Activity.Id;
commandActivity.ServiceUrl = turnContext.Activity.ServiceUrl;
commandActivity.ChannelId = turnContext.Activity.ChannelId;
return(commandActivity);
}
/// <summary>
/// Converts this command argument to its <c>string</c> representation.
/// </summary>
/// <returns>The <c>string</c> representation of this command argument.</returns>
public override string ToString()
{
StringBuilder retVal = new StringBuilder();
retVal.Append(Command);
if (CommandValue != null)
{
if (CommandValue is string)
{
retVal.Append(EscapeStringCommandArgument((string)CommandValue));
}
else if (CommandValue is DateTime)
{
retVal.Append("\"").Append(((DateTime)CommandValue).ToString("g")).Append("\"");
}
else if ((CommandValue is int) || (CommandValue is long) || (CommandValue is float) || (CommandValue is double))
{
retVal.Append(CommandValue);
}
else
{
retVal.Append(EscapeStringCommandArgument(CommandValue.ToString()));
}
}
return(retVal.ToString());
}
public Task <Command> Update(Guid id, Guid actuatorId, CommandValue commandValue)
{
_serialCancellation.RemoveSource(id);
var result = _repo.Update(id, commandValue);
// Start task to serial write to arduino
StartWriteTask(actuatorId, result);
return(result);
}
public Task <Command> Create(Guid actuatorId, CommandValue commandValue)
{
commandValue.IssueDate = DateTime.Now;
// Add to database
var result = _repo.Add(actuatorId, commandValue);
// Start task to serial write to arduino
StartWriteTask(actuatorId, result);
return(result);
}
private void ExecuteCommand(IModbusFunction command)
{
try
{
command.Execute(ModbusClient);
}
catch (Exception e)
{
string message = "Exception on currentCommand.Execute().";
Logger.LogWarn(message, e);
ModbusClient.Disconnect();
return;
}
if (command is IReadAnalogModusFunction readAnalogCommand)
{
MakeAnalogEntryToMeasurementCache(readAnalogCommand.Data, true);
}
else if (command is IReadDiscreteModbusFunction readDiscreteCommand)
{
MakeDiscreteEntryToMeasurementCache(readDiscreteCommand.Data, true);
}
else if (command is IWriteModbusFunction writeModbusCommand)
{
CommandValue commandValue = new CommandValue()
{
Address = writeModbusCommand.ModbusWriteCommandParameters.OutputAddress,
Value = writeModbusCommand.ModbusWriteCommandParameters.Value,
CommandOrigin = writeModbusCommand.CommandOrigin,
};
PointType pointType;
switch (writeModbusCommand.ModbusWriteCommandParameters.FunctionCode)
{
case (byte)ModbusFunctionCode.WRITE_SINGLE_REGISTER:
pointType = PointType.ANALOG_OUTPUT;
break;
case (byte)ModbusFunctionCode.WRITE_SINGLE_COIL:
pointType = PointType.DIGITAL_OUTPUT;
break;
default:
Logger.LogError($"Function code {writeModbusCommand.ModbusWriteCommandParameters.FunctionCode} is not comatible with write command.");
return;
}
if (SCADAModel.CurrentAddressToGidMap[pointType].ContainsKey(commandValue.Address))
{
long gid = SCADAModel.CurrentAddressToGidMap[pointType][commandValue.Address];
SCADAModel.CommandedValuesCache[gid] = commandValue;
}
}
}
protected override void _PreRender(CancellationTokenSource tokenSource = null)
{
_elementData = new EffectIntents();
if (_data == null)
{
return;
}
ICommand command = null;
switch (ValueType)
{
case CustomValueType._8Bit:
command = new _8BitCommand(Value8Bit);
break;
case CustomValueType._16Bit:
command = new _16BitCommand(Value16Bit);
break;
case CustomValueType._32Bit:
command = new _32BitCommand(Value32Bit);
break;
case CustomValueType._64Bit:
command = new _64BitCommand(Value64Bit);
break;
case CustomValueType.Color:
command = new ColorCommand(ColorValue);
break;
case CustomValueType.String:
command = new StringCommand(StringValue);
break;
}
CommandValue value = new CommandValue(command);
foreach (ElementNode node in TargetNodes)
{
foreach (var leafNode in node.GetLeafEnumerator())
{
if (tokenSource != null && tokenSource.IsCancellationRequested)
{
return;
}
IIntent intent = new CommandIntent(value, TimeSpan);
_elementData.AddIntentForElement(leafNode.Element.Id, intent, TimeSpan.Zero);
}
}
}
internal Command(CommandTypeFlags type, CommandValue value, Action <BinaryWriter> writeParameters, Func <BinaryReader, T> parseReply)
{
if (type != CommandTypeFlags.Direct && type != CommandTypeFlags.System)
{
throw new ArgumentOutOfRangeException("Can only be system or direct", nameof(type));
}
this.type = type;
this.value = value;
this.writeParameters = writeParameters ?? throw new ArgumentNullException(nameof(writeParameters));
this.parseReply = parseReply ?? throw new ArgumentNullException(nameof(parseReply));
}
protected override void _PreRender(CancellationTokenSource cancellationToken = null)
{
_elementData = new EffectIntents();
var value = new CommandValue(new StringCommand(string.Format("{0}|{1},{2}", "Launcher", _data.Executable, _data.Arguments)));
foreach (var node in TargetNodes)
{
foreach (var elementNode in node.GetLeafEnumerator())
{
IIntent i = new CommandIntent(value, TimeSpan);
_elementData.AddIntentForElement(elementNode.Element.Id, i, TimeSpan.Zero);
}
}
}
public void CommandValueInits()
{
var id = "myCommandId";
var data = new { };
var commandValue = new CommandValue <object>()
{
CommandId = id,
Data = data,
};
Assert.NotNull(commandValue);
Assert.IsType <CommandValue <object> >(commandValue);
Assert.Equal(id, commandValue.CommandId);
Assert.Equal(data, commandValue.Data);
}
/// <summary>
/// Check only allowed values for each Command in the CommandItem.
/// </summary>
/// <param name="item"></param>
/// <returns>Returns true if values are correct otherwise false.</returns>
private bool CheckCommandItem(CommandItem item)
{
switch (Enum.Parse <Command>(item.Command.ToString()))
{
case Command.CheckUser:
case Command.OpenDoor when item.CommandValue.Equals(CommandValue.Open.ToString()) ||
item.CommandValue.Equals(CommandValue.Close.ToString()):
case Command.OpenGate when item.CommandValue.Equals(CommandValue.Open.ToString()) ||
item.CommandValue.Equals(CommandValue.Close.ToString()) ||
item.CommandValue.Equals(CommandValue.ForceOpen.ToString()) ||
item.CommandValue.Equals(CommandValue.ForceClose.ToString()):
return(true);
default:
return(false);
}
}
protected override void _PreRender(CancellationTokenSource tokenSource = null)
{
_elementData = new EffectIntents();
CommandValue value = new CommandValue(new StringCommand(string.Format("{0}|{1}", "RDS", _data.Title)));
foreach (ElementNode node in TargetNodes)
{
if (tokenSource != null && tokenSource.IsCancellationRequested)
{
return;
}
IIntent i = new CommandIntent(value, TimeSpan);
_elementData.AddIntentForElement(node.Element.Id, i, TimeSpan.Zero);
}
}
protected override void _PreRender(CancellationTokenSource cancellationToken = null)
{
_elementData = new EffectIntents();
var value = new CommandValue(new StringCommand(string.Format("{0}|{1},{2}", "Launcher", _data.Executable, _data.Arguments)));
var targetNodes = TargetNodes.AsParallel();
if (cancellationToken != null)
{
targetNodes = targetNodes.WithCancellation(cancellationToken.Token);
}
targetNodes.ForAll(node => {
IIntent i = new CommandIntent(value, TimeSpan);
_elementData.AddIntentForElement(node.Element.Id, i, TimeSpan.Zero);
});
}
public async Task <Command> Add(Guid actuatorId, CommandValue value)
{
var toBeAdded = new Command(Guid.NewGuid(), value);
var dataModel = _converter.ToCommandDataModel(toBeAdded);
await _db.Commands.AddAsync(dataModel);
var actuator = await _db.Actuators.FindAsync(actuatorId);
if (actuator == null)
{
return(null);
}
actuator.Commands.Add(dataModel);
await _db.SaveChangesAsync();
return(await Get(toBeAdded.Id));
}
public async Task <Command> Update(Guid commandId, CommandValue value)
{
var toBeUpdated = await _db.Commands.FindAsync(commandId);
if (toBeUpdated == null)
{
return(null);
}
toBeUpdated.Value = value.Value;
toBeUpdated.Units = value.Units;
toBeUpdated.Issuer = value.Issuer;
toBeUpdated.Purpose = value.Purpose;
toBeUpdated.IssueDate = value.IssueDate;
toBeUpdated.ExecuteDate = value.ExecuteDate;
toBeUpdated.Repeat = value.Repeat;
toBeUpdated.Completed = false;
await _db.SaveChangesAsync();
return(_converter.ToCommandDomainModel(toBeUpdated));
}
public static void CallRunCommand(IPipeline pipeline, string commandName, string callWithCommandDefinition)
{
switch (callWithCommandDefinition)
{
case BasicCommand:
pipeline.RunCommand(commandName, CommandValue.BasicCommand());
break;
case DerivedCommand:
pipeline.RunCommand(commandName, CommandValue.DerivedCommand());
break;
case DerivedCommandV2:
pipeline.RunCommand(commandName, CommandValue.DerivedCommandV2());
break;
case UnrelatedCommand:
pipeline.RunCommand(commandName, CommandValue.UnrelatedCommand());
break;
default:
throw new NotImplementedException(callWithCommandDefinition);
}
}
private static void FetchOptions(CommandContext state)
{
state.Commands.Clear();
foreach (MethodInfo i in state.CurrentObject.GetType().GetMethods(BindingFlags.Public | BindingFlags.Instance))
{
var cmd = i.GetCustomAttribute(typeof(CommandAttribute)) as CommandAttribute;
if (cmd == null)
{
continue;
}
CommandValue value = new CommandValue()
{
Arguments = cmd,
Method = i,
Instance = state.CurrentObject
};
state.Commands.Replace(value.Arguments.Name, value);
}
foreach (PropertyInfo i in state.CurrentObject.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance))
{
var cmd = i.GetCustomAttribute(typeof(CommandAttribute)) as CommandAttribute;
var nvalue = i.GetCustomAttribute(typeof(NamedValueAttribute)) as NamedValueAttribute;
var flag = i.GetCustomAttribute(typeof(FlagValueAttribute)) as FlagValueAttribute;
if (cmd != null)
{
CommandValue value = new CommandValue()
{
Arguments = cmd,
Property = i,
Instance = state.CurrentObject
};
state.Commands.Replace(value.Arguments.Name, value);
}
if (nvalue != null)
{
NamedValue value = new NamedValue()
{
Arguments = nvalue,
Property = i,
Instance = state.CurrentObject
};
state.NamedValues.Replace(value.Arguments.Name, value);
if (value.Arguments.Name == "")
{
state.DefaultValue = value;
}
}
if (flag != null)
{
FlagValue value = new FlagValue()
{
Arguments = flag,
Property = i,
Instance = state.CurrentObject
};
state.LongFlags.Replace(value.Arguments.Name, value);
state.ShortFlags.Replace(value.Arguments.ShortName, value);
}
}
}