public static IRtTag AddExpression(IRtConnector creator, string expresionFull, IRtTagOptions options = null) { MatchCollection matches = rgx.Matches(expresionFull); if (matches.Count > 0) { string expresion = expresionFull; int i = 0; var argumentsTags = new IRtTag[matches.Count]; foreach (Match match in matches) { var tagDefinition = match.Value.Trim().TrimStart('{').TrimEnd('}'); argumentsTags[i] = creator.AddTagDefinition(tagDefinition, options); expresion = expresion.Replace(match.Value, $"arg{i}"); i++; } return(new RtTagExpression(expresionFull, expresion, argumentsTags)); } else if (expresionFull.StartsWith("=")) { return(new RtTagExpression(expresionFull, expresionFull, null)); } else { return(creator.AddTagDefinition(expresionFull, options)); } }
public RtTagDecoratorBase(IRtTag tag) { this.tag = tag; this.tag.ValueSetted += OnTagValueSetted; this.tag.ValueUpdated += OnTagValueUpdated; this.tag.StatusChanged += OnStatusChanged; }
public override bool WriteValue(IRtTag tag, IRtValue value) { try { if (mqttClient.IsConnected) { RtTagMqttOptions options = tag.Options as RtTagMqttOptions; var writed = mqttClient.Client.Publish(tag.Topic, value.Binary, (byte)options.qosLevels, options.retain); if (writed > 0) { lock (rtTags) { foreach (var _tag in rtTags.Where(t => t.Topic == tag.Topic)) { _tag.RaiseOnSetValue(value); } } RaiseOnSetValue(tag); logger?.LogDebug("WriteValue TagName:{0} Value:{1} return:{2}", tag.TagName, tag.Value.Text, true); return(true); } } } catch { } logger?.LogWarning("WriteValue TagName:{0} return:{1}", tag.TagName, false); return(false); }
public override bool WriteValue(IRtTag tag, IRtValue value) { if (IsConnected && keyValueMemory != null) { var writed = keyValueMemory.SetValue(tag.Topic, value.Binary, true); if (writed) { lock (rtTags) { foreach (var _tag in rtTags.Where(t => t.Topic == tag.Topic)) { _tag.RaiseOnSetValue(value); } } RaiseOnSetValue(tag); logger?.LogDebug("WriteValue TagName:{0} return:{1}", tag.TagName, true); return(true); } } logger?.LogWarning("WriteValue TagName:{0} return:{1}", tag.TagName, false); return(false); }
public void RemoveTag(IRtTag tag) { lock (rtTags) { rtTags.Remove(tag as RtTagMqtt); } logger?.LogInformation("RemoveTag TagName:{0}", tag.TagName); }
public void RemoveTag(IRtTag tag) { if (!syncWithExistentTopics) { lock (rtTags) rtTags.Remove(tag as RtTagMemoryMapped); } logger?.LogDebug("RemoveTag TagName:{0}", tag.TagName); }
private void TagArgumentOnUpdatedValue(object sender, IRtTag e) { lock (this) { if (HasNewValue() || HasNewStatus()) { Eval(); } } }
internal TagChangeTracker(string tagName, IRtTag tag, int tagId) { this.historicValues = new ConcurrentQueue <HistoricTagValueRecord>(); this.historicValuesCache = new ConcurrentQueue <HistoricTagValueRecord>(); this.TagName = tagName; this.TagId = tagId; this.Enable = true; this.tag = tag; this.IsChanged(); }
internal TagRuleDefinition( TEvent eventId, TagRuleCheckType ruleCheckType, IRtTag tagExpression, double tolerance = 0.01, double discardValue = 0, Func <ITagRuleDefinition <TEvent>, bool> action = null, ILogger logger = null) { this.logger = logger ?? Configuration.Configuration.DefaultLogger; EventId = eventId; TagExpression = tagExpression; RuleCheckType = ruleCheckType; this.tolerance = tolerance; this.DiscardValue = discardValue; this.action = action; }
public void AddRule( TEvent eventId, TagRuleCheckType ruleCheckType, IRtTag tagExpression, double?tolerance = null, double?discardValue = null, Func <ITagRuleDefinition <TEvent>, bool> action = null) { var rule = new TagRuleDefinition <TEvent>(eventId, ruleCheckType, tagExpression, tolerance ?? defaultTolerance, discardValue ?? defaultDiscardValue, action ?? defaultAction, logger); tagRules.Add(rule); logger?.LogInformation("Add Rule [{0}] {1} TagName:[{2}] TagExpression:[{3}] Status:{4} Updated:{5} ", rule.EventId, rule.RuleCheckType, rule.TagExpression.TagName, rule.TagExpression, rule.TagExpression.Status, rule.TagExpression.Updated); }
} = "o"; // "yyyy/MM/dd HH:mm:ss.fff"; /// <summary> /// Obtiene DateTime del tag /// </summary> /// <param name="tag"></param> /// <param name="defaultDate"></param> /// <param name="dateFormat"></param> /// <returns></returns> public static DateTimeOffset GetDateTime(this IRtTag tag, DateTimeOffset?defaultDate = null, string dateFormat = null) { try { return(DateTimeOffset.ParseExact(tag.Value.Text, dateFormat ?? DefaultDateTimeFormat, System.Globalization.CultureInfo.InvariantCulture)); } catch (Exception e) { DateTimeOffset result; if (string.IsNullOrEmpty(dateFormat) && DateTimeOffset.TryParse(tag.Value.Text, out result)) { return(result); } return(defaultDate ?? throw e); } }
private IRtValue TryParseValue(IRtTag tag) { lock (this) { try { var parsed = tag.Value.Binary.Parser(TagBinaryDataParserPattern); Status = parsed != null && base.Status; return((parsed is string parserStr) ? RtValue.Create(parserStr) : RtValue.Create(Convert.ToDouble(parsed))); } catch { Status = false; return(RtValue.Create(string.Empty)); } } }
private IRtValue TryParseValue(IRtTag tag) { lock (this) { try { DateTimeOffset dt = tag.GetDateTime(); var parsed = string.Empty; switch (TagDateTimeValuePattern.ToUpper()) { case "UNIXTIMESTAMP": parsed = dt.LocalDateTime.ToUnixTimestamp().ToString(); break; case "UNIXTIMEMILLISECONDS": parsed = dt.ToUnixTimeMilliseconds().ToString(); break; case "UNIXTIMESECONDS": parsed = dt.ToUnixTimeSeconds().ToString(); break; default: parsed = dt.ToString(TagDateTimeValuePattern); break; } Status = !string.IsNullOrEmpty(parsed) && base.Status; return(RtValue.Create(parsed)); } catch { Status = false; return(RtValue.Create(string.Empty)); } } }
public static bool SetBinary(this IRtTag tag, byte[] value) { return(tag.Set(RtValue.Create(value))); }
public static bool SetText(this IRtTag tag, string value) { return(tag.Set(RtValue.Create(value))); }
public static bool SetNumeric(this IRtTag tag, double value) { return(tag.Set(RtValue.Create(value))); }
public RtTagType(IRtTag tag) : base(tag) { }
private static void OnUpdatedValue(object sender, IRtTag e) { logger.LogInformation($"+++++ OnUpdatedValue TagName:{e.Topic} Value:{e.Value} "); }
public RtTagBinaryDataParser(IRtTag tag, string dateTimePatter) : base(tag) { TagBinaryDataParserPattern = dateTimePatter; currentValueParsed = TryParseValue(tag); parsedTime = Updated; }
protected virtual void RaiseOnSetValue(IRtTag tag) { ValueSetted?.Invoke(this, tag); }
protected virtual void RaiseOnUpdatedValue(IRtTag tag) { ValueUpdated?.Invoke(this, tag); }
public abstract bool WriteValue(IRtTag tag, IRtValue value);
protected virtual void OnStatusChanged(object sender, IRtTag e) { StatusChanged?.Invoke(sender, this); }
/// <summary> /// Setea un DateTime al tag /// </summary> /// <param name="tag"></param> /// <param name="date"></param> /// <param name="dateFormat"></param> /// <returns></returns> public static bool SetDateTime(this IRtTag tag, DateTimeOffset date, string dateFormat = null) { return(tag.SetText(date.ToString(dateFormat ?? DefaultDateTimeFormat))); }
private static void Conn_ValueUpdated(object sender, IRtTag e) { logger.LogInformation($"+++++ Connection ValueUpdated TagName:{e.Topic} Value:{e.Value} "); }
/// <summary> /// Obtiene el Json Objeto del tag /// </summary> /// <typeparam name="T"></typeparam> /// <param name="tag"></param> /// <returns></returns> public static T GetJson <T>(this IRtTag tag) { return(JsonSerializer.Deserialize <T>(tag.Value.Text)); }
public RtTagRegex(IRtTag tag, string regexPattern) : base(tag) { TagRegexValuePattern = regexPattern; currentValueParsed = TryParseValue(tag.Value.Text); parsedTime = Updated; }
/// <summary> /// Setea el objecto Json al tag /// </summary> /// <param name="tag"></param> /// <param name="json"></param> /// <returns></returns> public static bool SetJson <T>(this IRtTag tag, T json) { return(tag.SetText(JsonSerializer.Serialize(json))); }
internal TagChangeTracker(IRtTag tag, string tagName) { this.TagName = tagName; this.tag = tag; this.IsChanged(); }
public RtTagJson(IRtTag tag, string jsonValuePattern) : base(tag) { TagJsonValuePattern = jsonValuePattern; currentValueParsed = TryParseValue(tag.Value.Text); parsedTime = Updated; }