public bool LogEvent(TheEventLogData pItem) { if (pItem == null) { return(false); } bool bRet = false; List <TheThing> tDevList = TheThingRegistry.GetThingsOfEngine(MyBaseThing.EngineName); if (tDevList?.Count > 0) { foreach (TheThing tDev in tDevList) { var tTwin = tDev.GetObject() as ICDELoggerEngine; var tRes = tTwin?.LogEvent(pItem); if (!bRet && tRes == true) { bRet = true; } } } if (PublishEvents) //This allows to have a logger on a different node { TheCommCore.PublishCentral(new TSM(eEngineName.ContentService, eEngineEvents.NewEventLogEntry, pItem.EventLevel, TheCommonUtils.SerializeObjectToJSONString(pItem)), true); } return(bRet); }
private static void SendGlobalThings(Guid targetNodeId) { // Do not send more often than every 60 seconds if (lastGlobalThingSendPerNode.TryGetValue(targetNodeId, out thingSendStatus timeAndPending)) { if (DateTimeOffset.Now.Subtract(timeAndPending.lastSend).TotalSeconds < 59) // && !timeAndPending.Pending) { return; } } var globalThings = TheThingRegistry.GetThingsByFunc("*", (t) => TheThing.GetSafePropertyBool(t, "IsRegisteredGlobally") && t.IsOnLocalNode()); if (globalThings != null) { TSM tTSM = new TSM(eEngineName.ContentService, "CDE_SYNC_THINGS", TheCommonUtils.SerializeObjectToJSONString(globalThings)); tTSM.SetToServiceOnly(true); if (targetNodeId == Guid.Empty) { TheCommCore.PublishCentral(tTSM); } else { TheCommCore.PublishToNode(targetNodeId, tTSM); } lastGlobalThingSendPerNode[targetNodeId] = new thingSendStatus { lastSend = DateTimeOffset.Now, Pending = false }; } }
public void StartPropertyUpdateLoop() { testThing = new TheThing() { FriendlyName = "MyTestSensor" }; TheThingRegistry.RegisterThing(testThing); Random rand = new Random(); // Used for generating "fake" sensor values cdeP[] props = new cdeP[propertyCount]; // Run the loop on another thread TheCommonUtils.cdeRunAsync("PropertyUpdateLoop", true, (o) => { while (TheBaseAssets.MasterSwitch) { // Set the properties and log props[0] = testThing.SetProperty(properties[0], rand.Next(25, 51)); props[1] = testThing.SetProperty(properties[1], rand.NextDouble()); props[2] = testThing.SetProperty(properties[2], rand.Next(10000, 50000)); LogChanges(false, props); // Wait timeout of 1 second between property updates TheCommonUtils.SleepOneEye(1000, 500); } }); }
void sinkRuleThingEvent(ICDEThing sender, object pIncoming) { if (sender == null) { return; } TheThing tThing = TheThingRegistry.GetThingByProperty("*", Guid.Empty, "TriggerObject", TheThing.GetSafePropertyString(sender, "ID")); if (tThing != null) { TheRule tRule = tThing.GetObject() as TheRule; if (tRule == null || !tRule.IsRuleActive) { return; } if (tRule.TriggerStartTime > DateTimeOffset.Now) { return; } if (tRule.TriggerEndTime < DateTimeOffset.Now) { RemoveTrigger(tRule, false); return; } tRule.FireAction(false); } }
void SendRuleTSM(bool serviceOnly) { string engine = TheCommonUtils.CStr(GetProperty("TSMEngine", false)); string text = TheCommonUtils.CStr(GetProperty("TSMText", false)); string payload = TheCommonUtils.CStr(GetProperty("TSMPayload", false)); //payload = payload.Replace("%DTO%", TheCommonUtils.CStr(DateTimeOffset.Now)); //text = text.Replace("%DTO%", TheCommonUtils.CStr(DateTimeOffset.Now)); ICDEThing triggerThing = TheThingRegistry.GetThingByMID("*", TheCommonUtils.CGuid(TriggerObject)) as ICDEThing; string escPayload = TheCommonUtils.GenerateFinalStr(payload, triggerThing); escPayload = TheCommonUtils.GenerateFinalStr(escPayload, MyBaseThing); string escText = TheCommonUtils.GenerateFinalStr(text, triggerThing); escText = TheCommonUtils.GenerateFinalStr(escText, MyBaseThing); if (!string.IsNullOrEmpty(engine) && !string.IsNullOrEmpty(text)) { TSM customTSM = new TSM(engine, escText, escPayload); if (serviceOnly) { customTSM.SetToServiceOnly(true); } TheCommCore.PublishCentral(customTSM, true); } if (IsRuleLogged) { LogEvent(escPayload); } if (TheThing.GetSafePropertyBool(MyBaseThing, "IsEVTLogged")) { TheLoggerFactory.LogEvent(eLoggerCategory.RuleEvent, TheCommonUtils.GenerateFinalStr(MyBaseThing.FriendlyName, MyBaseThing), eMsgLevel.l4_Message, TheBaseAssets.MyServiceHostInfo.GetPrimaryStationURL(false), escText, escPayload); } }
private void InitServices() { if (TheBaseAssets.MyServiceHostInfo.IsCloudService) { return; } List <TheThing> tDevList = TheThingRegistry.GetThingsOfEngine(MyBaseEngine.GetEngineName()); if (tDevList.Count > 0) { foreach (TheThing tDev in tDevList) { switch (tDev.DeviceType) { case eWebAppTypes.TheWebApp: TheRelayAppInfo tApp = new TheRelayAppInfo(tDev, null, this); if (string.IsNullOrEmpty(tApp.HomePage)) { tApp.HomePage = "/"; } if (!tApp.HomePage.StartsWith("/")) { tApp.HomePage = "/" + tApp.HomePage; } tApp.SSID = TheScopeManager.GetScrambledScopeID(); TheThingRegistry.RegisterThing(tApp); break; } } } }
public bool RegisterRule(TheThingRule pRule) { if (pRule == null || TheBaseAssets.MyServiceHostInfo.IsCloudService) { return(false); } pRule.GetBaseThing().EngineName = MyBaseEngine.GetEngineName(); if (pRule.TriggerCondition == eRuleTrigger.Set) { pRule.ActionValue = null; } pRule.IsRuleRunning = false; pRule.IsRuleWaiting = true; pRule.IsIllegal = false; pRule.IsTriggerObjectAlive = false; pRule.Parent = MyBaseThing.ID; pRule.GetBaseThing().EngineName = MyBaseEngine.GetEngineName(); TheSystemMessageLog.WriteLog(4445, TSM.L(eDEBUG_LEVELS.VERBOSE) ? null : new TSM(eKnownDeviceTypes.TheThingRule, $"Rule {pRule.FriendlyName} stopped during Register Rule - waiting for startup"), false); TheThing.SetSafePropertyDate(pRule.GetBaseThing(), "LastTriggered", DateTimeOffset.MinValue); TheThing.SetSafePropertyDate(pRule.GetBaseThing(), "LastAction", DateTimeOffset.MinValue); TheThingRegistry.RegisterThing(pRule); return(true); }
string LoadXMLDefinition(string pFile) { string path = TheCommonUtils.cdeFixupFileName(pFile); TheBaseAssets.MySYSLOG.WriteToLog(500, new TSM(MyBaseEngine.GetEngineName(), $"Trying to open Modbus configuration file: {pFile}")); ModbusConfiguration config = null; try { config = ModbusConfiguration.ReadFromFile(path); } catch (IOException) { return("File not found or parsing failed"); } List <TheThing> tDevList = TheThingRegistry.GetThingsOfEngine(MyBaseThing.EngineName); foreach (var dd in config.Devices) { var tDev = tDevList.Find((t) => t.FriendlyName == dd.Name); if (tDev == null || !tDev.HasLiveObject) { TheBaseAssets.MySYSLOG.WriteToLog(500, new TSM(MyBaseEngine.GetEngineName(), $"Adding Modbus Device {dd.Name}")); var pm = new ModbusTCPDevice(tDev, this, dd); TheThingRegistry.RegisterThing(pm); } } return("XML Definition loaded correctly."); }
public override bool Init() { if (!mIsInitStarted) { mIsInitStarted = true; MyBaseEngine.RegisterEvent(eEngineEvents.ShutdownEvent, OnShutdown); TheThing.SetSafePropertyBool(MyBaseThing, "IsConnected", false); IBaseEngine tBase = TheThingRegistry.GetBaseEngine(TheThing.GetSafePropertyString(MyBaseThing, "ISOLaterName"), true); if (tBase != null) { MyIsolator = tBase.GetISOLater() as Process; if (MyIsolator == null) { MyBaseThing.LastMessage = "Engine not isolated"; MyBaseThing.StatusLevel = 3; mIsInitCompleted = true; return(true); } MyBaseThing.LastMessage = "KPIs monitor ready"; MyBaseThing.StatusLevel = 1; if (TheThing.GetSafePropertyBool(MyBaseThing, "AutoConnect")) { Connect(); } } else { MyBaseThing.LastMessage = "Base Engine cloud not be located"; MyBaseThing.StatusLevel = 3; } mIsInitCompleted = true; } return(true); }
public override void DoCreateUX(TheFormInfo tMyForm, ThePropertyBag pChartsBag = null) { base.DoCreateUX(tMyForm); AddSpeedGauge(tMyForm); var tEngage = TheNMIEngine.AddSmartControl(MyBaseThing, tMyForm, eFieldType.TileButton, 25012, 2, 0xC0, "Restart KPI", null, new nmiCtrlNumber { ParentFld = TheDefaultSensor.SensorActionArea, TileWidth = 6, NoTE = true }); tEngage.RegisterUXEvent(MyBaseThing, eUXEvents.OnClick, "reset", (sender, para) => { EngageMapper(); }); var tRemove = TheNMIEngine.AddSmartControl(MyBaseThing, tMyForm, eFieldType.TileButton, 25013, 2, 0xC0, "Delete this KPI Report", null, new nmiCtrlNumber { ParentFld = TheDefaultSensor.SensorActionArea, TileWidth = 6, NoTE = true }); tRemove.RegisterUXEvent(MyBaseThing, eUXEvents.OnClick, "remove", (sender, para) => { TheThing tT = TheThingRegistry.GetThingByID(MyBaseEngine.GetEngineName(), MyBaseThing.ID); if (tT != null) { TheThingRegistry.UnmapPropertyMapper(mRealThingGuid); TheThingRegistry.DeleteThing(tT); } }); }
T CreateOrUpdateService <T>(TheThing tDevice, bool bRegisterThing) where T : TheNetworkServiceBase { T tServer; if (tDevice == null || !tDevice.HasLiveObject) { tServer = (T)Activator.CreateInstance(typeof(T), tDevice, this); if (bRegisterThing) { TheThingRegistry.RegisterThing(tServer); tServer.GetBaseThing().RegisterOnChange("DeviceType", OnServerDeviceTypeChanged); } } else { tServer = tDevice.GetObject() as T; if (tServer != null) { //tServer.InitServer(null); } else { tServer = (T)Activator.CreateInstance(typeof(T), tDevice, this); } } return(tServer); }
void InitServers() { List <TheThing> tDevList = TheThingRegistry.GetThingsOfEngine(this.MyBaseEngine.GetEngineName()); if (tDevList.Count > 0) { foreach (TheThing tDev in tDevList) { try { if (!tDev.HasLiveObject) { switch (tDev.DeviceType) { case PrometheusDeviceTypes.PrometheusExporter: var tPS = new ThePrometheusExporter(tDev, this); TheThingRegistry.RegisterThing(tPS); break; } } } catch (Exception e) { TheBaseAssets.MySYSLOG.WriteToLog(181001, TSM.L(eDEBUG_LEVELS.OFF) ? null : new TSM(MyBaseThing.EngineName, $"Error creating exporter instance {tDev?.cdeMID} / {tDev?.FriendlyName}", eMsgLevel.l1_Error, e.ToString())); } } } MyBaseEngine.SetStatusLevel(-1); }
void InitServers() { List <TheThing> tDevList = TheThingRegistry.GetThingsOfEngine(MyBaseThing.EngineName); // TheThingRegistry.GetThingsByProperty("*", Guid.Empty, "DeviceType", eOPCDeviceTypes.OPCServer); if (tDevList.Count > 0) { foreach (TheThing tDev in tDevList) { if (!tDev.HasLiveObject) { switch (tDev.DeviceType) { case eOPCDeviceTypes.OPCRemoteServer: TheOPCUARemoteServer tS = new TheOPCUARemoteServer(tDev, this, null); TheThingRegistry.RegisterThing(tS); break; case eOPCDeviceTypes.OPCLiveTag: TheOPCUATagThing tag = new TheOPCUATagThing(tDev, null); TheThingRegistry.RegisterThing(tag); break; case eOPCDeviceTypes.OPCMethod: TheOPCUAMethodThing tMeth = new TheOPCUAMethodThing(tDev, MyBaseEngine.GetEngineName()); TheThingRegistry.RegisterThing(tMeth); break; } } } } MyBaseEngine.SetStatusLevel(-1); }
private static string AddHTMLHeader() { string outText = "<html><head>"; outText += TheBaseAssets.MyServiceHostInfo.GetMeta(""); if (TheThingRegistry.IsEngineStarted("NMIService.TheNMIHtml5RT", false)) { outText += "<link rel=\"stylesheet\" type=\"text/css\" href=\"css/cdeStyles.min.css\" />"; outText += "<link rel=\"stylesheet\" type=\"text/css\" href=\"css/MyStyles.min.css\" />"; outText += "<script src=\"cdeSorttable.js\"></script>"; outText += "<script src=\"excellentexport.js\"></script>"; outText += "<script>window.jdenticon_config = { replaceMode: \"observe\" }; </script>"; outText += "<script src=\"jdenticon-2.2.0.min.js\"></script>"; } else { outText += "<style>"; outText += "table.cdeHilite {font-family: 'robotothin','Segoe UI',Arial,sans-serif;margin: 1em;border-collapse: collapse;font-weight: normal;text-decoration: none;}"; outText += ".cdeLogEntry {padding: .1em;border-bottom-style: solid;border-bottom-width: 1px;}"; outText += ".cdeClip {overflow: hidden;text-overflow: ellipsis;}"; outText += ".cdeClip:hover { overflow: visible;text-overflow: initial;}"; outText += "</style>"; } outText += "<title>" + TheBaseAssets.MyServiceHostInfo.GetPrimaryStationURL(false) + " - System Log</title>"; outText += "</head><body class=\"cdeLogBody\">\r"; return(outText); }
void sinkRegisterIsos() { var tEngs = TheThingRegistry.GetBaseEnginesAsThing(false, true); foreach (var t in tEngs) { if (TheThing.GetSafePropertyBool(t, "IsIsolated")) { IBaseEngine tBase = TheThingRegistry.GetBaseEngine(t, true); if (tBase != null && tBase.GetISOLater() != null) { TheThing tT = TheThingRegistry.GetThingByFunc(MyBaseEngine.GetEngineName(), s => s.DeviceType == TheISOlaterKPIs.eDeviceType && TheThing.GetSafePropertyString(s, "ISOLaterName") == t.EngineName); var tKPI = new TheISOlaterKPIs(tT, this, t.EngineName); TheThingRegistry.RegisterThing(tKPI); } } } List <TheThing> tDevList = TheThingRegistry.GetThingsByProperty(MyBaseEngine.GetEngineName(), Guid.Empty, "DeviceType", TheKPIReport.eDeviceType); if (tDevList.Count > 0) { foreach (TheThing tDev in tDevList) { if (tDev.GetObject() == null) { TheKPIReport cs = new TheKPIReport(tDev, this); TheThingRegistry.RegisterThing(cs); } } } }
void sinkThingWasUpdated(ICDEThing sender, object pPara) { if (TheBaseAssets.MyServiceHostInfo.IsCloudService) { return; //TODO: Allow Cloud Rules } TheThing pThing = sender as TheThing; if (pThing != null && TheThing.GetSafePropertyString(pThing, "DeviceType") == eKnownDeviceTypes.TheThingRule) { TheRule tRule = pThing.GetObject() as TheRule; if (tRule == null) { tRule = new TheRule(pThing, this); tRule.RegisterEvent(eEngineEvents.ThingUpdated, sinkUpdated); RegisterRule(tRule); } { tRule.IsRuleWaiting = true; tRule.IsRuleRunning = false; TheSystemMessageLog.WriteLog(4445, TSM.L(eDEBUG_LEVELS.VERBOSE) ? null : new TSM(eKnownDeviceTypes.TheThingRule, $"Rule {tRule.FriendlyName} stopped on Rule Update"), false); TheThingRegistry.UpdateThing(tRule, false); } ActivateRules(); } }
public void IncomingMessageEventTest() { var contentServiceThing = TheThingRegistry.GetBaseEngineAsThing(eEngineName.ContentService); var contentServiceEng = contentServiceThing.GetBaseEngine(); int numberOfMessages = 0; string txt = "TEST_TXT"; string payload = "TestPayload"; TSM testMsg = new TSM(eEngineName.ContentService, txt, payload); contentServiceEng?.RegisterEvent(eEngineEvents.IncomingMessage, (t, o) => { numberOfMessages++; if (o is TheProcessMessage msg) { Assert.AreEqual(msg.Message.TXT, txt); Assert.AreEqual(msg.Message.PLS, payload); Assert.AreEqual(msg.Message.ENG, contentServiceEng.GetEngineName()); testMsg.PLS = "TestPayload2"; //Assert.AreNotEqual(msg.Message.PLS, testMsg.PLS); // This fails } if (t is ICDEThing thing) { Assert.AreEqual(thing.GetBaseThing().cdeMID, contentServiceThing.cdeMID); } }); TheCommCore.PublishCentral(testMsg, true); TheCommonUtils.SleepOneEye(5000, 1000); Assert.AreEqual(numberOfMessages, 1); }
/// <summary> /// Activates a given rule /// </summary> /// <param name="pRuleID">ID To activate</param> /// <param name="pTurnActive">if true, the rule will be activated otherwise deactivated</param> /// <returns></returns> public static bool ActivateRule(Guid pRuleID, bool pTurnActive) { InitRR(); if (MyRulesRegistry != null) { ICDEThing pRule = TheThingRegistry.GetThingByID(eEngineName.ThingService, pRuleID.ToString()); if (pRule != null) { try { if (pRule.GetBaseThing().GetObject() is TheThingRule tRule) { tRule.IsRuleActive = pTurnActive; MyRulesRegistry.ActivateRules(); return(true); } } catch { //ignored } } } return(false); }
private void UpdateUx() { ThePropertyBag.MergeUXBagFromProperties(CountBar?.PropertyBag, MyBaseThing); SetCtrlType(); if (TimestampField != null) { TimestampField?.SetUXProperty(Guid.Empty, $"Visibility={ShowTimestamp}"); ChangeTimestampField?.SetUXProperty(Guid.Empty, $"Visibility={ShowChangeTimestamp}"); } TheThingRegistry.UnmapPropertyMapper(MapperGuid); if (!string.IsNullOrEmpty(MyBaseThing.Address)) { MapperGuid = TheThingRegistry.PropertyMapper(TheCommonUtils.CGuid(MyBaseThing.Address), TheThing.GetSafePropertyString(MyBaseThing, "SourceProp"), MyBaseThing.cdeMID, "Value", true); if (MapperGuid != Guid.Empty) { MyBaseThing.StatusLevel = 1; MyBaseThing.LastMessage = "Mapper engaged"; } else { MyBaseThing.StatusLevel = 2; MyBaseThing.LastMessage = "Mapper failed to engaged"; } } else { MyBaseThing.StatusLevel = 0; MyBaseThing.LastMessage = "Mapper not engaged"; } }
private static IServiceCollection AddCdePubSubServices(this IServiceCollection collection) { collection.AddSingleton(sp => { sp.UseCde(); var engines = TheThingRegistry.GetBaseEngines(false); var engine = engines.FirstOrDefault(e => e.GetEngineName() == InfrastructureEngine); if (engine != null) { return(engine.GetBaseThing()); } if (!TheCDEngines.RegisterNewMiniRelay(InfrastructureEngine)) { throw new InvalidOperationException("Failed to register CDE infrastructure engine"); } engine = TheThingRegistry.GetBaseEngine(InfrastructureEngine, false); return(engine.GetBaseThing()); }); collection.AddSingleton(sp => new Publisher(Operator.GetLine(sp.GetRequiredService <TheThing>())).ConnectAsync().Result as Publisher) .AddSingleton(sp => sp.GetRequiredService <Publisher>() as IPublisher); collection.AddSingleton(sp => new Subscriber(Operator.GetLine(sp.GetRequiredService <TheThing>()), sp.GetRequiredService <Publisher>())) .AddSingleton(sp => sp.GetRequiredService <Subscriber>() as ISubscriber); return(collection); }
T CreateOrUpdateService <T>(TheThing tDevice, bool bRegisterThing) where T : TheLoggerBase { T tServer; if (tDevice == null || !tDevice.HasLiveObject) { tServer = (T)Activator.CreateInstance(typeof(T), tDevice, this); if (bRegisterThing) { TheThingRegistry.RegisterThing((ICDEThing)tServer); } } else { tServer = tDevice.GetObject() as T; if (tServer != null) { tServer.Connect(null); //Expose a Connect(TheProcessMessage) method on TheThing } else { tServer = (T)Activator.CreateInstance(typeof(T), tDevice, this); } } return(tServer); }
private void OnDownloadClick(ICDEThing pThing, object pPara) { TheProcessMessage pMSG = pPara as TheProcessMessage; if (pMSG == null || pMSG.Message == null) { return; } string[] cmd = pMSG.Message.PLS.Split(':'); if (cmd.Length > 2) { TheThing tThing = TheThingRegistry.GetThingByMID("*", TheCommonUtils.CGuid(cmd[2]), true); if (tThing == null) { return; } TSM tFilePush = new TSM(eEngineName.ContentService, string.Format("CDE_FILE:{0}.JSON:application/zip", tThing.FriendlyName)) { SID = pMSG.Message.SID, PLS = "bin", PLB = TheCommonUtils.CUTF8String2Array(TheCommonUtils.SerializeObjectToJSONString(tThing)) }; TheCommCore.PublishToOriginator(pMSG.Message, tFilePush); } }
void InitServers() { List <TheThing> tDevList = TheThingRegistry.GetThingsOfEngine(MyBaseThing.EngineName); // TheThingRegistry.GetThingsByProperty("*", Guid.Empty, "DeviceType", eOPCDeviceTypes.OPCServer); if (tDevList.Count > 0) { foreach (TheThing tDev in tDevList) { switch (tDev.DeviceType) { case eMessageTypes.EMAIL: TheEmailMessage tS = null; if (!tDev.HasLiveObject) { tS = new TheEmailMessage(tDev, this); TheThingRegistry.RegisterThing(tS); } break; case eMessageTypes.SMS: TheSMSMessage tSMS = null; if (!tDev.HasLiveObject) { tSMS = new TheSMSMessage(tDev, this); TheThingRegistry.RegisterThing(tSMS); } break; } } } MyBaseEngine.SetStatusLevel(-1); }
void InitServices() { var tThing = TheThingRegistry.GetThingByProperty(MyBaseThing.EngineName, Guid.Empty, "DeviceType", eTheDemoScreensTypes.DemoIFrame); var t = new DemoIFrame(tThing, this); var tThing2 = TheThingRegistry.GetThingByProperty(MyBaseThing.EngineName, Guid.Empty, "DeviceType", eTheDemoScreensTypes.DemoStandardForm); var t2 = new DemoStandardForm(tThing2, this); var tThing3 = TheThingRegistry.GetThingByProperty(MyBaseThing.EngineName, Guid.Empty, "DeviceType", eTheDemoScreensTypes.DemoControls); var t3 = new DemoControls(tThing3, this); var tThing4 = TheThingRegistry.GetThingByProperty(MyBaseThing.EngineName, Guid.Empty, "DeviceType", eTheDemoScreensTypes.DemoWizard); var t4 = new DemoWizard(tThing4, this); var tThing5 = TheThingRegistry.GetThingByProperty(MyBaseThing.EngineName, Guid.Empty, "DeviceType", eTheDemoScreensTypes.AudioWizard); var t5 = new AudioRuleWizard(tThing5, this); var tThing9 = TheThingRegistry.GetThingByProperty(MyBaseThing.EngineName, Guid.Empty, "DeviceType", eTheDemoScreensTypes.MeshPicker); var t9 = new TheMeshPicker(tThing9, this); var tThing10 = TheThingRegistry.GetThingByProperty(MyBaseThing.EngineName, Guid.Empty, "DeviceType", eTheDemoScreensTypes.TestAutomationWizard); var t10 = new TestAutoWizard(tThing10, this); MyBaseEngine.SetStatusLevel(1); }
private void UpdateUx(TheThing pThing) { ThePropertyBag.MergeUXBagFromProperties(MySampleControl?.PropertyBag, pThing); SetCtrlType(); TheThingRegistry.UnmapPropertyMapper(MapperGuid); if (!string.IsNullOrEmpty(pThing.Address)) { MapperGuid = TheThingRegistry.PropertyMapper(TheCommonUtils.CGuid(pThing.Address), TheThing.GetSafePropertyString(pThing, "SourceProp"), pThing.cdeMID, "Value", true); if (MapperGuid != Guid.Empty) { pThing.StatusLevel = 1; pThing.LastMessage = "Mapper engaged"; } else { pThing.StatusLevel = 2; pThing.LastMessage = "Mapper failed to engaged"; } } else { pThing.StatusLevel = 0; pThing.LastMessage = "Mapper not engaged"; } }
IEnumerable <JSonOpcArrayElement> GetJSONArray(TheThingStore thingEvent) { // TODO Replace with linkid some identifier that represents the activated instance/customer, and make this more efficient (avoid or cache thing registry lookup) string linkid; var tThing = TheThingRegistry.GetThingByMID("*", TheCommonUtils.CGuid(thingEvent.cdeMID), true); if (tThing != null && !String.IsNullOrEmpty(tThing.FriendlyName)) { linkid = tThing.FriendlyName; } else { if (thingEvent.PB.ContainsKey("Address")) { linkid = TheCommonUtils.CStr(thingEvent.PB["Address"]); } else { if (tThing != null) { linkid = tThing.Address; } else { linkid = TheCommonUtils.cdeGuidToString(thingEvent.cdeMID); } } } var jsonArray = new List <JSonOpcArrayElement>(); jsonArray.AddRange(thingEvent.PB.Select(propKV => GetJSONArrayElement(linkid, propKV.Key, thingEvent.cdeCTIM, propKV.Value))); return(jsonArray.OrderBy(ev => ev.sourcetimestamp)); }
public MainWindow() { InitializeComponent(); // Start the CDEngine communication channels StartCDEngineHost(); TheBaseEngine.WaitForEnginesStartedAsync().ContinueWith(t => { try { // Express our interest in the EngineName used for the chat, so that a subscription to the cloud is established even though the engine has not matching plug-in on this node TheCDEngines.RegisterNewMiniRelay(strChatEngine); // Intercept any messages sent to the chat engine var chatEngine = TheThingRegistry.GetBaseEngine(strChatEngine); chatEngine.RegisterEvent(eEngineEvents.IncomingMessage, HandleMessage); // Intercept any messages sent to the ContentService (we will use that as the originating thing, and acknowledge messages will come back to it) TheThingRegistry.GetBaseEngineAsThing(eEngineName.ThingService).RegisterEvent(eThingEvents.IncomingMessage, HandleMessage); } catch { } }); }
public bool CreateUX() { if (mIsUXInitCalled) { return(false); } mIsUXInitCalled = true; //NUI Definition for All clients mMyDashboard = TheNMIEngine.AddDashboard(MyBaseThing, new TheDashboardInfo(MyBaseEngine, "<i class='cl-font cl-Logo fa-5x'></i><br>Mesh Receiver") { PropertyBag = new ThePropertyBag() { "Category=Connectors" } }); TheFormInfo tAllCloudConnections = new TheFormInfo(MyBaseEngine) { cdeMID = TheThing.GetSafeThingGuid(MyBaseThing, "MeshR"), defDataSource = string.Format("TheThing;:;0;:;True;:;EngineName={0}", MyBaseEngine.GetEngineName()), FormTitle = "Mesh Receiver Connections", AddButtonText = "Add a Connection" }; TheNMIEngine.AddFormToThingUX(MyBaseThing, tAllCloudConnections, "CMyTable", "Mesh Receivers", 1, 0x0D, 0xC0, TheNMIEngine.GetNodeForCategory(), null, new ThePropertyBag() { "Thumbnail=MicrosoftAzure.png;0.5" }); TheNMIEngine.AddCommonTableColumns(MyBaseThing, tAllCloudConnections, MeshDeviceTypes.GetValues(), MeshDeviceTypes.MeshReceiver, false, true); TheNMIEngine.AddField(tAllCloudConnections, new TheFieldInfo() { FldOrder = 5, cdeA = 0xC0, Flags = 6, Type = eFieldType.SingleCheck, FldWidth = 1, Header = "Auto-Connect", DataItem = "MyPropertyBag.AutoConnect.Value" }); TheNMIEngine.AddField(tAllCloudConnections, new TheFieldInfo() { FldOrder = 6, cdeA = 0xC0, Flags = 0, Type = eFieldType.SingleCheck, FldWidth = 1, Header = "Is Connected", DataItem = "MyPropertyBag.IsConnected.Value", PropertyBag = new nmiCtrlSingleCheck { AreYouSure = "Are you sure you want to connect/disconnect?" } }); TheNMIEngine.AddField(tAllCloudConnections, new TheFieldInfo() { FldOrder = 7, cdeA = 0xC0, Flags = 0, Type = eFieldType.SingleCheck, FldWidth = 1, Header = "Connecting", DataItem = "MyPropertyBag.Connecting.Value" }); TheNMIEngine.AddField(tAllCloudConnections, new TheFieldInfo() { FldOrder = 8, cdeA = 0xC0, Flags = 0, Type = eFieldType.SingleCheck, FldWidth = 1, Header = "Disconnecting", DataItem = "MyPropertyBag.Disconnecting.Value" }); TheNMIEngine.AddField(tAllCloudConnections, new TheFieldInfo() { FldOrder = 50, cdeA = 0xFF, Type = eFieldType.DateTime, FldWidth = 2, Header = "Last Update", DataItem = "MyPropertyBag.LastUpdate.Value" }); TheThingRegistry.UpdateEngineUX(MyBaseEngine.GetEngineName()); TheNMIEngine.AddAboutButton(MyBaseThing, true, "REFRESH_DASH", 0xc0); TheNMIEngine.RegisterEngine(MyBaseEngine); mIsUXInitialized = true; return(true); }
TheThing GetOpcThing() { if (_opcThing == null) { _opcThing = TheThingRegistry.GetThingByMID(OpcThingAddress.EngineName, OpcThingAddress.ThingMID); } return(_opcThing); }
public TheDemoBase(TheThing tBaseThing, ICDEPlugin pPluginBase) { MyBaseThing = tBaseThing ?? new TheThing(); MyBaseEngine = pPluginBase.GetBaseEngine(); MyBaseThing.EngineName = MyBaseEngine.GetEngineName(); MyBaseThing.SetIThingObject(this); TheThingRegistry.RegisterThing(this); }