using Microsoft.EntityFrameworkCore;

using System.Collections.Generic;

using System.Linq;

using System;

using System.Linq.Dynamic.Core;

using System.Linq.Expressions;

​

namespace EFTest

{

    public class Parcelamento

    {

        public int Id { get; set; }

        public Parcela Parcela { get; set; }

        //public List<Parcela> Parcelas { get; set; }

        public override string ToString()

        {

            var s = $"Parcelamento {Id}{Environment.NewLine}";

            s += string.Join(Environment.NewLine, Parcela.ToString());

            return s;

        }

    }

    public class Parcela

    {

        public int ParcelamentoId { get; set; }

        public int Id { get; set; }

        public List<Debito> Debitos { get; set; }

        public override string ToString()

        {

            var s = $"    Parcela {Id}{Environment.NewLine}";

            s += string.Join(Environment.NewLine, Debitos.Select(d => d.ToString()));

            return s;

        }

    }

    public class Debito

    {

        public int ParcelamentoId { get; set; }

        public int ParcelaId { get; set; }

        public int Id { get; set; }

        public byte OrigemId { get; set; }

        public override string ToString()

        {

            return $"        Débito {Id}/{OrigemId}";

        }

    }

​

    public class ParcelamentoContext : DbContext

    {

        public ParcelamentoContext(){ }

​

        public ParcelamentoContext(DbContextOptions<ParcelamentoContext> options)

            : base(options){ }

​

        public DbSet<Parcelamento> Parcelamentos { get; set; }

    }

​

    public class ParcelamentoService

    {

        private ParcelamentoContext _context;

​

        public ParcelamentoService(ParcelamentoContext context)

        {

            _context = context;

        }

​

        public void Add(int id, byte origemID)

        {

            var debito = new Debito { ParcelamentoId = id, ParcelaId = id * 2, Id = id * 3, OrigemId = origemID };

            var parcela = new Parcela { ParcelamentoId = id, Id = id * 2, Debitos = new() { debito } };

            //var parcelamento = new Parcelamento { Id = id, Parcelas = new() { parcela } };

            var parcelamento = new Parcelamento { Id = id };

            _context.Parcelamentos.Add(parcelamento);

            _context.SaveChanges();

        }

        public IEnumerable<Parcelamento> GetAll()

        {

            return _context.Parcelamentos

                .Include(x => x.Parcela)

                    .ThenInclude(x => x.Debitos)

                .AsNoTracking()

                .ToList();

        }

        public IEnumerable<Parcelamento> Find(List<byte> origens)

        {

            return _context.Parcelamentos

                .FilterOrigins(origens, p => p.Parcela.Debitos.Select(d => d.OrigemId))

                .Include(x => x.Parcela)

                    .ThenInclude(x => x.Debitos)

                .AsNoTracking()

                .ToList();

        }

    }

​

    class Program

    {

        static void Main(string[] args)

        {

            Console.WriteLine("This is an example of using EF Core InMemory Database");

            Console.WriteLine("======================================================");

            Console.WriteLine("");

            var options = new DbContextOptionsBuilder<ParcelamentoContext>()

                .UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString())

                .ConfigureWarnings(x => x.Ignore(Microsoft.EntityFrameworkCore.Diagnostics.InMemoryEventId.TransactionIgnoredWarning))

                .Options;

​

            // Run the test against one instance of the context

            using (var context = new ParcelamentoContext(options))

            {

                var service = new ParcelamentoService(context);

                Console.WriteLine("Adding new Parcelamento");

                Console.WriteLine("");

                context.Database.BeginTransaction();

                try

                {

                    service.Add(1, 1);

                    service.Add(2, 1);

                    service.Add(3, 2);

                    service.Add(4, 3);

                }

                finally

                {

                    context.Database.CommitTransaction();

                }

            }

            Console.WriteLine("");

            Console.WriteLine("======================================================");

            Console.WriteLine("");

​

            // Use a separate instance of the context to verify correct data was saved to database

            using (var context = new ParcelamentoContext(options))

            {

                var service = new ParcelamentoService(context);

                var ps = service.GetAll();

                //Console.WriteLine($"Parcelamentos Count: {ps.Count()}");

                var s = string.Join(Environment.NewLine + "----------------------------------" + Environment.NewLine, ps.Select(p => p.ToString()));

                Console.WriteLine($"Parcelamentos: {s}");

            }

            Console.WriteLine("");

            Console.WriteLine("======================================================");

            Console.WriteLine("");

            using (var context = new ParcelamentoContext(options))

            {

                var origens = new List<byte> { 2, 3};

                var service = new ParcelamentoService(context);

                var ps = service.Find(origens);

                if (ps.Any())

                {

                    var s = string.Join(Environment.NewLine + "----------------------------------" + Environment.NewLine, ps.Select(p => p.ToString()));

                    Console.WriteLine($"Parcelamentos: {s}");

                }

                else

                {

                    Console.WriteLine("Parcelamentos: Nenhum");

                }

            }

        }

    }

    public static class DbSetExtension

    {

        public static IQueryable<TEntity> FilterOrigins<TEntity>(this DbSet<TEntity> dbSet, List<byte> sessionOrigins, Expression<Func<TEntity, byte>> originSelector) where TEntity : class

        {

            if (sessionOrigins.Any())

            {

                var allOrigins = new List<byte> { 1, 2, 3, 4, 5 };

​

                if (allOrigins.Except(sessionOrigins).Any())

                {

                    var parameter = originSelector.Parameters[0];

​

                    var originContain = Expression.Call(

                        Expression.Constant(sessionOrigins),

                        nameof(Enumerable.Contains),

                        Type.EmptyTypes,

                        originSelector.Body

                    );

​

                    var predicate = Expression.Lambda<Func<TEntity, bool>>(originContain, parameter);

                    return dbSet.Where(predicate);

                }

                else

                {

                    return dbSet;

                }

            }

            else

            {

                return dbSet.Where(x => false);

            }

        }

​

        public static IQueryable<TEntity> FilterOrigins<TEntity>(this DbSet<TEntity> dbSet, List<byte> sessionOrigins, Expression<Func<TEntity, IEnumerable<byte>>> originSelector) where TEntity : class

        {

            if (sessionOrigins.Any())

            {

                var allOrigins = new List<byte> { 1, 2, 3, 4, 5 };

​

                if (allOrigins.Except(sessionOrigins).Any())

                {

                    var parameter = originSelector.Parameters[0];

                    var originParameter = Expression.Parameter(typeof(byte), "x");

​

                    var originContainsAll = Expression.Call(

                        typeof(Enumerable),

                        nameof(Enumerable.All),

                        new[] { typeof(byte) },

                        originSelector.Body,

                        Expression.Lambda<Func<byte, bool>>(

                            Expression.Call(

                                Expression.Constant(sessionOrigins),

                                nameof(Enumerable.Contains),

                                Type.EmptyTypes,

                                originParameter

                            ),

                            originParameter

                        )

                    );

​

                    var predicate = Expression.Lambda<Func<TEntity, bool>>(originContainsAll, parameter);

                    return dbSet.Where(predicate);

                }

                else

                {

                    return dbSet;

                }

            }

            else

            {

                return dbSet.Where(x => false);

​

            }

        }

    }

}