public static void FindBuildingInfo(AFDatabase database, string templateName)
{
if (database == null)
{
throw new ArgumentNullException(nameof(database));
}
Console.WriteLine("Find Building Info: {0}", 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.FindObjects())
{
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 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();
}
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 static AFElementTemplate CreateMeterBasicTemplate(AFDatabase database)
{
AFElementTemplate meterBasicTemplate = database.ElementTemplates["MeterBasic"];
if (meterBasicTemplate != null)
{
return(meterBasicTemplate);
}
UOM uom = database.PISystem.UOMDatabase.UOMs["kilowatt hour"];
AFCategory mEnergyE = database.ElementCategories["Measures Energy"];
AFCategory bInfoA = database.AttributeCategories["Building Info"];
AFCategory locationA = database.AttributeCategories["Location"];
AFCategory tsDataA = database.AttributeCategories["Time-Series Data"];
AFEnumerationSet bTypeNum = database.EnumerationSets["Building Type"];
AFPlugIn PIPoint = database.PISystem.DataReferencePlugIns["PI Point"];
meterBasicTemplate = database.ElementTemplates.Add("MeterBasic");
meterBasicTemplate.Categories.Add(mEnergyE);
AFAttributeTemplate substationAttrTemp = meterBasicTemplate.AttributeTemplates.Add("Substation");
substationAttrTemp.Type = typeof(string);
AFAttributeTemplate usageLimitAttrTemp = meterBasicTemplate.AttributeTemplates.Add("Usage Limit");
usageLimitAttrTemp.Type = typeof(string);
usageLimitAttrTemp.DefaultUOM = uom;
AFAttributeTemplate buildingAttrTemp = meterBasicTemplate.AttributeTemplates.Add("Building");
buildingAttrTemp.Type = typeof(string);
buildingAttrTemp.Categories.Add(bInfoA);
AFAttributeTemplate bTypeAttrTemp = meterBasicTemplate.AttributeTemplates.Add("Building Type");
bTypeAttrTemp.TypeQualifier = bTypeNum;
bTypeAttrTemp.Categories.Add(bInfoA);
AFAttributeTemplate cityAttrTemp = meterBasicTemplate.AttributeTemplates.Add("City");
cityAttrTemp.Type = typeof(string);
cityAttrTemp.Categories.Add(locationA);
AFAttributeTemplate energyUsageAttrTemp = meterBasicTemplate.AttributeTemplates.Add("Energy Usage");
energyUsageAttrTemp.Type = typeof(Single);
energyUsageAttrTemp.Categories.Add(tsDataA);
energyUsageAttrTemp.DefaultUOM = uom;
energyUsageAttrTemp.DataReferencePlugIn = PIPoint;
energyUsageAttrTemp.ConfigString = @"\\%@\Configuration|PIDataArchiveName%\%Element%.%Attribute%;UOM=kWh";
return(meterBasicTemplate);
}
public void DeleteTest()
{
instance.Delete(webId);
AFDatabase db = StandardPISystem.Databases[Constants.AF_DATABASE_NAME];
db.Refresh();
AFCategory analysisCategory = AFObject.FindObject(Constants.AF_ANALYSIS_CATEGORY_PATH) as AFCategory;
Assert.IsNull(analysisCategory);
DeleteSampleDatabaseForTests();
CreateSampleDatabaseForTests();
}
private AFCategory CreateCategory(AFCategories categories, string categoryName, int number = 1)
{
string compl = string.Empty;
if (number > 1)
{
compl = number.ToString();
}
AFCategory category = categories[categoryName + compl];
if (category == null)
{
category = categories.Add(categoryName + compl);
}
category.Description = "Original description";
return(category);
}
public void Run()
{
PISystems piSystems = new PISystems();
PISystem piSystem = piSystems["<AFSERVER>"];
AFDatabase afDatabase = piSystem.Databases["NuGreen"];
AFCategory elementCategory = afDatabase.ElementCategories["Equipment Assets"];
AFCategory attributeCategory = afDatabase.AttributeCategories["Real-Time Data"];
AFElementTemplate elementTemplate = afDatabase.ElementTemplates["Boiler"];
const int pageSize = 1000;
int startIndex = 0;
int totalCount;
do
{
// Find all "Water Flow" attributes in the NuGreen database.
AFAttributeList attrList = AFAttribute.FindElementAttributes(
database: afDatabase,
searchRoot: null,
nameFilter: "*",
elemCategory: elementCategory,
elemTemplate: elementTemplate,
elemType: AFElementType.Any,
attrNameFilter: "*",
attrCategory: attributeCategory,
attrType: TypeCode.Double,
searchFullHierarchy: true,
sortField: AFSortField.Name,
sortOrder: AFSortOrder.Ascending,
startIndex: startIndex,
maxCount: pageSize,
totalCount: out totalCount);
foreach (AFAttribute attr in attrList)
{
Console.WriteLine("Parent element name: {0}", attr.Element);
}
startIndex += pageSize;
} while (startIndex < totalCount);
}
public void CreateSampleDatabaseForTests()
{
DeleteSampleDatabaseForTests();
CreateSecurityIdentities();
CreateSecurityMappings();
CreateUOMClasses();
AFDatabase db = CreateDatabase();
AFCategory analysisCategory1 = CreateCategory(db.AnalysisCategories, Constants.AF_ANALYSIS_CATEGORY_NAME, 1);
AFCategory analysisCategory2 = CreateCategory(db.AnalysisCategories, Constants.AF_ANALYSIS_CATEGORY_NAME, 2);
AFCategory tableCategory1 = CreateCategory(db.TableCategories, Constants.AF_TABLE_CATEGORY_NAME, 1);
AFCategory tableCategory2 = CreateCategory(db.TableCategories, Constants.AF_TABLE_CATEGORY_NAME, 2);
AFCategory attributeCategory1 = CreateCategory(db.AttributeCategories, Constants.AF_ATTRIBUTE_CATEGORY_NAME, 1);
AFCategory attributeCategory2 = CreateCategory(db.AttributeCategories, Constants.AF_ATTRIBUTE_CATEGORY_NAME, 2);
AFCategory elementCategory1 = CreateCategory(db.ElementCategories, Constants.AF_ELEMENT_CATEGORY_NAME, 1);
AFCategory elementCategory2 = CreateCategory(db.ElementCategories, Constants.AF_ELEMENT_CATEGORY_NAME, 2);
AFTable table = CreateTable(db);
table.Categories.Add(tableCategory1);
AFEnumerationSet enumSet = CreateEnumerationSet(db);
AFElementTemplate elementTemplate = CreateElementTemplate(db);
CreateElementFromTemplate(db, elementTemplate);
AFElement el = CreateElementAndAttributes(db, elementCategory1, attributeCategory1);
CreateElementForStreamSet(db);
AFAnalysisTemplate analysisTemplate = CreateAnalysisTemplate(db);
AFAnalysis an = CreateAnalysis(db, el, analysisCategory1, analysisCategory2);
AFEventFrame ef = CreateEventFrame(db, null, elementCategory1);
AFElementTemplate eventFrameTemplate = CreateEventFrameTemplate(db);
AFEventFrame ef2 = CreateEventFrame(db, eventFrameTemplate, elementCategory1);
db.CheckIn();
}
private AFAnalysis CreateAnalysis(AFDatabase db, AFElement el, AFCategory analysisCategory1, AFCategory analysisCategory2)
{
AFAttribute attribute = el.Attributes["Temperature Average"];
AFAnalysis an = el.Analyses[Constants.AF_ANALYSIS_NAME];
if (an == null)
{
an = el.Analyses.Add(Constants.AF_ANALYSIS_NAME);
an.Description = "Analysis for Washington Temeperature Average";
an.AnalysisRulePlugIn = _piSystem.AnalysisRulePlugIns["EventFrame"];
an.AnalysisRule.ConfigString = "Avg2d := TagAvg('Temperature','*-2d','*');Avg1d := TagAvg('Temperature','*-1d','*');SumAvg := Avg1d+Avg2d+2;";
an.AnalysisRule.MapVariable("SumAvg", attribute);
an.TimeRulePlugIn = _piSystem.TimeRulePlugIns[Constants.AF_TIMERULE_NAME];
an.TimeRule.ConfigString = "Frequency=300";
an.SetStatus(AFStatus.Enabled);
an.Categories.Add(analysisCategory1);
an.Categories.Add(analysisCategory2);
}
return(an);
}
public void UpdateTest()
{
string path = Constants.AF_ANALYSIS_CATEGORY_PATH;
PIAnalysisCategory category = instance.Get(webId, null);
category.WebId = null;
category.Id = null;
category.Links = null;
category.Path = null;
category.Description = "This is the new analysis category swagger description";
instance.Update(webId, category);
StandardPISystem.Refresh();
AFCategory myCategory = AFObject.FindObject(path) as AFCategory;
myCategory.Refresh();
if (myCategory != null)
{
Assert.IsTrue(myCategory.Description == category.Description);
}
}
public void UpdateTest()
{
string path = Constants.AF_TABLE_CATEGORY_PATH;
PITableCategory tableCategory = instance.GetByPath(path, null);
tableCategory.Id = null;
tableCategory.Description = "New table category description";
tableCategory.Links = null;
tableCategory.Path = null;
tableCategory.WebId = null;
instance.Update(webId, tableCategory);
StandardPISystem.Refresh();
AFCategory myCategory = AFObject.FindObject(path) as AFCategory;
myCategory.Refresh();
if (myCategory != null)
{
Assert.IsTrue(myCategory.Description == tableCategory.Description);
}
}
public void UpdateTest()
{
string path = Constants.AF_ELEMENT_CATEGORY_PATH;
PIElementCategory category = instance.GetByPath(path, null);
category.Id = null;
category.Description = "New element category description";
category.Links = null;
category.Path = null;
category.WebId = null;
instance.Update(webId, category);
StandardPISystem.Refresh();
AFCategory myCategory = AFObject.FindObject(path) as AFCategory;
myCategory.Refresh();
myCategory.Database.Refresh();
if (myCategory != null)
{
Assert.IsTrue(myCategory.Description == category.Description);
}
}
/// <summary>
///
/// </summary>
/// <param name="owningElement"></param>
/// <param name="restrictByTemplate"></param>
/// <param name="requiredTemplate"></param>
/// <returns></returns>
public AFValue Count(AFElement owningElement, bool restrictByTemplate, AFElementTemplate requiredTemplate, bool restrictByCategory, AFCategory requiredCategory)
{
try
{
long _count = 0;
if ((restrictByTemplate) && (requiredTemplate != null))
{
foreach (AFElement child in owningElement.Elements)
{
if (child.Template == requiredTemplate)
{
_count++;
}
}
return(new AFValue(_count));
//return new AFValue(_count, (AFTime)DateTime.Now);
}
else if ((restrictByCategory) && (requiredCategory != null))
{
foreach (AFElement child in owningElement.Elements)
{
if (child.Categories.Contains(requiredCategory))
{
_count++;
}
}
return(new AFValue(_count));
}
else
{
return(new AFValue(owningElement.Elements.Count, (AFTime)DateTime.Now));
}
}
catch
{
return(new AFValue(Double.NaN, (AFTime)DateTime.Now, null, AFValueStatus.Bad));
}
}
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);
}
}
private AFEventFrame CreateEventFrame(AFDatabase db, AFElementTemplate eventFrameTemplate, AFCategory elementCategory)
{
AFEventFrame ef = null;
if (eventFrameTemplate == null)
{
AFElement el2 = db.Elements[Constants.AF_ELEMENT_NAME + "2"];
AFElement el = db.Elements[Constants.AF_ELEMENT_NAME];
AFTime startTime = new AFTime(DateTime.Now.AddDays(-1));
ef = new AFEventFrame(db, Constants.AF_EVENT_FRAME_NAME);
ef.ReferencedElements.Add(el);
ef.ReferencedElements.Add(el2);
ef.PrimaryReferencedElement = el;
ef.SetStartTime(startTime);
ef.CanBeAcknowledged = true;
ef.SetEndTime(new AFTime("*"));
ef.Categories.Add(elementCategory);
AFEventFrame ef1 = ef.EventFrames.Add(Constants.AF_EVENT_FRAME_NAME + "Child1");
AFEventFrame ef2 = ef.EventFrames.Add(Constants.AF_EVENT_FRAME_NAME + "Child2");
ef.Attributes.Add(Constants.AF_ATTRIBUTE_NAME);
IList <AFAnnotation> annotations = el.GetAnnotations();
AFAnnotation ann = new AFAnnotation(ef);
ann.Name = Constants.AF_EVENT_FRAME_ANNOTATION_NAME;
ann.Value = "Sample value for annotation";
ann.Save();
}
else
{
AFElement myTank1 = db.Elements["Tank 1"];
AFElement myTank2 = db.Elements["Tank 2"];
AFTime startTime = new AFTime("*-1d");
ef = new AFEventFrame(db, "Tank Level 1", eventFrameTemplate);
ef.ReferencedElements.Add(myTank1);
ef.ReferencedElements.Add(myTank2);
ef.PrimaryReferencedElement = myTank1;
ef.SetStartTime(AFTime.Now);
ef.CheckIn();
AFTime endTime = AFTime.Now;
ef.SetEndTime(endTime);
}
return(ef);
}
private AFElement CreateElementAndAttributes(AFDatabase db, AFCategory elementCategory, AFCategory attributeCategory)
{
AFElement el2 = db.Elements[Constants.AF_ELEMENT_NAME + "2"];
if (el2 == null)
{
el2 = db.Elements.Add(Constants.AF_ELEMENT_NAME + "2");
}
AFElement el = db.Elements[Constants.AF_ELEMENT_NAME];
if (el == null)
{
el = db.Elements.Add(Constants.AF_ELEMENT_NAME);
el.Elements.Add(Constants.AF_ELEMENT_NAME + "Child1");
el.Elements.Add(Constants.AF_ELEMENT_NAME + "Child2");
el.Categories.Add(elementCategory);
}
AFAttribute tempAvg = el.Attributes["Temperature Average"];
if (tempAvg == null)
{
tempAvg = el.Attributes.Add("Temperature Average");
tempAvg.Type = typeof(Double);
tempAvg.DefaultUOM = _piSystem.UOMDatabase.UOMClasses["Temperature"].UOMs["degree Celsius"];
}
AFAttribute temp = el.Attributes["Temperature"];
if (temp == null)
{
temp = el.Attributes.Add("Temperature");
temp.Type = typeof(Double);
temp.DataReferencePlugIn = _piSystem.DataReferencePlugIns["PI Point"];
temp.ConfigString = @"\\" + Constants.PI_DATA_SERVER_NAME + @"\sinusoid";
temp.DefaultUOM = _piSystem.UOMDatabase.UOMClasses["Temperature"].UOMs["degree Celsius"];
AFAttribute limitHiAttr = temp.Attributes.Add(AFAttributeTrait.LimitHi.Abbreviation);
limitHiAttr.Trait = AFAttributeTrait.LimitHi;
limitHiAttr.SetValue(100, temp.DefaultUOM);
}
AFAttribute attribute = el.Attributes[Constants.AF_ATTRIBUTE_NAME];
if (attribute == null)
{
attribute = el.Attributes.Add(Constants.AF_ATTRIBUTE_NAME);
attribute.Type = typeof(Double);
attribute.DefaultUOM = _piSystem.UOMDatabase.UOMClasses["Temperature"].UOMs["degree Celsius"];
attribute.Categories.Add(attributeCategory);
AFAttribute childAttribute = attribute.Attributes.Add(Constants.AF_ATTRIBUTE_NAME + "Child1");
AFAttribute childAttribute2 = attribute.Attributes.Add(Constants.AF_ATTRIBUTE_NAME + "Child2");
AFAttribute limitHiAttr = attribute.Attributes.Add(AFAttributeTrait.LimitHi.Abbreviation);
limitHiAttr.Trait = AFAttributeTrait.LimitHi;
limitHiAttr.SetValue(100, temp.DefaultUOM);
}
return(el);
}
private static void CreateTemplates(AFDatabase database)
{
if (database == null)
{
return;
}
UOM uom = database.PISystem.UOMDatabase.UOMs["kilowatt hour"];
AFCategory mEnergyE = database.ElementCategories["Measures Energy"];
AFCategory sStatusE = database.ElementCategories["Shows Status"];
AFCategory bInfoA = database.AttributeCategories["Building Info"];
AFCategory locationA = database.AttributeCategories["Location"];
AFCategory tsDataA = database.AttributeCategories["Time-Series Data"];
AFEnumerationSet bTypeNum = database.EnumerationSets["Building Type"];
AFEnumerationSet mStatusEnum = database.EnumerationSets["Meter Status"];
// Create MeterBasic Element Template
AFElementTemplate meterBasicTemplate;
if (!database.ElementTemplates.Contains("MeterBasic"))
{
meterBasicTemplate = database.ElementTemplates.Add("MeterBasic");
meterBasicTemplate.Categories.Add(mEnergyE);
AFAttributeTemplate substationAttrTemp = meterBasicTemplate.AttributeTemplates.Add("Substation");
substationAttrTemp.Type = typeof(string);
AFAttributeTemplate usageLimitAttrTemp = meterBasicTemplate.AttributeTemplates.Add("Usage Limit");
usageLimitAttrTemp.Type = typeof(string);
usageLimitAttrTemp.DefaultUOM = uom;
AFAttributeTemplate buildingAttrTemp = meterBasicTemplate.AttributeTemplates.Add("Building");
buildingAttrTemp.Type = typeof(string);
buildingAttrTemp.Categories.Add(bInfoA);
AFAttributeTemplate bTypeAttrTemp = meterBasicTemplate.AttributeTemplates.Add("Building Type");
bTypeAttrTemp.TypeQualifier = bTypeNum;
bTypeAttrTemp.Categories.Add(bInfoA);
AFAttributeTemplate districtAttrTemp = meterBasicTemplate.AttributeTemplates.Add("District");
districtAttrTemp.Type = typeof(string);
districtAttrTemp.Categories.Add(locationA);
AFAttributeTemplate energyUsageAttrTemp = meterBasicTemplate.AttributeTemplates.Add("Energy Usage");
energyUsageAttrTemp.Type = typeof(double);
energyUsageAttrTemp.Categories.Add(tsDataA);
energyUsageAttrTemp.DefaultUOM = uom;
energyUsageAttrTemp.DataReferencePlugIn = database.PISystem.DataReferencePlugIns["PI Point"];
energyUsageAttrTemp.ConfigString = @"\\%Server%\%Element%.%Attribute%;UOM=kWh";
}
else
{
meterBasicTemplate = database.ElementTemplates["MeterBasic"];
}
// Create MeterAdvanced Element Template
if (!database.ElementTemplates.Contains("MeterAdvanced"))
{
AFElementTemplate meterAdvancedTemplate = database.ElementTemplates.Add("MeterAdvanced");
meterAdvancedTemplate.BaseTemplate = meterBasicTemplate;
AFAttributeTemplate statusAttrTemp = meterAdvancedTemplate.AttributeTemplates.Add("Status");
statusAttrTemp.TypeQualifier = mStatusEnum;
statusAttrTemp.Categories.Add(tsDataA);
statusAttrTemp.DataReferencePlugIn = database.PISystem.DataReferencePlugIns["PI Point"];
statusAttrTemp.ConfigString = @"\\%Server%\%Element%.%Attribute%";
// Create District Element Template
AFElementTemplate districtTemplate = database.ElementTemplates.Add("District");
AFAttributeTemplate districtEnergyUsageAttrTemp = districtTemplate.AttributeTemplates.Add("Energy Usage");
districtEnergyUsageAttrTemp.Type = typeof(double);
districtEnergyUsageAttrTemp.DefaultUOM = uom;
districtEnergyUsageAttrTemp.DataReferencePlugIn = database.PISystem.DataReferencePlugIns["PI Point"];
districtEnergyUsageAttrTemp.ConfigString = @"\\%Server%\%Element%.%Attribute%";
}
// Do a checkin at the end instead of one-by-one.
database.CheckIn();
}
public static bool convertTagNaming(AFDatabase db)
{
AFCategory tagnameCategory = db.AttributeCategories[tagname];
if (tagnameCategory == null)
{
tagnameCategory = db.AttributeCategories.Add(tagname);
}
foreach (AFElementTemplate template in db.ElementTemplates)
{
int depth = lookUpDepth(template);
foreach (AFAttributeTemplate attr in template.AttributeTemplates)
{
AFAttributeTemplate child = attr.AttributeTemplates[tagname];
if (child == null)
{
continue;
}
//attr.ConfigString = attr.ConfigString.Replace(tagname, "タグ名");
child.Name = tagname;
child.Description = "The name of the attribute";
string configString = @"'.|The English Name of the Attribute';";
child.IsHidden = true;
AFAttributeTemplate attributelookup = child.AttributeTemplates.Add("The English Name of the Attribute");
attributelookup.Categories.Add(tagnameCategory);
attributelookup.DataReferencePlugIn = db.PISystem.DataReferencePlugIns["Table Lookup"];
attributelookup.Description = "The English translation of the attribute's name";
var dummy = $" Translations_{language}";
attributelookup.DataReference.ConfigString = $"SELECT en FROM [Translations_{language}] WHERE {language} = '%..|..|attribute%';RWM=%..|..|Attribute%";
attributelookup.IsHidden = true;
string attributeName = "The English name of the Element";
string description = "The English translation of the element's name";
string elementField = "Element%";
for (int i = 0; i <= depth; i++)
{
configString = $@"'.|{attributeName}';""."";" + configString;
AFAttributeTemplate elementLookup = child.AttributeTemplates.Add(attributeName);
elementLookup.Categories.Add(tagnameCategory);
elementLookup.Description = description;
elementLookup.DataReferencePlugIn = db.PISystem.DataReferencePlugIns["Table Lookup"];
elementLookup.DataReference.ConfigString = $"SELECT en FROM [Translations_{language}] WHERE {language} = '%{elementField}';RWM=%{elementField}";
elementLookup.IsHidden = true;
if (attributeName.Contains("Parent"))
{
attributeName = attributeName.Replace("Parent", "Great-Parent");
}
else
{
attributeName = attributeName.Replace("Element", "Parent Element");
}
// description = "親の" + description;
elementField = @"..\" + elementField;
}
child.ConfigString = @"OSIDEMO_;" + configString + @";""."";%..|AttributeID%";
}
}
db.CheckIn();
return(true);
}
