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;
}
