/// <summary>
/// Creates info from a net request
/// </summary>
/// <param name="fromReq"></param>
public AssetRequestInfo(TransferRequestPacket fromReq, IClientAPI userInfo)
{
_origin = RequestOrigin.SRC_NET;
_netSrc = (NetSourceType)fromReq.TransferInfo.SourceType;
if (fromReq.TransferInfo.SourceType == 2)
{
//direct asset request
_requestedId = new UUID(fromReq.TransferInfo.Params, 0);
}
else if (fromReq.TransferInfo.SourceType == 3)
{
//inventory asset request
_requestedId = new UUID(fromReq.TransferInfo.Params, 80);
}
else if (fromReq.TransferInfo.SourceType == 4)
{
//sim estate request
//We have to just send the covenent in this case,
// I've looked through the params, and the UUID
// of the covenent isn't in there (Matt Beardmore)
_requestedId = userInfo.Scene.RegionInfo.RegionSettings.Covenant;
}
_transferId = fromReq.TransferInfo.TransferID;
_params = fromReq.TransferInfo.Params;
}
/// <summary>
/// Creates an event object from a node object.
/// </summary>
/// <param name="Node">Node added.</param>
/// <param name="Language">Language</param>
/// <param name="Caller">Original caller.</param>
/// <param name="Sniffable">If the node is sniffable.</param>
public static async Task <NodeAdded> FromNode(INode Node, Language Language, RequestOrigin Caller, bool Sniffable)
{
List <Parameter> Parameters = new List <Parameter>();
foreach (Parameter P in await Node.GetDisplayableParametersAsync(Language, Caller))
{
Parameters.Add(P);
}
return(new NodeAdded()
{
Parameters = Parameters.ToArray(),
NodeType = Node.GetType().FullName,
Sniffable = Sniffable,
DisplayName = await Node.GetTypeNameAsync(Language),
HasChildren = Node.HasChildren,
ChildrenOrdered = Node.ChildrenOrdered,
IsReadable = Node.IsReadable,
IsControllable = Node.IsControllable,
HasCommands = Node.HasCommands,
ParentId = Node.Parent?.NodeId ?? string.Empty,
ParentPartition = Node.Parent?.Partition ?? string.Empty,
Updated = DateTime.MinValue,
State = Node.State,
NodeId = Node.NodeId,
Partition = Node.Partition,
LogId = EmptyIfSame(Node.LogId, Node.NodeId),
LocalId = EmptyIfSame(Node.LocalId, Node.NodeId),
SourceId = Node.SourceId,
Timestamp = DateTime.Now
});
}
/// <summary>
/// Tries to move the child node down.
/// </summary>
/// <param name="Child">Child node to move.</param>
/// <param name="Caller">Information about caller.</param>
/// <returns>If the child node was moved down.</returns>
public virtual async Task <bool> MoveDownAsync(MeteringNode Child, RequestOrigin Caller)
{
if (!this.ChildrenOrdered || this.children == null)
{
return(false);
}
if (!await this.CanEditAsync(Caller) || !await Child.CanEditAsync(Caller))
{
return(false);
}
lock (this.children)
{
int c = this.children.Count;
int i = this.children.IndexOf(Child);
if (i < 0 || i + 1 >= c)
{
return(false);
}
this.children.RemoveAt(i);
this.children.Insert(i + 1, Child);
}
await MeteringTopology.NewEvent(new NodeMovedDown()
{
NodeId = Child.NodeId,
Partition = Child.Partition,
SourceId = Child.SourceId,
Timestamp = DateTime.Now
});
return(true);
}
/// <summary>
/// Gets messages logged on the node.
/// </summary>
/// <returns>Set of messages.</returns>
public virtual async Task<IEnumerable<Message>> GetMessagesAsync(RequestOrigin Caller)
{
IEnumerable<MeteringMessage> Messages = await Database.Find<MeteringMessage>(
new FilterFieldEqualTo("NodeId", this.objectId), "Timestamp");
LinkedList<Message> Result = new LinkedList<Message>();
foreach (MeteringMessage Msg in Messages)
Result.AddLast(new Message(Msg.Created, Msg.Type, Msg.EventId, Msg.Body)); // TODO: Include Updated & Count also.
return Result;
}
/// <summary>
/// Gets messages logged on the node.
/// </summary>
/// <returns>Array of messages.</returns>
public async Task <Message[]> GetMessageArrayAsync(RequestOrigin Caller)
{
List <Message> Result = new List <Message>();
foreach (Message Msg in await this.GetMessagesAsync(Caller))
{
Result.Add(Msg);
}
return(Result.ToArray());
}
/// <summary>
/// Tries to move the node down.
/// </summary>
/// <param name="Caller">Information about caller.</param>
/// <returns>If the node was moved down.</returns>
public virtual Task <bool> MoveDownAsync(RequestOrigin Caller)
{
MeteringNode Parent = this.Parent as MeteringNode;
if (Parent == null)
{
return(Task.FromResult <bool>(false));
}
else
{
return(Parent.MoveDownAsync(this, Caller));
}
}
/// <summary>
/// Creates an event object from a node object.
/// </summary>
/// <param name="Node">Node added.</param>
/// <param name="Language">Language</param>
/// <param name="Caller">Original caller.</param>
/// <param name="OldId">Old Node ID, if differrent from previous NodeId.</param>
public static Task <NodeUpdated> FromNode(INode Node, Language Language, RequestOrigin Caller, string OldId)
{
return(FromNode(Node, Language, Caller, OldId, null));
}
public override Task <object> OnUnhandledReceive(RequestOrigin origin, object message)
{
origins.Add(new Tuple <string, bool>(origin.Behavior, origin.Timer));
return(TaskResult.Done);
}
/// <summary>
/// Creates an event object from a node object.
/// </summary>
/// <param name="Node">Node added.</param>
/// <param name="Language">Language</param>
/// <param name="Caller">Original caller.</param>
public static Task <NodeUpdated> FromNode(INode Node, Language Language, RequestOrigin Caller)
{
return(FromNode(Node, Language, Caller, string.Empty));
}
public Task <bool> CanViewAsync(RequestOrigin Caller)
{
return(Task.FromResult <bool>(true));
}
public Task <bool> MoveDownAsync(RequestOrigin Caller)
{
return(Task.FromResult <bool>(false));
}
public async Task <IEnumerable <Parameter> > GetDisplayableParametersAsync(Language Language, RequestOrigin Caller)
{
LinkedList <Parameter> Parameters = new LinkedList <Parameter>();
if (App.Instance.Output.HasValue)
{
Parameters.AddLast(new BooleanParameter("Output", await Language.GetStringAsync(typeof(MeteringTopology), 6, "Output"), App.Instance.Output.Value));
}
return(Parameters);
}
/// <summary>
/// Gets displayable parameters.
/// </summary>
/// <param name="Language">Language to use.</param>
/// <param name="Caller">Information about caller.</param>
/// <returns>Set of displayable parameters.</returns>
public async override Task <IEnumerable <Parameter> > GetDisplayableParametersAsync(Language Language, RequestOrigin Caller)
{
LinkedList <Parameter> Result = await base.GetDisplayableParametersAsync(Language, Caller) as LinkedList <Parameter>;
Result.AddLast(new Int32Parameter("Port", await Language.GetStringAsync(typeof(IpHost), 10, "Port"), this.port));
return(Result);
}
public override Task <object> OnUnhandledReceive(RequestOrigin origin, object message)
{
UnhandledMessage = message;
UnhandledMessageOrigin = origin;
return(Task.FromResult((object)"test"));
}
/// <summary>
/// Tries to move the node down.
/// </summary>
/// <param name="Caller">Information about caller.</param>
/// <returns>If the node was moved down.</returns>
public virtual Task<bool> MoveDownAsync(RequestOrigin Caller)
{
return Task.FromResult<bool>(false);
}
/// <summary>
/// If the node can be added to by the caller.
/// </summary>
/// <param name="Caller">Information about caller.</param>
/// <returns>If the node can be added to by the caller.</returns>
public virtual Task<bool> CanDestroyAsync(RequestOrigin Caller)
{
return Task.FromResult<bool>(true); // TODO: Check user privileges
}
public virtual Task <object> OnUnhandledReceive(RequestOrigin origin, object message) => throw new UnhandledMessageException(this, message);
/// <summary>
/// Gets displayable parameters.
/// </summary>
/// <param name="Language">Language to use.</param>
/// <param name="Caller">Information about caller.</param>
/// <returns>Set of displayable parameters.</returns>
public override async Task <IEnumerable <Parameter> > GetDisplayableParametersAsync(Language Language, RequestOrigin Caller)
{
LinkedList <Parameter> Result = await base.GetDisplayableParametersAsync(Language, Caller) as LinkedList <Parameter>;
Result.AddLast(new BooleanParameter("Provisioned", await Language.GetStringAsync(typeof(MeteringTopology), 25, "Provisioned"), this.provisioned));
if (this.provisioned)
{
Result.AddLast(new StringParameter("Owner", await Language.GetStringAsync(typeof(MeteringTopology), 26, "Owner"), this.owner));
Result.AddLast(new BooleanParameter("Public", await Language.GetStringAsync(typeof(MeteringTopology), 27, "Public"), this.isPublic));
}
return(Result);
}
/// <summary>
/// Gets displayable parameters.
/// </summary>
/// <param name="Language">Language to use.</param>
/// <param name="Caller">Information about caller.</param>
/// <returns>Set of displayable parameters.</returns>
public virtual async Task <IEnumerable <Parameter> > GetDisplayableParametersAsync(Language Language, RequestOrigin Caller)
{
Namespace Namespace = await Language.GetNamespaceAsync(typeof(MeteringNode).Namespace);
if (Namespace == null)
{
Namespace = await Language.CreateNamespaceAsync(typeof(MeteringNode).Namespace);
}
LinkedList <Parameter> Result = new LinkedList <Parameter>();
string s;
Result.AddLast(new StringParameter("NodeId", await Namespace.GetStringAsync(1, "Node ID"), this.nodeId));
Result.AddLast(new StringParameter("Type", await Namespace.GetStringAsync(4, "Type"), await this.GetTypeNameAsync(Language)));
if (this.parent != null)
{
Result.AddLast(new StringParameter("ParentId", await Namespace.GetStringAsync(2, "Parent ID"), this.parent.nodeId));
}
if (!this.childrenLoaded)
{
await this.LoadChildren();
}
if (this.children != null)
{
int i;
lock (this.synchObject)
{
i = this.children.Count;
}
Result.AddLast(new Int32Parameter("NrChildren", await Namespace.GetStringAsync(3, "#Children"), i));
}
switch (this.state)
{
case NodeState.Information:
s = await Namespace.GetStringAsync(8, "Information");
break;
case NodeState.WarningUnsigned:
s = await Namespace.GetStringAsync(9, "Unsigned Warning");
break;
case NodeState.WarningSigned:
s = await Namespace.GetStringAsync(10, "Warning");
break;
case NodeState.ErrorUnsigned:
s = await Namespace.GetStringAsync(11, "Unsigned Error");
break;
case NodeState.ErrorSigned:
s = await Namespace.GetStringAsync(12, "Error");
break;
case NodeState.None:
default:
s = null;
break;
}
if (!string.IsNullOrEmpty(s))
{
Result.AddLast(new StringParameter("State", await Namespace.GetStringAsync(5, "State"), s));
}
Result.AddLast(new DateTimeParameter("Created", await Namespace.GetStringAsync(6, "Created"), this.created));
if (this.updated != DateTime.MinValue)
{
Result.AddLast(new DateTimeParameter("Updated", await Namespace.GetStringAsync(7, "Updated"), this.updated));
}
return(Result);
}
public override async Task <IEnumerable <Parameter> > GetDisplayableParametersAsync(Language Language, RequestOrigin Caller)
{
LinkedList <Parameter> Result = await base.GetDisplayableParametersAsync(Language, Caller) as LinkedList <Parameter>;
Result.AddLast(new StringParameter("Pin", await Language.GetStringAsync(typeof(Module), 18, "Pin"), this.PinNrStr));
return(Result);
}
public Task <IEnumerable <Message> > GetMessagesAsync(RequestOrigin Caller)
{
return(Task.FromResult <IEnumerable <Message> >(null));
}
public async Task <IEnumerable <Parameter> > GetDisplayableParametersAsync(Language Language, RequestOrigin Caller)
{
LinkedList <Parameter> Parameters = new LinkedList <Parameter>();
if (App.Instance.Light.HasValue)
{
Parameters.AddLast(new DoubleParameter("Light", await Language.GetStringAsync(typeof(MeteringTopology), 2, "Light (%)"), App.Instance.Light.Value));
}
if (App.Instance.Motion.HasValue)
{
Parameters.AddLast(new BooleanParameter("Motion", await Language.GetStringAsync(typeof(MeteringTopology), 3, "Motion"), App.Instance.Motion.Value));
}
return(Parameters);
}
public Task <bool> CanEditAsync(RequestOrigin Caller)
{
return(Task.FromResult <bool>(false));
}
public async Task <IEnumerable <Parameter> > GetDisplayableParametersAsync(LinkedList <Parameter> Parameters,
Language Language, RequestOrigin _)
{
if (this.data != null)
{
Parameters.AddLast(new StringParameter("Type", await Language.GetStringAsync(typeof(MqttTopicNode), 25, "Type"),
await this.data.GetTypeName(Language)));
}
if (this.dataCount > 0)
{
Parameters.AddLast(new Int64Parameter("Data Count", await Language.GetStringAsync(typeof(MqttTopicNode), 26, "Data Count"),
this.dataCount));
}
return(Parameters);
}
/// <summary>
/// If the data source is visible to the caller.
/// </summary>
/// <param name="Caller">Information about caller.</param>
/// <returns>If the source is visible to the caller.</returns>
public Task <bool> CanViewAsync(RequestOrigin Caller)
{
return(Task.FromResult <bool>(true)); // TODO: Check user privileges
}
/// <summary>
/// Gets displayable parameters.
/// </summary>
/// <param name="Language">Language to use.</param>
/// <param name="Caller">Information about caller.</param>
/// <returns>Set of displayable parameters.</returns>
public override async Task <IEnumerable <Parameter> > GetDisplayableParametersAsync(Language Language, RequestOrigin Caller)
{
LinkedList <Parameter> Result = await base.GetDisplayableParametersAsync(Language, Caller) as LinkedList <Parameter>;
if (!string.IsNullOrEmpty(this.name))
{
Result.AddLast(new StringParameter("Name", await Language.GetStringAsync(typeof(MeteringTopology), 30, "Name"), this.name));
}
if (!string.IsNullOrEmpty(this.className))
{
Result.AddLast(new StringParameter("Class", await Language.GetStringAsync(typeof(MeteringTopology), 33, "Class"), this.className));
}
if (!string.IsNullOrEmpty(this.serialNumber))
{
Result.AddLast(new StringParameter("SerialNumber", await Language.GetStringAsync(typeof(MeteringTopology), 36, "S/N"), this.serialNumber));
}
if (!string.IsNullOrEmpty(this.meterNumber))
{
Result.AddLast(new StringParameter("MeterNumber", await Language.GetStringAsync(typeof(MeteringTopology), 39, "Meter Nr."), this.meterNumber));
}
if (!string.IsNullOrEmpty(this.meterLocation))
{
Result.AddLast(new StringParameter("MeterLocation", await Language.GetStringAsync(typeof(MeteringTopology), 42, "Meter Loc."), this.meterLocation));
}
if (!string.IsNullOrEmpty(this.manufacturerDomain))
{
Result.AddLast(new StringParameter("Manufacturer", await Language.GetStringAsync(typeof(MeteringTopology), 45, "Manufacturer"), this.manufacturerDomain));
}
if (!string.IsNullOrEmpty(this.model))
{
Result.AddLast(new StringParameter("Model", await Language.GetStringAsync(typeof(MeteringTopology), 48, "Model"), this.model));
}
if (this.version.HasValue)
{
Result.AddLast(new StringParameter("Version", await Language.GetStringAsync(typeof(MeteringTopology), 80, "Version"), this.version.ToString()));
}
if (!string.IsNullOrEmpty(this.country))
{
Result.AddLast(new StringParameter("Country", await Language.GetStringAsync(typeof(MeteringTopology), 54, "Country"), this.country));
}
if (!string.IsNullOrEmpty(this.region))
{
Result.AddLast(new StringParameter("Region", await Language.GetStringAsync(typeof(MeteringTopology), 57, "Region"), this.region));
}
if (!string.IsNullOrEmpty(this.city))
{
Result.AddLast(new StringParameter("City", await Language.GetStringAsync(typeof(MeteringTopology), 60, "City"), this.city));
}
if (!string.IsNullOrEmpty(this.area))
{
Result.AddLast(new StringParameter("Area", await Language.GetStringAsync(typeof(MeteringTopology), 63, "Area"), this.area));
}
string s = this.StreetAndNr;
if (!string.IsNullOrEmpty(s))
{
Result.AddLast(new StringParameter("Street", await Language.GetStringAsync(typeof(MeteringTopology), 66, "Street"), s));
}
if (!string.IsNullOrEmpty(this.building))
{
Result.AddLast(new StringParameter("Building", await Language.GetStringAsync(typeof(MeteringTopology), 71, "Building"), this.building));
}
if (!string.IsNullOrEmpty(this.apartment))
{
Result.AddLast(new StringParameter("Apartment", await Language.GetStringAsync(typeof(MeteringTopology), 74, "Apartment"), this.apartment));
}
if (!string.IsNullOrEmpty(this.room))
{
Result.AddLast(new StringParameter("Room", await Language.GetStringAsync(typeof(MeteringTopology), 77, "Room"), this.room));
}
if (this.latitude.HasValue)
{
Result.AddLast(new StringParameter("Latitude", await Language.GetStringAsync(typeof(MeteringTopology), 88, "Latitude"), this.latitude.ToString()));
}
if (this.longitude.HasValue)
{
Result.AddLast(new StringParameter("Longitude", await Language.GetStringAsync(typeof(MeteringTopology), 89, "Longitude"), this.longitude.ToString()));
}
if (this.altitude.HasValue)
{
Result.AddLast(new StringParameter("Altitude", await Language.GetStringAsync(typeof(MeteringTopology), 90, "Altitude"), this.altitude.ToString()));
}
return(Result);
}
public override async Task <IEnumerable <Parameter> > GetDisplayableParametersAsync(Language Language, RequestOrigin Caller)
{
LinkedList <Parameter> Result = await base.GetDisplayableParametersAsync(Language, Caller) as LinkedList <Parameter>;
Result.AddLast(new StringParameter("Mode", await Language.GetStringAsync(typeof(Controller), 23, "Mode"), this.mode.ToString()));
return(Result);
}
/// <summary>
/// Creates an event object from a node object.
/// </summary>
/// <param name="Node">Node added.</param>
/// <param name="Language">Language</param>
/// <param name="Caller">Original caller.</param>
/// <param name="Sniffable">If the node is sniffable.</param>
public static Task <NodeAdded> FromNode(INode Node, Language Language, RequestOrigin Caller, bool Sniffable)
{
return(FromNode(Node, Language, Caller, Sniffable, null));
}
/// <summary>
/// Creates an event object from a node object.
/// </summary>
/// <param name="Node">Node added.</param>
/// <param name="Language">Language</param>
/// <param name="Caller">Original caller.</param>
/// <param name="AdditionalParameters">Additional node parameters.</param>
public static Task <NodeUpdated> FromNode(INode Node, Language Language, RequestOrigin Caller,
params Parameter[] AdditionalParameters)
{
return(FromNode(Node, Language, Caller, string.Empty, AdditionalParameters));
}
/// <summary>
/// Creates info from a net request
/// </summary>
/// <param name="fromReq"></param>
public AssetRequestInfo(TransferRequestPacket fromReq, IClientAPI userInfo)
{
_origin = RequestOrigin.SRC_NET;
_netSrc = (NetSourceType)fromReq.TransferInfo.SourceType;
_netChannel = (NetChannelType)fromReq.TransferInfo.ChannelType;
if (fromReq.TransferInfo.SourceType == 2)
{
//direct asset request
_requestedId = new UUID(fromReq.TransferInfo.Params, 0);
}
else if (fromReq.TransferInfo.SourceType == 3)
{
//inventory asset request
_requestedId = new UUID(fromReq.TransferInfo.Params, 80);
}
else if (fromReq.TransferInfo.SourceType == 4)
{
//sim estate request
//We have to just send the covenent in this case,
// I've looked through the params, and the UUID
// of the covenent isn't in there (Matt Beardmore)
_requestedId = userInfo.Scene.RegionInfo.RegionSettings.Covenant;
}
_transferId = fromReq.TransferInfo.TransferID;
_params = fromReq.TransferInfo.Params;
}
/// <summary>
/// Creates an event object from a node object.
/// </summary>
/// <param name="Node">Node added.</param>
/// <param name="Language">Language</param>
/// <param name="Caller">Original caller.</param>
/// <param name="OldId">Old Node ID, if differrent from previous NodeId.</param>
/// <param name="AdditionalParameters">Additional node parameters.</param>
public static async Task <NodeUpdated> FromNode(INode Node, Language Language, RequestOrigin Caller, string OldId,
params Parameter[] AdditionalParameters)
{
List <Parameter> Parameters = new List <Parameter>();
foreach (Parameter P in await Node.GetDisplayableParametersAsync(Language, Caller))
{
Parameters.Add(P);
}
if (!(AdditionalParameters is null))
{
foreach (Parameter P in AdditionalParameters)
{
Parameters.Add(P);
}
}
return(new NodeUpdated()
{
OldId = OldId,
Parameters = Parameters.ToArray(),
HasChildren = Node.HasChildren,
ChildrenOrdered = Node.ChildrenOrdered,
IsReadable = Node.IsReadable,
IsControllable = Node.IsControllable,
HasCommands = Node.HasCommands,
ParentId = Node.Parent?.NodeId ?? string.Empty,
ParentPartition = Node.Parent?.Partition ?? string.Empty,
Updated = DateTime.Now,
State = Node.State,
NodeId = Node.NodeId,
Partition = Node.Partition,
LogId = NodeAdded.EmptyIfSame(Node.LogId, Node.NodeId),
LocalId = NodeAdded.EmptyIfSame(Node.LocalId, Node.NodeId),
SourceId = Node.SourceId,
Timestamp = DateTime.Now
});
}
/// <summary>
/// Creates request info with the given origin
/// </summary>
/// <param name="origin"></param>
public AssetRequestInfo(RequestOrigin origin)
{
_origin = origin;
}
