MetaMeteringNode.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Waher.Content;
using Waher.Persistence.Attributes;
using Waher.Runtime.Collections;
using Waher.Runtime.Language;
using Waher.Things.Attributes;
using Waher.Things.DisplayableParameters;
using Waher.Things.SensorData;
 
namespace Waher.Things.Metering
{
    public abstract class MetaMeteringNode : MeteringNode
    {
        private string name = string.Empty;                     // NAME
        private string className = string.Empty;                // CLASS
        private string serialNumber = string.Empty;             // SN
        private string meterNumber = string.Empty;              // MNR
        private string meterLocation = string.Empty;            // MLOC
        private string manufacturerDomain = string.Empty;       // MAN
        private string model = string.Empty;                    // MODEL
        private string productUrl = string.Empty;               // PURL
 
        private string country = string.Empty;                  // COUNTRY
        private string region = string.Empty;                   // REGION
        private string city = string.Empty;                     // CITY
        private string area = string.Empty;                     // AREA
        private string street = string.Empty;                   // STREET
        private string streetNr = string.Empty;                 // STREETNR
        private string building = string.Empty;                 // BLD
        private string apartment = string.Empty;                // APT
        private string room = string.Empty;                     // ROOM
 
        private double? latitude = null;                        // LAT
        private double? longitude = null;                       // LON
        private double? altitude = null;                        // ALT
        private double? version = null;                         // V
 
        public MetaMeteringNode()
            : base()
        {
        }
 
        [Page(16, "Identity", 0)]
        [Header(28, "Name:", 10)]
        [ToolTip(29, "An additional name can be provided here.")]
        [DefaultValueStringEmpty]
        public string Name
        {
            get => this.name;
            set => this.name = value;
        }
 
        [Page(16, "Identity", 0)]
        [Header(31, "Class:", 20)]
        [ToolTip(32, "Class of node.")]
        [DefaultValueStringEmpty]
        public string Class
        {
            get => this.className;
            set => this.className = value;
        }
 
        [Page(16, "Identity", 0)]
        [Header(34, "Serial number:", 30)]
        [ToolTip(35, "Serial number of device.")]
        [DefaultValueStringEmpty]
        public string SerialNumber
        {
            get => this.serialNumber;
            set => this.serialNumber = value;
        }
 
        [Page(16, "Identity", 0)]
        [Header(37, "Meter number:", 40)]
        [ToolTip(38, "Additional identity of meter.")]
        [DefaultValueStringEmpty]
        public string MeterNumber
        {
            get => this.meterNumber;
            set => this.meterNumber = value;
        }
 
        [Page(16, "Identity", 0)]
        [Header(40, "Meter location:", 50)]
        [ToolTip(41, "Identity of the location of the meter.")]
        [DefaultValueStringEmpty]
        public string MeterLocation
        {
            get => this.meterLocation;
            set => this.meterLocation = value;
        }
 
        [Page(16, "Identity", 0)]
        [Header(43, "Manufacturer domain:", 60)]
        [ToolTip(44, "A domain controlled by the manufacturer.")]
        [DefaultValueStringEmpty]
        public string ManufacturerDomain
        {
            get => this.manufacturerDomain;
            set => this.manufacturerDomain = value;
        }
 
        [Page(16, "Identity", 0)]
        [Header(46, "Model:", 70)]
        [ToolTip(47, "Model name of the device.")]
        [DefaultValueStringEmpty]
        public string Model
        {
            get => this.model;
            set => this.model = value;
        }
 
        [Page(16, "Identity", 0)]
        [Header(78, "Version:", 80)]
        [ToolTip(79, "Version number of model of device.")]
        [DefaultValueNull]
        public double? Version
        {
            get => this.version;
            set => this.version = value;
        }
 
        [Page(16, "Identity", 0)]
        [Header(49, "Product URL:", 90)]
        [ToolTip(50, "A URL with more information about the product.")]
        [DefaultValueStringEmpty]
        public string ProductUrl
        {
            get => this.productUrl;
            set => this.productUrl = value;
        }
 
        [Page(51, "Location", 10)]
        [Header(52, "Country:", 10)]
        [ToolTip(53, "Country of device.")]
        [DefaultValueStringEmpty]
        public string Country
        {
            get => this.country;
            set => this.country = value;
        }
 
        [Page(51, "Location", 10)]
        [Header(55, "Region:", 20)]
        [ToolTip(56, "Region of device.")]
        [DefaultValueStringEmpty]
        public string Region
        {
            get => this.region;
            set => this.region = value;
        }
 
        [Page(51, "Location", 10)]
        [Header(58, "City:", 30)]
        [ToolTip(59, "City of device.")]
        [DefaultValueStringEmpty]
        public string City
        {
            get => this.city;
            set => this.city = value;
        }
 
        [Page(51, "Location", 10)]
        [Header(61, "Area:", 40)]
        [ToolTip(62, "Area of device.")]
        [DefaultValueStringEmpty]
        public string Area
        {
            get => this.area;
            set => this.area = value;
        }
 
