EdmxResource.tt

<#@ template language="C#" debug="false" hostspecific="true" #><#@ output extension=".resx" #><#@ include file="EF.Utility.CS.ttinclude"#><#
const string MODEL_FILE_NAME = @"..\Libricola.edmx";

MetadataLoader loader = new MetadataLoader(this);
EdmItemCollection items = loader.CreateEdmItemCollection(MODEL_FILE_NAME);
CreateResxFile(items);
#>
<#+
void CreateResxFile(EdmItemCollection items) {
    // Write XML and RESX header
    this.WriteLine("<?xml version=\"1.0\" encoding=\"utf-8\"?>");
    this.WriteLine("<root>");
    WriteResourceHeader();

    // Process all entities
    foreach (EntityType entity in items.GetItems<EntityType>().OrderBy(e => e.Name)) {
        // Process common properties
        foreach (EdmMember property in entity.Properties.Where(p => p.DeclaringType == entity)) {
            if(property.Name.EndsWith("Id", StringComparison.Ordinal)) continue;
            ProcessResxProperty(property);
        }

        // Process navigation properties
        foreach (EdmMember property in entity.NavigationProperties.Where(np => np.DeclaringType == entity)) {
            ProcessResxProperty(property);
        }
    }

    // Write RESX footer
    this.WriteLine("</root>");
}

void ProcessResxProperty(EdmMember property) {
    const string ATR_NAME = "<data name=\"{0}_{1}_Name\"><value xml:space=\"preserve\">{2}</value><comment>(generated from model)</comment></data>";                                                // DisplayAttribute.Name
    const string ATR_DESCRIPTION = "<data name=\"{0}_{1}_Description\"><value xml:space=\"preserve\">{2}</value><comment>(generated from model)</comment></data>";                                  // DisplayAttribute.Name
    const string ATR_REQUIRED = "<data name=\"{0}_{1}_Required\"><value xml:space=\"preserve\">{{0}} is missing.</value><comment>(generated from model)</comment></data>";                      // RequiredAttribute.ErrorMessage
    const string ATR_STRLENGTH_MAX = "<data name=\"{0}_{1}_StrLength\"><value xml:space=\"preserve\">{{0}} is longer than {{1}} characters.</value><comment>(generated from model)</comment></data>";   // StringLengthAttribute.ErrorMessage
    const string ATR_STRLENGTH_FIX = "<data name=\"{0}_{1}_StrLength\"><value xml:space=\"preserve\">{{0}} is not {{1}} characters long.</value><comment>(generated from model)</comment></data>";      // StringLengthAttribute.ErrorMessage

    // Ignore primary keys
    EdmProperty p = property as EdmProperty;
    if(p != null){
        MetadataTools ef = new MetadataTools(this);
        if(ef.IsKey(p)) return;
    }

    // Get display name
    string displayName;
    if(property.Documentation == null || string.IsNullOrWhiteSpace(property.Documentation.Summary)) displayName = FormatPropertyName(property.Name);
    else displayName = property.Documentation.Summary;

    // Get description
    string description = null;
    if(property.Documentation != null && !string.IsNullOrWhiteSpace(property.Documentation.LongDescription)) description = property.Documentation.LongDescription;

    // DisplayAttribute
    this.WriteLine(ATR_NAME,
        property.DeclaringType.Name,
        property.Name,
        displayName);
    if(!string.IsNullOrWhiteSpace(description)) {
        this.WriteLine(ATR_DESCRIPTION,
            property.DeclaringType.Name,
            property.Name,
            description);
    }

    // RequiredAttribute
    if(!GetFacetValue(property.TypeUsage.Facets.SingleOrDefault(f=>f.Name.Equals("Nullable")), false)) {
        this.WriteLine(ATR_REQUIRED,
            property.DeclaringType.Name,
            property.Name,
            displayName);
    }

    // Type-specific attributes
    if(property.TypeUsage.EdmType is PrimitiveType) {
        switch (((PrimitiveType)property.TypeUsage.EdmType).PrimitiveTypeKind) {
            case PrimitiveTypeKind.String:
                // StringLengthAttribute
                var maxLength = GetFacetValue(property.TypeUsage.Facets.SingleOrDefault(f=>f.Name.Equals("MaxLength")), int.MaxValue);
                if(maxLength != int.MaxValue) {
                    var fixedLength= GetFacetValue(property.TypeUsage.Facets.SingleOrDefault(f=>f.Name.Equals("FixedLength")), false);
                    if(fixedLength) {
                        this.WriteLine(ATR_STRLENGTH_FIX,
                            property.DeclaringType.Name,
                            property.Name,
                            displayName,
                            maxLength);
                    } else {
                        this.WriteLine(ATR_STRLENGTH_MAX,
                            property.DeclaringType.Name,
                            property.Name,
                            displayName,
                            maxLength);
                    }
                }
                break;
            case PrimitiveTypeKind.DateTime:
            case PrimitiveTypeKind.DateTimeOffset:
            case PrimitiveTypeKind.Time:
            case PrimitiveTypeKind.Binary:
            case PrimitiveTypeKind.Boolean:
            case PrimitiveTypeKind.Byte:
            case PrimitiveTypeKind.Decimal:
            case PrimitiveTypeKind.Double:
            case PrimitiveTypeKind.Guid:
            case PrimitiveTypeKind.Int16:
            case PrimitiveTypeKind.Int32:
            case PrimitiveTypeKind.Int64:
            case PrimitiveTypeKind.SByte:
            case PrimitiveTypeKind.Single:
            default:
                break;
        }
    }
}

