// Create an attribute with a specified name.
private static void CreateAttribute(Guid modelId, Guid entityId, string attributeName)
{
try
{
// Create the request object for attribute creation.
MetadataCreateRequest createRequest = new MetadataCreateRequest();
createRequest.Metadata = new Metadata();
createRequest.Metadata.Attributes = new System.Collections.ObjectModel.Collection<MetadataAttribute> { };
MetadataAttribute newAttribute = new MetadataAttribute();
// Set model id, entity id, and attribute name.
newAttribute.Identifier = new MemberTypeContextIdentifier { Name = attributeName, ModelId = new Identifier { Id = modelId }, EntityId = new Identifier { Id = entityId }, MemberType = MemberType.Leaf };
newAttribute.AttributeType = AttributeType.FreeForm;
newAttribute.DataType = AttributeDataType.Text;
// When the DataType is "Text", set the length (100) to DataTypeInformation.
newAttribute.DataTypeInformation = 100;
newAttribute.DisplayWidth = 100;
createRequest.Metadata.Attributes.Add(newAttribute);
// Create a new attribute
MetadataCreateResponse createResponse = clientProxy.MetadataCreate(createRequest);
HandleOperationErrors(createResponse.OperationResult);
}
catch (Exception ex)
{
Console.WriteLine("Error: {0}", ex);
}
}
public static MetadataAttribute ToAttribute(this Attribute attr)
{
var firstCtor = attr.GetType().GetConstructors().OrderBy(x => x.GetParameters().Length).FirstOrDefault();
var metaAttr = new MetadataAttribute {
Name = attr.GetType().Name,
ConstructorArgs = firstCtor != null
? firstCtor.GetParameters().ToList().ConvertAll(x => x.ToProperty())
: null,
Args = attr.NonDefaultProperties(),
};
return metaAttr;
}
public static MetadataAttribute ToMetadataAttribute(this MetadataRoute route)
{
var attr = new MetadataAttribute
{
Name = "Route",
ConstructorArgs = new List<MetadataPropertyType>
{
new MetadataPropertyType { Type = "string", Value = route.Path },
},
};
if (route.Verbs != null)
{
attr.ConstructorArgs.Add(
new MetadataPropertyType { Type = "string", Value = route.Verbs });
}
return attr;
}
public MetadataAttribute ToAttribute(Attribute attr)
{
var firstCtor = attr.GetType().GetConstructors()
//.OrderBy(x => x.GetParameters().Length)
.FirstOrDefault();
var metaAttr = new MetadataAttribute
{
Name = attr.GetType().Name.Replace("Attribute", ""),
ConstructorArgs = firstCtor != null
? firstCtor.GetParameters().ToList().ConvertAll(ToProperty)
: null,
Args = NonDefaultProperties(attr),
};
//Populate ctor Arg values from matching properties
var argValues = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
metaAttr.Args.Each(x => argValues[x.Name] = x.Value);
metaAttr.Args.RemoveAll(x => x.ReadOnly == true);
if (metaAttr.ConstructorArgs != null)
{
foreach (var arg in metaAttr.ConstructorArgs)
{
string value;
if (argValues.TryGetValue(arg.Name, out value))
{
arg.Value = value;
}
}
metaAttr.ConstructorArgs.RemoveAll(x => x.Value == null);
if (metaAttr.ConstructorArgs.Count == 0)
metaAttr.ConstructorArgs = null;
}
//Only emit ctor args or property args
if (metaAttr.ConstructorArgs == null
|| metaAttr.ConstructorArgs.Count != metaAttr.Args.Count)
{
metaAttr.ConstructorArgs = null;
}
else
{
metaAttr.Args = null;
}
return metaAttr;
}
// Update the attribute group name and add an attribute to it.
private static void UpdateAttributeGroup(Guid modelId, Guid entityId, Guid attributeGroupId, string newAttributeGroupName, Guid attributeId)
{
try
{
// Create the request object for updating attribute group information.
MetadataUpdateRequest updateRequest = new MetadataUpdateRequest();
updateRequest.Metadata = new Metadata();
updateRequest.Metadata.AttributeGroups = new System.Collections.ObjectModel.Collection<AttributeGroup> { };
// Set model id, entity id, attribute group id, and new attribute group name.
AttributeGroup anAttributeGroup = new AttributeGroup { Identifier = new MemberTypeContextIdentifier { Name = newAttributeGroupName, Id = attributeGroupId, ModelId = new Identifier { Id = modelId }, EntityId = new Identifier { Id = entityId }, MemberType = MDSTestService.MemberType.Leaf } };
// Add the attribute object with the attribute id.
anAttributeGroup.Attributes = new System.Collections.ObjectModel.Collection<MetadataAttribute> { };
MetadataAttribute anAttribute = new MetadataAttribute { Identifier = new MemberTypeContextIdentifier { Id = attributeId } };
anAttributeGroup.Attributes.Add(anAttribute);
updateRequest.Metadata.AttributeGroups.Add(anAttributeGroup);
// Update the attribute group information.
MetadataUpdateResponse updateResponse = clientProxy.MetadataUpdate(updateRequest);
HandleOperationErrors(updateResponse.OperationResult);
}
catch (Exception ex)
{
Console.WriteLine("Error: {0}", ex);
}
}
public MetadataAttribute ToAttribute(Attribute attr)
{
var firstCtor = attr.GetType().GetConstructors().OrderBy(x => x.GetParameters().Length).FirstOrDefault();
var metaAttr = new MetadataAttribute
{
Name = attr.GetType().Name.Replace("Attribute", ""),
ConstructorArgs = firstCtor != null
? firstCtor.GetParameters().ToList().ConvertAll(ToProperty)
: null,
Args = NonDefaultProperties(attr),
};
return metaAttr;
}
// Delete an attribute with the specified attribute id.
private static void DeleteAttribute(Guid attributeId)
{
try
{
// Create the request object for attribute deletion.
MetadataDeleteRequest deleteRequest = new MetadataDeleteRequest();
deleteRequest.Metadata = new Metadata();
deleteRequest.Metadata.Attributes = new System.Collections.ObjectModel.Collection<MetadataAttribute> { };
MetadataAttribute anAttribute = new MetadataAttribute();
// Set the attribute id.
anAttribute.Identifier = new MemberTypeContextIdentifier { Id = attributeId };
deleteRequest.Metadata.Attributes.Add(anAttribute);
// Delete a specified attribute
MetadataDeleteResponse deleteResponse = clientProxy.MetadataDelete(deleteRequest);
HandleOperationErrors(deleteResponse.OperationResult);
}
catch (Exception ex)
{
Console.WriteLine("Error: {0}", ex);
}
}
public void SetMetadataAttr(AlternateContentProperty altProp, AlternateContent altContent,
Metadata md, MetadataAttribute mdAttr, string newName, string newValue)
{
if (string.IsNullOrEmpty(newName) || string.IsNullOrEmpty(newValue))
{
return;
}
Tuple <TreeNode, TreeNode> selection = m_UrakawaSession.GetTreeNodeSelection();
TreeNode node = selection.Item2 ?? selection.Item1;
if (node == null)
{
return;
}
var altProp_ = node.GetAlternateContentProperty();
if (altProp_ == null)
{
return;
}
if (altProp != null && altProp_ != altProp)
{
return;
}
if (altContent != null && altProp_.AlternateContents.IndexOf(altContent) < 0)
{
return;
}
if (mdAttr == null)
{
MetadataAttribute attr = md.NameContentAttribute;
if (attr.Name != newName)
{
AlternateContentMetadataSetNameCommand cmd1 =
node.Presentation.CommandFactory.CreateAlternateContentMetadataSetNameCommand(
altProp,
altContent,
attr,
newName
);
node.Presentation.UndoRedoManager.Execute(cmd1);
}
if (attr.Value != newValue)
{
AlternateContentMetadataSetContentCommand cmd2 =
node.Presentation.CommandFactory.CreateAlternateContentMetadataSetContentCommand(
altProp,
altContent,
attr,
newValue
);
node.Presentation.UndoRedoManager.Execute(cmd2);
}
}
else
{
if (mdAttr.Name != newName)
{
AlternateContentMetadataSetNameCommand cmd1 =
node.Presentation.CommandFactory.CreateAlternateContentMetadataSetNameCommand(
altProp,
altContent,
mdAttr,
newName
);
node.Presentation.UndoRedoManager.Execute(cmd1);
}
if (mdAttr.Value != newValue)
{
AlternateContentMetadataSetContentCommand cmd2 =
node.Presentation.CommandFactory.CreateAlternateContentMetadataSetContentCommand(
altProp,
altContent,
mdAttr,
newValue
);
node.Presentation.UndoRedoManager.Execute(cmd2);
}
}
RaisePropertyChanged(() => Metadatas);
RaisePropertyChanged(() => Descriptions);
}
private void LoadAttributes(ModelMetadata metadata)
{
//TO-DO: Refazer os métodos para tornar-los mais dinâmicos...
if (metadata != null)
{
MetadataAttribute commonAttribute = new MetadataAttribute()
{
AttributeName = "Common" + "Attribute",
Property = new Dictionary <string, object>()
{
{ "DisplayName", metadata.DisplayName },
{ "ShortDisplayName", metadata.ShortDisplayName },
{ "IsRequired", metadata.IsRequired },
{ "IsReadOnly", metadata.IsReadOnly },
{ "IsNullableValueType", metadata.IsNullableValueType },
{ "Description", metadata.Description },
{ "Watermark", metadata.Watermark },
{ "ShowForDisplay", metadata.ShowForDisplay },
{ "ShowForEdit", metadata.ShowForEdit },
{ "DataTypeName", metadata.DataTypeName },
{ "IsComplexType", metadata.IsComplexType },
{ "EditFormatString", metadata.EditFormatString },
{ "HideSurroundingHtml", metadata.HideSurroundingHtml },
{ "HtmlEncode", metadata.HtmlEncode },
{ "ConvertEmptyStringToNull", metadata.ConvertEmptyStringToNull },
{ "NullDisplayText", metadata.NullDisplayText },
{ "SimpleDisplayText", metadata.SimpleDisplayText },
{ "TemplateHint", metadata.TemplateHint },
{ "DisplayFormatString", metadata.DisplayFormatString },
}
};
metadataAttributes.Add(commonAttribute);
}
HtmlAttributesAttribute htmlAttributesAttribute = GetModelMetadataAttributes(metadata).OfType <HtmlAttributesAttribute>().FirstOrDefault();
if (htmlAttributesAttribute != null)
{
MetadataAttribute metaAttribute = new MetadataAttribute()
{
AttributeName = "HtmlAttributes" + "Attribute",
Property = new Dictionary <string, object>()
{
{ "ID", htmlAttributesAttribute.ID },
{ "Name", htmlAttributesAttribute.Name },
{ "Class", htmlAttributesAttribute.Class },
{ "Style", htmlAttributesAttribute.Style },
{ "Width", htmlAttributesAttribute.Width },
{ "Height", htmlAttributesAttribute.Height },
{ "Placeholder", htmlAttributesAttribute.Placeholder },
}
};
metadataAttributes.Add(metaAttribute);
}
DataTypeAttribute dataTypeAttribute = GetModelMetadataAttributes(metadata).OfType <DataTypeAttribute>().FirstOrDefault();
if (dataTypeAttribute != null)
{
MetadataAttribute metaAttribute = new MetadataAttribute()
{
AttributeName = "DataType" + "Attribute",
Property = new Dictionary <string, object>()
{
{ "DataType", dataTypeAttribute.DataType },
{ "ErrorMessage", dataTypeAttribute.ErrorMessage },
{ "ErrorMessageResourceName", dataTypeAttribute.ErrorMessageResourceName },
{ "RequiresValidationContext", dataTypeAttribute.RequiresValidationContext },
}
};
metadataAttributes.Add(metaAttribute);
}
DataTypeFieldAttribute dataTypeFieldAttribute = GetModelMetadataAttributes(metadata).OfType <DataTypeFieldAttribute>().FirstOrDefault();
if (dataTypeFieldAttribute != null)
{
MetadataAttribute metaAttribute = new MetadataAttribute()
{
AttributeName = "DataTypeField" + "Attribute",
Property = new Dictionary <string, object>()
{
{ "DataType", dataTypeFieldAttribute.DataType },
{ "ErrorMessage", dataTypeFieldAttribute.ErrorMessage },
{ "ErrorMessageResourceName", dataTypeFieldAttribute.ErrorMessageResourceName },
{ "RequiresValidationContext", dataTypeFieldAttribute.RequiresValidationContext },
{ "Cols", dataTypeFieldAttribute.Cols },
{ "Rows", dataTypeFieldAttribute.Rows },
{ "Wrap", (dataTypeFieldAttribute.HardWrap ? "hard" : null) },
{ "MinLength", dataTypeFieldAttribute.MinLength },
{ "MaxLength", dataTypeFieldAttribute.MaxLength },
}
};
metadataAttributes.Add(metaAttribute);
}
RegularExpressionAttribute regularExpressionAttribute = GetModelMetadataAttributes(metadata).OfType <RegularExpressionAttribute>().FirstOrDefault();
if (regularExpressionAttribute != null)
{
MetadataAttribute metaAttribute = new MetadataAttribute()
{
AttributeName = "RegularExpression" + "Attribute",
Property = new Dictionary <string, object>()
{
{ "Pattern", regularExpressionAttribute.Pattern },
{ "ErrorMessage", regularExpressionAttribute.ErrorMessage },
{ "ErrorMessageResourceName", regularExpressionAttribute.ErrorMessageResourceName },
{ "RequiresValidationContext", regularExpressionAttribute.RequiresValidationContext },
}
};
metadataAttributes.Add(metaAttribute);
}
StringLengthAttribute stringLengthAttribute = GetModelMetadataAttributes(metadata).OfType <StringLengthAttribute>().FirstOrDefault();
if (stringLengthAttribute != null)
{
MetadataAttribute metaAttribute = new MetadataAttribute()
{
AttributeName = "StringLength" + "Attribute",
Property = new Dictionary <string, object>()
{
{ "MinimumLength", stringLengthAttribute.MinimumLength },
{ "MaximumLength", stringLengthAttribute.MaximumLength },
{ "ErrorMessage", stringLengthAttribute.ErrorMessage },
{ "FormatErrorMessage", stringLengthAttribute.FormatErrorMessage(metadata.PropertyName) },
{ "ErrorMessageResourceName", stringLengthAttribute.ErrorMessageResourceName },
{ "RequiresValidationContext", stringLengthAttribute.RequiresValidationContext },
}
};
metadataAttributes.Add(metaAttribute);
}
MinLengthAttribute minLengthAttribute = GetModelMetadataAttributes(metadata).OfType <MinLengthAttribute>().FirstOrDefault();
if (minLengthAttribute != null)
{
MetadataAttribute metaAttribute = new MetadataAttribute()
{
AttributeName = "MinLength" + "Attribute",
Property = new Dictionary <string, object>()
{
{ "Length", minLengthAttribute.Length },
{ "TypeId", minLengthAttribute.TypeId },
{ "ErrorMessage", minLengthAttribute.ErrorMessage },
{ "ErrorMessageResourceName", minLengthAttribute.ErrorMessageResourceName },
{ "RequiresValidationContext", minLengthAttribute.RequiresValidationContext },
}
};
metadataAttributes.Add(metaAttribute);
}
MaxLengthAttribute maxLengthAttribute = GetModelMetadataAttributes(metadata).OfType <MaxLengthAttribute>().FirstOrDefault();
if (maxLengthAttribute != null)
{
MetadataAttribute metaAttribute = new MetadataAttribute()
{
AttributeName = "MaxLength" + "Attribute",
Property = new Dictionary <string, object>()
{
{ "Length", maxLengthAttribute.Length },
{ "TypeId", maxLengthAttribute.TypeId },
{ "ErrorMessage", maxLengthAttribute.ErrorMessage },
{ "ErrorMessageResourceName", maxLengthAttribute.ErrorMessageResourceName },
{ "RequiresValidationContext", maxLengthAttribute.RequiresValidationContext },
}
};
metadataAttributes.Add(metaAttribute);
}
DisplayAttribute displayAttribute = GetModelMetadataAttributes(metadata).OfType <DisplayAttribute>().FirstOrDefault();
if (displayAttribute != null)
{
MetadataAttribute metaAttribute = new MetadataAttribute()
{
AttributeName = "Display" + "Attribute",
Property = new Dictionary <string, object>()
{
{ "ShortName", displayAttribute.ShortName },
{ "Name", displayAttribute.Name },
{ "Prompt", displayAttribute.Prompt },
{ "GroupName", displayAttribute.GroupName },
{ "Description", displayAttribute.Description },
}
};
metadataAttributes.Add(metaAttribute);
}
RequiredAttribute requiredAttribute = GetModelMetadataAttributes(metadata).OfType <RequiredAttribute>().FirstOrDefault();
if (requiredAttribute != null)
{
MetadataAttribute metaAttribute = new MetadataAttribute()
{
AttributeName = "Required" + "Attribute",
Property = new Dictionary <string, object>()
{
{ "IsRequired", true },
{ "AllowEmptyStrings", requiredAttribute.AllowEmptyStrings },
{ "ErrorMessage", requiredAttribute.ErrorMessage },
{ "ErrorMessageResourceName", requiredAttribute.ErrorMessageResourceName },
{ "RequiresValidationContext", requiredAttribute.RequiresValidationContext },
}
};
metadataAttributes.Add(metaAttribute);
}
RangeAttribute rangeAttribute = GetModelMetadataAttributes(metadata).OfType <RangeAttribute>().FirstOrDefault();
if (rangeAttribute != null)
{
MetadataAttribute metaAttribute = new MetadataAttribute()
{
AttributeName = "Range" + "Attribute",
Property = new Dictionary <string, object>()
{
{ "OperandType", rangeAttribute.OperandType },
{ "AllowEmptyStrings", rangeAttribute.Minimum },
{ "Maximum", rangeAttribute.Maximum },
{ "ErrorMessage", rangeAttribute.ErrorMessage },
{ "ErrorMessageResourceName", rangeAttribute.ErrorMessageResourceName },
{ "RequiresValidationContext", rangeAttribute.RequiresValidationContext },
}
};
metadataAttributes.Add(metaAttribute);
}
DisplayFormatAttribute displayFormatAttribute = GetModelMetadataAttributes(metadata).OfType <DisplayFormatAttribute>().FirstOrDefault();
if (displayFormatAttribute != null)
{
MetadataAttribute metaAttribute = new MetadataAttribute()
{
AttributeName = "DisplayFormat" + "Attribute",
Property = new Dictionary <string, object>()
{
{ "DataFormatString", displayFormatAttribute.DataFormatString },
{ "ApplyFormatInEditMode", displayFormatAttribute.ApplyFormatInEditMode },
{ "ConvertEmptyStringToNull", displayFormatAttribute.ConvertEmptyStringToNull },
{ "HtmlEncode", displayFormatAttribute.HtmlEncode },
{ "NullDisplayText", displayFormatAttribute.NullDisplayText },
{ "IsDefault" + "Attribute", displayFormatAttribute.IsDefaultAttribute() },
}
};
metadataAttributes.Add(metaAttribute);
}
CreditCardAttribute creditCardAttribute = GetModelMetadataAttributes(metadata).OfType <CreditCardAttribute>().FirstOrDefault();
if (creditCardAttribute != null)
{
MetadataAttribute metaAttribute = new MetadataAttribute()
{
AttributeName = "CreditCard" + "Attribute",
Property = new Dictionary <string, object>()
{
{ "DataType", creditCardAttribute.DataType },
{ "CustomDataType", creditCardAttribute.CustomDataType },
{ "DisplayFormat", creditCardAttribute.DisplayFormat },
{ "ErrorMessage", creditCardAttribute.ErrorMessage },
{ "FormatErrorMessage", stringLengthAttribute.FormatErrorMessage(metadata.PropertyName) },
{ "ErrorMessageResourceName", creditCardAttribute.ErrorMessageResourceName },
{ "ErrorMessageResourceType", creditCardAttribute.ErrorMessageResourceType },
{ "RequiresValidationContext", creditCardAttribute.RequiresValidationContext },
}
};
metadataAttributes.Add(metaAttribute);
}
CustomValidationAttribute customValidationAttribute = GetModelMetadataAttributes(metadata).OfType <CustomValidationAttribute>().FirstOrDefault();
if (customValidationAttribute != null)
{
MetadataAttribute metaAttribute = new MetadataAttribute()
{
AttributeName = "CustomValidation" + "Attribute",
Property = new Dictionary <string, object>()
{
{ "ValidatorType", customValidationAttribute.ValidatorType },
{ "Method", customValidationAttribute.Method },
{ "ErrorMessage", creditCardAttribute.ErrorMessage },
{ "FormatErrorMessage", stringLengthAttribute.FormatErrorMessage(metadata.PropertyName) },
{ "ErrorMessageResourceName", creditCardAttribute.ErrorMessageResourceName },
{ "ErrorMessageResourceType", creditCardAttribute.ErrorMessageResourceType },
{ "RequiresValidationContext", creditCardAttribute.RequiresValidationContext },
}
};
metadataAttributes.Add(metaAttribute);
}
EmailAddressAttribute emailAddressAttribute = GetModelMetadataAttributes(metadata).OfType <EmailAddressAttribute>().FirstOrDefault();
if (emailAddressAttribute != null)
{
MetadataAttribute metaAttribute = new MetadataAttribute()
{
AttributeName = "EmailAddress" + "Attribute",
Property = new Dictionary <string, object>()
{
{ "DataType", emailAddressAttribute.DataType },
{ "CustomDataType", emailAddressAttribute.CustomDataType },
{ "DisplayFormat", emailAddressAttribute.DisplayFormat },
{ "ErrorMessage", creditCardAttribute.ErrorMessage },
{ "FormatErrorMessage", stringLengthAttribute.FormatErrorMessage(metadata.PropertyName) },
{ "ErrorMessageResourceName", creditCardAttribute.ErrorMessageResourceName },
{ "ErrorMessageResourceType", creditCardAttribute.ErrorMessageResourceType },
{ "RequiresValidationContext", creditCardAttribute.RequiresValidationContext },
}
};
metadataAttributes.Add(metaAttribute);
}
FileExtensionsAttribute fileExtensionsAttribute = GetModelMetadataAttributes(metadata).OfType <FileExtensionsAttribute>().FirstOrDefault();
if (fileExtensionsAttribute != null)
{
MetadataAttribute metaAttribute = new MetadataAttribute()
{
AttributeName = "FileExtensions" + "Attribute",
Property = new Dictionary <string, object>()
{
{ "DataType", emailAddressAttribute.DataType },
{ "CustomDataType", emailAddressAttribute.CustomDataType },
{ "DisplayFormat", emailAddressAttribute.DisplayFormat },
{ "ErrorMessage", creditCardAttribute.ErrorMessage },
{ "FormatErrorMessage", stringLengthAttribute.FormatErrorMessage(metadata.PropertyName) },
{ "ErrorMessageResourceName", creditCardAttribute.ErrorMessageResourceName },
{ "ErrorMessageResourceType", creditCardAttribute.ErrorMessageResourceType },
{ "RequiresValidationContext", creditCardAttribute.RequiresValidationContext },
}
};
metadataAttributes.Add(metaAttribute);
}
TimestampAttribute timestampAttribute = GetModelMetadataAttributes(metadata).OfType <TimestampAttribute>().FirstOrDefault();
if (timestampAttribute != null)
{
MetadataAttribute metaAttribute = new MetadataAttribute()
{
AttributeName = "FileExtensions" + "Attribute",
Property = new Dictionary <string, object>()
{
{ "TypeId", timestampAttribute.TypeId },
}
};
metadataAttributes.Add(metaAttribute);
}
ViewDisabledAttribute viewDisabledAttribute = GetModelMetadataAttributes(metadata).OfType <ViewDisabledAttribute>().FirstOrDefault();
if (viewDisabledAttribute != null)
{
MetadataAttribute metaAttribute = new MetadataAttribute()
{
AttributeName = "ViewDisabled" + "Attribute",
Property = new Dictionary <string, object>()
{
{ "Declared", true },
}
};
metadataAttributes.Add(metaAttribute);
}
TextAreaAttribute textAreaAttribute = GetModelMetadataAttributes(metadata).OfType <TextAreaAttribute>().FirstOrDefault();
if (textAreaAttribute != null)
{
MetadataAttribute metaAttribute = new MetadataAttribute()
{
AttributeName = "TextArea" + "Attribute",
Property = new Dictionary <string, object>()
{
{ "Cols", textAreaAttribute.Cols },
{ "Rows", textAreaAttribute.Rows },
{ "Wrap", (textAreaAttribute.HardWrap ? "hard" : null) },
{ "MinLength", textAreaAttribute.MinLength },
{ "MaxLength", textAreaAttribute.MaxLength },
}
};
metadataAttributes.Add(metaAttribute);
}
OnlyNumberAttribute onlyNumberAttribute = GetModelMetadataAttributes(metadata).OfType <OnlyNumberAttribute>().FirstOrDefault();
if (onlyNumberAttribute != null)
{
MetadataAttribute metaAttribute = new MetadataAttribute()
{
AttributeName = "OnlyNumber" + "Attribute",
Property = new Dictionary <string, object>()
{
{ "Declared", true },
{ "ClassDecorator", "onlyNumber" },
}
};
metadataAttributes.Add(metaAttribute);
}
CurrencyAttribute currencyAttribute = GetModelMetadataAttributes(metadata).OfType <CurrencyAttribute>().FirstOrDefault();
if (currencyAttribute != null)
{
MetadataAttribute metaAttribute = new MetadataAttribute()
{
AttributeName = "Currency" + "Attribute",
Property = new Dictionary <string, object>()
{
{ "Declared", true },
{ "ClassDecorator", "onlyNumber" },
{ "Pattern", "currency" },
}
};
metadataAttributes.Add(metaAttribute);
}
NoEspecialCharsAttribute noEspecialCharsAttribute = GetModelMetadataAttributes(metadata).OfType <NoEspecialCharsAttribute>().FirstOrDefault();
if (noEspecialCharsAttribute != null)
{
MetadataAttribute metaAttribute = new MetadataAttribute()
{
AttributeName = "NoEspecialChars" + "Attribute",
Property = new Dictionary <string, object>()
{
{ "Declared", true },
{ "ClassDecorator", "noCaracEsp" },
}
};
metadataAttributes.Add(metaAttribute);
}
ProgressAttribute progressAttribute = GetModelMetadataAttributes(metadata).OfType <ProgressAttribute>().FirstOrDefault();
if (progressAttribute != null)
{
MetadataAttribute metaAttribute = new MetadataAttribute()
{
AttributeName = "Progress" + "Attribute",
Property = new Dictionary <string, object>()
{
{ "MinValue", progressAttribute.MinValue },
{ "MaxValue", progressAttribute.MaxValue },
{ "Step", progressAttribute.Step },
}
};
metadataAttributes.Add(metaAttribute);
}
PlaceHolderAttribute placeHolderAttribute = GetModelMetadataAttributes(metadata).OfType <PlaceHolderAttribute>().FirstOrDefault();
if (placeHolderAttribute != null)
{
MetadataAttribute metaAttribute = new MetadataAttribute()
{
AttributeName = "PlaceHolder" + "Attribute",
Property = new Dictionary <string, object>()
{
{ "Declared", true },
{ "Text", placeHolderAttribute.Text },
}
};
metadataAttributes.Add(metaAttribute);
}
}
private static void addDic(Dictionary <Metadata, List <MetadataAttribute> > dic, Metadata md, MetadataAttribute mdAttr)
{
List <MetadataAttribute> list;
dic.TryGetValue(md, out list);
if (list != null)
{
list.Add(mdAttr);
}
else
{
list = new List <MetadataAttribute>();
list.Add(mdAttr);
dic.Add(md, list);
}
}
private static XmlNode addFlatDiagramHeadMetadata(
MetadataAttribute metaAttr, IEnumerable <MetadataAttribute> metaAttrs,
XmlNode parentNode, XmlDocument descriptionDocument, XmlNode descriptionNode)
{
XmlNode metaNode = descriptionDocument.CreateElement(
DiagramContentModelHelper.StripNSPrefix(DiagramContentModelHelper.Meta),
DiagramContentModelHelper.NS_URL_ZAI);
parentNode.AppendChild(metaNode);
if (metaAttr != null)
{
if (metaAttr.Name != DiagramContentModelHelper.NA)
{
XmlDocumentHelper.CreateAppendXmlAttribute(descriptionDocument, metaNode,
DiagramContentModelHelper.Property,
metaAttr.Name,
DiagramContentModelHelper.NS_URL_ZAI);
}
if (metaAttr.Value != DiagramContentModelHelper.NA)
{
// TODO: INNER_TEXT vs CONTENT_ATTR => is this specified anywhere?
if (
DiagramContentModelHelper.DIAGRAM_Purpose.Equals(metaAttr.Name, StringComparison.OrdinalIgnoreCase) ||
DiagramContentModelHelper.DIAGRAM_Credentials.Equals(metaAttr.Name, StringComparison.OrdinalIgnoreCase) ||
SupportedMetadata_Z39862005.DC_AccessRights.Equals(metaAttr.Name, StringComparison.OrdinalIgnoreCase)
//
|| SupportedMetadata_Z39862005.DC_Creator.Equals(metaAttr.Name, StringComparison.OrdinalIgnoreCase) ||
SupportedMetadata_Z39862005.DC_Description.Equals(metaAttr.Name, StringComparison.OrdinalIgnoreCase) ||
SupportedMetadata_Z39862005.DC_Title.Equals(metaAttr.Name, StringComparison.OrdinalIgnoreCase) ||
SupportedMetadata_Z39862005.DC_Subject.Equals(metaAttr.Name, StringComparison.OrdinalIgnoreCase)
)
{
metaNode.InnerText = metaAttr.Value;
}
else
{
XmlDocumentHelper.CreateAppendXmlAttribute(descriptionDocument, metaNode,
DiagramContentModelHelper.Content,
metaAttr.Value,
DiagramContentModelHelper.NS_URL_ZAI);
}
}
}
if (metaAttrs != null)
{
foreach (MetadataAttribute metaAttribute in metaAttrs)
{
if (metaAttribute.Name == Metadata.PrimaryIdentifierMark)
{
continue;
}
if (metaAttribute.Name.StartsWith(XmlReaderWriterHelper.NS_PREFIX_XML + ":"))
{
XmlDocumentHelper.CreateAppendXmlAttribute(descriptionDocument, metaNode,
metaAttribute.Name,
metaAttribute.Value,
XmlReaderWriterHelper.NS_URL_XML);
}
else if (metaAttribute.Name.StartsWith(DiagramContentModelHelper.NS_PREFIX_ZAI + ":"))
{
XmlDocumentHelper.CreateAppendXmlAttribute(descriptionDocument, metaNode,
metaAttribute.Name,
metaAttribute.Value,
DiagramContentModelHelper.NS_URL_ZAI);
}
else if (metaAttribute.Name.StartsWith(DiagramContentModelHelper.NS_PREFIX_DIAGRAM + ":"))
{
XmlDocumentHelper.CreateAppendXmlAttribute(descriptionDocument, metaNode,
metaAttribute.Name,
metaAttribute.Value,
DiagramContentModelHelper.NS_URL_DIAGRAM);
}
else if (DiagramContentModelHelper.Rel.Equals(metaAttribute.Name, StringComparison.OrdinalIgnoreCase) ||
DiagramContentModelHelper.Resource.Equals(metaAttribute.Name, StringComparison.OrdinalIgnoreCase) ||
DiagramContentModelHelper.About.Equals(metaAttribute.Name, StringComparison.OrdinalIgnoreCase))
{
XmlDocumentHelper.CreateAppendXmlAttribute(descriptionDocument, metaNode,
metaAttribute.Name.ToLower(),
metaAttribute.Value,
DiagramContentModelHelper.NS_URL_ZAI);
}
else
{
XmlDocumentHelper.CreateAppendXmlAttribute(descriptionDocument, metaNode,
DiagramContentModelHelper.StripNSPrefix(metaAttribute.Name),
metaAttribute.Value,
descriptionNode.NamespaceURI);
}
}
}
return(metaNode);
}
private static void createDiagramHeadMetadata(XmlDocument descriptionDocument, XmlNode descriptionNode, AlternateContentProperty altProperty)
{
XmlNode headNode = descriptionDocument.CreateElement(
DiagramContentModelHelper.NS_PREFIX_DIAGRAM,
DiagramContentModelHelper.StripNSPrefix(DiagramContentModelHelper.D_Head),
DiagramContentModelHelper.NS_URL_DIAGRAM);
descriptionNode.AppendChild(headNode);
//TODO: ALWAYS DISABLE THE DEBUG CODE BELOW UNLESS NEEDED FOR TESTING!!
#if false && DEBUG
foreach (Metadata md in altProperty.Metadatas.ContentsAs_Enumerable)
{
addFlatDiagramHeadMetadata(
md.NameContentAttribute, md.OtherAttributes.ContentsAs_Enumerable,
headNode, descriptionDocument, descriptionNode);
}
#endif // DEBUG
List <Metadata> flatMetadatas = new List <Metadata>();
Dictionary <string, List <Metadata> > groupedMetadata_Id = new Dictionary <string, List <Metadata> >();
Dictionary <string, List <Metadata> > groupedMetadata_RelResource = new Dictionary <string, List <Metadata> >();
foreach (Metadata md in altProperty.Metadatas.ContentsAs_Enumerable)
{
if (md.NameContentAttribute == null)
{
#if DEBUG
Debugger.Break();
#endif // DEBUG
continue;
}
if (
md.NameContentAttribute.Name.StartsWith(XmlReaderWriterHelper.NS_PREFIX_XML + ":")
//&& (md.OtherAttributes == null || md.OtherAttributes.Count == 0)
&& (descriptionNode.Attributes == null || descriptionNode.Attributes.GetNamedItem(md.NameContentAttribute.Name) == null))
{
XmlDocumentHelper.CreateAppendXmlAttribute(descriptionDocument, descriptionNode,
md.NameContentAttribute.Name,
md.NameContentAttribute.Value,
XmlReaderWriterHelper.NS_URL_XML);
}
else
{
if (md.OtherAttributes != null && md.OtherAttributes.Count > 0)
{
MetadataAttribute mdAttr_Rel = null;
MetadataAttribute mdAttr_Resource = null;
MetadataAttribute mdAttr_Id = null;
bool hasOtherAttrs = false;
foreach (MetadataAttribute mdAttr in md.OtherAttributes.ContentsAs_Enumerable)
{
if (mdAttr.Name == Metadata.PrimaryIdentifierMark)
{
continue;
}
if (mdAttr.Name == DiagramContentModelHelper.Rel)
{
mdAttr_Rel = mdAttr;
continue;
}
if (mdAttr.Name == DiagramContentModelHelper.Resource)
{
mdAttr_Resource = mdAttr;
continue;
}
if (mdAttr.Name == XmlReaderWriterHelper.XmlId)
{
mdAttr_Id = mdAttr;
continue;
}
hasOtherAttrs = true;
}
if (mdAttr_Id != null)
{
addDic_(groupedMetadata_Id, mdAttr_Id.Value, md);
continue;
}
else if (mdAttr_Rel != null || mdAttr_Resource != null)
{
string key = (mdAttr_Rel != null ? mdAttr_Rel.Value : "")
+ "_-_"
+ (mdAttr_Resource != null ? mdAttr_Resource.Value : "");
addDic_(groupedMetadata_RelResource, key, md);
continue;
}
}
//md.NameContentAttribute.Name != DiagramContentModelHelper.NA
// && md.NameContentAttribute.Value != DiagramContentModelHelper.NA
flatMetadatas.Add(md);
}
}
foreach (Metadata md in flatMetadatas)
{
addFlatDiagramHeadMetadata(
md.NameContentAttribute, md.OtherAttributes.ContentsAs_Enumerable,
headNode, descriptionDocument, descriptionNode);
}
handleMetadataGroup(headNode, descriptionDocument, descriptionNode, groupedMetadata_Id);
handleMetadataGroup(headNode, descriptionDocument, descriptionNode, groupedMetadata_RelResource);
}
