/// <summary>
/// Add the commaseparated fields in the collection by calling AddField on each one.
/// If the field is an array field, all the array elements are added.
/// </summary>
/// <param name="result">The result where the fields are added</param>
/// <param name="fields">The collection of fields to add</param>
/// <param name="first">A parameter specifying whether or not this is the first field.</param>
private void AddFields(StringBuilder result, AxTable table, IEnumerable <AxTableField> fields, ref bool first)
{
foreach (AxTableField field in fields)
{
if (field.SaveContents == Metadata.Core.MetaModel.NoYes.Yes)
{
var label = this.GetFieldLabel(field);
this.AddField(result, table.Name, field.Name, label, ref first);
var edt = field.ExtendedDataType;
if (!string.IsNullOrWhiteSpace(edt))
{
// See if it happens to be an array field. If so, the first index
// does not have a suffix ([<n>]), and has already been written.
if (this.MetadataProvider.Edts.Exists(edt))
{
AxEdt typeDefinition = this.metadataProvider.Edts.Read(edt);
for (int i = 2; i <= typeDefinition.ArrayElements.Count + 1; i++)
{
var fn = field.Name + "[" + i.ToString(CultureInfo.InvariantCulture) + "]";
this.AddField(result, table.Name, fn, null, ref first);
}
}
}
}
}
}
public void InitFromSelectedElement(AddinDesignerEventArgs e)
{
Fields = new List <AxTableFieldParm>();
FieldsStr = "";
int curPos = 0;
foreach (BaseField baseField in e.SelectedElements.OfType <BaseField>())
{
curPos++;
AxTableFieldParm fieldParm = new AxTableFieldParm();
fieldParm.FieldName = baseField.Name;
fieldParm.FieldType = baseField.ExtendedDataType;
fieldParm.IsMandatory = baseField.Mandatory == NoYes.Yes ? true : false;
fieldParm.Position = curPos;
if (fieldParm.FieldType == "")
{
if (baseField is FieldEnum)
{
fieldParm.FieldType = (baseField as FieldEnum).EnumType;
}
}
Fields.Add(fieldParm);
FieldsStr += fieldParm.FieldName + Environment.NewLine;
}
var field = (BaseField)e.SelectedElement;
AxTable axTable = (AxTable)field.Table.GetMetadataType();
TableName = axTable.Name;
VarName = AxHelper.GetVarNameFromType(TableName);
}
/// <summary>
/// Add the system fields to the output file, if the metadata describing the table
/// indicates that the field is used.
/// </summary>
/// <param name="result">The string builder that contains the output</param>
/// <param name="table">The metadata describing the table.</param>
/// <param name="first">A parameter specifying whether or not this is the first field.</param>
private void AddSystemFields(StringBuilder result, AxTable table, ref bool first)
{
if (table.CreatedBy == Metadata.Core.MetaModel.NoYes.Yes)
{
this.AddField(result, table.Name, "CreatedBy", null, ref first);
}
if (table.CreatedDateTime == Metadata.Core.MetaModel.NoYes.Yes)
{
this.AddField(result, table.Name, "CreatedDateTime", null, ref first);
}
if (table.ModifiedBy == Metadata.Core.MetaModel.NoYes.Yes)
{
this.AddField(result, table.Name, "ModifiedBy", null, ref first);
}
if (table.ModifiedDateTime == Metadata.Core.MetaModel.NoYes.Yes)
{
this.AddField(result, table.Name, "ModifiedDateTime", null, ref first);
}
if (table.SaveDataPerPartition == Metadata.Core.MetaModel.NoYes.Yes)
{
this.AddField(result, table.Name, "Partition", null, ref first);
}
if (table.SaveDataPerCompany == Metadata.Core.MetaModel.NoYes.Yes)
{
this.AddField(result, table.Name, "DataAreaId", null, ref first);
}
this.AddField(result, table.Name, "RecId", null, ref first);
}
static public string MessageFromCompilerBaseType(CompilerBaseType type, string typeName)
{
string ret = string.Empty;
switch (type)
{
case CompilerBaseType.ExtendedDataType:
AxEdt axEdt = Utils.MetadataProvider.Edts.Read(typeName);
ret = $"{Utils.ResolveLabel(axEdt.Label).ToLower()} value";
break;
case CompilerBaseType.Record:
AxTable axTable = Utils.MetadataProvider.Tables.Read(typeName);
ret = $"A <c>{typeName}</c> table record";
break;
case CompilerBaseType.Class:
ret = $"A <c>{typeName}</c> class instance";
break;
default:
break;
}
return(ret);
}
public void CheckData(List <NewFieldEngine> fieldsValuesList, AxHelper axHelperLocal)
{
KeyedObjectCollection <AxTableField> tableFields;
List <string> newFieldsList = new List <string>();
if (TableName.Contains(".") == false)
{
AxTable axTable = axHelperLocal.MetadataProvider.Tables.Read(TableName);
tableFields = axTable.Fields;
}
else
{
AxTableExtension axTableExtension = axHelperLocal.MetadataProvider.TableExtensions.Read(TableName);
tableFields = axTableExtension.Fields;
}
foreach (NewFieldEngine newFieldEngine in GetFieldsValues())
{
if (tableFields.Contains(newFieldEngine.FieldName))
{
throw new Exception($"Field {newFieldEngine.FieldName} already exists in the table {TableName}");
}
if (newFieldsList.Contains(newFieldEngine.FieldName))
{
throw new Exception($"Field {newFieldEngine.FieldName} specified several times");
}
newFieldsList.Add(newFieldEngine.FieldName);
}
}
protected override void Create()
{
var element = new AxTable {
Name = ElementName
};
MetaService.CreateTable(element, Model);
}
public void InitFromTable()
{
_axHelper = new AxHelper();
AxTable newTable = _axHelper.MetadataProvider.Tables.Read(TableName);
if (newTable != null)
{
FormName = TableName;
FormLabel = newTable.Label;
}
}
void DoTableUpdate()
{
AxTable newTable = _axHelper.MetadataProvider.Tables.Read(TableName);
if (newTable != null)
{
AxTableFieldGroup axTableFieldGroup;
bool isTableModified = false;
switch (TemplateType)
{
case FormTemplateType.SimpleList:
if (!string.IsNullOrWhiteSpace(GroupNameGrid) && !newTable.FieldGroups.Contains(GroupNameGrid))
{
axTableFieldGroup = new AxTableFieldGroup {
Name = GroupNameGrid, Label = "Overview"
};
newTable.AddFieldGroup(axTableFieldGroup);
isTableModified = true;
AddLog($"Group added: {GroupNameGrid}; ");
}
break;
case FormTemplateType.SimpleListDetails:
if (!string.IsNullOrWhiteSpace(GroupNameGrid) && !newTable.FieldGroups.Contains(GroupNameGrid))
{
axTableFieldGroup = new AxTableFieldGroup {
Name = GroupNameGrid, Label = "Overview"
};
newTable.AddFieldGroup(axTableFieldGroup);
isTableModified = true;
AddLog($"Group added: {GroupNameGrid}; ");
}
if (!string.IsNullOrWhiteSpace(GroupNameHeader) && !newTable.FieldGroups.Contains(GroupNameHeader))
{
axTableFieldGroup = new AxTableFieldGroup {
Name = GroupNameHeader, Label = "Details header"
};
newTable.AddFieldGroup(axTableFieldGroup);
isTableModified = true;
AddLog($"Group added: {GroupNameHeader}; ");
}
break;
}
if (isTableModified)
{
_axHelper.MetaModelService.UpdateTable(newTable, _axHelper.ModelSaveInfo);
_axHelper.AppendToActiveProject(newTable);
//AddLog($"Table modified: {newTable.Name}; ");
}
}
}
public void InitFromRelation(Relation relation)
{
Table1 = relation.RelatedTable;
Table2 = relation.Table.Name;
Table1Var = AxHelper.GetVarNameFromType(Table1);
Table2Var = AxHelper.GetVarNameFromType(Table2);
string relationName;
relationName = relation.Name;
RelationsList = new List <RelationDef>();
AxHelper axHelper = new AxHelper();
AxTable axTable = axHelper.MetadataProvider.Tables.Read(Table2);
AxTableRelation axTableRelation = axTable.Relations[relationName];
foreach (AxTableRelationConstraint relationPair in axTableRelation.Constraints)
{
RelationDef pair = new RelationDef();
if (relationPair is AxTableRelationConstraintField)
{
pair.Field1 = (relationPair as AxTableRelationConstraintField).RelatedField;
pair.Field2 = (relationPair as AxTableRelationConstraintField).Field;
}
else
{
if (relationPair is AxTableRelationConstraintFixed)
{
pair.Field1 = (relationPair as AxTableRelationConstraintFixed).ValueStr;
pair.Field2 = (relationPair as AxTableRelationConstraintFixed).Field;
pair.Field1Fixed = true;
}
else
{
if (relationPair is AxTableRelationConstraintRelatedFixed)
{
pair.Field1 = (relationPair as AxTableRelationConstraintRelatedFixed).RelatedField;
pair.Field2 = (relationPair as AxTableRelationConstraintRelatedFixed).ValueStr;
pair.Field2Fixed = true;
}
}
}
if (!String.IsNullOrEmpty(pair.Field1))
{
RelationsList.Add(pair);
}
}
}
/// <summary>
/// Find the sequence of tables from the table to its root in the inheritance chain.
/// If the indicated table is not part of a supertype subtype relationship, the
/// result contains just the single table.
/// </summary>
/// <param name="leafTableName">The most derived table.</param>
/// <returns>The sequence of tables, with the root at the top of the stack.</returns>
private Stack <AxTable> SuperTables(string leafTableName)
{
Stack <AxTable> result = new Stack <AxTable>();
AxTable table = this.MetadataProvider.Tables.Read(leafTableName);
while (table.SupportInheritance == Metadata.Core.MetaModel.NoYes.Yes &&
!string.IsNullOrWhiteSpace(table.Extends))
{
result.Push(table);
table = this.MetadataProvider.Tables.Read(table.Extends);
}
result.Push(table); // stack the root.
return(result);
}
protected string ConvertRelationFilterToString(AxEdtTableReferenceFilter referenceFilter)
{
string res = "";
AxTable axTableRef = _axHelper.MetadataProvider.Tables.Read(referenceFilter.Table);
AxTableFieldEnum field = axTableRef?.Fields[referenceFilter.RelatedField] as AxTableFieldEnum;
if (field != null && !String.IsNullOrEmpty(field.EnumType))
{
AxEnum axEnum = _axHelper.MetadataProvider.Enums.Read(field.EnumType);
AxEnumValue axEnumValue = axEnum?.EnumValues[referenceFilter.Value];
if (axEnumValue != null && axEnumValue.Value == referenceFilter.Value)
{
res = $"{axEnum.Name}::{axEnumValue.Name}";
}
}
return(res);
}
protected void addField(Metadata.MetaModel.AxTableField field)
{
if (this.namedElement is Table)
{
AxTable axTable = this.MetadataProvider.Tables.Read(this.namedElement.Name);
axTable.Fields.Add(field);
this.MetadataProvider.Tables.Update(axTable, this.ModelSaveInfo);
}
else
{
var extensionName = this.namedElement.Name.Split('.');
AxTableExtension axTableExtension = this.MetadataProvider.TableExtensions.Read(this.namedElement.Name);
axTableExtension.Fields.Add(field);
this.MetadataProvider.TableExtensions.Update(axTableExtension, this.ModelSaveInfo);
}
}
public void InitFromSelectedElement(AddinDesignerEventArgs e)
{
if (_axHelper == null)
{
_axHelper = new AxHelper();
}
BaseField baseField = e.SelectedElements.OfType <BaseField>().First();
SelectedField = baseField.Name;
TableName = baseField.Table != null?baseField.Table.GetMetadataType().Name : baseField.TableExtension?.GetMetadataType().Name;
NewFieldEngine newFieldEngine = new NewFieldEngine();
newFieldEngine.GetSetHelper = _axHelper;
if (TableName.Contains(".") == false)
{
_axTable = _axHelper.MetadataProvider.Tables.Read(TableName);
AxTableField axTableField = _axTable.Fields[baseField.Name];
TableRelationForeignKey = newFieldEngine.AddTableRelation(axTableField, _axTable.Relations);
}
else
{
_axTableExtension = _axHelper.MetadataProvider.TableExtensions.Read(TableName);
AxTableField axTableField = _axTableExtension.Fields[baseField.Name];
TableRelationForeignKey = newFieldEngine.AddTableRelation(axTableField, _axTableExtension.Relations);
}
if (TableRelationForeignKey == null)
{
throw new System.Exception($"Field {baseField.Name} doesn't have an EDT relation");
}
RelationName = TableRelationForeignKey.Name;
}
protected void AddField(AxTableField field)
{
AxTableFieldGroup axTableFieldGroup;
AxTableFieldGroupField axTableFieldGroupField = new AxTableFieldGroupField();
axTableFieldGroupField.Name = field.Name;
axTableFieldGroupField.DataField = field.Name;
if (TableName.Contains(".") == false)
{
AxTable axTable = _axHelper.MetadataProvider.Tables.Read(TableName);
if (IsDisplayMethod)
{
AxMethod axMethod = new AxMethod();
axMethod.Name = field.Name;
axMethod.Source = $"public display {field.ExtendedDataType} {field.Name}() " +
Environment.NewLine + "{" + Environment.NewLine + " return '';" + Environment.NewLine + "}";
axTable.AddMethod(axMethod);
}
else
{
axTable.Fields.Add(field);
}
if (GroupName != String.Empty)
{
if (axTable.FieldGroups.Contains(GroupName))
{
axTableFieldGroup = axTable.FieldGroups.getObject(GroupName);
axTableFieldGroup.AddField(axTableFieldGroupField);
}
else
{
axTableFieldGroup = new AxTableFieldGroup {
Name = GroupName
};
axTableFieldGroup.AddField(axTableFieldGroupField);
axTable.AddFieldGroup(axTableFieldGroup);
}
}
if (!IsDisplayMethod)
{
AxTableRelationForeignKey axTableRelationForeignKey = AddTableRelation(field, axTable.Relations);
if (axTableRelationForeignKey != null)
{
axTable.AddRelation(axTableRelationForeignKey);
}
}
_axHelper.MetadataProvider.Tables.Update(axTable, _axHelper.ModelSaveInfo);
}
else
{
AxTableExtension axTableExtension = _axHelper.MetadataProvider.TableExtensions.Read(TableName);
if (!IsDisplayMethod)
{
axTableExtension.Fields.Add(field);
}
if (GroupName != String.Empty)
{
if (axTableExtension.FieldGroups.Contains(GroupName))
{
axTableFieldGroup = axTableExtension.FieldGroups.getObject(GroupName);
axTableFieldGroup.AddField(axTableFieldGroupField);
}
else
{
axTableFieldGroup = new AxTableFieldGroup {
Name = GroupName
};
axTableFieldGroup.AddField(axTableFieldGroupField);
axTableExtension.FieldGroups.Add(axTableFieldGroup);
}
}
if (!IsDisplayMethod)
{
AxTableRelationForeignKey axTableRelationForeignKey = AddTableRelation(field, axTableExtension.Relations);
if (axTableRelationForeignKey != null)
{
axTableExtension.Relations.Add(axTableRelationForeignKey);
}
}
_axHelper.MetadataProvider.TableExtensions.Update(axTableExtension, _axHelper.ModelSaveInfo);
}
}
void DoTableCreate()
{
AxTable newTable = _axHelper.MetadataProvider.Tables.Read(TableName);
if (newTable == null)
{
newTable = new AxTable();
newTable.Name = TableName;
newTable.Label = TableLabel;
newTable.TitleField1 = KeyFieldName;
newTable.CacheLookup = RecordCacheLevel.Found;
newTable.ClusteredIndex = $"{KeyFieldName}Idx";
newTable.PrimaryIndex = newTable.ClusteredIndex;
newTable.ReplacementKey = newTable.ClusteredIndex;
newTable.TableGroup = TableGroup.Group;
newTable.CreatedBy = NoYes.Yes;
newTable.CreatedDateTime = NoYes.Yes;
newTable.ModifiedBy = NoYes.Yes;
newTable.ModifiedDateTime = NoYes.Yes;
AxTableField primaryField = new AxTableFieldString();
primaryField.Name = KeyFieldName;
primaryField.ExtendedDataType = PrimaryKeyEdtName;
primaryField.IgnoreEDTRelation = NoYes.Yes;
primaryField.AllowEdit = NoYes.No;
primaryField.Mandatory = NoYes.Yes;
newTable.AddField(primaryField);
AxTableField descriptionField = new AxTableFieldString();
descriptionField.Name = "Description";
descriptionField.ExtendedDataType = "Description";
newTable.AddField(descriptionField);
AxTableIndexField axTableIndexField = new AxTableIndexField();
axTableIndexField.DataField = KeyFieldName;
axTableIndexField.Name = KeyFieldName;
AxTableIndex axTableIndex = new AxTableIndex();
axTableIndex.Name = newTable.ClusteredIndex;
axTableIndex.AlternateKey = NoYes.Yes;
axTableIndex.AddField(axTableIndexField);
newTable.AddIndex(axTableIndex);
AxTableFieldGroup axTableFieldGroup;
AxTableFieldGroupField axTableFieldGroupField;
axTableFieldGroup = new AxTableFieldGroup {
Name = "AutoReport", IsSystemGenerated = NoYes.Yes
};
axTableFieldGroupField = new AxTableFieldGroupField
{
Name = KeyFieldName,
DataField = KeyFieldName
};
axTableFieldGroup.AddField(axTableFieldGroupField);
newTable.AddFieldGroup(axTableFieldGroup);
axTableFieldGroup = new AxTableFieldGroup {
Name = "AutoLookup", IsSystemGenerated = NoYes.Yes
};
newTable.AddFieldGroup(axTableFieldGroup);
axTableFieldGroup = new AxTableFieldGroup {
Name = "AutoIdentification", IsSystemGenerated = NoYes.Yes, AutoPopulate = NoYes.Yes
};
newTable.AddFieldGroup(axTableFieldGroup);
axTableFieldGroup = new AxTableFieldGroup {
Name = "AutoSummary", IsSystemGenerated = NoYes.Yes
};
newTable.AddFieldGroup(axTableFieldGroup);
axTableFieldGroup = new AxTableFieldGroup {
Name = "AutoBrowse", IsSystemGenerated = NoYes.Yes
};
newTable.AddFieldGroup(axTableFieldGroup);
axTableFieldGroup = new AxTableFieldGroup {
Name = "Overview", Label = "Overview"
};
axTableFieldGroupField = new AxTableFieldGroupField
{
Name = KeyFieldName, DataField = KeyFieldName
};
axTableFieldGroup.AddField(axTableFieldGroupField);
if (descriptionField != null)
{
axTableFieldGroupField = new AxTableFieldGroupField
{
Name = descriptionField.Name,
DataField = descriptionField.Name
};
axTableFieldGroup.AddField(axTableFieldGroupField);
}
newTable.AddFieldGroup(axTableFieldGroup);
AddTableFindMethodParms findMethodParms = new AddTableFindMethodParms();
findMethodParms.IsCreateFind = true;
findMethodParms.IsTestMode = true;
findMethodParms.TableName = TableName;
findMethodParms.VarName = TableVarName;
findMethodParms.Fields = new List <AxTableFieldParm>
{
new AxTableFieldParm
{
FieldName = KeyFieldName, FieldType = PrimaryKeyEdtName, IsMandatory = true
}
};
AxMethod axMethod = new AxMethod();
axMethod.Name = "find";
axMethod.IsStatic = true;
axMethod.Source = findMethodParms.GenerateResult();
newTable.AddMethod(axMethod);
_axHelper.MetaModelService.CreateTable(newTable, _axHelper.ModelSaveInfo);
_axHelper.AppendToActiveProject(newTable);
AddLog($"Table: {newTable.Name}; ");
AxEdt edtLocal = _axHelper.MetadataProvider.Edts.Read(PrimaryKeyEdtName);
if (edtLocal != null)
{
if (String.IsNullOrEmpty(edtLocal.ReferenceTable)) //check for the existing EDT. Do not modify it
{
if (edtLocal.Relations == null || edtLocal.Relations.Count == 0) //no old style relations
{
edtLocal.ReferenceTable = TableName;
edtLocal.AddTableReference(TableName, KeyFieldName);
_axHelper.MetaModelService.UpdateExtendedDataType(edtLocal, _axHelper.ModelSaveInfo);
_axHelper.AppendToActiveProject(edtLocal);
}
}
//AddLog($"EDT: {edtLocal.Name}; ");
}
}
}
public static void Create(UtilElementType type, string name)
{
if (Project == null)
{
throw new InvalidOperationException("No project selected.");
}
_name = name;
switch (type)
{
case UtilElementType.DisplayTool:
var existsDisplayTool = LocalUtils.MetaService.GetMenuItemDisplayNames().Contains(name);
if (!existsDisplayTool)
{
var displayMenu = new AxMenuItemDisplay {
Name = name
};
LocalUtils.MetaService.CreateMenuItemDisplay(displayMenu, Model);
AddAotElement <AxMenuItemDisplay>();
}
break;
case UtilElementType.OutputTool:
var existsOutputTool = LocalUtils.MetaService.GetMenuItemDisplayNames().Contains(name);
if (!existsOutputTool)
{
var outputMenu = new AxMenuItemOutput {
Name = name
};
LocalUtils.MetaService.CreateMenuItemOutput(outputMenu, Model);
AddAotElement <AxMenuItemOutput>();
}
break;
case UtilElementType.ActionTool:
var existsActionTool = LocalUtils.MetaService.GetMenuItemDisplayNames().Contains(name);
if (!existsActionTool)
{
var actionMenu = new AxMenuItemAction {
Name = name
};
LocalUtils.MetaService.CreateMenuItemAction(actionMenu, Model);
AddAotElement <AxMenuItemAction>();
}
break;
case UtilElementType.Query:
var existsQuery = LocalUtils.MetaService.GetQueryNames().Contains(name);
if (!existsQuery)
{
var query = new AxQuerySimple {
Name = name
};
LocalUtils.MetaService.CreateQuery(query, Model);
AddAotElement <AxQuerySimple>();
}
break;
case UtilElementType.Enum:
var Enum = LocalUtils.MetaService.GetEnumNames().Contains(name);
if (!Enum)
{
var edtEnum = new AxEnum {
Name = name
};
LocalUtils.MetaService.CreateEnum(edtEnum, Model);
AddAotElement <AxEnum>();
}
break;
case UtilElementType.ExtendedType:
break;
case UtilElementType.Table:
var existsTable = LocalUtils.MetaService.GetTableNames().Contains(name);
if (!existsTable)
{
var table = new AxTable {
Name = name
};
LocalUtils.MetaService.CreateTable(table, Model);
AddAotElement <AxTable>();
}
break;
case UtilElementType.Class:
var existsClass = LocalUtils.MetaService.GetClassNames().Contains(name);
if (!existsClass)
{
var axClass = new AxClass {
Name = name
};
LocalUtils.MetaService.CreateClass(axClass, Model);
AddAotElement <AxClass>();
}
break;
case UtilElementType.SSRSReport:
var existsSsrsReport = LocalUtils.MetaService.GetReportNames().Contains(name);
if (!existsSsrsReport)
{
var srsReport = new AxReport {
Name = name
};
LocalUtils.MetaService.CreateReport(srsReport, Model);
AddAotElement <AxReport>();
}
break;
case UtilElementType.Form:
var existsForm = LocalUtils.MetaService.GetFormNames().Contains(name);
if (!existsForm)
{
var axForm = new AxForm {
Name = name
};
LocalUtils.MetaService.CreateForm(axForm, Model);
AddAotElement <AxForm>();
}
break;
case UtilElementType.Menu:
var existsMenu = LocalUtils.MetaService.GetMenuNames().Contains(name);
if (!existsMenu)
{
var axMenu = new AxMenu {
Name = name
};
LocalUtils.MetaService.CreateMenu(axMenu, Model);
AddAotElement <AxMenu>();
}
break;
case UtilElementType.SecDuty:
var existsSecDuty = LocalUtils.MetaService.GetSecurityDutyNames().Contains(name);
if (!existsSecDuty)
{
var axDuty = new AxSecurityDuty {
Name = name
};
LocalUtils.MetaService.CreateSecurityDuty(axDuty, Model);
AddAotElement <AxSecurityDuty>();
}
break;
case UtilElementType.SecPolicy:
var existsSecPolicy = LocalUtils.MetaService.GetSecurityPolicyNames().Contains(name);
if (!existsSecPolicy)
{
var axPolicy = new AxSecurityPolicy {
Name = name
};
LocalUtils.MetaService.CreateSecurityPolicy(axPolicy, Model);
AddAotElement <AxSecurityPolicy>();
}
break;
case UtilElementType.SecPrivilege:
var existsSecPrivilege = LocalUtils.MetaService.GetSecurityPrivilegeNames().Contains(name);
if (!existsSecPrivilege)
{
var privilege = new AxSecurityPrivilege {
Name = name
};
LocalUtils.MetaService.CreateSecurityPrivilege(privilege, Model);
AddAotElement <AxSecurityPrivilege>();
}
break;
case UtilElementType.SecRole:
var existsSecRole = LocalUtils.MetaService.GetSecurityRoleNames().Contains(name);
if (!existsSecRole)
{
var role = new AxSecurityRole {
Name = name
};
LocalUtils.MetaService.CreateSecurityRole(role, Model);
AddAotElement <AxSecurityRole>();
}
break;
default:
throw new Exception("Element not supported");
}
}
/// <summary>
/// Generate the SQL command selecting the given fields from the underlying table.
/// </summary>
/// <param name="fields">The list of fields to select</param>
/// <returns>The string containing the SQL command.</returns>
private StringBuilder GenerateFromViewFieldList(IEnumerable <ViewsAutomation.IViewBaseField> fields)
{
var result = new StringBuilder();
result.AppendLine(string.Format(CultureInfo.InvariantCulture, "use {0}", BusinessDatabaseName));
result.AppendLine("go");
if (!fields.Any())
{
return(result);
}
ViewsAutomation.IView selectedView1 = fields.FirstOrDefault().View;
AxView view = this.MetadataProvider.Views.Read(selectedView1.Name);
// Expand the developer documentation, if any
if (!string.IsNullOrEmpty(view.DeveloperDocumentation))
{
result.Append("-- " + view.Name);
result.AppendLine(" : " + this.ResolveLabel(view.DeveloperDocumentation));
}
else
{
result.AppendLine();
}
result.AppendLine("select");
bool first = true;
foreach (ViewsAutomation.IViewField field in fields.OfType <ViewsAutomation.IViewField>())
{
this.AddField(result, view.Name, field.Name, null, ref first);
// The field name refers to a name on the datasource. Find the datasource
// and the underlying table.
AxTable table = this.FindTableInDataSource(view, field.DataSource);
table = this.SuperTables(table.Name).First();
if (table != null)
{
AxTableField tableField = table.Fields[field.DataField];
if (tableField != null)
{
var edt = tableField.ExtendedDataType;
if (!string.IsNullOrWhiteSpace(edt))
{
// See if it happens to be an array field. If so, the first index
// does not have a suffix ([<n>]), and has already been written.
if (this.MetadataProvider.Edts.Exists(edt))
{
AxEdt typeDefinition = this.metadataProvider.Edts.Read(edt);
for (int i = 2; i <= typeDefinition.ArrayElements.Count + 1; i++)
{
var fn = field.Name + "[" + i.ToString(CultureInfo.InvariantCulture) + "]";
this.AddField(result, view.Name, fn, null, ref first);
}
}
}
}
}
}
// Now deal with computed columns.
foreach (ViewsAutomation.IViewComputedColumn computedColumn in fields.OfType <ViewsAutomation.IViewComputedColumn>())
{
this.AddField(result, view.Name, computedColumn.Name, null, ref first);
}
result.AppendLine("from " + SqlNameMangling.GetSqlTableName(view.Name));
return(result);
}
