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();
}
}
static void translateTableHeaders(AFTable table, DataTable translations)
{
foreach (DataColumn column in table.Table.Columns)
{
column.ColumnName = translate(translations, column.ColumnName, "Japanese");
}
}
public void UpdateDataTest()
{
string path = Constants.AF_TABLE_PATH;
PITableData data = new PITableData();
data.Columns = new Dictionary <string, string>();
data.Columns.Add("Model", "String");
data.Columns.Add("4WD", "Boolean");
data.Columns.Add("TopSpeed", "Int32");
data.Rows = new List <Dictionary <string, object> >();
var item1 = new Dictionary <string, object>();
item1.Add("Model", "Jeep");
item1.Add("4WD", true);
item1.Add("TopSpeed", 100);
var item2 = new Dictionary <string, object>();
item2.Add("Model", "Prius");
item2.Add("4WD", false);
item2.Add("TopSpeed", 80);
data.Rows.Add(item1);
data.Rows.Add(item2);
instance.UpdateData(webId, data);
StandardPISystem.Refresh();
AFTable myTable = AFObject.FindObject(path) as AFTable;
myTable.Refresh();
Assert.IsTrue(myTable.Table.Rows.Count == 2);
Assert.IsTrue(myTable.Table.Columns.Count == 3);
}
static void addLanguageTitles(AFTable table)
{
DataTable datatable = new DataTable();
datatable.Columns.Add("en", typeof(System.String));
datatable.Columns.Add(language, typeof(System.String));
datatable.Columns.Add($"{language}_Check", typeof(System.Boolean));
table.Table = datatable;
}
static void addLanguageTitles(AFTable table)
{
DataTable datatable = new DataTable();
datatable.Columns.Add("English", typeof(System.String));
datatable.Columns.Add("Japanese", typeof(System.String));
datatable.Columns.Add("Chinese", typeof(System.String));
table.Table = datatable;
}
static void Main(string[] args)
{
PISystem local = new PISystems().DefaultPISystem;
AFDatabase db = local.Databases.DefaultDatabase;
AFTable translation = db.Tables["Translations"];
local.ExportXml(translation, PIExportMode.AllReferences, @"..\translation.xml", null, null, null);
AFTable uomconversion = db.Tables["UOM Conversion"];
local.ExportXml(uomconversion, PIExportMode.AllReferences, @"..\uomConversion.xml", null, null, null);
}
static AFTable createOrReturnTranslationLibrary(AFDatabase db)
{
AFTable translations = db.Tables["Translations"];
if (translations == null)
{
translations = db.Tables.Add("Translations");
addLanguageTitles(translations);
db.CheckIn();
}
return(translations);
}
static AFTable createOrReturnTranslationTable(AFDatabase db)
{
AFTable translations = db.Tables[$"Translations_{language}"];
if (translations == null)
{
translations = db.Tables.Add($"Translations_{language}");
addLanguageTitles(translations);
db.CheckIn();
}
return(translations);
}
public void DeleteTest()
{
instance.Delete(webId);
AFDatabase db = StandardPISystem.Databases[Constants.AF_DATABASE_NAME];
db.Refresh();
AFTable table = AFObject.FindObject(Constants.AF_ANALYSIS_CATEGORY_PATH) as AFTable;
Assert.IsNull(table);
DeleteSampleDatabaseForTests();
CreateSampleDatabaseForTests();
}
static AFTable createUOMTable(AFDatabase db)
{
AFTable table = db.Tables["UOM Groupings"];
if (table == null)
{
table = db.Tables.Add("UOM Groupings");
DataTable datatable = new DataTable();
datatable.Columns.Add("Original", typeof(System.String));
datatable.Columns.Add(uomgrouping, typeof(System.String));
table.Table = datatable;
db.CheckIn();
}
return(table);
}
static void storeAllTableHeaders(AFTable table, DataTable dt)
{
addNameAndDescription(dt, table, table);
foreach (DataColumn column in table.Table.Columns)
{
insert(dt, column.ColumnName);
}
foreach (DataRow row in table.Table.Rows)
{
foreach (var entry in row.ItemArray)
{
if (entry is string)
{
insert(dt, entry.ToString());
}
}
}
}
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 AFTable CreateTable(AFDatabase db)
{
DataTable dtMyTable = new DataTable();
dtMyTable.Locale = CultureInfo.InvariantCulture;
AFTable myTable = db.Tables.Add(Constants.AF_TABLE_NAME);
myTable.Description = "This is my table.";
dtMyTable.Columns.Add("TankName", typeof(System.String));
dtMyTable.Columns.Add("Height", typeof(System.Double));
dtMyTable.Columns.Add("Volume", typeof(System.Double));
DataRow drMyRow0 = dtMyTable.NewRow();
drMyRow0["TankName"] = "TK101";
drMyRow0["Height"] = 0;
drMyRow0["Volume"] = 0;
DataRow drMyRow1 = dtMyTable.NewRow();
drMyRow1["TankName"] = "TK101";
drMyRow1["Height"] = 1;
drMyRow1["Volume"] = 12.4;
DataRow drMyRow2 = dtMyTable.NewRow();
drMyRow2["TankName"] = "TK101";
drMyRow2["Height"] = 2;
drMyRow2["Volume"] = 48.6;
dtMyTable.Rows.Add(drMyRow0);
dtMyTable.Rows.Add(drMyRow1);
dtMyTable.Rows.Add(drMyRow2);
// Set the Table and CachInterval Properties
// and Set the UOM for Volume
myTable.Table = dtMyTable;
myTable.CacheInterval = TimeSpan.FromMinutes(10);
myTable.SetExtendedProperty("Volume", "UOM", "US gal");
return(myTable);
}
private AFAttributeList LoadParameters()
{
if (Attribute == null || Attribute.Element == null)
{
throw new ApplicationException("Attribute and/or element is null");
}
AFDatabase afDB = base.Database;
AFTable afTable = afDB.Tables[fTableName];
if (afTable == null)
{
throw new ArgumentException("Table not found");
}
fDataRows = afTable.Table.Select();
var paramAttributes = new AFAttributeList();
if (!string.IsNullOrEmpty(fAttributeName))
{
// find Attribute's object by it name from parameters (this attribute contains key values)
var refAttr = AFAttribute.FindAttribute(fAttributeName, Attribute);
if (refAttr == null)
{
throw new ApplicationException(string.Format(Resources.ERR_AttributeHasNotBeenFound, fAttributeName));
}
if (!Extensions.IsNumericType(refAttr.Type))
{
throw new ApplicationException(string.Format("The attribute `{0}` has no numeric type ", fAttributeName));
}
paramAttributes.Add(refAttr);
}
else
{
throw new ApplicationException("Name of lookup attribute is null or empty");
}
return(paramAttributes);
}
public void UpdateTest()
{
string path = Constants.AF_TABLE_PATH;
PITable table = instance.GetByPath(path, null);
table.Id = null;
table.Description = "New table description";
table.Links = null;
table.Path = null;
table.WebId = null;
instance.Update(webId, table);
StandardPISystem.Refresh();
AFTable myTable = AFObject.FindObject(path) as AFTable;
myTable.Refresh();
if (myTable != null)
{
Assert.IsTrue(myTable.Description == table.Description);
}
}
private void cmbTable_SelectedIndexChanged(object sender, EventArgs e)
{
string selectedTableName = cmbTable.Text;
AFTable selectedTable = fTables[selectedTableName];
if (selectedTable != null && selectedTable.IsDeleted)
{
selectedTable = null;
}
if (selectedTable != null)
{
cmbKeyField.Items.Clear();
cmbValueField.Items.Clear();
DataTable dataTable;
try {
dataTable = selectedTable.Table;
} catch (Exception) {
dataTable = null;
}
if (dataTable != null)
{
cmbKeyField.BeginUpdate();
cmbValueField.BeginUpdate();
foreach (DataColumn dataColumn in dataTable.Columns)
{
cmbKeyField.Items.Add(dataColumn.ColumnName);
cmbValueField.Items.Add(dataColumn.ColumnName);
}
cmbKeyField.EndUpdate();
cmbValueField.EndUpdate();
}
}
}
static void fillEnglishTable(AFDatabase db)
{
AFTable translation = createOrReturnTranslationTable(db);
DataTable dt = translation.Table;
insert(dt, db.Description);
foreach (AFElement element in db.Elements)
{
storeAllElement(element, dt);
}
db.CheckIn();
foreach (AFTable table in db.Tables)
{
if (!table.Name.StartsWith("Translations_") && table.Name != "UOM Groupings" && table.Name != "Currency Conversion")
{
storeAllTableHeaders(table, dt);
}
}
db.CheckIn();
foreach (AFElementTemplate elem in db.ElementTemplates)
{
addNameAndDescription(dt, elem, elem);
insert(dt, elem.NamingPattern);
}
foreach (var analysis in db.AnalysisTemplates)
{
addNameAndDescription(dt, analysis, analysis);
if (analysis.AnalysisRulePlugIn.Name == "PerformanceEquation")
{
addCodeComments(analysis, dt);
}
}
db.CheckIn();
foreach (AFCategory category in db.AnalysisCategories)
{
addNameAndDescription(dt, category, category);
}
foreach (AFCategory category in db.ElementCategories)
{
addNameAndDescription(dt, category, category);
}
foreach (AFCategory category in db.AttributeCategories)
{
addNameAndDescription(dt, category, category);
}
foreach (AFCategory category in db.TableCategories)
{
addNameAndDescription(dt, category, category);
}
foreach (AFCategory category in db.ReferenceTypeCategories)
{
addNameAndDescription(dt, category, category);
}
db.CheckIn();
foreach (var enumSet in db.EnumerationSets)
{
storeEnumerationSet(enumSet, dt);
}
removeUnused(dt);
}
