DomainService.tt

<#@ template debug="false" hostspecific="true" language="C#" #>
<#@ include file="EF.Utility.CS.ttinclude"#>
<#@ assembly name="System.Core" #>
<#@ assembly name="System.Data.Entity" #>
<#@ Assembly Name="$(SolutionDir)packages\EntityFramework.5.0.0\lib\net45\EntityFramework.dll" #>
<#@ import namespace="System.Linq" #>
<#@ import namespace="System.Collections.Generic" #>
<#@ import namespace="System.Data.Entity.Infrastructure" #>
<#@ import namespace="System.Data.Metadata.Edm" #>
<#@ output extension=".cs" #><#

// settings start
string inputFile = @"../../%project%.Server.Data/%project%Model.edmx";
string serviceName = "%project%Service";
string modelNamespace = "%namespace%";
// settings end

var textTransform = DynamicTextTransformation.Create(this);
var code = new CodeGenerationTools(this);
var itemCollection = new EdmMetadataLoader(textTransform.Host, textTransform.Errors).CreateEdmItemCollection(inputFile);

Generate(itemCollection, code, serviceName, modelNamespace);
#><#+
void Generate(IEnumerable<GlobalItem> itemCollection, CodeGenerationTools code, string serviceName, string modelNamespace)
{
    ArgumentNotNull(itemCollection, "itemCollection");
    ArgumentNotNull(code, "code");
    ArgumentNotNull(serviceName, "serviceName");

    var container = itemCollection.OfType<EntityContainer>().First();
    string codeNamespace = modelNamespace;//code.VsNamespaceSuggestion();
#>
namespace <#= code.EscapeNamespace(codeNamespace) #>
{
    using System.Data;
    using System.Linq;
    using System.ServiceModel.DomainServices.EntityFramework;
    using System.ServiceModel.DomainServices.Hosting;
    using System.ServiceModel.DomainServices.Server;
    using System.Web.DomainServices.FluentMetadata;
    using RIAServices.M2M.Configuration;
    using RIAServices.M2M.DbContext;
<#+
    if (!string.IsNullOrEmpty(modelNamespace) && codeNamespace != modelNamespace)
    {
#>
    using <#= code.EscapeNamespace(modelNamespace) #>;
<#+
    }
#>

    [EnableClientAccess()]
    [FluentMetadata(typeof(MetadataConfiguration))]
    public partial class <#= code.Escape(serviceName) #> : DbDomainService<<#= code.Escape(container.Name) #>>
    {
<#+
    foreach (var entitySet in container.BaseEntitySets.Where(set => set.BuiltInTypeKind == BuiltInTypeKind.EntitySet))
    {
        string elementName = code.Escape(entitySet.ElementType.Name);
        string setName = code.Escape(entitySet.Name);
        string findLine = GenerateFindLine(entitySet.ElementType);
#>
        [Query]
        public IQueryable<<#= elementName #>> Get<#= elementName #>s()
        {
            return this.DbContext.<#= setName #>;
        }

        [Insert]
        public void Insert<#= elementName #>(<#= elementName #> entity)
        {
            if ((DbContext.Entry(entity).State != EntityState.Detached))
            {
                this.DbContext.Entry(entity).State = EntityState.Added;
            }
            else
            {
                this.DbContext.<#= setName #>.Add(entity);
            }
        }

        [Update]
        public void Update<#= elementName #>(<#= elementName #> entity)
        {
            var local = this.DbContext.<#= setName #>.Local.FirstOrDefault(t => <#= findLine #>);
            if (local == null)
            {
                this.DbContext.<#= setName #>.AttachAsModified(entity, this.DbContext);
            }
            else
            {
                this.DbContext.Entry(local).CurrentValues.SetValues(entity);
                this.DbContext.Entry(local).State = EntityState.Modified;
            }
        }

        [Delete]
        public void Delete<#= elementName #>(<#= elementName #> entity)
        {
            var local = this.DbContext.<#= setName #>.Local.FirstOrDefault(t => <#= findLine #>);
            if (local == null)
            {
                this.DbContext.<#= setName #>.Attach(entity);
                this.DbContext.<#= setName #>.Remove(entity);
            }
            else
            {
                this.DbContext.<#= setName #>.Remove(local);
            }

        }

<#+
    }

    // M2M support http://m2m4ria.codeplex.com/wikipage?title=Step-by-step%20instructions%20for%20using%20M2M%20with%20WCR%20RIA%20Services
    var associations = container.BaseEntitySets
        .Where(es => es.BuiltInTypeKind == BuiltInTypeKind.EntitySet)
        .OfType<EntitySet>()
        .SelectMany(es => es.ElementType.NavigationProperties)
        .Where(np => np.ToEndMember.RelationshipMultiplicity == RelationshipMultiplicity.Many && np.FromEndMember.RelationshipMultiplicity == RelationshipMultiplicity.Many)
        .GroupBy(np => np.RelationshipType);
    foreach (var propertiesGroup in associations)
    {
        var relationship = propertiesGroup.Key;
        var className = code.Escape("M2M_" + relationship.Name);
        var type1 = relationship.RelationshipEndMembers.First().GetEntityType();
        var type2 = relationship.RelationshipEndMembers.Last().GetEntityType();
        var basetype1 = type1;
        while (basetype1.BaseType != null && basetype1.BaseType.BuiltInTypeKind == BuiltInTypeKind.EntityType)
            basetype1 = (EntityType)basetype1.BaseType;
        var set1 = container.BaseEntitySets
            .Where(es => es.BuiltInTypeKind == BuiltInTypeKind.EntitySet)
            .OfType<EntitySet>()
            .First(es => es.ElementType == basetype1);
        string findLine = GenerateFindLine(basetype1);
        var prop1 = propertiesGroup.First(np => np.DeclaringType == type1);
        var prop2 = propertiesGroup.First(np => np.DeclaringType == type2);
#>
        [Insert]
        public void Insert<#= className #>(<#= className #> m2m_entity)
        {
            var entity = m2m_entity.FetchObject1(ChangeSet, DbContext);
            var <#= code.Escape(type2.Name) #> = m2m_entity.FetchObject2(ChangeSet, DbContext);
            if (this.DbContext.Entry(entity).State == EntityState.Detached)
            {
                var local = this.DbContext.<#= code.Escape(set1.Name) #>.Local.FirstOrDefault(t => <#= findLine #>);
                if (local == null)
                {
                    this.DbContext.<#= code.Escape(set1.Name) #>.Attach(entity);
                }
                else
                {
                    entity = (<#= code.Escape(type1.Name) #>)local;
                }
            }
            entity.<#= code.Escape(prop1.Name) #>.Add(<#= code.Escape(type2.Name) #>);
            DbContext.ChangeTracker.DetectChanges();
        }

        [Delete]
        public void Delete<#= className #>(<#= className #> m2m_entity)
        {
            var entity = m2m_entity.FetchObject1(ChangeSet, DbContext);
            var <#= code.Escape(type2.Name) #> = m2m_entity.FetchObject2(ChangeSet, DbContext);
            if (this.DbContext.Entry(entity).State == EntityState.Detached)
            {
                var local = this.DbContext.<#= code.Escape(set1.Name) #>.Local.FirstOrDefault(t => <#= findLine #>);
                if (local == null)
                {
                    this.DbContext.<#= code.Escape(set1.Name) #>.Attach(entity);
                }
                else
                {
                    entity = (<#= code.Escape(type1.Name) #>)local;
                }
            }
            DbContext.LoadM2M<<#= code.Escape(type1.Name) #>, <#= code.Escape(type2.Name) #>, <#= className #>>(entity, <#= code.Escape(type2.Name) #>);
            entity.<#= code.Escape(prop1.Name) #>.Remove(<#= code.Escape(type2.Name) #>);
            DbContext.ChangeTracker.DetectChanges();
        }

<#+
    }
#>
    }
    public class MetadataConfiguration : IFluentMetadataConfiguration
    {
        public void OnTypeCreation(MetadataContainer metadataContainer)
        {
<#+
    foreach (var propertiesGroup in associations)
    {
        var relationship = propertiesGroup.Key;
        var className = code.Escape("M2M_" + relationship.Name);
        var type1 = relationship.RelationshipEndMembers.First().GetEntityType();
        var type2 = relationship.RelationshipEndMembers.Last().GetEntityType();
        var prop1 = propertiesGroup.First(np => np.DeclaringType == type1);
        var prop2 = propertiesGroup.First(np => np.DeclaringType == type2);
#>
            metadataContainer.Entity<<#= code.Escape(type1.Name) #>>()
                .Projection(x => x.<#= code.Escape(prop1.Name) #>)
                    .M2M(x => x.<#= className #>, x => x.<#= className #>, x => x.<#= code.Escape(prop2.Name) #>);
<#+
    }
#>
        }
    }
}
<#+
}

string GenerateFindLine(EntityTypeBase entityType)
{
    string findLine = "";
    var last = entityType.KeyMembers.Last();
    foreach (var keyMember in entityType.KeyMembers)
    {
        findLine += "t." + keyMember.Name + " == entity." + keyMember.Name;
        if (keyMember != last)
            findLine += " && ";
    }
    return findLine;
}

public class EdmMetadataLoader
{
    private readonly IDynamicHost _host;
    private readonly System.Collections.IList _errors;

    public EdmMetadataLoader(IDynamicHost host, System.Collections.IList errors)
    {
        ArgumentNotNull(host, "host");
        ArgumentNotNull(errors, "errors");

        _host = host;
        _errors = errors;
    }

    public IEnumerable<GlobalItem> CreateEdmItemCollection(string sourcePath)
    {
        ArgumentNotNull(sourcePath, "sourcePath");

        if (!ValidateInputPath(sourcePath))
        {
            return new EdmItemCollection();
        }

        var schemaElement = LoadRootElement(_host.ResolvePath(sourcePath));
        if (schemaElement != null)
        {
            using (var reader = schemaElement.CreateReader())
            {
                IList<EdmSchemaError> errors;
                var itemCollection = MetadataItemCollectionFactory.CreateEdmItemCollection(new[] { reader }, out errors);

                ProcessErrors(errors, sourcePath);

                return itemCollection;
            }
        }
        return new EdmItemCollection();
    }

    public string GetModelNamespace(string sourcePath)
    {
        ArgumentNotNull(sourcePath, "sourcePath");

        if (!ValidateInputPath(sourcePath))
        {
            return string.Empty;
        }

        var model = LoadRootElement(_host.ResolvePath(sourcePath));
        if (model == null)
        {
            return string.Empty;
        }

        var attribute = model.Attribute("Namespace");
        return attribute != null ? attribute.Value : "";
    }

    private bool ValidateInputPath(string sourcePath)
    {
        if (sourcePath == "$" + "edmxInputFile" + "$")
        {
            _errors.Add(
                new CompilerError(_host.TemplateFile ?? sourcePath, 0, 0, string.Empty,
                    GetResourceString("Template_ReplaceVsItemTemplateToken")));
            return false;
        }

        return true;
    }

    public XElement LoadRootElement(string sourcePath)
    {
        ArgumentNotNull(sourcePath, "sourcePath");

        var root = XElement.Load(sourcePath, LoadOptions.SetBaseUri | LoadOptions.SetLineInfo);
        return root.Elements()
            .Where(e => e.Name.LocalName == "Runtime")
            .Elements()
            .Where(e => e.Name.LocalName == "ConceptualModels")
            .Elements()
            .Where(e => e.Name.LocalName == "Schema")
            .FirstOrDefault()
                ?? root;
    }

    private void ProcessErrors(IEnumerable<EdmSchemaError> errors, string sourceFilePath)
    {
        foreach (var error in errors)
        {
            _errors.Add(
                new CompilerError(
                    error.SchemaLocation ?? sourceFilePath,
                    error.Line,
                    error.Column,
                    error.ErrorCode.ToString(CultureInfo.InvariantCulture),
                    error.Message)
                {
                    IsWarning = error.Severity == EdmSchemaErrorSeverity.Warning
                });
        }
    }

    public bool IsLazyLoadingEnabled(EntityContainer container)
    {
        string lazyLoadingAttributeValue;
        var lazyLoadingAttributeName = MetadataConstants.EDM_ANNOTATION_09_02 + ":LazyLoadingEnabled";
        bool isLazyLoading;
        return !MetadataTools.TryGetStringMetadataPropertySetting(container, lazyLoadingAttributeName, out lazyLoadingAttributeValue)
            || !bool.TryParse(lazyLoadingAttributeValue, out isLazyLoading)
            || isLazyLoading;
    }
}

public static void ArgumentNotNull<T>(T arg, string name) where T : class
{
    if (arg == null)
    {
        throw new ArgumentNullException(name);
    }
}

private static readonly Lazy<System.Resources.ResourceManager> ResourceManager =
    new Lazy<System.Resources.ResourceManager>(
        () => new System.Resources.ResourceManager("System.Data.Entity.Design", typeof(MetadataItemCollectionFactory).Assembly), isThreadSafe: true);

public static string GetResourceString(string resourceName)
{
    ArgumentNotNull(resourceName, "resourceName");

    return ResourceManager.Value.GetString(resourceName, null);
}
#>