string FormatPropertyName(string propertyName) {
    var uppercaseWords = new string[] { "ID", "XML" };
    var lastWasUpperCase = false;
    var words = new List<string>();
    var word = string.Empty;
    for (int i = 0; i < propertyName.Length; i++) {
        if(Char.IsUpper(propertyName[i])) {
            if(!lastWasUpperCase && i > 0) {
                if(uppercaseWords.Contains(word,  StringComparer.CurrentCultureIgnoreCase)) word = word.ToUpper();
                words.Add(word);
                word = string.Empty;
            }
            lastWasUpperCase = true;
        } else {
            lastWasUpperCase = false;
        }
        word += propertyName[i];
    }
    if(uppercaseWords.Contains(word,  StringComparer.CurrentCultureIgnoreCase)) word = word.ToUpper();
    words.Add(word);
    return string.Join(" ", words.ToArray());
}

T GetFacetValue<T>(Facet f, T defaultValue) {
    if (f == null) return defaultValue;
    try {
        return (T)f.Value;
    } catch {
        return defaultValue;
    }
}

void WriteResourceHeader(){
    #>
    <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
        <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
        <xsd:element name="root" msdata:IsDataSet="true">
            <xsd:complexType>
                <xsd:choice maxOccurs="unbounded">
                    <xsd:element name="metadata">
                        <xsd:complexType>
                            <xsd:sequence>
                                <xsd:element name="value" type="xsd:string" minOccurs="0" />
                            </xsd:sequence>
                            <xsd:attribute name="name" use="required" type="xsd:string" />
                            <xsd:attribute name="type" type="xsd:string" />
                            <xsd:attribute name="mimetype" type="xsd:string" />
                            <xsd:attribute ref="xml:space" />
                        </xsd:complexType>
                    </xsd:element>
                    <xsd:element name="assembly">
                        <xsd:complexType>
                            <xsd:attribute name="alias" type="xsd:string" />
                            <xsd:attribute name="name" type="xsd:string" />
                        </xsd:complexType>
                    </xsd:element>
                    <xsd:element name="data">
                        <xsd:complexType>
                            <xsd:sequence>
                                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
                                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
                            </xsd:sequence>
                            <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
                            <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
                            <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
                            <xsd:attribute ref="xml:space" />
                        </xsd:complexType>
                    </xsd:element>
                    <xsd:element name="resheader">
                        <xsd:complexType>
                            <xsd:sequence>
                                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
                            </xsd:sequence>
                            <xsd:attribute name="name" type="xsd:string" use="required" />
                        </xsd:complexType>
                    </xsd:element>
                </xsd:choice>
            </xsd:complexType>
        </xsd:element>
    </xsd:schema>
    <resheader name="resmimetype">
        <value>text/microsoft-resx</value>
    </resheader>
    <resheader name="version">
        <value>2.0</value>
    </resheader>
    <resheader name="reader">
        <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
    </resheader>
    <resheader name="writer">
        <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
    </resheader>
<#+ } #>