public ResultData Run(StepStartData data) { object value = data.Data[VALUE_INPUT]; OPCTag tag; string serverUrl; if (chooseTagAtRuntime) { string tagPath = data.Data[TAG_INPUT] as string; serverUrl = data.Data[SERVER_URL_INPUT] as string; if (string.IsNullOrEmpty(tagPath)) { throw new Exception("No tag specified"); } if (string.IsNullOrEmpty(serverUrl)) { throw new Exception("No server URL specified"); } tag = EntityCache <OPCTag> .GetCache().AllEntities.FirstOrDefault(x => x.Path == tagPath && x.ServerUrl == serverUrl); if (tag == null) { throw new Exception($"No tag found at '{tagPath}' on server '{serverUrl}'"); } } else { tag = EntityCache <OPCTag> .GetCache().GetById(tagId); if (tag == null) { throw new Exception($"Tag '{tagId}' not found"); } serverUrl = tag.ServerUrl; } BaseTagValue tagValue = TagValueUtils.GetTagWithValue(TypeUtilities.FindTypeByFullName(tag.TypeName), value); tagValue.Path = tag.Path; OPCServerFolderBehaviorData folderExt = EntityCache <OPCServerFolderBehaviorData> .GetCache().AllEntities.FirstOrDefault(s => s.Url == serverUrl); Folder folder = folderExt?.GetEntity() as Folder; if (folder == null) { throw new Exception($"No server folder configured for URL '{serverUrl}'."); } OPCEngine.SetTagValues(serverUrl, folderExt.AgentId, new BaseTagValue[] { tagValue }); return(new ResultData(PATH_DONE, new KeyValuePair <string, object>[] { })); }
public static object GetObjectValueFromTag(BaseTagValue tag) { if (tag is SByteTagValue) { return((tag as SByteTagValue).Value); } if (tag is ByteTagValue) { return((tag as ByteTagValue).Value); } if (tag is ShortTagValue) { return((tag as ShortTagValue).Value); } if (tag is UShortTagValue) { return((tag as UShortTagValue).Value); } if (tag is IntTagValue) { return((tag as IntTagValue).Value); } if (tag is UIntTagValue) { return((tag as UIntTagValue).Value); } if (tag is LongTagValue) { return((tag as LongTagValue).Value); } if (tag is ULongTagValue) { return((tag as ULongTagValue).Value); } if (tag is FloatTagValue) { return((tag as FloatTagValue).Value); } if (tag is DoubleTagValue) { return((tag as DoubleTagValue).Value); } if (tag is DecimalTagValue) { return((tag as DecimalTagValue).Value); } if (tag is BoolTagValue) { return((tag as BoolTagValue).Value); } if (tag is DateTimeTagValue) { return((tag as DateTimeTagValue).Value); } if (tag is StringTagValue) { return((tag as StringTagValue).Value); } if (tag is SByteArrayTagValue) { return((tag as SByteArrayTagValue).Value); } if (tag is ByteArrayTagValue) { return((tag as ByteArrayTagValue).Value); } if (tag is ShortArrayTagValue) { return((tag as ShortArrayTagValue).Value); } if (tag is UShortArrayTagValue) { return((tag as UShortArrayTagValue).Value); } if (tag is IntArrayTagValue) { return((tag as IntArrayTagValue).Value); } if (tag is UIntArrayTagValue) { return((tag as UIntArrayTagValue).Value); } if (tag is LongArrayTagValue) { return((tag as LongArrayTagValue).Value); } if (tag is ULongArrayTagValue) { return((tag as ULongArrayTagValue).Value); } if (tag is FloatArrayTagValue) { return((tag as FloatArrayTagValue).Value); } if (tag is DoubleArrayTagValue) { return((tag as DoubleArrayTagValue).Value); } if (tag is DecimalArrayTagValue) { return((tag as DecimalArrayTagValue).Value); } if (tag is BoolArrayTagValue) { return((tag as BoolArrayTagValue).Value); } if (tag is DateTimeArrayTagValue) { return((tag as DateTimeArrayTagValue).Value); } if (tag is StringArrayTagValue) { return((tag as StringArrayTagValue).Value); } throw new Exception("Unknown tag value type"); }
public object GetValue(string name) { Log.Debug($"GetValue called on path {Path}"); if (Path == null || !Path.Contains(".")) { // If at the top, or at a server, the next part can't be a tag: string nextPath = (Path == null) ? name : $"{Path}.{name}"; return(new OPCDataProvider { Path = nextPath, Snapshot = this.Snapshot }); } string[] pathSplit = Path.Split(new char[] { '.' }, 2); // {Server Name}.{remaining.tag.path} Folder folder = opcServerOrm.Fetch().Select(ext => ext.GetEntity()).FirstOrDefault(f => f.EntityName == pathSplit[0]) as Folder; if (folder == null) { throw new Exception($"Could not find server named {pathSplit[0]}"); } string[] eventIds = FolderService.GetFolderEntities <OPCEvent>(folder.FolderID).Select(e => e.Id).ToArray(); BaseTagValue mostRecentTag = null; IDictionary <string, BaseTagValue> sourceDict = ((Snapshot as IDictionary <string, BaseTagValue>) ?? OPCEngine.mostRecentValues); foreach (string eventId in eventIds) { string key = $"{eventId}|{pathSplit[1]}.{name}"; BaseTagValue tag; if (sourceDict.TryGetValue(key, out tag)) { if (mostRecentTag == null || mostRecentTag.TimeStamp < tag.TimeStamp) { mostRecentTag = tag; } } } if (mostRecentTag != null) { return(TagValueUtils.GetObjectValueFromTag(mostRecentTag)); } // No current value found, so check folders to see whether this is a folder or a tag: Folder tagDataFolder = folder.GetSubFolder().FirstOrDefault(x => x.EntityName == "Tag Data"); if (tagDataFolder == null) { throw new Exception("Tag data folder not found"); } string[] parts = pathSplit[1].Split('.'); Folder currentFolder = tagDataFolder; for (int i = 0; i < parts.Length; ++i) { // descend for each part, arriving at the folder which should contain the named entity Folder nextFolder = currentFolder.GetSubFolder().FirstOrDefault(x => x.EntityName == parts[i]); if (nextFolder == null) { throw new Exception($"Folder '{parts[i]}' not found in folder '{currentFolder?.EntityName}'."); } currentFolder = nextFolder; } Folder namedFolder = FolderService.GetFolderEntities <Folder>(currentFolder.FolderID).FirstOrDefault(x => x.EntityName == name); if (namedFolder != null) { return new OPCDataProvider { Path = $"{this.Path}.{name}", Snapshot = this.Snapshot } } ; OPCTag namedTag = FolderService.GetFolderEntities <OPCTag>(currentFolder.FolderID).FirstOrDefault(x => x.EntityName == name); if (namedTag != null) { throw new Exception($"Tag '{name}' has no known value"); } else { throw new Exception($"No tag or folder '{name}' found in '{currentFolder.EntityName}'"); } }
private void SetValues(string opcServerUrl, string eventId, BaseTagValueWrapper valuesWrapper) { BaseTagValue[] values = valuesWrapper.Values; using (UserContextHolder.Register(new SystemUserContext())) { Folder configFolder = EntityCache <OPCServerFolderBehaviorData> .GetCache().AllEntities.FirstOrDefault(s => s.Url == opcServerUrl)?.GetEntity() as Folder; if (configFolder == null) { return; } Array.ForEach(values, tagValue => { LOG.Debug($"Value Change: {tagValue.Path} - {TagValueUtils.GetObjectValueFromTag(tagValue)}"); }); // put values in last cache foreach (var v in values) { string key = eventId + "|" + v.Path; BaseTagValue priorValue; OPCEngine.mostRecentValues.TryGetValue(key, out priorValue); OPCEngine.mostRecentValues[key] = v; if (priorValue == null) { OPCEngine.priorValues[key] = v; } else { OPCEngine.priorValues[key] = priorValue; } } OPCEvent opcEvent = opcEventOrm.Fetch(eventId); if (opcEvent == null || opcEvent.Disabled) { return; } bool runIt = false; // see if this event is interested in this change foreach (var v in opcEvent.EventValues) { if (values.FirstOrDefault(changedValue => changedValue.Path == v.PathToValue) != null) { runIt = true; break; } } if (runIt) { try { List <DataPair> inputs = new List <DataPair>(); foreach (var v in opcEvent.EventValues) { string key = eventId + "|" + v.PathToValue; BaseTagValue value = null; OPCEngine.mostRecentValues.TryGetValue(key, out value); inputs.Add(new DataPair(v.Name, value)); BaseTagValue priorvalue = null; OPCEngine.priorValues.TryGetValue(key, out priorvalue); inputs.Add(new DataPair("Last " + v.Name, priorvalue)); } inputs.Add(new DataPair("LastWorkflowRun", opcEvent.LastRun)); // check rule to see if it matches var ruleResult = RuleEngine.RunRule(opcEvent.Rule, inputs.ToArray()); if (ruleResult != null && ruleResult is bool) { if (((bool)ruleResult) == true) { new Log("OPC").Error("Value Changed And Rule Returned True - running flow"); FlowEngine.Start(FlowEngine.LoadFlowByID(opcEvent.Flow, false, true), new FlowStateData(inputs.ToArray())); } else { new Log("OPC").Error("Value Changed But Rule Returned False"); } } else { new Log("OPC").Error("Value Changed But Rule Returned False"); } } catch (Exception except) { new Log("OPC").Error(except, "Error running flow from event"); } } } }