        [Page(51, "Location", 10)]
        [Header(64, "Street:", 50)]
        [ToolTip(65, "Street device resides on.")]
        [DefaultValueStringEmpty]
        public string Street
        {
            get => this.street;
            set => this.street = value;
        }
 
        [Page(51, "Location", 10)]
        [Header(67, "Street number:", 60)]
        [ToolTip(68, "Street number where device resides.")]
        [DefaultValueStringEmpty]
        public string StreetNr
        {
            get => this.streetNr;
            set => this.streetNr = value;
        }
 
        public string StreetAndNr
        {
            get
            {
                if (string.IsNullOrEmpty(this.streetNr))
                    return this.street;
                else if (string.IsNullOrEmpty(this.street))
                    return this.streetNr;
                else
                    return this.street + " " + this.streetNr;
            }
        }
 
        [Page(51, "Location", 10)]
        [Header(69, "Building:", 70)]
        [ToolTip(70, "Building device resides in.")]
        [DefaultValueStringEmpty]
        public string Building
        {
            get => this.building;
            set => this.building = value;
        }
 
        [Page(51, "Location", 10)]
        [Header(72, "Apartment:", 80)]
        [ToolTip(73, "Apartment device resides in.")]
        [DefaultValueStringEmpty]
        public string Apartment
        {
            get => this.apartment;
            set => this.apartment = value;
        }
 
        [Page(51, "Location", 10)]
        [Header(75, "Room:", 90)]
        [ToolTip(76, "Room device resides in.")]
        [DefaultValueStringEmpty]
        public string Room
        {
            get => this.room;
            set => this.room = value;
        }
 
        [Page(81, "Position", 20)]
        [Header(82, "Latitude:", 10)]
        [ToolTip(83, "Latitude of device.")]
        [DefaultValueNull]
        [Range(-90, 90)]
        public double? Latitude
        {
            get => this.latitude;
            set => this.latitude = value;
        }
 
        [Page(81, "Position", 20)]
        [Header(84, "Longitude:", 20)]
        [ToolTip(85, "Longitude of device.")]
        [DefaultValueNull]
        [Range(-180, 180)]
        public double? Longitude
        {
            get => this.longitude;
            set => this.longitude = value;
        }
 
        [Page(81, "Position", 20)]
        [Header(86, "Altitude:", 30)]
        [ToolTip(87, "Altitude of device.")]
        [DefaultValueNull]
        public double? Altitude
        {
            get => this.altitude;
            set => this.altitude = value;
        }
 
        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<KeyValuePair<string, object>[]> GetMetaData()
        {
            List<KeyValuePair<string, object>> Result = new List<KeyValuePair<string, object>>(await base.GetMetaData());
 
            if (!string.IsNullOrEmpty(this.name))
                Result.Add(new KeyValuePair<string, object>("NAME", this.name));
 
            if (!string.IsNullOrEmpty(this.className))
                Result.Add(new KeyValuePair<string, object>("CLASS", this.className));
 
            if (!string.IsNullOrEmpty(this.serialNumber))
                Result.Add(new KeyValuePair<string, object>("SN", this.serialNumber));
 
            if (!string.IsNullOrEmpty(this.meterNumber))
                Result.Add(new KeyValuePair<string, object>("MNR", this.meterNumber));
 
            if (!string.IsNullOrEmpty(this.meterLocation))
                Result.Add(new KeyValuePair<string, object>("MLOC", this.meterLocation));
 
            if (!string.IsNullOrEmpty(this.manufacturerDomain))
                Result.Add(new KeyValuePair<string, object>("MAN", this.manufacturerDomain));
 
            if (!string.IsNullOrEmpty(this.model))
                Result.Add(new KeyValuePair<string, object>("MODEL", this.model));
 
            if (this.version.HasValue)
                Result.Add(new KeyValuePair<string, object>("V", this.version.Value));
 
            if (!string.IsNullOrEmpty(this.productUrl))
                Result.Add(new KeyValuePair<string, object>("PURL", this.productUrl));
 
            if (!string.IsNullOrEmpty(this.country))
                Result.Add(new KeyValuePair<string, object>("COUNTRY", this.country));
 
            if (!string.IsNullOrEmpty(this.region))
                Result.Add(new KeyValuePair<string, object>("REGION", this.region));
 
            if (!string.IsNullOrEmpty(this.city))
                Result.Add(new KeyValuePair<string, object>("CITY", this.city));
 
            if (!string.IsNullOrEmpty(this.area))
                Result.Add(new KeyValuePair<string, object>("AREA", this.area));
 
            if (!string.IsNullOrEmpty(this.street))
                Result.Add(new KeyValuePair<string, object>("STREET", this.street));
 
            if (!string.IsNullOrEmpty(this.streetNr))
                Result.Add(new KeyValuePair<string, object>("STREETNR", this.streetNr));
 
            if (!string.IsNullOrEmpty(this.building))
                Result.Add(new KeyValuePair<string, object>("BLD", this.building));
 
            if (!string.IsNullOrEmpty(this.apartment))
                Result.Add(new KeyValuePair<string, object>("APT", this.apartment));
 
            if (!string.IsNullOrEmpty(this.room))
                Result.Add(new KeyValuePair<string, object>("ROOM", this.room));
 
            if (this.latitude.HasValue)
                Result.Add(new KeyValuePair<string, object>("LAT", this.latitude.Value));
 
            if (this.longitude.HasValue)
                Result.Add(new KeyValuePair<string, object>("LON", this.longitude.Value));
 
            if (this.altitude.HasValue)
                Result.Add(new KeyValuePair<string, object>("ALT", this.altitude.Value));
 
            return Result.ToArray();
        }
 
