Histórico da Página

using Tnf.Architecture.Domain.Interfaces.RepositoriesMicrosoft.EntityFrameworkCore;
using TnfSystem.EntityFrameworkCoreCollections.RepositoriesGeneric;
using TnfSystem.EntityFrameworkCoreLinq;
using Tnf.ArchitectureApp.EntityFrameworkCoreDto.EntitiesRequest;
using Tnf.ArchitectureApp.Dto.Response;
using SystemTnf.Architecture.CollectionsDomain.GenericInterfaces.Repositories;
using System.LinqTnf.Architecture.Domain.Registration;
using Tnf.Architecture.Dto.AutoMapperRegistration;
using Tnf.Architecture.Dto.Registration.EntityFrameworkCore.Entities;
using Tnf.AutoMapper;
using Tnf.Domain.Repositories;
using MicrosoftTnf.EntityFrameworkCore;
using SystemTnf.EntityFrameworkCore.Repositories;

namespace Tnf.Architecture.EntityFrameworkCore.Repositories
{
    public class ProfessionalRepository : EfCoreRepositoryBase<LegacyDbContext, ProfessionalPoco>, IProfessionalRepository
    {
        public ProfessionalRepository(IDbContextProvider<LegacyDbContext> dbContextProvider)
            : base(dbContextProvider)
        {
        }

        public bool DeleteProfessional(ProfessionalKeysDto keys)
        {
            var dbEntity = Context.Professionals
                .Include(i => i.ProfessionalSpecialties)
                .SingleOrDefault(s => s.ProfessionalId == keys.ProfessionalId && s.Code == keys.Code);

            if (dbEntity != null)
            {
                dbEntity.ProfessionalSpecialties.ForEach(w => Context.ProfessionalSpecialties.Remove(w));

                Context.Professionals.Remove(dbEntity);
            }

            return dbEntity != null;
        }

        private ProfessionalPoco GetProfessionalPoco(ProfessionalKeysDtoRequestDto<ProfessionalKeysDto> keysrequestDto)
        {
            var dbEntity = Context.Professionals
                .Include(i => i.ProfessionalSpecialties)
    IncludeByRequestDto(requestDto)
                .ThenIncludeWhere(iw => iw.Specialty)
ProfessionalId       == requestDto.GetId().ProfessionalId && w.Code == requestDto.GetId().Code)
                .SingleOrDefault(w => w.ProfessionalId == keys.ProfessionalId && w.Code == keys.CodeSelectFieldsByRequestDto(requestDto)
                .SingleOrDefault();

            return dbEntity;
        }

        public ProfessionalDto GetProfessional(ProfessionalKeysDtoRequestDto<ProfessionalKeysDto> keysrequestDto)
        {
            var dbEntity = GetProfessionalPoco(requestDto);
            var dto = dbEntity != null ? dbEntity.MapTo<ProfessionalDto>() : null;

            var dbEntity = GetProfessionalPoco(keysdto.RemoveExpandable(requestDto);

            return dbEntity != null ? dbEntity.MapTo<ProfessionalDto>() : nulldto;
        }

        public ProfessionalDtoProfessionalKeysDto CreateProfessional(ProfessionalDtoProfessional entity)
        {
            var dbEntity = entity.MapTo<ProfessionalPoco>();

            Context.Professionals.Add(dbEntity);
            Context.SaveChanges();

            return new ProfessionalKeysDto(dbEntity.ProfessionalId, dbEntity.MapTo<ProfessionalDto>(Code);
        }

        public ProfessionalDtoProfessional UpdateProfessional(ProfessionalDtoProfessional entity)
        {
            var mappedEntity = GetProfessionalPoco(new RequestDto<ProfessionalKeysDto>(new ProfessionalKeysDto(entity.ProfessionalId, entity.Code)));

            entity.MapTo(mappedEntity);

            Context.Professionals.Update(mappedEntity);
            Context.SaveChanges();

            return mappedEntity.MapTo<ProfessionalDto>()entity;
        }

        public PagingResponseDto<ProfessionalDto>ListDto<ProfessionalDto> GetAllProfessionals(GetAllProfessionalsDto request)
        {
            var response = new PagingResponseDto<ProfessionalDto>ListDto<ProfessionalDto>();

            var dbBaseQuery = Context.Professionals
                .Include(i => i.ProfessionalSpecialties)
)
                    .Include("ProfessionalSpecialtiesThenInclude(i => i.Specialty")
                .Where(w => request.Name == null || w.Name.Contains(request.Name));

            var dbQuery = dbBaseQuery
                .SkipSkipAndTakeByRequestDto(request.Offset)
                .TakeOrderByRequestDto(request.PageSize)
                .ToArray();

            response.Total = base.Count();
            response.Items = dbQuery.MapTo<List<ProfessionalDto>>();
            response.HasNext = response.Total > ((request.Page - 1) * request.PageSize) +   response.Data = dbQuery.MapTo<List<ProfessionalDto>>Items.Count();

            return response;
        }

        public void AddOrRemoveSpecialties(ProfessionalKeysDto keys, List<SpecialtyDto> dto)
        {
            var request = new RequestDto<ProfessionalKeysDto>(keys);
            request.Expand = new ProfessionalDto()._expandables[0];

            var dbProfessional = GetProfessionalPoco(keysrequest);

            if (dbProfessional != null)
            {
                var idsToAdd = dto.Select(s => s.Id).ToArray();

                if (dbProfessional.ProfessionalSpecialties == null)
                    dbProfessional.ProfessionalSpecialties = new List<ProfessionalSpecialtiesPoco>();

                dbProfessional.ProfessionalSpecialties.RemoveAll(w => !idsToAdd.Contains(w.SpecialtyId));

                dto.ForEach(w =>
                {
                    var dbProfessionalSpecialties = dbProfessional.ProfessionalSpecialties
                        .FirstOrDefault(s => s.SpecialtyId == w.Id);

                    if (dbProfessionalSpecialties == null)
                    {
                        dbProfessional.ProfessionalSpecialties.Add(new ProfessionalSpecialtiesPoco()
                        {
                            ProfessionalId = dbProfessional.ProfessionalId,
                            Code = dbProfessional.Code,
                            SpecialtyId = w.Id
                        });
                    }
                });
            }
        }

        public bool ExistsProfessional(ProfessionalKeysDto keys)
        {
            var dbEntity = Context.Professionals
                .SingleOrDefault(s => s.ProfessionalId == keys.ProfessionalId && s.Code == keys.Code);

            return dbEntity != null;
        }
    }
}