Histórico da Página

public interface ICountryRepository : IRepository<Country>
{
}

using Tnf.Architecture.Domain.Interfaces.RepositoriesMicrosoft.EntityFrameworkCore;
using System;
using System.Collections.Generic;
using TnfSystem.EntityFrameworkCore.RepositoriesLinq;
using TnfSystem.EntityFrameworkCoreTransactions;
using Tnf.ArchitectureApp.EntityFrameworkCore.EntitiesAutoMapper;
using Tnf.ArchitectureApp.Dto.Request;
using SystemTnf.CollectionsApp.GenericEntityFrameworkCore;
using System.LinqTnf.App.EntityFrameworkCore.Repositories;
using Tnf.Architecture.Common.AutoMapperValueObjects;
using Tnf.Architecture.DtoDomain.Interfaces.RegistrationRepositories;
using Microsoft.EntityFrameworkCoreTnf.Architecture.Domain.Registration;
using System;

namespace Tnf.Architecture.Dto.Registration;
using Tnf.Architecture.EntityFrameworkCore.Contexts;
using Tnf.Architecture.EntityFrameworkCore.Entities;
using Tnf.Domain.Uow;
using Tnf.EntityFrameworkCore;

namespace Tnf.Architecture.EntityFrameworkCore.Repositories
{
    public class ProfessionalRepository : EfCoreRepositoryBase<LegacyDbContextAppEfCoreRepositoryBase<LegacyDbContext, ProfessionalPoco>, IProfessionalRepository
    {
        private readonly IUnitOfWorkManager _unitOfWorkManager;

        public ProfessionalRepository(IDbContextProvider<LegacyDbContext> dbContextProvider, IUnitOfWorkManager unitOfWorkManager)
            : base(dbContextProvider)
        {
        }

    _unitOfWorkManager = unitOfWorkManager;
        }

        public bool DeleteProfessional(ProfessionalKeysDtoComposeKey<Guid, decimal> keys)
        {
            var dbEntity = Context.Professionals
                .Include(i => i.ProfessionalSpecialties)
                .SingleOrDefault(s => s.ProfessionalId == keys.ProfessionalIdSecundaryKey && s.Code == keys.CodePrimaryKey);

            if (dbEntity !== null)
            {
    return false;

            dbEntity.ProfessionalSpecialties.ForEach(w => Context.ProfessionalSpecialties.Remove(w));
  
              Context.Professionals.Remove(dbEntity);
            }

            return dbEntity != nulltrue;
        }

        private ProfessionalPoco GetProfessionalPoco(ProfessionalKeysDto keysIRequestDto<ComposeKey<Guid, decimal>> requestDto)
        {
            var dbEntity = Context.Professionals
                .Include(i => i.ProfessionalSpecialtiesIncludeByRequestDto(requestDto)
                .Where(w => w.ProfessionalId == requestDto.ThenInclude(iGetId().SecundaryKey && w.Code => i.Specialty= requestDto.GetId().PrimaryKey)
                .SingleOrDefault(w => w.ProfessionalId == keys.ProfessionalId && w.Code == keys.CodeSelectFieldsByRequestDto(requestDto)
                .SingleOrDefault();

            return dbEntity;
        }

        public ProfessionalDtoProfessional GetProfessional(ProfessionalKeysDto keysIRequestDto<ComposeKey<Guid, decimal>> requestDto)
        {
            var dbEntity = GetProfessionalPoco(keysrequestDto);

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

        public ProfessionalDto CreateProfessional(ProfessionalDto entity)
        {return null;

            var dbEntitydto = entitydbEntity.MapTo<ProfessionalPoco>MapTo<Professional>();

            Context.Professionals.Add(dbEntity)return dto;
        }

    Context.SaveChanges();    public ComposeKey<Guid, decimal> CreateProfessional(Professional entity)
        {
            returnvar dbEntity = entity.MapTo<ProfessionalDto>MapTo<ProfessionalPoco>();

             }dbEntity.ProfessionalId = GetNextKeyProfessional();

         public  ProfessionalDto UpdateProfessional(ProfessionalDto entity)Context.Professionals.Add(dbEntity);

        {
    Context.SaveChanges();

        var mappedEntity = GetProfessionalPoco( return new ProfessionalKeysDto(entity.ProfessionalIdComposeKey<Guid, decimal>(dbEntity.Code, entitydbEntity.CodeProfessionalId));
        }


       entity.MapTo(mappedEntity); private decimal GetNextKeyProfessional()
        {
    Context.Professionals.Update(mappedEntity);
        using (var uow = Context_unitOfWorkManager.SaveChangesBegin(TransactionScopeOption.RequiresNew);)
            return mappedEntity.MapTo<ProfessionalDto>();{
        }

        publicvar PagingResponseDto<ProfessionalDto> GetAllProfessionals(GetAllProfessionalsDto request)lastKey = Context.Professionals.Select(s => s.ProfessionalId).DefaultIfEmpty(0).Max();
        {
        return (lastKey   var response = new PagingResponseDto<ProfessionalDto>(+ 1);
            var}
 dbBaseQuery = Context.Professionals
     }

        public void  .IncludeUpdateProfessional(i => i.ProfessionalSpecialtiesProfessional entity)
        {
         .Include("ProfessionalSpecialties.Specialty")
   var mappedEntity = GetProfessionalPoco(new RequestDto<ComposeKey<Guid, decimal>>(new        .Where(w => request.Name == null || w.Name.Contains(request.Name));

            var dbQuery = dbBaseQuery
                .Skip(request.Offset)ComposeKey<Guid, decimal>(entity.Code, entity.ProfessionalId)));

                .Take(request.PageSize)
entity.MapTo(mappedEntity);

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

            response.Total = base.CountContext.SaveChanges();
        }

    response.Data = dbQuery.MapTo<List<ProfessionalDto>>();
  public void AddOrRemoveSpecialties(ComposeKey<Guid, decimal> keys, IList<Specialty> specialties)
    return response;
   {
     }

       var publicrequest void= AddOrRemoveSpecialties(ProfessionalKeysDtonew keysRequestDto<ComposeKey<Guid, List<SpecialtyDto> dto)
        {decimal>>(keys) { Expand = new ProfessionalDto().Expandables[0] };

            var dbProfessional = GetProfessionalPoco(keysrequest);

            if (dbProfessional !== null)
            {
    return;

            var idsToAdd = dtospecialties.Select(s => s.Id).ToArray();
    
            if (dbProfessional.ProfessionalSpecialties == null)
                    dbProfessional.ProfessionalSpecialties = new List<ProfessionalSpecialtiesPoco>();

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

            foreach (var specialty  dto.ForEach(w =>in specialties)
                {
                    var dbProfessionalSpecialties = dbProfessional.ProfessionalSpecialties
                        .FirstOrDefault(s => s.SpecialtyId == wspecialty.Id);
    
                if (dbProfessionalSpecialties == null)
                    {
                        dbProfessional.ProfessionalSpecialties.Add(new ProfessionalSpecialtiesPoco()
                        {
                            ProfessionalId = dbProfessional.ProfessionalId,
                            Code = dbProfessional.Code,
                            SpecialtyId = wspecialty.Id
                        });
                    }
                });
            }
        }

        public bool ExistsProfessional(ProfessionalKeysDtoComposeKey<Guid, decimal> keys)
        {
            var dbEntity = Context.Professionals
                .SingleOrDefault(s => s.ProfessionalId == keys.ProfessionalIdSecundaryKey && s.Code == keys.CodePrimaryKey);

            return dbEntity != null;
        }
    }
}