Histórico da Página

using Microsoft.EntityFrameworkCore;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Transactions;
using Tnf.App.AutoMapper;
using Tnf.App.Dto.Request;
using Tnf.App.EntityFrameworkCore;
using Tnf.App.EntityFrameworkCore.Repositories;
using Tnf.Architecture.Common.ValueObjects;
using Tnf.Architecture.Domain.Interfaces.Repositories;
using Tnf.Architecture.Domain.Registration;
using 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 : AppEfCoreRepositoryBase<LegacyDbContext, ProfessionalPoco>, IProfessionalRepository
    {
        private readonly IUnitOfWorkManager _unitOfWorkManager;

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

        public bool DeleteProfessional(ComposeKey<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.ProfessionalSpecialties)
                    .ThenInclude(i => i.Specialty   .IncludeByRequestDto(requestDto)
                .SingleOrDefaultWhere(w => w.ProfessionalId == keys.ProfessionalIdrequestDto.GetId().SecundaryKey && w.Code == keys.Code);

requestDto.GetId().PrimaryKey)
            return dbEntity;
        }

        public ProfessionalDto GetProfessional(ProfessionalKeysDto keys)
  .SelectFieldsByRequestDto(requestDto)
      {
            var dbEntity = GetProfessionalPoco(keys.SingleOrDefault();

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

        public ProfessionalDtoProfessional CreateProfessional(ProfessionalDto entityGetProfessional(IRequestDto<ComposeKey<Guid, decimal>> requestDto)
        {
            var dbEntity = entity.MapTo<ProfessionalPoco>GetProfessionalPoco(requestDto);

            Context.Professionals.Addif (dbEntity == null)
                return null;

            Context.SaveChangesvar dto = dbEntity.MapTo<Professional>();

            return dbEntity.MapTo<ProfessionalDto>()dto;
        }

        public ComposeKey<Guid, ProfessionalDtodecimal> UpdateProfessionalCreateProfessional(ProfessionalDtoProfessional entity)
        {
            var mappedEntitydbEntity = GetProfessionalPoco(new ProfessionalKeysDto(entity.ProfessionalId, entity.Code))MapTo<ProfessionalPoco>();

            entity.MapTo(mappedEntitydbEntity.ProfessionalId = GetNextKeyProfessional();

            Context.Professionals.UpdateAdd(mappedEntitydbEntity);

            Context.SaveChanges();

            return mappedEntity.MapTo<ProfessionalDto>( new ComposeKey<Guid, decimal>(dbEntity.Code, dbEntity.ProfessionalId);
        }


        publicprivate PagingResponseDto<ProfessionalDto>decimal GetAllProfessionalsGetNextKeyProfessional(GetAllProfessionalsDto request)
        {
            using (var responseuow = new PagingResponseDto<ProfessionalDto>();_unitOfWorkManager.Begin(TransactionScopeOption.RequiresNew))
            var{
 dbBaseQuery = Context.Professionals
             var lastKey = Context.IncludeProfessionals.Select(is => i.ProfessionalSpecialties)s.ProfessionalId).DefaultIfEmpty(0).Max();
                .Include("ProfessionalSpecialties.Specialty")return (lastKey + 1);
            }
        }

     .Where(w => request.Name ==public null || w.Name.Contains(request.Name));

void UpdateProfessional(Professional entity)
        {
    var dbQuery = dbBaseQuery
     var mappedEntity = GetProfessionalPoco(new RequestDto<ComposeKey<Guid, decimal>>(new ComposeKey<Guid,     .Skip(request.Offset)
   decimal>(entity.Code, entity.ProfessionalId)));

             entity.TakeMapTo(request.PageSizemappedEntity);

                .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;
        }
    }
}