/EntModApp.Templates/DataAccess/ImplEFCF/DataModelRepository.ttinclude

<#+ 

protected class QueryableEntityImplEFCFRepositoy : DataModelBaseTemplate<EntityType>

{

	public QueryableEntityImplEFCFRepositoy(EntityType model, XmlMap<string, object> map) : base (model, map) {  }

	protected override void TransformOverride()

	{

#>

using System;

using System.Collections.Generic;

using System.Data.Entity;

using System.Linq;

using System.Linq.Expressions;



using EntModApp.EntServices;

using EntModApp.EntServices.Data;



using <#= DMPublicNames.DataAccessAbstractionsNamespace(this) #>;



namespace <#= DMPublicNames.DataAccessImplEFCFNamespace(this) #>

{

  public partial class Queryable<#= POCOName(Model) #>Repository : 

<#+ if (Model.BaseEntityTypeRef == null) { #>

    DbContextQueryableRepository<<#= Model.DataModel.Name #>DbContext, <#= POCOName(Model) #>>,

<#+ } else { #>

    DbContextQueryableRepository<<#= Model.DataModel.Name #>DbContext, <#= POCOName(Model.RootEntityType) #>, <#= POCOName(Model) #>>,

<#+ } #>

    IQueryable<#= POCOName(Model) #>Repository

  {

   public Queryable<#= POCOName(Model) #>Repository(<#= Model.DataModel.Name #>DbContext context)

      : this(context, false)

    {

    }



    public Queryable<#= POCOName(Model) #>Repository()

      : this(new <#= Model.DataModel.Name #>DbContext(), true)

    {

    }



    protected Queryable<#= POCOName(Model) #>Repository(<#= Model.DataModel.Name #>DbContext context, bool ownContext)

      : base(context, context.<#= Model.RootEntityType.EntitySetName #>, ownContext)

    {

    }

  }

}

<#+	}

}

protected class ManualQueryableEntityImplEFCFRepositoy : DataModelBaseTemplate<EntityType>

{

	public ManualQueryableEntityImplEFCFRepositoy(EntityType model, XmlMap<string, object> map) : base (model, map) {  }

	protected override void TransformOverride()

	{

#>

using System;

using System.Collections.Generic;



using EntModApp.EntServices;

using EntModApp.EntServices.Data;



using <#= DMPublicNames.DataAccessAbstractionsNamespace(this) #>;



namespace <#= DMPublicNames.DataAccessImplEFCFNamespace(this) #>

{

  public partial class Queryable<#= POCOName(Model) #>Repository

  {

  }

}

<#+	}

}

protected class DataEntityImplEFCFRepositoy : DataModelBaseTemplate<EntityType>

{

	public DataEntityImplEFCFRepositoy(EntityType model, XmlMap<string, object> map) : base (model, map) {  }

	protected override void TransformOverride()

	{

#>

using System;

using System.Collections.Generic;

using System.Linq;



using EntModApp.EntServices;

using EntModApp.EntServices.Data;



using <#= DMPublicNames.DataAccessAbstractionsNamespace(this) #>;



namespace <#= DMPublicNames.DataAccessImplEFCFNamespace(this) #>

{

  public partial class <#= POCOName(Model) #>Repository : 

<#+ if (Model.BaseEntityTypeRef == null) { #>

    DbContextDataRepository<<#= Model.DataModel.Name #>DbContext, <#= POCOName(Model) #>, <#= POCOName(Model) #>LoadSettings>,

<#+ } else { #>

    DbContextDataRepository<<#= Model.DataModel.Name #>DbContext, <#= POCOName(Model.RootEntityType) #>, <#= POCOName(Model) #>, <#= POCOName(Model) #>LoadSettings>,

<#+ } #>

    I<#= POCOName(Model) #>Repository

  {

    public <#= POCOName(Model) #>Repository(<#= Model.DataModel.Name #>DbContext context)

      : this(context, false)

    {

    }



    public <#= POCOName(Model) #>Repository()

      : this(new <#= Model.DataModel.Name #>DbContext(), true)

    {

    }



    protected <#= POCOName(Model) #>Repository(<#= Model.DataModel.Name #>DbContext context, bool ownContext)

      : base(context, context.<#= Model.RootEntityType.EntitySetName #>, ownContext)

    {

    }



    public override IEnumerable<<#= POCOName(Model) #>> RetrieveAll(out int total, bool retrieveTotal)

    {

      var query = new <#= POCOName(Model) #>LoadSettings

      {

        Paging = new PagingSettings { ComputeTotal = retrieveTotal }

      };

      return Retrieve(query, out total);

    }



    public override IEnumerable<<#= POCOName(Model) #>> Retrieve(<#= POCOName(Model) #>LoadSettings query, out int total)

    {

<#+ if (Model.BaseEntityTypeRef == null) { #>

      var dbQuery = DataSet.Apply<#= POCOName(Model) #>LoadSettings(query, out total);

<#+ } else { #>

      var dbQuery = DataSet.OfType<<#= POCOName(Model) #>>().Apply<#= POCOName(Model) #>LoadSettings(query, out total);

<#+ } #>

      return dbQuery.ToList();

    }



    public override int Count()

    {

      return DataSet.Count();

    }



    public override int Count(<#= POCOName(Model) #>LoadSettings query)

    {

<#+ if (Model.BaseEntityTypeRef == null) { #>

      var dbQuery = DataSet.Apply<#= Model.Name #>FilterExpression(query.Filter);

<#+ } else { #>

      var dbQuery = DataSet.OfType<<#= POCOName(Model) #>>().Apply<#= Model.Name #>FilterExpression(query.Filter);

<#+ } #>

      return dbQuery.Count();

    }

  }

}

<#+	}

}

protected class ManualDataEntityImplEFCFRepositoy : DataModelBaseTemplate<EntityType>

{

	public ManualDataEntityImplEFCFRepositoy(EntityType model, XmlMap<string, object> map) : base (model, map) {  }

	protected override void TransformOverride()

	{

#>

using System;

using System.Collections.Generic;



using EntModApp.EntServices;

using EntModApp.EntServices.Data;



using <#= DMPublicNames.DataAccessAbstractionsNamespace(this) #>;



namespace <#= DMPublicNames.DataAccessImplEFCFNamespace(this) #>

{

  public partial class <#= Model.Name #>Repository

  {

  }

}

<#+	}

}

protected class DataModelImplEFCFRepositoyExtensions : DataModelBaseTemplate<EntityType>

{

	public DataModelImplEFCFRepositoyExtensions(EntityType model, XmlMap<string, object> map) : base (model, map) {  }

	protected override void TransformOverride()

	{

#>

using System;

using System.Collections.Generic;

using System.Data.Entity;

using System.Linq;

using System.Linq.Expressions;



using EntModApp.EntServices;

using EntModApp.EntServices.Data;



using <#= DMPublicNames.DataAccessAbstractionsNamespace(this) #>;



namespace <#= DMPublicNames.DataAccessImplEFCFNamespace(this) #>

{

  public static class <#= POCOName(Model) #>RepositoryExtensions

  {

<#+ foreach (var entity in Seq.Build(Model)) { #>

    public static IQueryable<<#= POCOName(entity) #>> Apply<#= POCOName(entity) #>LoadSettings(this IQueryable<<#= POCOName(entity) #>> query, <#= POCOName(entity) #>LoadSettings loadSettings, out int total)

    {

      if (loadSettings == null)

        loadSettings = new <#= POCOName(entity) #>LoadSettings();



      query = query.Apply<#= entity.Name #>InclusionSettings(loadSettings.Inclusion);



      query = query.Apply<#= entity.Name #>FilterExpression(loadSettings.Filter);



      query = query.Apply<#= entity.Name #>SortingSettings(loadSettings.Sorting);



      query = query.ApplyPagingSettings(loadSettings.Paging, out total);



      query = query.Apply<#= entity.Name #>SelectionSettings(loadSettings.Selection);



      return query;

    }



    public static IEnumerable<string> GetDirect<#= entity.Name #>InclusionPaths(this <#= POCOName(entity) #>InclusionSettings inclusionSettings)

    {

<#+ if (entity.BaseEntityTypeRef != null) { #>

      foreach (var path in inclusionSettings.GetDirect<#= entity.BaseEntityTypeRef.Name #>InclusionPaths())

        yield return path;



<#+ } #>

<#+ foreach (var prop in entity.References) { #>

      if (inclusionSettings.Include<#= prop.Name #>) yield return "<#= prop.Name #>";

<#+ } #>



      yield break;

    }



    public static IEnumerable<string> Get<#= entity.Name #>InclusionPaths(this <#= POCOName(entity) #>InclusionSettings inclusionSettings)

    {

      foreach (var path in inclusionSettings.GetDirect<#= entity.Name #>InclusionPaths())

        yield return path;



<#+ foreach (var prop in entity.References) { #>

      if (inclusionSettings.Include<#= prop.Name #>)

        foreach (var referencePath in inclusionSettings.Included<#= prop.Name #>Settings.Inclusion.Get<#= prop.EntityTypeRef.Name #>InclusionPaths())

          yield return "<#= prop.Name #>." + referencePath;

<#+ } #>



      yield break;

    }



    public static IQueryable<<#= POCOName(entity) #>> Apply<#= entity.Name #>InclusionSettings(this IQueryable<<#= POCOName(entity) #>> query, <#= POCOName(entity) #>InclusionSettings inclusionSettings)

    {

      foreach (var path in inclusionSettings.Get<#= entity.Name #>InclusionPaths())

        query = query.Include(path);



      return query;

    }



    public static IQueryable<<#= POCOName(entity) #>> Apply<#= entity.Name #>FilterExpression(this IQueryable<<#= POCOName(entity) #>> query, <#= POCOName(entity) #>FilterExpression filterExpression)

    {

      if (filterExpression.ByKey != null)

        query = query.Where(o => <#= Model.RootEntityType.ConformKey().ToStringList(" && ", k => string.Format("o.{0} == filterExpression.ByKey.{0}", k.KeyName())) #>);



      var parameter = Expression.Parameter(typeof(<#= POCOName(entity) #>), "e");

<#+ foreach (var prop in Model.AllPlainProperties)

	{ 

		var propType = prop.Type.ToCommonString(prop.AllowNull);

#>

      if (filterExpression.<#= prop.Name #>Filter != null)

        query = query.Where(filterExpression.<#= prop.Name #>Filter.CreateExpressionBody<<#= POCOName(entity) #>, <#= propType #>>(<#= Model.DataModel.Name #>DataAccessConstants.<#= POCOName(entity) #>.<#= prop.Name #>, parameter).ToLambda<<#= POCOName(entity) #>>(parameter));

<#+ } #>

<#+ foreach (var prop in Model.AllReferences.Where(r => !r.IsMultiple))

	{ 

		var refKeys = prop.ConformKey();

		var entKeys = prop.EntityTypeRef.ConformKey();

		var tups = Tup.Create(refKeys, entKeys).Enumerate();

#>

      if (filterExpression.<#= prop.Name #>Key != null)

        query = query.Where(o => <#= tups.ToStringList(" && ", k => string.Format("o.{0} == filterExpression.{1}Key.{2}", k.Item1.KeyName(), prop.Name, k.Item2.KeyName())) #>);

<#+ } #>



      if (filterExpression.Skip.HasValue)

        query = query.Skip(filterExpression.Skip.Value);

      if (filterExpression.Take.HasValue)

        query = query.Take(filterExpression.Take.Value);



      return query;

    }



    public static IQueryable<<#= POCOName(entity) #>> Apply<#= entity.Name #>SortingSettings(this IQueryable<<#= POCOName(entity) #>> query, <#= POCOName(entity) #>SortingSettings sortingSettings)

    {

      return query;

    }



    public static IQueryable<<#= POCOName(entity) #>> Apply<#= entity.Name #>SelectionSettings(this IQueryable<<#= POCOName(entity) #>> query, <#= POCOName(entity) #>SelectionSettings selectionSettings)

    {

      return query;

    }



<#+ } #>

  }

}

<#+	}

}

protected class QueryableModelImplEFCFRepositoy : DataModelBaseTemplate<DataModel>

{

	public QueryableModelImplEFCFRepositoy(DataModel model, XmlMap<string, object> map) : base (model, map) {  }

	protected override void TransformOverride()

	{

#>

using System;

using System.Collections.Generic;



using EntModApp.EntServices;

using EntModApp.EntServices.Data;



using <#= DMPublicNames.DataAccessAbstractionsNamespace(this) #>;



namespace <#= DMPublicNames.DataAccessImplEFCFNamespace(this) #>

{

  public class Queryable<#= Model.Name #>Repository : 

    IQueryable<#= Model.Name #>Repository

  {

    public Queryable<#= Model.Name #>Repository(<#= Model.DataModel.Name #>DbContext context)

      : this(context, false)

    {

    }



    public Queryable<#= Model.Name #>Repository()

      : this(new <#= Model.DataModel.Name #>DbContext(), true)

    {

    }



    protected Queryable<#= Model.Name #>Repository(<#= Model.DataModel.Name #>DbContext context, bool ownContext)

    {

      if (context == null) throw new ArgumentNullException();

      Context = context;

      OwnContext = ownContext;

    }



    protected <#= Model.DataModel.Name #>DbContext Context { get; private set; }

    protected bool OwnContext { get; private set; }



<#+ foreach (var entity in Model.EntityTypes) { #>

    private IQueryable<#= POCOName(entity) #>Repository _<#= entity.EntitySetName #>;

    public IQueryable<#= POCOName(entity) #>Repository <#= entity.EntitySetName #>

    {

      get { return _<#= entity.EntitySetName #> ?? (_<#= entity.EntitySetName #> = new Queryable<#= POCOName(entity) #>Repository(Context)); }

    }

		 

<#+ } #>

    public void Commit()

    {

      if (OwnContext)

        Context.SaveChanges();

    }



    public void Dispose()

    {

      if (OwnContext)

      {

        Context.Dispose();

        OwnContext = false;

      }

      GC.SuppressFinalize(this);

    }

  }

}

<#+	}

}

protected class DataModelImplEFCFRepositoy : DataModelBaseTemplate<DataModel>

{

	public DataModelImplEFCFRepositoy(DataModel model, XmlMap<string, object> map) : base (model, map) {  }

	protected override void TransformOverride()

	{

#>

using System;

using System.Collections.Generic;



using EntModApp.EntServices;

using EntModApp.EntServices.Data;



using <#= DMPublicNames.DataAccessAbstractionsNamespace(this) #>;



namespace <#= DMPublicNames.DataAccessImplEFCFNamespace(this) #>

{

  public class <#= Model.Name #>Repository : 

    I<#= Model.Name #>Repository

  {

    public <#= Model.Name #>Repository(<#= Model.DataModel.Name #>DbContext context)

      : this(context, false)

    {

    }



    public <#= Model.Name #>Repository()

      : this(new <#= Model.DataModel.Name #>DbContext(), true)

    {

    }



    protected <#= Model.Name #>Repository(<#= Model.DataModel.Name #>DbContext context, bool ownContext)

    {

      if (context == null) throw new ArgumentNullException();

      Context = context;

      OwnContext = ownContext;

    }



    protected <#= Model.DataModel.Name #>DbContext Context { get; private set; }

    protected bool OwnContext { get; private set; }



<#+ foreach (var entity in Model.EntityTypes/*.Where(e => e.BaseEntityTypeRef == null)*/) { #>

    private I<#= POCOName(entity) #>Repository _<#= entity.EntitySetName #>;

    public I<#= POCOName(entity) #>Repository <#= entity.EntitySetName #>

    {

      get { return _<#= entity.EntitySetName #> ?? (_<#= entity.EntitySetName #> = new <#= POCOName(entity) #>Repository(Context)); }

    }

		 

<#+ } #>

    public void Commit()

    {

      if (OwnContext)

        Context.SaveChanges();

    }



    public void Dispose()

    {

      if (OwnContext)

      {

        Context.Dispose();

        OwnContext = false;

      }

      GC.SuppressFinalize(this);

    }

  }

}

<#+	}

}

protected class QueryableModelImplEFCFRepositoyFactory : DataModelBaseTemplate<DataModel>

{

	public QueryableModelImplEFCFRepositoyFactory(DataModel model, XmlMap<string, object> map) : base (model, map) {  }

	protected override void TransformOverride()

	{

#>

using System;

using System.Collections.Generic;



using EntModApp.EntServices;

using EntModApp.EntServices.Data;



using <#= DMPublicNames.DataAccessAbstractionsNamespace(this) #>;



namespace <#= DMPublicNames.DataAccessImplEFCFNamespace(this) #>

{

  public class Queryable<#= Model.Name #>RepositoryFactory : 

    IQueryable<#= Model.Name #>RepositoryFactory

  {

    public IQueryable<#= Model.Name #>Repository CreateRepository()

    {

      return new Queryable<#= Model.Name #>Repository();

    }

  }

}

<#+	}

}

protected class DataModelImplEFCFRepositoyFactory : DataModelBaseTemplate<DataModel>

{

	public DataModelImplEFCFRepositoyFactory(DataModel model, XmlMap<string, object> map) : base (model, map) {  }

	protected override void TransformOverride()

	{

#>

using System;

using System.Collections.Generic;



using EntModApp.EntServices;

using EntModApp.EntServices.Data;



using <#= DMPublicNames.DataAccessAbstractionsNamespace(this) #>;



namespace <#= DMPublicNames.DataAccessImplEFCFNamespace(this) #>

{

  public class <#= Model.Name #>RepositoryFactory : 

    I<#= Model.Name #>RepositoryFactory

  {

    public I<#= Model.Name #>Repository CreateRepository()

    {

      return new <#= Model.Name #>Repository();

    }

  }

}

<#+	}

}

#>