        public virtual void AddIdentityReadout(ChunkedList<Field> Fields, DateTime Now)
        {
            string Module = typeof(MeteringTopology).Namespace;
 
            if (!string.IsNullOrEmpty(this.name))
                Fields.Add(new StringField(this, Now, "Name", this.name, FieldType.Identity, FieldQoS.AutomaticReadout, Module, 30));
 
            if (!string.IsNullOrEmpty(this.className))
                Fields.Add(new StringField(this, Now, "Class", this.className, FieldType.Identity, FieldQoS.AutomaticReadout, Module, 33));
 
            if (!string.IsNullOrEmpty(this.serialNumber))
                Fields.Add(new StringField(this, Now, "Serial Number", this.serialNumber, FieldType.Identity, FieldQoS.AutomaticReadout, Module, 91));
 
            if (!string.IsNullOrEmpty(this.meterNumber))
                Fields.Add(new StringField(this, Now, "Meter Number", this.meterNumber, FieldType.Identity, FieldQoS.AutomaticReadout, Module, 92));
 
            if (!string.IsNullOrEmpty(this.meterLocation))
                Fields.Add(new StringField(this, Now, "Meter Location", this.meterLocation, FieldType.Identity, FieldQoS.AutomaticReadout, Module, 93));
 
            if (!string.IsNullOrEmpty(this.manufacturerDomain))
                Fields.Add(new StringField(this, Now, "Manufacturer", this.manufacturerDomain, FieldType.Identity, FieldQoS.AutomaticReadout, Module, 45));
 
            if (!string.IsNullOrEmpty(this.model))
                Fields.Add(new StringField(this, Now, "Model", this.model, FieldType.Identity, FieldQoS.AutomaticReadout, Module, 48));
 
            if (this.version.HasValue)
                Fields.Add(new QuantityField(this, Now, "Version", this.version.Value, CommonTypes.GetNrDecimals(this.version.Value), string.Empty, FieldType.Identity, FieldQoS.AutomaticReadout, Module, 80));
 
            if (!string.IsNullOrEmpty(this.country))
                Fields.Add(new StringField(this, Now, "Country", this.country, FieldType.Identity, FieldQoS.AutomaticReadout, Module, 54));
 
            if (!string.IsNullOrEmpty(this.region))
                Fields.Add(new StringField(this, Now, "Region", this.region, FieldType.Identity, FieldQoS.AutomaticReadout, Module, 57));
 
            if (!string.IsNullOrEmpty(this.city))
                Fields.Add(new StringField(this, Now, "City", this.city, FieldType.Identity, FieldQoS.AutomaticReadout, Module, 60));
 
            if (!string.IsNullOrEmpty(this.area))
                Fields.Add(new StringField(this, Now, "Area", this.area, FieldType.Identity, FieldQoS.AutomaticReadout, Module, 63));
 
            string s = this.StreetAndNr;
            if (!string.IsNullOrEmpty(s))
                Fields.Add(new StringField(this, Now, "Street", s, FieldType.Identity, FieldQoS.AutomaticReadout, Module, 66));
 
            if (!string.IsNullOrEmpty(this.building))
                Fields.Add(new StringField(this, Now, "Building", this.building, FieldType.Identity, FieldQoS.AutomaticReadout, Module, 71));
 
            if (!string.IsNullOrEmpty(this.apartment))
                Fields.Add(new StringField(this, Now, "Apartment", this.apartment, FieldType.Identity, FieldQoS.AutomaticReadout, Module, 74));
 
            if (!string.IsNullOrEmpty(this.room))
                Fields.Add(new StringField(this, Now, "Room", this.room, FieldType.Identity, FieldQoS.AutomaticReadout, Module, 77));
 
            if (this.latitude.HasValue)
                Fields.Add(new QuantityField(this, Now, "Latitude", this.latitude.Value, CommonTypes.GetNrDecimals(this.latitude.Value), string.Empty, FieldType.Identity, FieldQoS.AutomaticReadout, Module, 88));
 
            if (this.longitude.HasValue)
                Fields.Add(new QuantityField(this, Now, "Longitude", this.longitude.Value, CommonTypes.GetNrDecimals(this.longitude.Value), string.Empty, FieldType.Identity, FieldQoS.AutomaticReadout, Module, 89));
 
            if (this.altitude.HasValue)
                Fields.Add(new QuantityField(this, Now, "Altitude", this.altitude.Value, CommonTypes.GetNrDecimals(this.altitude.Value), string.Empty, FieldType.Identity, FieldQoS.AutomaticReadout, Module, 90));
        }
 
    }
}