static void SwitchToJapanese(AFDatabase db)
{
AFTable translations = createOrReturnTranslationLibrary(db);
// Get all elements and all attributes
foreach (AFElement element in db.Elements)
{
translateElementAndChild(element, translations.Table);
db.CheckIn();
}
// Get all tables
foreach (AFTable table in db.Tables)
{
if (table != translations)
{
translateTableHeaders(table, translations.Table);
}
}
db.CheckIn();
foreach (AFElementTemplate elementTemplate in db.ElementTemplates)
{
translateElementTemplate(elementTemplate, translations.Table, db);
//insert(translations.Table, elemtemplate.NamingPattern);
db.CheckIn();
}
}
private static AFAttributeList GetAttributes(AFDatabase database)
{
int startIndex = 0;
int pageSize = 1000;
int totalCount;
AFAttributeList attrList = new AFAttributeList();
do
{
AFAttributeList results = AFAttribute.FindElementAttributes(
database: database,
searchRoot: null,
nameFilter: null,
elemCategory: null,
elemTemplate: database.ElementTemplates["Feeder"],
elemType: AFElementType.Any,
attrNameFilter: "Power",
attrCategory: null,
attrType: TypeCode.Empty,
searchFullHierarchy: true,
sortField: AFSortField.Name,
sortOrder: AFSortOrder.Ascending,
startIndex: startIndex,
maxCount: pageSize,
totalCount: out totalCount);
attrList.AddRange(results);
startIndex += pageSize;
} while (startIndex < totalCount);
return attrList;
}
public void RemoveReferencedElementTest()
{
AddReferencedElementTest();
string path = Constants.AF_DATABASE_PATH;
AFDatabase db = AFObject.FindObject(path) as AFDatabase;
db.Refresh();
if (db != null)
{
Assert.IsNotNull(db.Elements[Constants.AF_ELEMENT_NAME + "Child1"]);
Assert.IsNotNull(db.Elements[Constants.AF_ELEMENT_NAME + "Child2"]);
}
string path1 = Constants.AF_ELEMENT_PATH + @"\" + Constants.AF_ELEMENT_NAME + "Child1";
string path2 = Constants.AF_ELEMENT_PATH + @"\" + Constants.AF_ELEMENT_NAME + "Child2";
string webId1 = client.Element.GetByPath(path1).WebId;
string webId2 = client.Element.GetByPath(path2).WebId;
List <string> referencedElementWebId = new List <string>()
{
webId1, webId2
};
instance.RemoveReferencedElement(webId, referencedElementWebId);
db.Refresh();
if (db != null)
{
Assert.IsNull(db.Elements[Constants.AF_ELEMENT_NAME + "Child1"]);
Assert.IsNull(db.Elements[Constants.AF_ELEMENT_NAME + "Child2"]);
}
}
static void CreateEventFrames(AFDatabase database, AFElementTemplate eventFrameTemplate)
{
string queryString = "Template:MeterBasic";
{
// This method returns the collection of AFBaseElement objects that were created with this template.
using (AFElementSearch elementQuery = new AFElementSearch(database, "Meters", queryString))
{
DateTime timeReference = DateTime.Today.AddDays(-7);
int count = 0;
foreach (AFElement meter in elementQuery.FindElements())
{
foreach (int day in Enumerable.Range(1, 7))
{
AFTime startTime = new AFTime(timeReference.AddDays(day - 1));
AFTime endTime = new AFTime(startTime.LocalTime.AddDays(1));
AFEventFrame ef = new AFEventFrame(database, "*", eventFrameTemplate);
ef.SetStartTime(startTime);
ef.SetEndTime(endTime);
ef.PrimaryReferencedElement = meter;
// It is good practice to periodically check in the database
if (++count % 500 == 0)
{
database.CheckIn();
}
}
}
}
}
if (database.IsDirty)
{
database.CheckIn();
}
}
private static void CreateCategories(AFDatabase database)
{
if (database == null)
{
return;
}
if (!database.ElementCategories.Contains("Measures Energy"))
{
database.ElementCategories.Add("Measures Energy");
}
if (!database.ElementCategories.Contains("Shows Status"))
{
database.ElementCategories.Add("Shows Status");
}
if (!database.AttributeCategories.Contains("Building Info"))
{
database.AttributeCategories.Add("Building Info");
}
if (!database.AttributeCategories.Contains("Location"))
{
database.AttributeCategories.Add("Location");
}
if (!database.AttributeCategories.Contains("Time-Series Data"))
{
database.AttributeCategories.Add("Time-Series Data");
}
database.CheckIn();
}
public void afDatabasePicker1_SelectionChange(object sender, OSIsoft.AF.UI.SelectionChangeEventArgs e)
{
afTreeView1.AFRoot = null;
myAFDatabase = (AFDatabase)e.SelectedObject;
if (myAFDatabase != null)
{
//Clear ListBoxes
EFListView.Items.Clear();
EFAttrView.Items.Clear();
chart1.Series.Clear();
//Populate the AF Treeview with Elements only.
afTreeView1.AFRoot = myAFDatabase.Elements;
//Put Element Template Name to ComboBox
EventFrameTemplateComboBox.Items.Clear();
myElementTemplates = myAFDatabase.ElementTemplates;
foreach (AFElementTemplate myElementTemplate in myElementTemplates)
{
if (myElementTemplate.InstanceType.Name == "AFEventFrame")
{
EventFrameTemplateComboBox.Items.Add(myElementTemplate.Name);
//Adding selected item
EventFrameTemplateComboBox.SelectedItem = myElementTemplate.Name;
}
}
}
}
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();
}
private static AFAttributeList GetAttributes(AFDatabase database)
{
int startIndex = 0;
int pageSize = 1000;
int totalCount;
AFAttributeList attrList = new AFAttributeList();
do
{
AFAttributeList results = AFAttribute.FindElementAttributes(
database: database,
searchRoot: null,
nameFilter: null,
elemCategory: null,
elemTemplate: database.ElementTemplates["Feeder"],
elemType: AFElementType.Any,
attrNameFilter: "Power",
attrCategory: null,
attrType: TypeCode.Empty,
searchFullHierarchy: true,
sortField: AFSortField.Name,
sortOrder: AFSortOrder.Ascending,
startIndex: startIndex,
maxCount: pageSize,
totalCount: out totalCount);
attrList.AddRange(results);
startIndex += pageSize;
} while (startIndex < totalCount);
return(attrList);
}
static void PrintHourlyAverage(AFDatabase database, string meterName, string startTime, string endTime)
{
Console.WriteLine(string.Format("Print Hourly Average - 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);
IDictionary <AFSummaryTypes, AFValues> vals = attr.Data.Summaries(
timeRange: timeRange,
summaryDuration: new AFTimeSpan(TimeSpan.FromHours(1)),
summaryType: AFSummaryTypes.Average,
calcBasis: AFCalculationBasis.TimeWeighted,
timeType: AFTimestampCalculation.EarliestTime);
foreach (AFValue val in vals[AFSummaryTypes.Average])
{
Console.WriteLine("Timestamp (Local): {0:yyyy-MM-dd HH\\h}, Value: {1:0.00} {2}", val.Timestamp.LocalTime, val.Value, val?.UOM.Abbreviation);
}
Console.WriteLine();
}
public void afDatabasePicker1_SelectionChange(object sender, OSIsoft.AF.UI.SelectionChangeEventArgs e)
{
afTreeView1.AFRoot = null;
myAFDatabase = (AFDatabase)e.SelectedObject;
if (myAFDatabase != null)
{
//Clear ListBoxes
EFListView.Items.Clear();
EFAttrView.Items.Clear();
chart1.Series.Clear();
//Populate the AF Treeview with Elements only.
afTreeView1.AFRoot = myAFDatabase.Elements;
//Put Element Template Name to ComboBox
EventFrameTemplateComboBox.Items.Clear();
myElementTemplates = myAFDatabase.ElementTemplates;
foreach (AFElementTemplate myElementTemplate in myElementTemplates)
{
if (myElementTemplate.InstanceType.Name == "AFEventFrame")
{
EventFrameTemplateComboBox.Items.Add(myElementTemplate.Name);
//Adding selected item
EventFrameTemplateComboBox.SelectedItem = myElementTemplate.Name;
}
}
}
}
static void Main(string[] args)
{
AFDatabase db = ConnectionHelper.GetDatabase("PISRV01", "Feeder Voltage Monitoring");
AFAttributeList attrList = GetAttributes(db);
try
{
Task <IList <IDictionary <AFSummaryTypes, AFValue> > > summariesTask = AFAsyncDataReader.GetSummariesAsync(attrList);
// Wait for the summaries result
IList <IDictionary <AFSummaryTypes, AFValue> > summaries = summariesTask.Result;
foreach (var summary in summaries)
{
WriteSummaryItem(summary);
}
}
catch (AggregateException ae)
{
Console.WriteLine("{0}", ae.Flatten().InnerException.Message);
}
Console.WriteLine("Press any key to quit");
Console.ReadKey();
}
private static void CreateWeakReferences(AFDatabase database)
{
if (database == null)
{
return;
}
AFReferenceType weakRefType = database.ReferenceTypes["Weak Reference"];
AFElement meters = database.Elements["Meters"];
AFElement locations = database.Elements["Geographical Locations"];
AFElementTemplate cityTemplate = database.ElementTemplates["City"];
foreach (AFElement meter in meters.Elements)
{
string cityName = meter.Attributes["City"].GetValue().ToString();
if (string.IsNullOrEmpty(cityName))
{
continue;
}
AFElement city = locations.Elements[cityName];
if (city == null)
{
locations.Elements.Add(cityName, cityTemplate);
}
if (!city.Elements.Contains(meter.Name))
{
city.Elements.Add(meter, weakRefType);
}
}
if (database.IsDirty)
{
database.CheckIn();
}
}
private static void CreateCategories(AFDatabase database)
{
if (database == null)
{
return;
}
var items = new List <string>
{
"Measures Energy",
"Shows Status",
"Building Info",
"Location",
"Time - Series Data"
};
foreach (var item in items)
{
if (!database.ElementCategories.Contains(item))
{
database.ElementCategories.Add(item);
}
}
if (database.IsDirty)
{
database.CheckIn();
}
}
static void Main(string[] args)
{
// This factory method is new in 2.8.
PISystem ps = PISystem.CreatePISystem("PISRV01");
using (new AFProbe("PrintAttributeCounts", ps))
{
AFDatabase db = ps.Databases["Feeder Voltage Monitoring"];
// Build search object
AFSearchToken searchToken = new AFSearchToken(
filter: AFSearchFilter.Root,
searchOperator: AFSearchOperator.Equal,
value: db.Elements["Assets"].GetPath());
AFElementSearch elementSearch = new AFElementSearch(db, "Feeders and Transformers", new[] { searchToken });
Console.WriteLine("Feeders and Transformers");
// Use full load: true to fully load the elements
foreach (AFElement element in elementSearch.FindElements(fullLoad: true))
{
Console.WriteLine("Element: {0}, # Attributes: {1}", element.Name, element.Attributes.Count);
}
Console.WriteLine();
}
Console.WriteLine();
Console.WriteLine("Press any key to quit");
Console.ReadKey();
}
private static void CreateMeterAdvancedTemplate(AFElementTemplate meterBasicTemplate)
{
AFDatabase database = meterBasicTemplate.Database;
AFElementTemplate meterAdvancedTemplate = database.ElementTemplates["MeterAdvanced"];
if (meterAdvancedTemplate == null)
{
database.ElementTemplates.Add("MeterAdvanced");
}
AFCategory tsDataA = database.AttributeCategories["Time-Series Data"];
AFEnumerationSet mStatusEnum = database.EnumerationSets["Meter Status"];
meterAdvancedTemplate.BaseTemplate = meterBasicTemplate;
AFAttributeTemplate statusAttrTemp = meterAdvancedTemplate.AttributeTemplates["Status"];
if (statusAttrTemp == null)
{
meterAdvancedTemplate.AttributeTemplates.Add("Status");
}
statusAttrTemp.TypeQualifier = mStatusEnum;
if (!statusAttrTemp.Categories.Contains(tsDataA))
{
statusAttrTemp.Categories.Add(tsDataA);
}
statusAttrTemp.DataReferencePlugIn = database.PISystem.DataReferencePlugIns["PI Point"];
statusAttrTemp.ConfigString = @"\\%@\Configuration|PIDataArchiveName%\%Element%.%Attribute%";
}
private AFElementTemplate CreateEventFrameTemplate(AFDatabase db)
{
AFElementTemplate evTemplate = db.ElementTemplates[Constants.AF_EVENT_FRAME_TEMPLATE_NAME];
if (evTemplate == null)
{
evTemplate = db.ElementTemplates.Add("TankEventFrameTemplate");
evTemplate.Description = "Tank Event Frame Template!";
evTemplate.InstanceType = typeof(AFEventFrame);
AFAttributeTemplate Level = evTemplate.AttributeTemplates.Add("Level");
Level.Type = typeof(double);
Level.DataReferencePlugIn = Level.PISystem.DataReferencePlugIns["PI Point"];
Level.ConfigString = @".\Elements[.]|Level";
Level.Description = "Level of the tank";
Level.DefaultUOM = _piSystem.UOMDatabase.UOMClasses["Ratio"].UOMs["percent"];
AFAttributeTemplate Pressure = evTemplate.AttributeTemplates.Add("Pressure");
Pressure.Type = typeof(double);
Pressure.DataReferencePlugIn = Level.PISystem.DataReferencePlugIns["PI Point"];
Pressure.ConfigString = @".\Elements[.]|Pressure;TimeRangeMethod=StartTime";
Pressure.Description = "Pressure of the tank";
Pressure.DefaultUOM = _piSystem.UOMDatabase.UOMClasses["Pressure"].UOMs["pascal"];
evTemplate.DefaultAttribute = Level;
}
return(evTemplate);
}
private AFAnalysisTemplate CreateAnalysisTemplate(AFDatabase db)
{
var analysisTemplate = db.AnalysisTemplates.Add(Constants.AF_ANALYSIS_TEMPLATE_NAME);
analysisTemplate.Description = "This is the old analysis template swagger description";
return(analysisTemplate);
}
static void Main(string[] args)
{
PISystems myPISystems = new PISystems();
PISystem myPISystem = myPISystems.DefaultPISystem;
if (myPISystem == null)
{
throw new InvalidOperationException("Default PISystem was not found.");
}
AFDatabase myDB = myPISystem.Databases["PE"];
if (myDB == null)
{
throw new InvalidOperationException("Database was not found.");
}
AFElement element = myDB.Elements["El"];
int count;
using (var search = new AFAnalysisSearch(myDB, "MyAnalysisSearch", string.Format(@"Target:'{0}'", element.GetPath())))
{
search.CacheTimeout = TimeSpan.FromMinutes(10);
count = search.GetTotalCount();
Console.WriteLine("Found {0} Analyses", count);
foreach (var item in search.FindObjects(fullLoad: true))
{
Console.Write("Analysis Name = {0},", item.Name);
Console.Write("Analysis Description = {0},", item.Description);
Console.Write("Analysis Target = {0}", item.Target);
Console.WriteLine();
}
}
}
public GraphQlAfDatabase(AFDatabase aAfDatabase, Field afElementsField)
{
name = aAfDatabase.Name;
path = aAfDatabase.GetPath();
thisAfDatabase = aAfDatabase;
if (afElementsField != null)
{
var afElementsNameFilterStrings = GraphQlHelpers.GetArgumentStrings(afElementsField, "nameFilter");
var afElementsAttributeValueFilterStrings = GraphQlHelpers.GetArgumentStrings(afElementsField, "attributeValueFilter");
var afElementsChildField = GraphQlHelpers.GetFieldFromSelectionSet(afElementsField, "afElements");
var afAttributesChildField = GraphQlHelpers.GetFieldFromSelectionSet(afElementsField, "afAttributes");
var returnElementsObject = new ConcurrentBag <GraphQlAfElement>();
var afElementList = aAfDatabase.Elements;
Parallel.ForEach(afElementList, aAfChildElement =>
{
if (GraphQlHelpers.JudgeElementOnFilters(aAfChildElement, afElementsNameFilterStrings, afElementsAttributeValueFilterStrings))
{
returnElementsObject.Add(new GraphQlAfElement(aAfChildElement, afElementsChildField, afAttributesChildField));
}
});
afElements = returnElementsObject.OrderBy(x => x.name).ToList();
}
}
private static void CreateEnumerationSets(AFDatabase database)
{
if (database == null)
{
return;
}
if (!database.EnumerationSets.Contains("Building Type"))
{
AFEnumerationSet bTypeEnum = database.EnumerationSets.Add("Building Type");
bTypeEnum.Add("Residential", 0);
bTypeEnum.Add("Business", 1);
}
if (!database.EnumerationSets.Contains("Meter Status"))
{
AFEnumerationSet mStatusEnum = database.EnumerationSets.Add("Meter Status");
mStatusEnum.Add("Good", 0);
mStatusEnum.Add("Bad", 1);
}
if (database.IsDirty)
{
database.CheckIn();
}
}
private void CreateTemplates(AFDatabase afDatabase)
{
AFElementTemplate elemTemplate = afDatabase.ElementTemplates.Add("BasicBoilerTemplate");
AFAttributeTemplate attrTemplate_Temperature = elemTemplate.AttributeTemplates.Add("Temperature");
AFAttributeTemplate attrTemplate_Pressure = elemTemplate.AttributeTemplates.Add("Pressure");
AFAttributeTemplate attrTemplate_Limit = elemTemplate.AttributeTemplates.Add("Limit");
AFAttributeTemplate attrTemplate_Mode = elemTemplate.AttributeTemplates.Add("Mode");
attrTemplate_Temperature.Type = typeof(float);
attrTemplate_Pressure.Type = typeof(float);
attrTemplate_Limit.Type = typeof(string);
AFEnumerationSet modes = afDatabase.EnumerationSets["Modes"];
attrTemplate_Mode.TypeQualifier = modes;
attrTemplate_Temperature.DataReferencePlugIn = AFDataReference.GetPIPointDataReference(afDatabase.PISystem);
attrTemplate_Pressure.DataReferencePlugIn = AFDataReference.GetPIPointDataReference(afDatabase.PISystem);
attrTemplate_Mode.DataReferencePlugIn = AFDataReference.GetPIPointDataReference(afDatabase.PISystem);
attrTemplate_Temperature.ConfigString = @"%Database%.%..\Element%.%Element%.%Attribute%;ptclassname=classic;pointtype=float32;";
attrTemplate_Pressure.ConfigString = @"%Database%.%..\Element%.%Element%.%Attribute%;ptclassname=classic;pointtype=float32;";
attrTemplate_Mode.ConfigString = @"%Database%.%..\Element%.%Element%.%Attribute%;ptclassname=classic;pointtype=digital;digitalset=modes;";
// Do a bulk check in of all changes made so far.
afDatabase.CheckIn();
}
private void CreateElement(AFDatabase afDatabase, string name, string path, string template)
{
// check if we have a parent element, if yes we get it, if not we set parent to database level
Logger.InfoFormat("Parsing parameters");
dynamic parent = !string.IsNullOrEmpty(path)?(object)AFElement.FindObject(path, afDatabase):afDatabase;
var elementTemplate = !string.IsNullOrEmpty(template) ? GetTemplate(afDatabase, template):null;
//if parent is null, the passed string did not resolve to a parent
if (parent == null)
{
throw new NoNullAllowedException(string.Format("The parent path passed {0} could not resolve to an AF object in the Database", path));
}
// here we check if the FindObject method has returned a Element, if not an exception will be thrown
if (!(parent is AFElement || parent is AFDatabase))
{
throw new InvalidAFObjectException();
}
// create the element
Logger.InfoFormat("Creating the element");
parent.Elements.Add(name, elementTemplate);
parent.CheckIn();
Logger.InfoFormat("Element {0} created.", name);
}
static void CreateFeederElements(AFDatabase database)
{
AFElementTemplate template = database.ElementTemplates["FeederTemplate"];
AFElement feeders = database.Elements["Feeders"];
if (template == null || feeders == null)
{
return;
}
if (feeders.Elements.Contains("Feeder001"))
{
return;
}
AFElement feeder001 = feeders.Elements.Add("Feeder001", template);
AFAttribute city = feeder001.Attributes["City"];
if (city != null)
{
city.SetValue(new AFValue("London"));
}
AFAttribute power = feeder001.Attributes["Power"];
power.ConfigString = @"%@\Configuration|PIDataArchiveName%\SINUSOID";
if (database.IsDirty)
{
database.CheckIn();
}
}
static void Main(string[] args)
{
AFDatabase db = ConnectionHelper.GetDatabase("PISRV01", "Feeder Voltage Monitoring");
AFAttributeTemplate attrTemp = db.ElementTemplates["Feeder"].AttributeTemplates["Reactive Power"];
AssetRankProvider rankProvider = new AssetRankProvider(attrTemp);
rankProvider.Start();
// Get top 3 Feeders every 5 seconds. Do this 10 times.
foreach (int i in Enumerable.Range(0, 10))
{
IList <AFRankedValue> rankings = rankProvider.GetTopNElements(3);
foreach (var r in rankings)
{
Console.WriteLine($"{r.Ranking} {r.Value.Attribute.Element.Name} {r.Value.Timestamp} {r.Value.Value}");
}
Console.WriteLine();
Thread.Sleep(5000);
}
// Remove unmanaged resources and server-side signup.
rankProvider.Dispose();
Console.WriteLine("Press any key to quit");
Console.ReadKey();
}
public 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 LimitCalculation(CalculationPreference preference)
{
this.preference = preference;
string afattributepath = preference.sensorPath;
string eventQuery = preference.eventFrameQuery;
calculationsToPerform = preference.getTraitDictionary();
foreach (KeyValuePair <AFAttributeTrait, string> pair in calculationsToPerform)
{
bounds[pair.Key] = new AFValues();
}
sensor = AFAttribute.FindAttribute(afattributepath, null);
pisystem = sensor.PISystem;
afdatabse = sensor.Database;
foreach (KeyValuePair <AFAttributeTrait, string> pair in calculationsToPerform)
{
boundAttributes[pair.Key] = sensor.GetAttributeByTrait(pair.Key);
}
eventFrameQuery = new AFEventFrameSearch(afdatabse, "eventFrameSearch", eventQuery);
List <AFSearchToken> tokens = eventFrameQuery.Tokens.ToList();
tokens.RemoveAll(t => t.Filter == AFSearchFilter.InProgress || t.Filter == AFSearchFilter.Start || t.Filter == AFSearchFilter.End);
timeLessQuery = new AFEventFrameSearch(afdatabse, "AllEventFrames", tokens);
InitialRun();
}
static AFElementTemplate CreateEventFrameTemplate(AFDatabase database)
{
AFElementTemplate eventFrameTemplate = database.ElementTemplates["Daily Usage"];
if (eventFrameTemplate != null)
{
return(eventFrameTemplate);
}
eventFrameTemplate = database.ElementTemplates.Add("Daily Usage");
eventFrameTemplate.InstanceType = typeof(AFEventFrame);
eventFrameTemplate.NamingPattern = @"%TEMPLATE%-%ELEMENT%-%STARTTIME:yyyy-MM-dd%-EF*";
AFAttributeTemplate usage = eventFrameTemplate.AttributeTemplates.Add("Average Energy Usage");
usage.Type = typeof(Single);
usage.DataReferencePlugIn = AFDataReference.GetPIPointDataReference();
usage.ConfigString = @".\Elements[.]|Energy Usage;TimeRangeMethod=Average";
usage.DefaultUOM = database.PISystem.UOMDatabase.UOMs["kilowatt hour"];
if (database.IsDirty)
{
database.CheckIn();
}
return(eventFrameTemplate);
}
public static void PrintHistorical(AFDatabase database, string meterName, string startTime, string endTime)
{
if (database == null)
{
throw new ArgumentNullException(nameof(database));
}
Console.WriteLine(string.Format("Print Historical 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);
AFValues vals = attr.Data.RecordedValues(
timeRange: timeRange,
boundaryType: AFBoundaryType.Inside,
desiredUOM: database.PISystem.UOMDatabase.UOMs["kilojoule"],
filterExpression: null,
includeFilteredValues: false);
foreach (AFValue val in vals)
{
Console.WriteLine("Timestamp (UTC): {0}, Value (kJ): {1}", val.Timestamp.UtcTime, val.Value);
}
Console.WriteLine();
}
static void FindBuildingInfo(AFDatabase database, string templateName)
{
Console.WriteLine("Find Building Info: {0}", templateName);
AFElementTemplate elemTemp = database.ElementTemplates[templateName];
AFCategory buildingInfoCat = database.AttributeCategories["Building Info"];
AFElement root = database.Elements["Wizarding World"];
AFNamedCollectionList <AFAttribute> foundAttributes = AFAttribute.FindElementAttributes(
database: database,
searchRoot: root,
nameFilter: "*",
elemCategory: null,
elemTemplate: elemTemp,
elemType: AFElementType.Any,
attrNameFilter: "*",
attrCategory: buildingInfoCat,
attrType: TypeCode.Empty,
searchFullHierarchy: true,
sortField: AFSortField.Name,
sortOrder: AFSortOrder.Ascending,
maxCount: 100);
Console.WriteLine("Found {0} attributes.", foundAttributes.Count);
Console.WriteLine();
}
public static void ProgrammaticAnalysisRecalculation(PISystem system, AFDatabase database, AFCategory category)
{
// we start by generating timestamps we want to recalculate
// we could get them from existing recorded values, etc...
//
// here we simply generate yesterdays hourly values ...
var recalculationTimeStamps = new List <AFTime>();
for (int i = 0; i < 24; i++)
{
recalculationTimeStamps.Add(new AFTime(DateTime.Today.Subtract(TimeSpan.FromDays(1)) + TimeSpan.FromDays(i) + TimeSpan.FromSeconds(2)));
}
AFNamedCollectionList <AFAnalysis> analysislist;
analysislist = AFAnalysis.FindAnalyses(database, null, null, null, category, null, null, AFStatus.None, AFSortField.ID, AFSortOrder.Ascending, 0, 1000);
Console.WriteLine(category.Name);
Console.WriteLine(analysislist.Count);
foreach (var afAnalysis in analysislist)
{
// we recalculate results
var results = Calculate(afAnalysis, recalculationTimeStamps);
// we could delete values here, but I simply replce them instead
// we insert our new values
AFListData.UpdateValues(results, AFUpdateOption.Replace);
}
}
static void FindBuildingInfo(AFDatabase database, string templateName)
{
Console.WriteLine("Find Building Info: {0}", templateName);
AFElementTemplate elemTemp = database.ElementTemplates[templateName];
AFCategory buildingInfoCat = database.AttributeCategories["Building Info"];
AFNamedCollectionList <AFAttribute> foundAttributes = new AFNamedCollectionList <AFAttribute>();
using (AFElementSearch elementQuery = new AFElementSearch(database, "AttributeCattegorySearch", string.Format("template:\"{0}\"", templateName)))
{
elementQuery.CacheTimeout = TimeSpan.FromMinutes(5);
foreach (AFElement element in elementQuery.FindElements())
{
foreach (AFAttribute attr in element.Attributes)
{
if (attr.Categories.Contains(buildingInfoCat))
{
foundAttributes.Add(attr);
}
}
}
}
Console.WriteLine("Found {0} attributes.", foundAttributes.Count);
Console.WriteLine();
}
static void CreateElementTemplate(AFDatabase database)
{
string templateName = "FeederTemplate";
AFElementTemplate feederTemplate;
if (database.ElementTemplates.Contains(templateName))
{
return;
}
else
{
feederTemplate = database.ElementTemplates.Add(templateName);
}
AFAttributeTemplate cityAttributeTemplate = feederTemplate.AttributeTemplates.Add("City");
cityAttributeTemplate.Type = typeof(string);
AFAttributeTemplate power = feederTemplate.AttributeTemplates.Add("Power");
power.Type = typeof(Single);
power.DefaultUOM = database.PISystem.UOMDatabase.UOMs["watt"];
power.DataReferencePlugIn = database.PISystem.DataReferencePlugIns["PI Point"];
database.CheckIn();
}
private static void CreateElements(AFDatabase database)
{
if (database == null)
{
return;
}
AFElement meters;
if (!database.Elements.Contains("Meters"))
{
meters = database.Elements.Add("Meters");
}
else
{
meters = database.Elements["Meters"];
}
AFElementTemplate basic = database.ElementTemplates["MeterBasic"];
AFElementTemplate advanced = database.ElementTemplates["MeterAdvanced"];
foreach (int i in Enumerable.Range(1, 12))
{
string name = "Meter" + i.ToString("D3");
if (!meters.Elements.Contains(name))
{
AFElementTemplate eTemp = i <= 8 ? basic : advanced;
AFElement e = meters.Elements.Add(name, eTemp);
}
}
database.CheckIn();
}
private static void CreateWeakReferences(AFDatabase database)
{
if (database == null)
{
return;
}
AFReferenceType weakRefType = database.ReferenceTypes["Weak Reference"];
AFElement meters = database.Elements["Meters"];
AFElement hogwarts = database.Elements["Wizarding World"].Elements["Hogwarts"];
hogwarts.Elements.Add(meters.Elements["Meter001"], weakRefType);
hogwarts.Elements.Add(meters.Elements["Meter002"], weakRefType);
hogwarts.Elements.Add(meters.Elements["Meter003"], weakRefType);
hogwarts.Elements.Add(meters.Elements["Meter004"], weakRefType);
AFElement diagonAlley = database.Elements["Wizarding World"].Elements["Diagon Alley"];
diagonAlley.Elements.Add(meters.Elements["Meter005"], weakRefType);
diagonAlley.Elements.Add(meters.Elements["Meter006"], weakRefType);
diagonAlley.Elements.Add(meters.Elements["Meter007"], weakRefType);
diagonAlley.Elements.Add(meters.Elements["Meter008"], weakRefType);
AFElement hogsmeade = database.Elements["Wizarding World"].Elements["Hogsmeade"];
hogsmeade.Elements.Add(meters.Elements["Meter009"], weakRefType);
hogsmeade.Elements.Add(meters.Elements["Meter010"], weakRefType);
hogsmeade.Elements.Add(meters.Elements["Meter011"], weakRefType);
hogsmeade.Elements.Add(meters.Elements["Meter012"], weakRefType);
database.CheckIn();
}
private void CreateEnumerationSet(AFDatabase afDatabase)
{
AFEnumerationSet modes = afDatabase.EnumerationSets.Add("Modes");
modes.Add("Manual", 0);
modes.Add("Auto", 1);
modes.Add("Cascade", 2);
modes.Add("Program", 3);
modes.Add("Prog-Auto", 4);
}
static void PrintRootElements(AFDatabase database)
{
Console.WriteLine("Print Root Elements: {0}", database.Elements.Count);
foreach (AFElement element in database.Elements)
{
Console.WriteLine(" {0}", element.Name);
}
Console.WriteLine();
}
static void CreateFeedersRootElement(AFDatabase database)
{
if (database.Elements.Contains("Feeders"))
return;
else
{
database.Elements.Add("Feeders");
}
database.CheckIn();
}
static void PrintEnergyUsageAtTime(AFDatabase database, string timeStamp)
{
Console.WriteLine("Print Energy Usage at Time: {0}", timeStamp);
AFAttributeList attrList = new AFAttributeList();
// Use this method if you get stuck trying to find attributes
// attrList = GetAttribute();
// Your code here
}
static void PrintAttributeTemplates(AFDatabase database, string elemTempName)
{
Console.WriteLine("Print Attribute Templates for Element Template: {0}", elemTempName);
AFElementTemplate elemTemp = database.ElementTemplates[elemTempName];
foreach (AFAttributeTemplate attrTemp in elemTemp.AttributeTemplates)
{
string drName = attrTemp.DataReferencePlugIn == null ? "None" : attrTemp.DataReferencePlugIn.Name;
Console.WriteLine("Name: {0}, DRPlugin: {1}", attrTemp.Name, drName);
}
Console.WriteLine();
}
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;
}
private void CreatePIPoints(AFDatabase afDatabase)
{
AFElementTemplate elemTemplate = afDatabase.ElementTemplates["BasicBoilerTemplate"];
AFNamedCollectionList<AFBaseElement> baseElements = elemTemplate.FindInstantiatedElements(
includeDerived: false,
sortField: AFSortField.Name,
sortOrder: AFSortOrder.Ascending,
maxCount: 1000);
foreach (AFBaseElement baseElement in baseElements)
{
int numModified = AFDataReference.CreateConfig(baseElement, false, null);
Console.WriteLine("Modified or created: {0}", numModified);
}
}
private void CreateEventFrames(AFDatabase afDatabase)
{
AFElementTemplate efTemplate = afDatabase.ElementTemplates["BasicEventFrameTemplate"];
for (int i = 0; i < 5; i++)
{
AFEventFrame ef = new AFEventFrame(afDatabase, "EF_" + i, efTemplate);
ef.SetStartTime(new AFTime(string.Format("t-{0}d", i + 1)));
ef.SetEndTime(new AFTime(string.Format("t-{0}d", i)));
AFElement element = afDatabase.Elements["Region_0"].Elements["BoilerA"];
ef.PrimaryReferencedElement = element;
}
// Do a bulk check in of all changes made so far.
afDatabase.CheckIn();
}
public void afDatabasePicker1_SelectionChange(object sender, OSIsoft.AF.UI.SelectionChangeEventArgs e)
{
afTreeView1.AFRoot = null;
myAFDatabase = (AFDatabase)e.SelectedObject;
if (myAFDatabase != null)
{
//Populate the AF Treeview with Elements only.
afTreeView1.AFRoot = myAFDatabase.Elements;
//Put Element Template Name to ComboBox
myElementTemplates = myAFDatabase.ElementTemplates;
foreach(AFElementTemplate myElementTemplate in myElementTemplates)
{
ElementTemplateComboBox.Items.Add(myElementTemplate.Name);
}
}
}
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;
}
static void FindMetersBySubstation(AFDatabase database, string substationLocation)
{
Console.WriteLine("Find Meters by Substation: {0}", substationLocation);
string templateName = "MeterBasic";
string attributeName = "Substation";
AFElementSearch elementquery = new AFElementSearch(database, "AttributeValueEQSearch",
string.Format("template:\"{0}\" \"|{1}\":\"{2}\"", templateName, attributeName, substationLocation));
int countNames = 0;
foreach (AFElement element in elementquery.FindElements())
{
Console.Write("{0}{1}", countNames++ == 0 ? string.Empty : ", ", element.Name);
}
Console.WriteLine("\n");
}
static void FindMetersByName(AFDatabase database, string elementNameFilter)
{
Console.WriteLine("Find Meters by Name: {0}", elementNameFilter);
// Default search is as an element name string mask.
string querystring = string.Format("{0}", elementNameFilter);
AFElementSearch elementquery = new AFElementSearch(database, "ElementSearch", querystring);
foreach (AFElement element in elementquery.FindElements())
{
Console.WriteLine("Element: {0}, Template: {1}, Categories: {2}",
element.Name,
element.Template.Name,
element.CategoriesString);
}
Console.WriteLine();
}
static void CreateFeederElements(AFDatabase database)
{
AFElementTemplate template = database.ElementTemplates["FeederTemplate"];
AFElement feeders = database.Elements["Feeders"];
if (template == null || feeders == null) return;
if (feeders.Elements.Contains("Feeder001")) return;
AFElement feeder001 = feeders.Elements.Add("Feeder001", template);
AFAttribute district = feeder001.Attributes["District"];
if (district != null) district.SetValue(new AFValue("Hogwarts"));
AFAttribute power = feeder001.Attributes["Power"];
power.ConfigString = @"\\PISRV01\SINUSOID";
database.CheckIn();
}
static void FindMetersByTemplate(AFDatabase database, string templateName)
{
Console.WriteLine("Find Meters by Template: {0}", templateName);
AFElementSearch elementquery = new AFElementSearch(database, "TemplateSearch", string.Format("template:\"{0}\"", templateName));
AFElementSearch templatefilter = new AFElementSearch(database, "DerivedTemplates", "templateName:\"MeterAdvanced\"");
int countderived = 0;
foreach (AFElement element in elementquery.FindElements())
{
Console.WriteLine("Element: {0}, Template: {1}", element.Name, element.Template.Name);
if (templatefilter.IsMatch(element))
countderived++;
}
Console.WriteLine(" Found {0} derived templates", countderived);
Console.WriteLine();
}
private void CreateEventFrameTemplate(AFDatabase afDatabase)
{
AFElementTemplate efTemplate = afDatabase.ElementTemplates.Add("BasicEventFrameTemplate");
// Specify that this is an Event Frame Template.
efTemplate.InstanceType = typeof(AFEventFrame);
AFAttributeTemplate tempAttr = efTemplate.AttributeTemplates.Add("Maximum temperature");
tempAttr.DataReferencePlugIn = AFDataReference.GetPIPointDataReference(afDatabase.PISystem);
AFAttributeTemplate pressAttr = efTemplate.AttributeTemplates.Add("Maximum pressure");
pressAttr.DataReferencePlugIn = AFDataReference.GetPIPointDataReference(afDatabase.PISystem);
tempAttr.ConfigString = @".\Elements[.]|Temperature;TimeMethod=NotSupported;TimeRangeMethod=Maximum";
pressAttr.ConfigString = @".\Elements[.]|Pressure;TimeMethod=NotSupported;TimeRangeMethod=Maximum";
// Do a bulk check in of all changes made so far.
afDatabase.CheckIn();
}
private static void CreateEnumerationSets(AFDatabase database)
{
if (database == null) return;
if (!database.EnumerationSets.Contains("Building Type"))
{
AFEnumerationSet bTypeEnum = database.EnumerationSets.Add("Building Type");
bTypeEnum.Add("Residential", 0);
bTypeEnum.Add("Business", 1);
}
if (!database.EnumerationSets.Contains("Meter Status"))
{
AFEnumerationSet mStatusEnum = database.EnumerationSets.Add("Meter Status");
mStatusEnum.Add("Good", 0);
mStatusEnum.Add("Bad", 1);
}
database.CheckIn();
}
static void CreateElementTemplate(AFDatabase database)
{
string templateName = "FeederTemplate";
AFElementTemplate feederTemplate;
if (database.ElementTemplates.Contains(templateName))
return;
else
feederTemplate = database.ElementTemplates.Add(templateName);
AFAttributeTemplate district = feederTemplate.AttributeTemplates.Add("District");
district.Type = typeof(string);
AFAttributeTemplate power = feederTemplate.AttributeTemplates.Add("Power");
power.Type = typeof(Single);
power.DefaultUOM = database.PISystem.UOMDatabase.UOMs["watt"];
power.DataReferencePlugIn = database.PISystem.DataReferencePlugIns["PI Point"];
database.CheckIn();
}
static void PrintElementTemplates(AFDatabase database)
{
Console.WriteLine("Print Element Templates");
AFNamedCollectionList<AFElementTemplate> elemTemplates = database.ElementTemplates.FilterBy(typeof(AFElement));
foreach (AFElementTemplate elemTemp in elemTemplates)
{
string[] categories = new string[elemTemp.Categories.Count];
int i = 0;
foreach (AFCategory category in elemTemp.Categories)
{
categories[i++] = category.Name;
}
// Note: An alternative approach is to use CategoriesString
string categoriesString = string.Join(",", categories);
Console.WriteLine("Name: {0}, Categories: {1}", elemTemp.Name, elemTemp.CategoriesString);
}
Console.WriteLine();
}
/// <summary>
/// Searches event frames that where ACTIVE at the specified time
/// </summary>
/// <remarks>There are a lot of ways to search event frames, this is just one way of doing it</remarks>
/// <param name="afDatabase"></param>
/// <param name="time"></param>
/// Search mode is the key to understand how EFs are found, in this scenario we look for overlapped:
/// <see cref="https://techsupport.osisoft.com/Documentation/PI-AF-SDK/html/T_OSIsoft_AF_Asset_AFSearchMode.htm"/>
private void SearchEventFrames(AFDatabase afDatabase, string time)
{
try
{
var searchTime = new AFTime(time);
Logger.InfoFormat("Searching for event frames in {0} database at time {1}",afDatabase.Name, searchTime);
var eventFrames = AFEventFrame.FindEventFrames(
database: afDatabase,
searchRoot: null,
searchMode: AFSearchMode.Overlapped,
startTime: searchTime,
endTime: searchTime,
nameFilter: string.Empty,
referencedElementNameFilter: string.Empty,
eventFrameCategory: null,
eventFrameTemplate: null,
referencedElementTemplate: null,
durationQuery: null,
searchFullHierarchy: false,
sortField: AFSortField.Name,
sortOrder: AFSortOrder.Ascending,
startIndex: 0,
maxCount: 1000
);
Logger.InfoFormat("Found {0} event frames: ", eventFrames.Count);
foreach (var ef in eventFrames)
{
Logger.InfoFormat("{0}-ST:{1}-ET:{2}", ef.Name, ef.StartTime, ef.EndTime);
}
}
catch (Exception ex)
{
Logger.Error(ex);
}
}
static AFElementTemplate CreateEventFrameTemplate(AFDatabase database)
{
AFElementTemplate eventframetemplate = null;
if (database.ElementTemplates.Contains("Daily Usage"))
{
return database.ElementTemplates["Daily Usage"];
}
eventframetemplate = database.ElementTemplates.Add("Daily Usage");
eventframetemplate.InstanceType = typeof(AFEventFrame);
eventframetemplate.NamingPattern = @"%TEMPLATE%-%ELEMENT%-%STARTTIME:yyyy-MM-dd%-EF*";
AFAttributeTemplate usage = eventframetemplate.AttributeTemplates.Add("Average Energy Usage");
usage.Type = typeof(double);
usage.DataReferencePlugIn = AFDataReference.GetPIPointDataReference();
usage.ConfigString = @".\Elements[.]|Energy Usage;TimeRangeMethod=Average";
usage.DefaultUOM = database.PISystem.UOMDatabase.UOMs["kilowatt hour"];
database.CheckIn();
return eventframetemplate;
}
private void CreateElements(AFDatabase afDatabase)
{
AFElementTemplate elemTemplate = afDatabase.ElementTemplates["BasicBoilerTemplate"];
for (int i = 0; i < 5; i++)
{
AFElement element = afDatabase.Elements.Add("Region_" + i);
}
foreach (AFElement element in afDatabase.Elements)
{
AFElement childA = element.Elements.Add("BoilerA", elemTemplate);
AFElement childB = element.Elements.Add("BoilerB", elemTemplate);
childA.Attributes["Limit"].SetValue(new AFValue("10"));
childB.Attributes["Limit"].SetValue(new AFValue("50"));
}
// Do a bulk check in of all changes made so far.
afDatabase.CheckIn();
}
private static void CreateCategories(AFDatabase database)
{
if (database == null) return;
if (!database.ElementCategories.Contains("Measures Energy"))
database.ElementCategories.Add("Measures Energy");
if (!database.ElementCategories.Contains("Shows Status"))
database.ElementCategories.Add("Shows Status");
if (!database.AttributeCategories.Contains("Building Info"))
database.AttributeCategories.Add("Building Info");
if (!database.AttributeCategories.Contains("Location"))
database.AttributeCategories.Add("Location");
if (!database.AttributeCategories.Contains("Time-Series Data"))
database.AttributeCategories.Add("Time-Series Data");
database.CheckIn();
}
static void CreateEventFrames(AFDatabase database, AFElementTemplate eventFrameTemplate)
{
const int pageSize = 1000;
int startIndex = 0;
int totalCount;
do
{
AFNamedCollectionList<AFBaseElement> results = database.ElementTemplates["MeterBasic"].FindInstantiatedElements(
includeDerived: true,
sortField: AFSortField.Name,
sortOrder: AFSortOrder.Ascending,
startIndex: startIndex,
maxCount: pageSize,
totalCount: out totalCount
);
IList<AFElement> meters = results.Select(elm => (AFElement)elm).ToList();
DateTime timereference = DateTime.Now.AddDays(-7);
//AFTime startTime = new AFTime(new DateTime(timereference.Year, timereference.Month, timereference.Day, 0, 0, 0, DateTimeKind.Local));
foreach (AFElement meter in meters)
{
foreach (int day in Enumerable.Range(1, 7))
{
AFTime startTime = new AFTime(timereference.AddDays(day - 1));
AFTime endTime = new AFTime(startTime.LocalTime.AddDays(1));
AFEventFrame ef = new AFEventFrame(database, "*", eventFrameTemplate);
ef.SetStartTime(startTime);
ef.SetEndTime(endTime);
ef.PrimaryReferencedElement = meter;
}
}
database.CheckIn();
startIndex += pageSize;
} while (startIndex < totalCount);
database.CheckIn();
}
/// <summary>
/// Loads Elements from an AF Database in a manner that is not blocking the application
/// and is more efficient with big databases
/// </summary>
/// <param name="database">The AFdatabase that contains the elements to load</param>
/// <param name="template"> the Element Template associated with the elements to load</param>
/// <param name="elementsConcurrentQueue">Concurrent queue in which the elements will be loaded</param>
public static void LoadElementsByTemplate(AFDatabase database, AFElementTemplate template, ConcurrentQueue<AFElement> elementsConcurrentQueue)
{
// set variables
const int chunkSize = 10000;
int index = 0;
int total;
do
{
// loads elements by chunk of 10K values
var elements = template.FindInstantiatedElements(true,
AFSortField.Name, AFSortOrder.Ascending, index, chunkSize, out total);
var elementCount = elements.Count;
if (elementCount == 0)
break;
// Convert a list of AFBaseElement to a list of AFElement
List<AFElement> elementsList = elements.Select(e => (AFElement)e).ToList();
// forces full load of elements
AFElement.LoadElementsToDepth(elementsList,true,5,1000000);
// if you'd like to filter the elements by attributes...
// however this would be sub-optimal, it would be better to filter directly on the FindInstanciated Elements query.
//i.e. elementsList = elementsList.Where(e => (bool)e.Attributes["attribute to filter"].GetValue().Value == true).ToList();
foreach (var afElement in elementsList)
{
elementsConcurrentQueue.Enqueue(afElement);
}
_logger.InfoFormat(" Load Elements by Template | StartIndex = {1} | Found a chunk of {2} elements", DateTime.Now, index, elementCount);
index += chunkSize;
} while (index < total);
// the findElements call we are using returns a paged collection to lower the memory foortprint
}
static void PrintHistorical(AFDatabase database, string meterName, string startTime, string endTime)
{
Console.WriteLine(string.Format("Print Historical 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);
AFValues vals = attr.Data.RecordedValues(
timeRange: timeRange,
boundaryType: AFBoundaryType.Inside,
desiredUOM: database.PISystem.UOMDatabase.UOMs["kilojoule"],
filterExpression: null,
includeFilteredValues: false);
foreach (AFValue val in vals)
{
Console.WriteLine("Timestamp (UTC): {0}, Value (kJ): {1}", val.Timestamp.UtcTime, val.Value);
}
Console.WriteLine();
}
public static AFConnectionHelper ConnectAndGetDatabase(string server, string databaseName, out AFDatabase database)
{
var manager=new AFConnectionHelper(server,databaseName);
manager.Connect();
database=manager.GetDatabase();
return manager;
}
