qliberace/Common/qdr.fnd.core.data/Repository/EntityRepository.cs

using System;
using System.Collections.Generic;
using System.Linq;

using Microsoft.EntityFrameworkCore;
using Quadarax.Foundation.Core.Data.Domain;
using Quadarax.Foundation.Core.Data.Entity;
using Quadarax.Foundation.Core.Data.Extensions;
using Quadarax.Foundation.Core.Data.Interface;
using Quadarax.Foundation.Core.Data.Interface.Domain;
using Quadarax.Foundation.Core.Data.Interface.Repository;

namespace Quadarax.Foundation.Core.Data.Repository
{
    public abstract class EntityRepository<TKey, TEntity> : IDaoRepository<TKey, TEntity> 
        where TEntity : Entity<TKey>, new() 
        where TKey : IEquatable<TKey>
    {
        private IUnitOfWork<IDataDomain> _unitOfWork;
        private DbSet<TEntity> DbSetInstance => _unitOfWork.Context.GetDbSet<DbSet<TEntity>>();
        protected IDataDomain Context => _unitOfWork.Context;
        protected IContext OperationContext { get; }

        
        protected IList<string> DefaultIncludes { get; }

        protected EntityRepository(IUnitOfWork<IDataDomain> unitOfWork)
        {
            _unitOfWork = unitOfWork ?? throw new ArgumentNullException(nameof(unitOfWork));
            DefaultIncludes = new List<string>();
            //_dbSet = domain.GetDbSet<DbSet<TEntity>>();
        }

        protected EntityRepository(IUnitOfWork<IDataDomain> unitOfWork, IContext currentOperationContext) : this(unitOfWork)
        {
            OperationContext = currentOperationContext ?? throw new ArgumentNullException(nameof(currentOperationContext));
        }

        public virtual IQueryable<TEntity> Query(IPaging paging,bool usingUncommited=false)
        {
            if (paging == null) throw new ArgumentNullException(nameof(paging));

            var local = DbSetInstance.Local.Page(paging.IsDisabled ? (int?) null : paging.Page, paging.PageSize).AsQueryable();
            if (local.Any() && usingUncommited)
            {
                return local.MultiInclude(DefaultIncludes.ToArray());
            }

            return DbSetInstance.Page(paging.IsDisabled ? (int?) null : paging.Page, paging.PageSize).MultiInclude(DefaultIncludes.ToArray());
        }

        public virtual TEntity Get(TKey id)
        {
            return Query(new Paging()).MultiInclude(DefaultIncludes.ToArray()).FirstOrDefault(x => Equals(x.Id, id));
        }

        public virtual IQueryable<TEntity> Get(IEnumerable<TKey> ids)
        {
            return Query(new Paging()).Where(x => ids.Contains(x.Id));
        }

        public virtual TEntity Set(TEntity entity)
        {
            //DbSetInstance.Update(entity);
            return entity;
        }

        public virtual IEnumerable<TEntity> Set(IEnumerable<TEntity> entities)
        {
            return entities.Select(Set).ToList();
        }

        public virtual TEntity New()
        {
            return DbSetInstance.Add(new TEntity()).Entity;
        }

        public virtual bool Remove(TKey id)
        {
            var dao = Get(id);
            if (dao == null) return false;
            DbSetInstance.Remove(dao);
            return true;
        }

        public virtual IEnumerable<bool> Remove(IEnumerable<TKey> ids)
        {
            return ids.Select(Remove).ToList();
        }

        public virtual bool Remove(TEntity entity)
        {
            DbSetInstance.Remove(entity);
            return true;
        }

        public virtual IEnumerable<bool> Remove(IEnumerable<TEntity> entities)
        {
            return entities.Select(Remove).ToList();
        }

    }
}