EdmxMetadata.tt

<#@ template language="C#" debug="false" hostspecific="true" #><#@ output extension=".cs" #><#@ include file="EF.Utility.CS.ttinclude"#><#

const string MODEL_FILE_NAME = @"..\Libricola.edmx";
const string RESOURCE_CLASS_NAME = "Resources.ModelLocalization";

MetadataLoader loader = new MetadataLoader(this);
EdmItemCollection items = loader.CreateEdmItemCollection(MODEL_FILE_NAME);
CreateMetaFile(items, RESOURCE_CLASS_NAME);
#>
<#+
void CreateMetaFile(EdmItemCollection items, string resourceTypeName){
    const string ATR_METADATA = "[MetadataType(typeof({0}Metadata))]";

    // Code generation helpers
    CodeGenerationTools code = new CodeGenerationTools(this);
    CodeRegion region = new CodeRegion(this, 0);

    // Get namespace without last directory
    var nsData = code.VsNamespaceSuggestion().Split('.');
    var ns = string.Join(".", nsData, 0, nsData.Length - 1);

    // Write file header
    this.WriteLine("using System;");
    this.WriteLine("using System.Collections.Generic;");
    this.WriteLine("using System.Collections.Specialized;");
    this.WriteLine("using System.ComponentModel.DataAnnotations;");
    this.WriteLine("");
    this.WriteLine("namespace {0} {{", ns);
    this.PushIndent("\t");
    this.WriteLine("");

    foreach (EntityType entity in items.GetItems<EntityType>().OrderBy(e => e.Name)) {
        // Write entity class header
        this.WriteLine(ATR_METADATA, code.Escape(entity.Name));
        this.WriteLine("{0} partial class {1} {{",
            Accessibility.ForType(entity),  // 0
            code.Escape(entity.Name));      // 1
        this.WriteLine("");
        this.PushIndent("\t");

        // Write metadata class header
        region.Begin(string.Format("{0} metadata", entity.Name));
        this.WriteLine("");
        this.WriteLine("{0} class {1}Metadata {{",
            Accessibility.ForType(entity),  // 0
            code.Escape(entity.Name));      // 1
        this.PushIndent("\t");
        this.WriteLine("");

        // Process common properties
        foreach (EdmMember property in entity.Properties.Where(p => p.DeclaringType == entity)) {
            if(property.Name.EndsWith("Id", StringComparison.Ordinal)) continue;
            ProcessMetaProperty(property, resourceTypeName);
        }

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

        // Write metadata class footer
        this.PopIndent();
        this.WriteLine("}");
        region.End();
        this.WriteLine("");

        // Write entity class footer
        this.PopIndent();
        this.WriteLine("}");
        this.WriteLine("");
    }

    // Write file footer
    this.PopIndent();
    this.WriteLine("}");
}

void ProcessMetaProperty(EdmMember property, string resourceTypeName) {
    const string ATR_DISPLAY_1 = "[Display(ResourceType = typeof({0}), Name = \"{1}_{2}_Name\")]";
    const string ATR_DISPLAY_2 = "[Display(ResourceType = typeof({0}), Name = \"{1}_{2}_Name\", Description = \"{1}_{2}_Description\")]";
    const string ATR_REQUIRED = "[Required(ErrorMessageResourceType = typeof({0}), ErrorMessageResourceName=\"{1}_{2}_Required\")]";
    const string ATR_STRLENGTH_MAX = "[StringLength({3}, ErrorMessageResourceType = typeof({0}), ErrorMessageResourceName=\"{1}_{2}_StrLength\")]";
    const string ATR_STRLENGTH_FIX = "[StringLength({3}, MinimumLength={3}, ErrorMessageResourceType = typeof({0}), ErrorMessageResourceName=\"{1}_{2}_StrLength\")]";
    const string ATR_TYPE_DATETIME ="[DataType(DataType.DateTime)]";
    const string ATR_TYPE_TIME ="[DataType(DataType.Time)]";

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

    CodeGenerationTools code = new CodeGenerationTools(this);

    // DisplayAttribute
    if(property.Documentation == null || string.IsNullOrEmpty(property.Documentation.LongDescription)) {
        this.WriteLine(ATR_DISPLAY_1,
            resourceTypeName,               // 0
            property.DeclaringType.Name,    // 1
            property.Name);                 // 2
    } else {
        this.WriteLine(ATR_DISPLAY_2,
            resourceTypeName,               // 0
            property.DeclaringType.Name,    // 1
            property.Name);                 // 2
    }

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

    // 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,
                            resourceTypeName,               // 0
                            property.DeclaringType.Name,    // 1
                            property.Name,                  // 2
                            maxLength);                     // 3
                    } else {
                        this.WriteLine(ATR_STRLENGTH_MAX,
                            resourceTypeName,               // 0
                            property.DeclaringType.Name,    // 1
                            property.Name,                  // 2
                            maxLength);                     // 3
                    }
                }
                break;
            case PrimitiveTypeKind.DateTime:
            case PrimitiveTypeKind.DateTimeOffset:
                this.WriteLine(ATR_TYPE_DATETIME);
                break;
            case PrimitiveTypeKind.Time:
                this.WriteLine(ATR_TYPE_TIME);
                break;
            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;
        }
    }

    // Property itself
    this.WriteLine("{0} {1} {2} {{ get; set; }}",
        Accessibility.ForProperty(property),    // 0
        code.Escape(property.TypeUsage),
        code.Escape(property.Name));
    this.WriteLine("");
}

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;
    }
}
#>