/// <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); }