static void PrintInterpolated(AFDatabase database, string meterName, string startTime, string endTime, TimeSpan timeSpan)
{
Console.WriteLine(string.Format("Print Interpolated Values - Meter: {0}, Start: {1}, End: {2}", meterName, startTime, endTime));
AFAttribute attr = AFAttribute.FindAttribute(@"\Meters\" + meterName + @"|Energy Usage", database);
AFTime start = new AFTime(startTime);
AFTime end = new AFTime(endTime);
AFTimeRange timeRange = new AFTimeRange(start, end);
AFTimeSpan interval = new AFTimeSpan(timeSpan);
AFValues vals = attr.Data.InterpolatedValues(
timeRange: timeRange,
interval: interval,
desiredUOM: null,
filterExpression: null,
includeFilteredValues: false);
foreach (AFValue val in vals)
{
Console.WriteLine("Timestamp (Local): {0}, Value: {1:0.00} {2}", val.Timestamp.LocalTime, val.Value, val?.UOM.Abbreviation);
}
Console.WriteLine();
}
public AFInterpolatedAttributeRetrievalClass(
AFAttribute attribute,
AFTimeRange timeRange,
AFTimeSpan timeSpan,
string outputDirectory,
PIRandomFunctionsUtil.TimeResolution timeResolution,
int numYears,
int pageSize = 200000,
Logger logger = null)
{
this.attribute = attribute;
this.tag = attribute.PIPoint;
if (tag == null)
{
throw new ArgumentException($"attribute PIPoint must be not null");
}
this.desiredUOM = attribute.DefaultUOM;
this.timeRange = timeRange;
this.timeSpan = timeSpan;
this.outputDirectory = outputDirectory;
this.timeResolution = timeResolution;
this.numYears = numYears;
this.pageSize = pageSize;
this.nextStartTime = timeRange.StartTime;
if (logger == null)
{
logger = new Logger();
}
this.logger = logger;
}
//Gets the array
private void composeArray()
{
this.aFTimeRange = new AFTimeRange(this.startDateTime, this.endDateTime);
//this.interval = new TimeSpan(0, 5, 0);
this.span = new AFTimeSpan(this.samplingInterval);
foreach (String windNodeTag in windNodePotentialTags)
{
PIPoint pi_point = PIPoint.FindPIPoint(this.piServer, windNodeTag);
//tagList.Add(pi_point.RecordedValues(aFTimeRange, OSIsoft.AF.Data.AFBoundaryType.Inside, "", false).ToString());
AFValues interpolated = pi_point.InterpolatedValues(this.aFTimeRange, this.span, "", false);
foreach (AFValue value in interpolated)
{
String[] temp = { windNodeTag, value.Value.ToString(), value.Timestamp.ToString() };
//Temp 0: Name of Wind Node Tag
//Temp 1: Value of the tag
//Temp 2: Time Stamp of the tag
Console.WriteLine(temp[0] + ", " + temp[1] + ", " + temp[2]);
this.valueList.Add(temp);
}
//this.rtu.setArray(this.valueList);
}
//this.rtu.sendToRTU();
}
static void PrintInterpolated(AFDatabase database, string meterName, string startTime, string endTime, TimeSpan timeSpan)
{
Console.WriteLine(string.Format("Print Interpolated Values - Meter: {0}, Start: {1}, End: {2}", meterName, startTime, endTime));
AFAttribute attr = AFAttribute.FindAttribute(@"\Meters\" + meterName + @"|Energy Usage", database);
AFTime start = new AFTime(startTime);
AFTime end = new AFTime(endTime);
AFTimeRange timeRange = new AFTimeRange(start, end);
AFTimeSpan interval = new AFTimeSpan(timeSpan);
AFValues vals = attr.Data.InterpolatedValues(
timeRange: timeRange,
interval: interval,
desiredUOM: null,
filterExpression: null,
includeFilteredValues: false);
foreach (AFValue val in vals)
{
Console.WriteLine("Timestamp (Local): {0}, Value (kWh): {1}", val.Timestamp.LocalTime, val.Value);
}
Console.WriteLine();
}
public PIValues GetInterpolatedValues(int i, string starttime, string endtime, string interval)
{
AFTime startTime = new AFTime(starttime);
AFTime endTime = new AFTime(endtime);
AFTimeRange timeRange = new AFTimeRange(startTime, endTime);
AFTimeSpan timeSpan = AFTimeSpan.Parse(interval);
AFValues myAFValues;
if (i == 1)
{
myAFValues = MyAtrbTag1.Data.InterpolatedValues(timeRange, timeSpan, null, null, false);
}
else if (i == 2)
{
myAFValues = MyAtrbTag2.Data.InterpolatedValues(timeRange, timeSpan, null, null, false);
}
else if (i == 3)
{
myAFValues = MyAtrbTag3.Data.InterpolatedValues(timeRange, timeSpan, null, null, false);
}
else if (i == 4)
{
myAFValues = MyAtrbTag4.Data.InterpolatedValues(timeRange, timeSpan, null, null, false);
}
else
{
myAFValues = MyAtrbTag5.Data.InterpolatedValues(timeRange, timeSpan, null, null, false);
}
return(ConvertToPIValues(myAFValues));
}
static void PrintInterpolated(AFDatabase database, string meterName, string start, string end, TimeSpan interval)
{
AFTime startTime = new AFTime(start);
AFTime endTime = new AFTime(end);
AFTimeRange timeRange = new AFTimeRange(startTime, endTime);
AFAttribute att = AFAttribute.FindAttribute(@"\Meters\" + meterName + @"|Energy Usage", database);
AFTimeSpan intervalNew = new AFTimeSpan(interval);
AFValues values = att.Data.InterpolatedValues(timeRange: timeRange, interval: intervalNew, desiredUOM: null, filterExpression: null, includeFilteredValues: false);
}
public PIValuesList GetInterpolatedValues(string startTime, string endTime, string interval)
{
AFTime start = new AFTime(startTime);
AFTime end = new AFTime(endTime);
AFTimeRange timeRange = new AFTimeRange(start, end);
AFTimeSpan timeSpan = AFTimeSpan.Parse(interval);
IEnumerable <AFValues> valueResults = pointList.InterpolatedValues(timeRange, timeSpan, string.Empty, false, new PIPagingConfiguration(PIPageType.TagCount, 100));
return(new PIValuesList(valueResults));
}
static void Main(string[] args)
{
var AFServerName = "SKYPI05";
var AFDatabaseName = "MBMC";
var user = @"skypi\lbowling";
var password = @"OFNxBKOZmG1w";
NetworkCredential credential = new NetworkCredential(user, password);
var piSystem = (new PISystems())[AFServerName];
piSystem.Connect(credential);
var afdb = piSystem.Databases[AFDatabaseName];
foreach (var item in afdb.Elements)
{
Console.WriteLine(item.Name);
}
var selectedElementName = "Element1";
var selectedElement = afdb.Elements[selectedElementName];
Console.WriteLine("Attributes for " + selectedElementName);
foreach (var attribute in selectedElement.Attributes)
{
Console.WriteLine(attribute.Name);
}
var selectedAttributeName = "Attribute1";
var selectedAttribute = selectedElement.Attributes[selectedAttributeName];
var start = DateTime.Today.AddDays(-1);
var end = start.AddDays(1);
var timeRange = new AFTimeRange(start, end);
var span = AFTimeSpan.Parse("1h");
//var afValues = selectedAttribute.Data.PlotValues(timeRange, 24, null);
//var afValues = selectedAttribute.Data.InterpolatedValues(timeRange, span, null, null, false);
var afValues = selectedAttribute.Data.RecordedValues(timeRange, OSIsoft.AF.Data.AFBoundaryType.Inside, null, null, false);
foreach (var afValue in afValues)
{
Console.WriteLine("Time: {0} \t Value: {1} \t", afValue.Timestamp, afValue.Value.ToString());
}
Console.WriteLine("Count: " + afValues.Count);
Console.ReadKey();
}
public static IDictionary<AFAttribute, AFValues> GetTotalsAsync(AFDatabase afDb)
{
AFAttributeList attributeList = GetAttributes(afDb);
// Beginning of current month to beginning of today.
Dictionary<AFAttribute, AFValues> totals = new Dictionary<AFAttribute, AFValues>();
AFTimeRange timeRange = new AFTimeRange(new AFTime(string.Format("{0}-{1}-01", DateTime.Now.Year, DateTime.Now.Month)), new AFTime("T"));
AFTimeSpan dayInterval = new AFTimeSpan(0, 0, 1);
List<Task<IDictionary<AFSummaryTypes, AFValues>>> processingList = new List<Task<IDictionary<AFSummaryTypes, AFValues>>>();
foreach (AFAttribute attribute in attributeList)
{
// Do not make the call if async is not supported
if ((attribute.SupportedDataMethods & AFDataMethods.Asynchronous) == 0)
continue;
try
{
processingList.Add(
attribute.Data.SummariesAsync(timeRange, dayInterval, AFSummaryTypes.Total, AFCalculationBasis.TimeWeighted, AFTimestampCalculation.Auto));
// periodically evaluate
if (processingList.Count > Environment.ProcessorCount * 2)
{
Task.WhenAll(processingList.ToArray());
foreach (var item in processingList)
{
WriteSummaryItem(item.Result[AFSummaryTypes.Total]);
}
processingList = new List<Task<IDictionary<AFSummaryTypes, AFValues>>>();
}
}
catch (AggregateException ae)
{
//if (ae.Flatten().InnerExceptions.Count == 1)
Console.WriteLine("{0}: {1}", attribute.Name, ae.Flatten().InnerException.Message);
}
}
if (processingList.Count > 0)
{
Task.WhenAll(processingList.ToArray());
foreach (var item in processingList)
{
WriteSummaryItem(item.Result[AFSummaryTypes.Total]);
}
}
return totals;
}
public static IDictionary<AFAttribute, AFValues> GetTotalsBulk(AFDatabase afDb)
{
AFAttributeList attributeList = GetAttributes(afDb);
Dictionary<AFAttribute, AFValues> totals = new Dictionary<AFAttribute, AFValues>();
AFTimeRange timeRange = new AFTimeRange(new AFTime(string.Format("{0}-{1}-01", DateTime.Now.Year, DateTime.Now.Month)), new AFTime("T"));
AFTimeSpan dayInterval = new AFTimeSpan(0, 0, 1);
PIPagingConfiguration pageConfig = new PIPagingConfiguration(PIPageType.TagCount, Environment.ProcessorCount * 2);
foreach (var item in attributeList.Data.Summaries(timeRange, dayInterval, AFSummaryTypes.Total, AFCalculationBasis.TimeWeighted, AFTimestampCalculation.Auto,
pageConfig))
{
WriteSummaryItem(item[AFSummaryTypes.Total]);
}
return totals;
}
public void GetPIData(string[] paths, string startTime, string endTime, string interval)
{
string[] correctPaths = paths.Select(m => m.Substring(3)).ToArray();
AFKeyedResults <string, AFAttribute> results = AFAttribute.FindAttributesByPath(correctPaths, null);
AFAttributeList attributeList = new AFAttributeList();
foreach (AFAttribute attribute in results)
{
attributeList.Add(attribute);
}
AFTime start = new AFTime(startTime);
AFTime end = new AFTime(endTime);
AFTimeRange timeRange = new AFTimeRange(start, end);
AFTimeSpan timeSpan = AFTimeSpan.Parse(interval);
IEnumerable <AFValues> valueResults = attributeList.Data.InterpolatedValues(timeRange, timeSpan, string.Empty, false, new PIPagingConfiguration(PIPageType.TagCount, 100));
piValuesList = new PIValuesList(valueResults);
}
private void btnRetrieveData_Click(object sender, EventArgs e)
{
try
{
lbData.Items.Clear();
AFAttribute selectedAttribute = lbAttributes.SelectedItem as AFAttribute;
AFTimeRange timeRange = new AFTimeRange(tbStartTime.Text, tbEndTime.Text);
AFValues vals = null;
switch (cbDataMethod.Text)
{
case "Recorded Values":
vals = selectedAttribute.Data.RecordedValues(timeRange, OSIsoft.AF.Data.AFBoundaryType.Inside, null, String.Empty, false, 0);
break;
case "Interpolated Values":
var interval = new AFTimeSpan();
AFTimeSpan.TryParse(tbInterval.Text, out interval);
vals = selectedAttribute.Data.InterpolatedValues(timeRange, interval, null, String.Empty, false);
break;
case "Snapshot":
vals = new AFValues();
vals.Add(selectedAttribute.Data.EndOfStream(null));
break;
default:
throw new InvalidExpressionException();
}
var valStrings = vals.Select(afv => String.Format("{0}\t{1}\t{2}\t{3}"
, afv.Attribute.Name
, afv.Timestamp.LocalTime
, afv.Value
, afv.UOM == null ? string.Empty : afv.UOM.Name));
lbData.Items.AddRange(valStrings.ToArray());
}
catch (Exception ex)
{
MessageBox.Show("Error getting PI Data: " + ex.Message);
}
}
public void GetPIData(string piDataArchiveName, string piPointName1, string piPointName2, string piPointName3, string startTime, string endTime, string interval)
{
IEnumerable <string> piPointNames = new List <string> {
piPointName1, piPointName2, piPointName3
};
PIServer piServer = new PIServers()[piDataArchiveName];
if (piServer == null)
{
return;
}
IList <PIPoint> points = PIPoint.FindPIPoints(piServer, piPointNames);
PIPointList pointList = new PIPointList(points);
AFTimeRange timeRange = new AFTimeRange(new AFTime(startTime), new AFTime(endTime));
AFTimeSpan timeSpan;
bool result = AFTimeSpan.TryParse(interval, out timeSpan);
if (result == false)
{
AFTimeSpan.TryParse("1h", out timeSpan);
}
IEnumerable <AFValues> valuesList = pointList.InterpolatedValues(timeRange, timeSpan, string.Empty, false, new PIPagingConfiguration(PIPageType.TagCount, 100));
foreach (AFValues values in valuesList)
{
if (values.PIPoint.Name == piPointName1)
{
values1 = values.Where(m => m.ValueTypeCode == TypeCode.Single || m.ValueTypeCode == TypeCode.Double).Select(m => m.ValueAsDouble()).ToArray();
}
else if (values.PIPoint.Name == piPointName2)
{
values2 = values.Where(m => m.ValueTypeCode == TypeCode.Single || m.ValueTypeCode == TypeCode.Double).Select(m => m.ValueAsDouble()).ToArray();
}
else if (values.PIPoint.Name == piPointName3)
{
values3 = values.Where(m => m.ValueTypeCode == TypeCode.Single || m.ValueTypeCode == TypeCode.Double).Select(m => m.ValueAsDouble()).ToArray();
}
}
}
public static IList <IDictionary <AFSummaryTypes, AFValues> > GetSummariesSync(AFAttributeList attributeList)
{
Console.WriteLine("Calling GetSummariesSync\n");
PIPagingConfiguration config = new PIPagingConfiguration(PIPageType.TagCount, 100);
try
{
AFSummaryTypes mySummaries = AFSummaryTypes.Minimum | AFSummaryTypes.Maximum | AFSummaryTypes.Average | AFSummaryTypes.Total;
AFTimeRange timeRange = new AFTimeRange(new AFTime("*-1d"), new AFTime("*"));
AFTimeSpan span = new AFTimeSpan(days: 1);
return(attributeList.Data.Summaries(timeRange, span,
mySummaries,
AFCalculationBasis.TimeWeighted,
AFTimestampCalculation.Auto,
config).ToList());
}
catch (AggregateException ae)
{
Console.WriteLine("{0}: {1}", attributeList.Count, ae.Flatten().InnerException.Message);
return(null);
}
}
public void GetInterpolatedTest()
{
// TODO uncomment below to test the method and replace null with proper value
string startTime = Constants.TIME_START;
string endTime = Constants.TIME_END;
string timeZone = null;
string interval = Constants.TIME_INTERVAL;
string desiredUnits = null;
string filterExpression = null;
bool includeFilteredValues = true;
string selectedFields = null;
var response = instance.GetInterpolated(webId, startTime: startTime, endTime: endTime, timeZone: timeZone, interval: interval, desiredUnits: desiredUnits, filterExpression: filterExpression, includeFilteredValues: includeFilteredValues, selectedFields: selectedFields);
Assert.IsInstanceOf <PITimedValues>(response, "response is PITimedValues");
AFTimeRange timeRange = new AFTimeRange(new AFTime(Constants.TIME_START), new AFTime(Constants.TIME_END));
AFTimeSpan timeSpan = AFTimeSpan.Parse(interval);
AFValues values = point.InterpolatedValues(timeRange, timeSpan, filterExpression, includeFilteredValues);
Assert.IsTrue(response.Items.Count > 10);
Assert.IsTrue(response.Items.Count == values.Count);
}
static void Main(string[] args)
{
NetworkCredential credential = new NetworkCredential(connectionInfo.user, connectionInfo.password);
var piSystem = (new PISystems())[connectionInfo.AFServerName];
Console.WriteLine($"connecting to : {connectionInfo.AFServerName} - {connectionInfo.AFDatabaseName}");
piSystem.Connect(credential);
var afdb = piSystem.Databases[connectionInfo.AFDatabaseName];
Console.WriteLine("connected");
var query = "Template:'Antimatter Relay' Name:T001";
var search = new AFElementSearch(afdb, "Relay Search", query);
var relay = search.FindElements(0, true, 1).FirstOrDefault();
if (relay != null)
{
var now = DateTime.Now;
//this will not work, the kind propery is not set and it treated as UTC
//var end = new DateTime(now.Year, now.Month, now.Day, now.Hour, 0, 0);
//the correct way to do it
var end = new DateTime(now.Year, now.Month, now.Day, now.Hour, 0, 0, DateTimeKind.Local);
var start = end.AddDays(-1);
AFTimeRange range = new AFTimeRange(start, end);
AFTimeSpan span = AFTimeSpan.Parse("1h");
var values = relay.Attributes["Ion Charge"].Data.InterpolatedValues(range, span, null, "", false);
foreach (var value in values)
{
Console.WriteLine($"value: {value.ValueAsDouble()} time: {value.Timestamp.ToString()}");
}
}
Console.WriteLine("completed execution");
Console.ReadKey();
}
public PIInterpolatedPointRetrievalClass(
PIPoint tag,
AFTimeRange timeRange,
AFTimeSpan timeSpan,
string outputDirectory,
PIRandomFunctionsUtil.TimeResolution timeResolution,
int numYears,
int pageSize = 200000,
Logger logger = null)
{
this.tag = tag;
this.timeRange = timeRange;
this.timeSpan = timeSpan;
this.nextStartTime = timeRange.StartTime;
this.outputDirectory = outputDirectory;
this.timeResolution = timeResolution;
this.numYears = numYears;
this.pageSize = pageSize;
if (logger == null)
{
logger = new Logger();
}
this.logger = logger;
}
public override AFValue GetValue(object context, object timeContext, AFAttributeList inputAttributes, AFValues inputValues)
{
// Declare Variables
AFTimeRange timeRange = new AFTimeRange();
AFTimeSpan span = new AFTimeSpan();
AFTime timeVal = new AFTime();
AFValue result = new AFValue();
//AFAttribute targetAttr = null;
AFAttribute targetAttr = inputAttributes[0];
bool useRecordedValue = false;
if (string.IsNullOrEmpty(ConfigString))
{
throw new Exception("ConfigString cannot be null or empty");
}
// ---------------------------------------------------------------------------------------------
// Parse the Time Context
// ---------------------------------------------------------------------------------------------
// Mimic AF Poi Point behaviour
// if TimeMethod is TimeRange, then apply the RelativeTime setting if the client supplys a single time (not a time range)
// If TimeMethod is TimeRangeOverride, then apply the relativeTime always
// If TimeMethod is NotSupported, then return an error message if the client sends a time instead of a timerange
//_timeMethod
switch (_timeMethod)
{
case RetrievalMethods.TimeRange:
if (timeContext is AFTime)
{
timeRange.EndTime = (AFTime)timeContext;
timeRange = ParseTimeRange(timeRange, _relativeTimeResolved);
}
else if (timeContext == null)
{
timeRange.EndTime = DateTime.Now;
timeRange = ParseTimeRange(timeRange, _relativeTimeResolved);
}
else
{
timeRange = (AFTimeRange)timeContext;
}
break;
case RetrievalMethods.TimeRangeOverride:
if (timeContext is AFTime)
{
timeRange.EndTime = (AFTime)timeContext;
}
else if (timeContext == null)
{
timeRange.EndTime = DateTime.Now;
}
else
{
// We use the end time of the time range and override the span.
timeRange.EndTime = ((AFTimeRange)timeContext).EndTime;
}
timeRange = ParseTimeRange(timeRange, _relativeTimeResolved);
break;
case RetrievalMethods.NotSupported:
if (timeContext is AFTime || timeContext == null)
{
throw new Exception("Not Supported");
}
else
{
timeRange = (AFTimeRange)timeContext;
}
break;
default:
// This is not a time range query. Just use recordedvalue
useRecordedValue = true;
if (timeContext is AFTime)
{
timeRange.EndTime = (AFTime)timeContext;
}
else if (timeContext == null)
{
timeRange.EndTime = DateTime.Now;
}
else
{
timeRange.EndTime = ((AFTimeRange)timeContext).EndTime;
}
break;
}
//------------------------------------------------------------------------------------------
//Query the archive
//------------------------------------------------------------------------------------------
if (useRecordedValue)
{
result = targetAttr.Data.RecordedValue(timeRange.EndTime, (AFRetrievalMode)_timeMethod, targetAttr.DefaultUOM);
}
else
{
//IDictionary<AFSummaryTypes, AFValue> value = targetAttr.Data.Summary(timeRange, AFSummaryTypes.All, _timeRangeBasis, _timestampCalculation);
IDictionary <AFSummaryTypes, AFValue> value = targetAttr.Data.Summary(timeRange, _timeRangeMethod | AFSummaryTypes.PercentGood, _timeRangeBasis, _timestampCalculation);
if (value[_timeRangeMethod].IsGood)
{
//Check the quality meets the min percent good rule
if (value[AFSummaryTypes.PercentGood].ValueAsSingle() >= _timeRangeMinPercentGood)
{
result = value[_timeRangeMethod];
//rate conversion for totals
if ((_timeRangeMethod == AFSummaryTypes.Total || _timeRangeMethod == AFSummaryTypes.TotalWithUOM) && _rateConversion != string.Empty)
{
result.Value = targetAttr.PISystem.UOMDatabase.UOMs[_rateConversion].Convert(value[_timeRangeMethod].ValueAsDouble(), targetAttr.PISystem.UOMDatabase.UOMs["day"]);
}
}
else
{
throw new Exception(String.Format("Value does not have the required percent good ({0}) over the time range in {1}|{2}. Parameter name: minPercentGood", _timeRangeMinPercentGood, this.Attribute.Element.Name, this.Attribute.Name));
}
}
else
{
throw new Exception((string)value[_timeRangeMethod].Value.ToString());
}
}
return(result);
}
public static int UpdateAttributeData(AFDatabase database)
{
AFAttributeList attributeList = GetAttributes(database);
AFTimeRange timeRange = new AFTimeRange(new AFTime(string.Format("{0}-{1}-01", DateTime.Now.Year, DateTime.Now.Month)), new AFTime("T"));
AFTimeSpan hourInterval = new AFTimeSpan(0, 0, 0, 1);
// Question: What risk is run by the following code?
List<Task<AFErrors<AFValue>>> processWrites = new List<Task<AFErrors<AFValue>>>();
foreach (AFAttribute attribute in attributeList)
{
AFValues vals = GenerateValueSequence(attribute, timeRange.StartTime, timeRange.EndTime, hourInterval);
processWrites.Add(attribute.Data.UpdateValuesAsync(vals, AFUpdateOption.Insert, AFBufferOption.DoNotBuffer));
}
int errorcount = 0;
try
{
Task.WaitAll(processWrites.ToArray());
foreach (var item in processWrites)
{
AFErrors<AFValue> errors = item.Result;
// Count PIPoint errors
if (errors != null && errors.HasErrors)
errorcount += errors.Errors.Count;
// Report PI Server, AF Server errors
}
}
catch (AggregateException ae)
{
}
return errorcount;
}
private void btnGetData(object sender, EventArgs e)
{
AFAttribute SelectedAttribute = lbAttributes.SelectedItem as AFAttribute;
AFTime starTime = new AFTime(tbStart.Text);
AFTime endTime = new AFTime(tbEnd.Text);
AFTimeRange timeRange = new AFTimeRange(starTime, endTime);
// get values from specified time range
UOM desiredUOM = cbUOM.SelectedItem as UOM;
// The desired consiulting mode
AFValues values;
switch (cbDataMethod.Text)
{
case "Recorded Values":
values = SelectedAttribute.Data.RecordedValues(timeRange
, AFBoundaryType.Interpolated
, desiredUOM
, null
, true);
break;
case "Interpolated Values":
values = SelectedAttribute.Data.InterpolatedValues(timeRange
, AFTimeSpan.Parse("5m")
, desiredUOM
, null
, true);
break;
case "Plot Values":
values = SelectedAttribute.Data.PlotValues(timeRange
, 300
, desiredUOM);
break;
default:
values = new AFValues();
break;
}
//AFValues Values = SelectedAttribute.GetValues(timeRange, 0, desiredUOM);
lbValues.Items.Clear();
if (values != null)
{
foreach (AFValue value in values)
{
String myStr = string.Format("{0} \t {1}, {2}"
, value.Timestamp.LocalTime
, value.Value
, value.UOM != null ? value.UOM.Abbreviation : null);
lbValues.Items.Add(myStr);
}
}
}
private static AFValues GenerateValueSequence(AFAttribute attribute, AFTime start, AFTime end, AFTimeSpan interval)
{
float zero = 100.0F;
float span = 360.0F;
AFValues values = new AFValues();
AFTime timestamp = start;
Random rnd = new Random((int)DateTime.Now.Ticks % 86400);
int idx = 1;
while (timestamp <= end)
{
values.Add(new AFValue(attribute, zero + (float)rnd.NextDouble() * span, timestamp));
timestamp = interval.Multiply(start, idx++);
}
return values;
}
public static List <AbstractRetrievePoints> LoadAttributeClassesInterpolated(
String inputFilePath,
String outputDirectory,
String timeResolution,
int numYears,
int pageSize,
PIServer piServer,
PISystem piSystem,
AFDatabase database,
int numParallelTasks,
Logger logger)
{
var inputLines = new List <String[]>();
using (var inputStreamReader = new StreamReader(inputFilePath))
{
while (!inputStreamReader.EndOfStream)
{
inputLines.Add(inputStreamReader.ReadLine().Split(','));
}
}
List <AbstractRetrievePoints> tagClasses = new List <AbstractRetrievePoints>();
Parallel.ForEach(
inputLines,
new ParallelOptions {
MaxDegreeOfParallelism = numParallelTasks
},
(String[] line) =>
{
string tagName = line[0];
string startTimeString = line[1];
string endTimeString = line[2];
string intervalString = line[3];
PIPoint tag;
try
{
AFAttribute attribute = AFUtil.FindAttribute(database, tagName);
tag = attribute.PIPoint;
AFTime startTime = new AFTime(startTimeString);
AFTime nextTime = AFQueryUtil.GetNextRecordedValue(tag, startTime).Timestamp;
if (nextTime > startTime)
{
startTime = new AFTime(nextTime.UtcTime.Date);
}
AFTime endTime = new AFTime(endTimeString);
AFTimeRange timeRange = new AFTimeRange(startTime, endTime);
AFTimeSpan timeSpan = new AFTimeSpan(TimeSpan.FromSeconds(Int32.Parse(intervalString)));
string startTimeStamp = startTime.UtcTime.ToString("yyyy/MM/dd HH:mm:ss");
string endTimeStamp = endTime.UtcTime.ToString("yyyy/MM/dd HH:mm:ss");
lock (logger) { logger.Log($"{startTimeStamp} : {timeSpan} : {endTimeStamp}, {tagName}"); }
lock (tagClasses)
{
tagClasses.Add(new AFInterpolatedAttributeRetrievalClass(
attribute,
timeRange,
timeSpan,
outputDirectory,
PIRandomFunctionsUtil.ParseTimeResolutionString(timeResolution),
numYears,
pageSize,
logger));
}
}
catch (Exception e)
{
logger.Log("Exception: could not FindPiPoint: " + e.ToString());
}
});
return(tagClasses);
}
internal void Execute(string command, PIPointList pointsList, AFTime st, AFTime et,
AFTimeSpan summaryDuration, string[] times, string addlparam1, PIServer myServer)
{
try
{
Console.WriteLine();
switch (command)
{
case "snap":
{
var sb = new StringBuilder();
sb.AppendLine($"Point Name(Point Id), Timestamp, Current Value");
sb.AppendLine(new string('-', 45));
AFListResults <PIPoint, AFValue> results = pointsList.EndOfStream();
if (results.HasErrors)
{
foreach (var e in results.Errors)
{
sb.AppendLine($"{e.Key}: {e.Value}");
}
}
foreach (var v in results.Results)
{
if (!results.Errors.ContainsKey(v.PIPoint))
{
sb.AppendLine($"{string.Concat($"{v.PIPoint.Name} ({v.PIPoint.ID})"),-15}," +
$" {v.Timestamp}, {v.Value}");
}
}
sb.AppendLine();
Console.Write(sb.ToString());
break;
}
case "arclist":
{
AFTimeRange timeRange = new AFTimeRange(st, et);
if (!Int32.TryParse(addlparam1, out int maxcount))
{
maxcount = 0;
}
// Holds the results keyed on the associated point
var resultsMap = new Dictionary <PIPoint, AFValues>();
var pagingConfig = new PIPagingConfiguration(PIPageType.TagCount, GlobalConfig.PageSize);
IEnumerable <AFValues> listResults = pointsList.RecordedValues(timeRange: timeRange,
boundaryType: AFBoundaryType.Inside,
filterExpression: null,
includeFilteredValues: false,
pagingConfig: pagingConfig,
maxCount: maxcount
);
foreach (var pointResults in listResults)
{
resultsMap[pointResults.PIPoint] = pointResults;
}
foreach (var pointValues in resultsMap)
{
var sb = new StringBuilder();
sb.AppendLine($"Point: {pointValues.Key} Archive Values " +
$"Count: {pointValues.Value.Count}");
sb.AppendLine(new string('-', 45));
pointValues.Value.ForEach(v => sb.AppendLine($"{v.Timestamp}, {v.Value}"));
sb.AppendLine();
Console.Write(sb.ToString());
}
break;
}
case "plot":
{
AFTimeRange timeRange = new AFTimeRange(st, et);
if (!Int32.TryParse(addlparam1, out int intervals))
{
intervals = 640; //horizontal pixels in the trend
}
var resultsMap = new Dictionary <PIPoint, AFValues>();
var pagingConfig = new PIPagingConfiguration(PIPageType.TagCount, GlobalConfig.PageSize);
IEnumerable <AFValues> listResults = pointsList.PlotValues(timeRange: timeRange,
intervals: intervals,
pagingConfig: pagingConfig
);
foreach (var pointResults in listResults)
{
resultsMap[pointResults.PIPoint] = pointResults;
}
foreach (var pointValues in resultsMap)
{
var sb = new StringBuilder();
sb.AppendLine($"Point: {pointValues.Key} Plot Values Interval: {intervals}" +
$" Count: {pointValues.Value.Count}");
sb.AppendLine(new string('-', 45));
pointValues.Value.ForEach(v => sb.AppendLine($"{v.Timestamp}, {v.Value}"));
sb.AppendLine();
Console.Write(sb.ToString());
}
break;
}
case "interp":
{
AFTimeRange timeRange = new AFTimeRange(st, et);
var resultsMap = new Dictionary <PIPoint, AFValues>();
var pagingConfig = new PIPagingConfiguration(PIPageType.TagCount, GlobalConfig.PageSize);
if (addlparam1.StartsWith("c="))
{
if (!Int32.TryParse(addlparam1.Substring(2), out int count))
{
count = 10; //default count
}
IEnumerable <AFValues> listResults = pointsList.InterpolatedValuesByCount(timeRange: timeRange,
numberOfValues: count,
filterExpression: null,
includeFilteredValues: false,
pagingConfig: pagingConfig
);
foreach (var pointResults in listResults)
{
resultsMap[pointResults.PIPoint] = pointResults;
}
foreach (var pointValues in resultsMap)
{
var sb = new StringBuilder();
sb.AppendLine($"Point: {pointValues.Key} Interpolated Values " +
$"Count: {pointValues.Value.Count}");
sb.AppendLine(new string('-', 45));
pointValues.Value.ForEach(v => sb.AppendLine($"{v.Timestamp}, {v.Value}"));
sb.AppendLine();
Console.Write(sb.ToString());
}
}
else
{
if (!AFTimeSpan.TryParse(addlparam1, out AFTimeSpan interval) || interval == new AFTimeSpan(0))
{
interval = summaryDuration;
}
IEnumerable <AFValues> listResults = pointsList.InterpolatedValues(timeRange: timeRange,
interval: interval,
filterExpression: null,
includeFilteredValues: false,
pagingConfig: pagingConfig
);
foreach (var pointResults in listResults)
{
resultsMap[pointResults.PIPoint] = pointResults;
}
foreach (var pointValues in resultsMap)
{
var sb = new StringBuilder();
sb.AppendLine($"Point: {pointValues.Key} Interpolated Values " +
$"Interval: {interval.ToString()}");
sb.AppendLine(new string('-', 45));
pointValues.Value.ForEach(v => sb.AppendLine($"{v.Timestamp}, {v.Value}"));
sb.AppendLine();
Console.Write(sb.ToString());
}
}
break;
}
case "summaries":
{
var resultsMap = new Dictionary <PIPoint, AFValues>();
var pagingConfig = new PIPagingConfiguration(PIPageType.TagCount, GlobalConfig.PageSize);
if (st > et) //summaries cannot handle reversed times
{
var temp = st;
st = et;
et = temp;
}
AFTimeRange timeRange = new AFTimeRange(st, et);
var intervalDefinitions = new AFTimeIntervalDefinition(timeRange, 1);
AFCalculationBasis calculationBasis = AFCalculationBasis.EventWeighted;
if (addlparam1 == "t")
{
calculationBasis = AFCalculationBasis.TimeWeighted;
}
foreach (var pt in pointsList)
{
var summaryType = AFSummaryTypes.All;
if (pt.PointType == PIPointType.Digital ||
pt.PointType == PIPointType.Timestamp ||
pt.PointType == PIPointType.Blob ||
pt.PointType == PIPointType.String ||
pt.PointType == PIPointType.Null)
{
summaryType = AFSummaryTypes.AllForNonNumeric;
}
IDictionary <AFSummaryTypes, AFValues> summaries = pt.Summaries(new List <AFTimeIntervalDefinition>()
{
intervalDefinitions
},
reverseTime: false,
summaryType: summaryType,
calcBasis: calculationBasis,
timeType: AFTimestampCalculation.Auto
);
var sb = new StringBuilder();
sb.AppendLine($"Point: {pt.Name} {calculationBasis} Summary");
sb.AppendLine(new string('-', 45));
foreach (var s in summaries)
{
AFValues vals = s.Value;
foreach (var v in vals)
{
if (v.Value.GetType() != typeof(PIException))
{
if (string.Compare(s.Key.ToString(), "Minimum", true) == 0 ||
string.Compare(s.Key.ToString(), "Maximum", true) == 0)
{
sb.AppendLine($"{s.Key,-16}: {v.Value,-20} {v.Timestamp}");
}
else
{
sb.AppendLine($"{s.Key,-16}: {v.Value}");
}
}
else
{
sb.AppendLine($"{s.Key,-16}: {v}");
}
}
}
sb.AppendLine();
Console.Write(sb.ToString());
}
/*
* Non numeric tags in pointsList requires splitting of queries so the above is preferred.
* The below implementation works when there are no non-numeric types or one particular summary needs to be run
*/
//var listResults = pointsList.Summaries(new List<AFTimeIntervalDefinition>() {
// intervalDefinitions },
// reverseTime: false,
// summaryTypes: AFSummaryTypes.All,
// calculationBasis: calculationBasis,
// timeType: AFTimestampCalculation.Auto,
// pagingConfig: pagingConfig
// );
//foreach (IDictionary<AFSummaryTypes, AFValues> summaries in listResults)
//{
// foreach (IDictionary<AFSummaryTypes, AFValues> pointResults in listResults)
// {
// AFValues pointValues = pointResults[AFSummaryTypes.Average];
// PIPoint point = pointValues.PIPoint;
// //Map the results back to the point
// resultsMap[point] = pointValues;
// }
//}
break;
}
case "update":
case "annotate":
{
string addlparam2 = string.Empty;
AFUpdateOption updateOption = AFUpdateOption.Replace;
AFBufferOption bufOption = AFBufferOption.BufferIfPossible;
AFValue val;
if (times.Length > 0)
{
addlparam1 = times[0];
if (times.Length > 1)
{
addlparam2 = times[1];
}
}
switch (addlparam1)
{
case "i":
updateOption = AFUpdateOption.Insert;
break;
case "nr":
updateOption = AFUpdateOption.NoReplace;
break;
case "ro":
updateOption = AFUpdateOption.ReplaceOnly;
break;
case "inc":
updateOption = AFUpdateOption.InsertNoCompression;
break;
case "rm":
updateOption = AFUpdateOption.Remove;
break;
}
switch (addlparam2)
{
case "dnb":
bufOption = AFBufferOption.DoNotBuffer;
break;
case "buf":
bufOption = AFBufferOption.Buffer;
break;
}
foreach (var pt in pointsList)
{
Console.WriteLine($"Point: {pt.Name} {command} ({updateOption} {bufOption})");
Console.WriteLine(new string('-', 45));
Console.Write("Enter timestamp: ");
var time = Console.ReadLine();
if (!AFTime.TryParse(time, out AFTime ts))
{
ParseArgs.PrintHelp("Invalid Timestamp");
break;
}
if (command == "update" ||
!(pt.RecordedValuesAtTimes(new List <AFTime>()
{
ts
}, AFRetrievalMode.Exact)[0].IsGood))
{
Console.Write("Enter new value: ");
var data = Console.ReadLine();
if (!Double.TryParse(data, out var value))
{
ParseArgs.PrintHelp("Invalid data");
break;
}
val = new AFValue(value, ts);
}
else
{
val = pt.RecordedValuesAtTimes(new List <AFTime>()
{
ts
}, AFRetrievalMode.Exact)[0];
}
if (command == "annotate")
{
Console.Write("Enter annotation: ");
var ann = Console.ReadLine();
pt.SetAnnotation(val, ann);
}
pt.UpdateValue(value: val, option: updateOption, bufferOption: bufOption);
Console.WriteLine($"Successfully {command}d");
}
Console.WriteLine();
break;
}
case "delete":
{
AFTimeRange timeRange = new AFTimeRange(st, et);
if (myServer.Supports(PIServerFeature.DeleteRange))
{
foreach (var pt in pointsList)
{
int delcount = 0;
var sb = new StringBuilder();
var intervalDefinitions = new AFTimeIntervalDefinition(timeRange, 1);
//getting the count of events - optional
IDictionary <AFSummaryTypes, AFValues> summaries = pt.Summaries(new List <AFTimeIntervalDefinition>()
{
intervalDefinitions
},
reverseTime: false,
summaryType: AFSummaryTypes.Count,
calcBasis: AFCalculationBasis.EventWeighted,
timeType: AFTimestampCalculation.Auto
);
foreach (var s in summaries)
{
AFValues vals = s.Value;
vals = s.Value;
foreach (var v in vals)
{
if (v.Value.GetType() != typeof(PIException))
{
delcount = v.ValueAsInt32(); //count
}
}
}
if (delcount > 0)
{
var errs = pt.ReplaceValues(timeRange, new List <AFValue>()
{
});
if (errs != null)
{
foreach (var e in errs.Errors)
{
sb.AppendLine($"{e.Key}: {e.Value}");
delcount--;
}
}
}
sb.AppendLine($"Point: {pt.Name} Deleted {delcount} events");
sb.AppendLine(new string('-', 45));
sb.AppendLine();
Console.Write(sb.ToString());
}
}
else
{
foreach (var pt in pointsList)
{
int delcount = 0;
var sb = new StringBuilder();
AFValues vals = pt.RecordedValues(timeRange: timeRange,
boundaryType: AFBoundaryType.Inside,
filterExpression: null,
includeFilteredValues: false,
maxCount: 0
);
delcount = vals.Count;
if (delcount > 0)
{
var errs = pt.UpdateValues(values: vals,
updateOption: AFUpdateOption.Remove,
bufferOption: AFBufferOption.BufferIfPossible);
if (errs != null)
{
foreach (var e in errs.Errors)
{
sb.AppendLine($"{e.Key}: {e.Value}");
delcount--;
}
}
}
sb.AppendLine($"Point: {pt.Name} Deleted {delcount} events");
sb.AppendLine(new string('-', 45));
sb.AppendLine();
Console.Write(sb.ToString());
}
}
break;
}
case "sign,t":
{
Dictionary <PIPoint, int> errPoints = pointsList.ToDictionary(key => key, value => 0);
//if (Int32.TryParse(myServer.ServerVersion.Substring(4, 3), out int srvbuild) && srvbuild >= 395);
if (myServer.Supports(PIServerFeature.TimeSeriesDataPipe))
{
PIDataPipe timeSeriesDatapipe = new PIDataPipe(AFDataPipeType.TimeSeries);
Console.WriteLine("Signing up for TimeSeries events");
var errs = timeSeriesDatapipe.AddSignups(pointsList);
if (errs != null)
{
foreach (var e in errs.Errors)
{
Console.WriteLine($"Failed timeseries signup: {e.Key}, {e.Value.Message}");
errPoints[e.Key]++;
}
foreach (var ep in errPoints)
{
if (ep.Value >= 1)
{
pointsList.Remove(ep.Key);
}
}
if (pointsList.Count == 0)
{
ParseArgs.PrintHelp("No valid PI Points");
if (timeSeriesDatapipe != null)
{
timeSeriesDatapipe.Close();
timeSeriesDatapipe.Dispose();
}
return;
}
}
timeSeriesDatapipe.Subscribe(new DataPipeObserver("TimeSeries"));
Console.WriteLine("Subscribed Points (current value): ");
AFListResults <PIPoint, AFValue> results = pointsList.EndOfStream();
if (results.HasErrors)
{
foreach (var e in results.Errors)
{
Console.WriteLine($"{e.Key}: {e.Value}");
}
}
foreach (var v in results.Results)
{
if (!results.Errors.ContainsKey(v.PIPoint))
{
Console.WriteLine($"{v.PIPoint.Name,-12}, {v.Timestamp}, {v.Value}");
}
}
Console.WriteLine(new string('-', 45));
//Fetch timeseries events till user termination
while (!GlobalConfig.CancelSignups)
{
timeSeriesDatapipe.GetObserverEvents(GlobalConfig.PipeMaxEvtCount, out bool hasMoreEvents);
Thread.Sleep(GlobalConfig.PipeCheckFreq);
}
Console.WriteLine("Cancelling signups ...");
if (timeSeriesDatapipe != null)
{
timeSeriesDatapipe.Close();
timeSeriesDatapipe.Dispose();
}
}
else
{
ParseArgs.PrintHelp($"Time series not supported in Archive version {myServer.ServerVersion}");
}
break;
}
case "sign,as":
case "sign,sa":
case "sign,a":
case "sign,s":
{
bool snapSubscribe = false;
bool archSubscribe = false;
PIDataPipe snapDatapipe = null;
PIDataPipe archDatapipe = null;
Dictionary <PIPoint, int> errPoints = pointsList.ToDictionary(key => key, value => 0);
if (command.Substring(5).Contains("s"))
{
snapSubscribe = true;
snapDatapipe = new PIDataPipe(AFDataPipeType.Snapshot);
Console.WriteLine("Signing up for Snapshot events");
var errs = snapDatapipe.AddSignups(pointsList);
snapDatapipe.Subscribe(new DataPipeObserver("Snapshot"));
if (errs != null)
{
foreach (var e in errs.Errors)
{
Console.WriteLine($"Failed snapshot signup: {e.Key}, {e.Value.Message}");
errPoints[e.Key]++;
}
}
}
if (command.Substring(5).Contains("a"))
{
archSubscribe = true;
archDatapipe = new PIDataPipe(AFDataPipeType.Archive);
Console.WriteLine("Signing up for Archive events");
var errs = archDatapipe.AddSignups(pointsList);
if (errs != null)
{
foreach (var e in errs.Errors)
{
Console.WriteLine($"Failed archive signup: {e.Key}, {e.Value.Message}");
errPoints[e.Key]++;
}
}
archDatapipe.Subscribe(new DataPipeObserver("Archive "));
}
//remove unsubscribable points
int errorLimit = snapSubscribe ? 1 : 0;
if (archSubscribe)
{
errorLimit++;
}
foreach (var ep in errPoints)
{
if (ep.Value >= errorLimit)
{
pointsList.Remove(ep.Key);
}
}
if (pointsList.Count == 0)
{
ParseArgs.PrintHelp("No valid PI Points");
if (snapDatapipe != null)
{
snapDatapipe.Close();
snapDatapipe.Dispose();
}
if (archDatapipe != null)
{
archDatapipe.Close();
archDatapipe.Dispose();
}
return;
}
Console.WriteLine("Subscribed Points (current value): ");
//foreach (var p in pointsList)
//{
// Console.WriteLine($"{p.Name,-12}, {p.EndOfStream().Timestamp}, {p.EndOfStream()}");
//}
AFListResults <PIPoint, AFValue> results = pointsList.EndOfStream();
if (results.HasErrors)
{
foreach (var e in results.Errors)
{
Console.WriteLine($"{e.Key}: {e.Value}");
}
}
foreach (var v in results.Results)
{
if (!results.Errors.ContainsKey(v.PIPoint))
{
Console.WriteLine($"{v.PIPoint.Name,-12}, {v.Timestamp}, {v.Value}");
}
}
Console.WriteLine(new string('-', 45));
//Fetch events from the data pipes
while (!GlobalConfig.CancelSignups)
{
if (snapSubscribe)
{
snapDatapipe.GetObserverEvents(GlobalConfig.PipeMaxEvtCount, out bool hasMoreEvents1);
}
if (archSubscribe)
{
archDatapipe.GetObserverEvents(GlobalConfig.PipeMaxEvtCount, out bool hasMoreEvents2);
}
Thread.Sleep(GlobalConfig.PipeCheckFreq);
}
Console.WriteLine("Cancelling signups ...");
if (snapDatapipe != null)
{
snapDatapipe.Close();
snapDatapipe.Dispose();
}
if (archDatapipe != null)
{
archDatapipe.Close();
archDatapipe.Dispose();
}
}
break;
}
Console.WriteLine(new string('~', 45));
}
catch (Exception ex)
{
ParseArgs.PrintHelp(ex.Message);
if (myServer != null)
{
myServer.Disconnect();
if (GlobalConfig.Debug)
{
Console.WriteLine($"Disconnecting from {myServer.Name}");
}
}
}
}
public void InterpolatedValues(WAFTime start, WAFTime end, string interval, string filterExp, bool includeFiltVals, ref WAFValue[] values)
{
List<WAFValue> retVals = null;
try
{
AFTimeRange range = new AFTimeRange(start.ToString(), end.ToString());
AFTimeSpan span = new AFTimeSpan();
if (!AFTimeSpan.TryParse(interval, out span))
{
span = AFTimeSpan.Parse("1h");
}
AFValues vals = m_Pipt.InterpolatedValues(range, span, filterExp, includeFiltVals);
retVals = vals.ConvertAll(new Converter<AFValue, WAFValue>(WAFValue.AFValueToWAFValue));
}
catch (Exception ex)
{
System.Console.WriteLine(ex.Message);
}
values = retVals.ToArray();
return;
}
static void Main(string[] args)
{
Console.WriteLine(new string('~', 45));
if (GlobalConfig.Debug)
{
Console.WriteLine($"Main thread: {Thread.CurrentThread.ManagedThreadId}");
}
if (GlobalConfig.Debug)
{
Console.WriteLine($"Args length: {args.Length}");
}
var commandsList = new List <string>()
{
"snap",
"sign,a",
"sign,s",
"sign,sa",
"sign,as",
"sign,t",
"arclist",
"interp",
"plot",
"summaries",
"update",
"annotate",
"delete"
};
var pointsList = new PIPointList();
var command = String.Empty;
var startTime = String.Empty;
var endTime = String.Empty;
var serverName = String.Empty;
var addlparam1 = string.Empty;
var tagMasks = new string[] { };
var times = new string[] { };
var summaryDuration = new AFTimeSpan(TimeSpan.FromMinutes(10));
var st = new AFTime();
var et = new AFTime();
PIServer myServer;
try
{
var AppplicationArgs = new ParseArgs(args);
if (!AppplicationArgs.CheckHelpVersionOrEmpty())
{
return;
}
if (!AppplicationArgs.CheckCommandExists(commandsList, out command))
{
return;
}
if (!AppplicationArgs.GetTagNames(out tagMasks))
{
return;
}
if (!AppplicationArgs.GetAddlParams(command, ref times, ref startTime, ref endTime, ref addlparam1, ref serverName))
{
return;
}
}
catch (Exception ex)
{
ParseArgs.PrintHelp(ex.Message);
return;
}
#region Connect Server, Verify Times and Points
if (!String.IsNullOrEmpty(startTime) && !String.IsNullOrEmpty(endTime))
{
if (!AFTime.TryParse(startTime, out st))
{
ParseArgs.PrintHelp($"Invalid start time {startTime}");
return;
}
if (!AFTime.TryParse(endTime, out et))
{
ParseArgs.PrintHelp($"Invalid end time {endTime}");
return;
}
if (st == et) //same time or min case (from initialization)
{
ParseArgs.PrintHelp("Incorrect or same time interval specified");
return;
}
}
try
{
PIServers myServers = new PIServers();
if (string.IsNullOrEmpty(serverName))
{
if (GlobalConfig.Debug)
{
Console.WriteLine("Attempting connection to default server ...");
}
myServer = myServers.DefaultPIServer;
}
else if (myServers.Contains(serverName))
{
if (GlobalConfig.Debug)
{
Console.WriteLine($"Attempting connection to {serverName} server ...");
}
myServer = myServers[serverName];
}
else
{
ParseArgs.PrintHelp($"Server {serverName} not found in KST");
return;
}
if (myServer != null)
{
myServer.ConnectionInfo.Preference = AFConnectionPreference.Any;
myServer.Connect();
Console.WriteLine($"Connected to {myServer.Name} as {myServer.CurrentUserIdentityString}");
}
}
catch (Exception ex)
{
ParseArgs.PrintHelp("Server Connection error: " + ex.Message);
return;
}
try
{
//foreach (var n in tagMasks)
//{
// if (PIPoint.TryFindPIPoint(myServer, n, out PIPoint p))
// {
// if (!pointsList.Contains(p)) pointsList.Add(p);
// else Console.WriteLine($"Duplicate point {p.Name}");
// }
// else
// {
// Console.WriteLine($"Point {n} not found");
// }
//}
pointsList.AddRange(PIPoint.FindPIPoints(myServer, new List <string>(tagMasks), null));
if (pointsList.Count == 0)
{
ParseArgs.PrintHelp("No valid PI Points");
myServer.Disconnect();
return;
}
}
catch (Exception ex)
{
ParseArgs.PrintHelp("Tagmask error " + ex.Message);
return;
}
#endregion
//Handle KeyPress event from the user
Console.CancelKeyPress += (sender, eventArgs) =>
{
if (GlobalConfig.Debug)
{
Console.WriteLine(Thread.CurrentThread.ManagedThreadId);
}
Console.WriteLine();
Console.WriteLine("Program termination received from user ...");
if (command == "sign,s" || command == "sign,as" || command == "sign,sa" || command == "sign,a" || command == "sign,t")
{
GlobalConfig.CancelSignups = true;
Thread.Sleep(Convert.ToInt32(GlobalConfig.PipeCheckFreq * 1.2));
}
else
{
if (myServer != null)
{
myServer.Disconnect();
}
Console.WriteLine(new string('~', 45));
}
};
var Exec = new ExecuteCommand();
if (GlobalConfig.Debug)
{
Console.WriteLine($"Command executing: {command}");
}
Exec.Execute(command, pointsList, st, et, summaryDuration, times, addlparam1, myServer);
bool isexec = true;
if (myServer != null)
{
myServer.Disconnect();
if (GlobalConfig.Debug)
{
Console.WriteLine($"Disconnecting from {myServer.Name}");
}
}
if (!isexec)
{
Console.WriteLine(new string('~', 45));
}
}
public override IDictionary <AFSummaryTypes, AFValues> Summaries(AFTimeRange timeRange, AFTimeSpan summaryDuration, AFSummaryTypes summaryType, AFCalculationBasis calcBasis, AFTimestampCalculation timeType)
{
AFAttribute targetAttr = this.GetAttribute(_targetAttributeName);
return(targetAttr.Data.Summaries(timeRange, summaryDuration, summaryType, calcBasis, timeType));
}
