/// <summary>
/// Get the label provided in the field metadata. If no such label is provided, check
/// if the label's type is an EDT, that possibly has a label. If that fails, return null.
/// </summary>
/// <param name="field">The metadata instance describing the field</param>
/// <returns>The field label, if one is found, or null.</returns>
private string GetFieldLabel(AxTableField field)
{
// if the field has a label, use it.
var fieldLabel = this.ResolveLabel(field.Label);
if (!string.IsNullOrWhiteSpace(fieldLabel))
{
return(fieldLabel);
}
// if not, use the label on the EDT, if there is one
if (!string.IsNullOrWhiteSpace(field.ExtendedDataType))
{
// Fetch the EDT through the metadata provider
AxEdt edt = this.MetadataProvider.Edts.Read(field.ExtendedDataType);
if (edt != null)
{
var edtLabel = this.ResolveLabel(edt.Label);
if (!string.IsNullOrWhiteSpace(edtLabel))
{
return(edtLabel);
}
}
}
return(null);
}
protected void addGeneralPropertiesToField(AxTableField axTableField, AxEdt edt)
{
axTableField.Name = this.controller.textBoxFieldName.Text;
if (edt != null)
{
axTableField.ExtendedDataType = edt.Name;
}
}
protected AxTableRelationForeignKey AddTableRelation(AxTableField field, KeyedObjectCollection <AxTableRelation> existingRelations)
{
if (!string.IsNullOrEmpty(field.ExtendedDataType))
{
var edt = _axHelper.MetadataProvider.Edts.Read(field.ExtendedDataType);
if (edt == null)
{
return(null);
}
if (string.IsNullOrEmpty(edt.ReferenceTable))
{
return(null);
}
AxEdtTableReference firstRef = edt.TableReferences.First();
if (firstRef == null)
{
return(null);
}
string newRelationName = edt.ReferenceTable;
if (existingRelations.Contains(newRelationName))
{
newRelationName = edt.ReferenceTable + "_" + field.Name;
}
AxTableRelationForeignKey axTableRelation = new AxTableRelationForeignKey();
axTableRelation.Name = newRelationName;
axTableRelation.EDTRelation = NoYes.Yes;
axTableRelation.Cardinality = Cardinality.ZeroMore;
axTableRelation.OnDelete = DeleteAction.Restricted;
axTableRelation.RelatedTable = edt.ReferenceTable;
axTableRelation.RelatedTableCardinality =
IsMandatory ? RelatedTableCardinality.ExactlyOne : RelatedTableCardinality.ZeroOne;
axTableRelation.RelationshipType = RelationshipType.Association;
AxTableRelationConstraintField axTableRelationConstraint = new AxTableRelationConstraintField();
axTableRelationConstraint.Name = field.Name;
axTableRelationConstraint.Field = field.Name;
axTableRelationConstraint.SourceEDT = field.ExtendedDataType;
axTableRelationConstraint.RelatedField = firstRef.RelatedField;
axTableRelation.AddConstraint(axTableRelationConstraint);
return(axTableRelation);
}
return(null);
}
protected void addGeneralPropertiesToField(AxTableField axTableField, AxEdt edt)
{
axTableField.Name = this.controller.textBoxFieldName.Text;
if (edt != null)
{
axTableField.ExtendedDataType = edt.Name;
}
if (edtExist)
{
if (this.labelText != String.Empty)
{
axTableField.Label = this.labelText;
}
if (this.helpTextText != String.Empty)
{
axTableField.HelpText = this.helpTextText;
}
}
}
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;
}
public void Run()
{
AxEdt axEdt = null;
if (_axHelper == null)
{
_axHelper = new AxHelper();
}
if (EdtText != String.Empty)
{
axEdt = BuildEdt();
if (!IsEdtExist && axEdt != null)
{
_axHelper.MetaModelService.CreateExtendedDataType(axEdt, _axHelper.ModelSaveInfo);
_axHelper.AppendToActiveProject(axEdt);
}
}
AxTableField axTableField = BuildField(axEdt);
AddField(axTableField);
}
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);
}
}
protected AxTableRelationForeignKey AddTableRelation(AxTableField field, KeyedObjectCollection <AxTableRelation> existingRelations)
{
if (!string.IsNullOrEmpty(field.ExtendedDataType))
{
var edt = _axHelper.MetadataProvider.Edts.Read(field.ExtendedDataType);
if (edt == null)
{
return(null);
}
AxTableRelationForeignKey axTableRelation = null;
if (!string.IsNullOrEmpty(edt.ReferenceTable))
{
AxEdtTableReference firstRef = edt.TableReferences.First();
if (firstRef == null)
{
return(null);
}
string newRelationName = edt.ReferenceTable;
if (existingRelations.Contains(newRelationName))
{
newRelationName = edt.ReferenceTable + "_" + field.Name;
}
axTableRelation = new AxTableRelationForeignKey();
axTableRelation.Name = newRelationName;
axTableRelation.EDTRelation = NoYes.Yes;
axTableRelation.Cardinality = Cardinality.ZeroMore;
axTableRelation.OnDelete = DeleteAction.Restricted;
axTableRelation.RelatedTable = edt.ReferenceTable;
axTableRelation.RelatedTableCardinality =
IsMandatory ? RelatedTableCardinality.ExactlyOne : RelatedTableCardinality.ZeroOne;
axTableRelation.RelationshipType = RelationshipType.Association;
foreach (AxEdtTableReference tableRefLine in edt.TableReferences)
{
var localLineRef = tableRefLine as AxEdtTableReferenceFilter;
if (localLineRef != null)
{
AxTableRelationConstraintRelatedFixed axTableRelationConstraint = new AxTableRelationConstraintRelatedFixed();
axTableRelationConstraint.Name = localLineRef.RelatedField;
axTableRelationConstraint.RelatedField = localLineRef.RelatedField;
axTableRelationConstraint.Value = localLineRef.Value;
axTableRelation.AddConstraint(axTableRelationConstraint);
}
else
{
AxTableRelationConstraintField axTableRelationConstraint = new AxTableRelationConstraintField();
axTableRelationConstraint.Name = field.Name;
axTableRelationConstraint.Field = field.Name;
axTableRelationConstraint.SourceEDT = field.ExtendedDataType;
axTableRelationConstraint.RelatedField = tableRefLine.RelatedField;
axTableRelation.AddConstraint(axTableRelationConstraint);
}
}
}
else
{
if (edt.Relations != null && edt.Relations.Count > 0) //old style relation
{
AxEdtRelation firstEdtRelation = edt.Relations.First();
string newRelationName = firstEdtRelation.Table;
if (existingRelations.Contains(newRelationName))
{
newRelationName = edt.ReferenceTable + "_" + field.Name;
}
axTableRelation = new AxTableRelationForeignKey();
axTableRelation.Name = newRelationName;
axTableRelation.EDTRelation = NoYes.Yes;
axTableRelation.Cardinality = Cardinality.ZeroMore;
axTableRelation.OnDelete = DeleteAction.Restricted;
axTableRelation.RelatedTable = firstEdtRelation.Table;
axTableRelation.RelatedTableCardinality =
IsMandatory ? RelatedTableCardinality.ExactlyOne : RelatedTableCardinality.ZeroOne;
axTableRelation.RelationshipType = RelationshipType.Association;
AxTableRelationConstraintField axTableRelationConstraint = new AxTableRelationConstraintField();
axTableRelationConstraint.Name = field.Name;
axTableRelationConstraint.Field = field.Name;
axTableRelationConstraint.SourceEDT = field.ExtendedDataType;
axTableRelationConstraint.RelatedField = firstEdtRelation.RelatedField;
axTableRelation.AddConstraint(axTableRelationConstraint);
}
}
return(axTableRelation);
}
return(null);
}
/// <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);
}
