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.Dto.Response.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.EntitiesContexts;
using Tnf.Architecture.AutoMapperEntityFrameworkCore.Entities;
using Tnf.Domain.RepositoriesUow;
using Tnf.EntityFrameworkCore;
using Tnf.EntityFrameworkCore.Repositories;

namespace Tnf.Architecture.EntityFrameworkCore.Repositories
{
    public class ProfessionalRepository : EfCoreRepositoryBase<LegacyDbContextAppEfCoreRepositoryBase<LegacyDbContext, ProfessionalPoco>, IProfessionalRepository
    {
        publicprivate ProfessionalRepository(IDbContextProvider<LegacyDbContext> dbContextProvider)
 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 true;
            return dbEntity != null;
        }}

        private ProfessionalPoco GetProfessionalPoco(RequestDto<ProfessionalKeysDto>IRequestDto<ComposeKey<Guid, decimal>> requestDto)
        {
            var dbEntity = Context.Professionals
                .IncludeByRequestDto(requestDto)
                .Where(w => w.ProfessionalId == requestDto.GetId().ProfessionalIdSecundaryKey && w.Code == requestDto.GetId().CodePrimaryKey)
                .SelectFieldsByRequestDto(requestDto)
                .SingleOrDefault();

            return dbEntity;
        }

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

            varif dto(dbEntity = dbEntity != null)
 ?  dbEntity.MapTo<ProfessionalDto>() : null;

            dto.RemoveExpandable(requestDto)return null;

            returnvar dto;
   = dbEntity.MapTo<Professional>();

            return dto;
        }

        public ProfessionalKeysDtoComposeKey<Guid, decimal> CreateProfessional(Professional entity)
        {
            var dbEntity = entity.MapTo<ProfessionalPoco>();

            dbEntity.ProfessionalId = GetNextKeyProfessional();

            Context.Professionals.Add(dbEntity);

            Context.SaveChanges();

            return new ProfessionalKeysDtoComposeKey<Guid, decimal>(dbEntity.ProfessionalIdCode, dbEntity.CodeProfessionalId);
        }


        publicprivate Professionaldecimal UpdateProfessionalGetNextKeyProfessional(Professional entity)
        {
            using (var mappedEntityuow = GetProfessionalPoco(new RequestDto<ProfessionalKeysDto>(new ProfessionalKeysDto(entity.ProfessionalId, entity.Code)));
_unitOfWorkManager.Begin(TransactionScopeOption.RequiresNew))
            entity.MapTo(mappedEntity);
{
            Context.Professionals.Update(mappedEntity);
    var lastKey    =   Context.Professionals.SaveChanges();

            return entity;
        }

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

            var dbBaseQuery = Context.Professionals
                .Include(i => i.ProfessionalSpecialties)
                    .ThenInclude(i => i.Specialty)
                .Where(w => request.Name == null || w.Name.Contains(request.Name));
Select(s => s.ProfessionalId).DefaultIfEmpty(0).Max();
            var dbQuery = dbBaseQuery
 return (lastKey + 1);
            .SkipAndTakeByRequestDto(request)}
        }

        public void .OrderByRequestDto(requestUpdateProfessional(Professional entity)
        {
        .ToArray();

    var mappedEntity = GetProfessionalPoco(new RequestDto<ComposeKey<Guid, decimal>>(new   response.Total = base.Count();ComposeKey<Guid, decimal>(entity.Code, entity.ProfessionalId)));

            response.Items = dbQuery.MapTo<List<ProfessionalDto>>(entity.MapTo(mappedEntity);

            response.HasNext = response.Total > ((request.Page - 1) * request.PageSize) + response.Items.Count()Context.Professionals.Update(mappedEntity);

            return responseContext.SaveChanges();
        }

        public void AddOrRemoveSpecialties(ProfessionalKeysDto AddOrRemoveSpecialties(ComposeKey<Guid, decimal> keys, List<SpecialtyDto>IList<Specialty> dtospecialties)
        {
            var request = new RequestDto<ComposeKey<Guid, RequestDto<ProfessionalKeysDto>decimal>>(keys);
            request. { Expand = new ProfessionalDto()._expandablesExpandables[0] };

            var dbProfessional = GetProfessionalPoco(request);

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