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.AutoMapper;
Architecture.EntityFrameworkCore.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
    {
 private readonly IUnitOfWorkManager  _unitOfWorkManager;   public ProfessionalRepository(IDbContextProvider<LegacyDbContext> dbContextProvider)
, IUnitOfWorkManager           unitOfWorkManager) : base(dbContextProvider)
 { _unitOfWorkManager = unitOfWorkManager; } public  {
        }

        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(RequestDto<ProfessionalKeysDto> requestDto)
        {
            var dbEntity = Context.Professionals
                .IncludeByRequestDto(requestDto)
                .Where(w => w.ProfessionalId == requestDto.GetId().ProfessionalId && w.Code == requestDto.GetId().Code)
                .SelectFieldsByRequestDto(requestDto)
                .SingleOrDefault();

            return dbEntity;
        }

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

            dto.RemoveExpandable(requestDto);

            return dto;
        }

        public ProfessionalKeysDto CreateProfessional(Professional entity)
        {
            var dbEntity = entity.MapTo<ProfessionalPoco>();

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

            return new ProfessionalKeysDto(dbEntity.ProfessionalId, dbEntity.Code);
        }

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

            entity.MapTo(mappedEntity);

            Context.Professionals.Update(mappedEntity);
            Context.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));

            var dbQuery = dbBaseQuery
                .SkipAndTakeByRequestDto(request)
                .OrderByRequestDto(request)
                .ToArray();

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

            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;
        }
    }
}
bool DeleteProfessional(ComposeKey<Guid, decimal> keys) { var dbEntity = Context.Professionals .Include(i => i.ProfessionalSpecialties) .SingleOrDefault(s => s.ProfessionalId == keys.SecundaryKey && s.Code == keys.PrimaryKey); if (dbEntity == null) return false; dbEntity.ProfessionalSpecialties.ForEach(w => Context.ProfessionalSpecialties.Remove(w)); Context.Professionals.Remove(dbEntity); return true; } private ProfessionalPoco GetProfessionalPoco(IRequestDto<ComposeKey<Guid, decimal>> requestDto) { var dbEntity = Context.Professionals .IncludeByRequestDto(requestDto) .Where(w => w.ProfessionalId == requestDto.GetId().SecundaryKey && w.Code == requestDto.GetId().PrimaryKey) .SelectFieldsByRequestDto(requestDto) .SingleOrDefault(); return dbEntity; } public Professional GetProfessional(IRequestDto<ComposeKey<Guid, decimal>> requestDto) { var dbEntity = GetProfessionalPoco(requestDto); if (dbEntity == null) return null; var dto = dbEntity.MapTo<Professional>(); return dto; } public ComposeKey<Guid, decimal> CreateProfessional(Professional entity) { var dbEntity = entity.MapTo<ProfessionalPoco>(); dbEntity.ProfessionalId = GetNextKeyProfessional(); Context.Professionals.Add(dbEntity); Context.SaveChanges(); return new ComposeKey<Guid, decimal>(dbEntity.Code, dbEntity.ProfessionalId); } private decimal GetNextKeyProfessional() { using (var uow = _unitOfWorkManager.Begin(TransactionScopeOption.RequiresNew)) { var lastKey = Context.Professionals.Select(s => s.ProfessionalId).DefaultIfEmpty(0).Max(); return (lastKey + 1); } } public void UpdateProfessional(Professional entity) { var mappedEntity = GetProfessionalPoco(new RequestDto<ComposeKey<Guid, decimal>>(new ComposeKey<Guid, decimal>(entity.Code, entity.ProfessionalId))); entity.MapTo(mappedEntity); Context.Professionals.Update(mappedEntity); Context.SaveChanges(); } public void AddOrRemoveSpecialties(ComposeKey<Guid, decimal> keys, IList<Specialty> specialties) { var request = new RequestDto<ComposeKey<Guid, decimal>>(keys) { Expand = new ProfessionalDto().Expandables[0] }; var dbProfessional = GetProfessionalPoco(request); if (dbProfessional == null) return; var idsToAdd = specialties.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 in specialties) { var dbProfessionalSpecialties = dbProfessional.ProfessionalSpecialties .FirstOrDefault(s => s.SpecialtyId == specialty.Id); if (dbProfessionalSpecialties == null) { dbProfessional.ProfessionalSpecialties.Add(new ProfessionalSpecialtiesPoco { ProfessionalId = dbProfessional.ProfessionalId, Code = dbProfessional.Code, SpecialtyId = specialty.Id }); } } } public bool ExistsProfessional(ComposeKey<Guid, decimal> keys) { var dbEntity = Context.Professionals .SingleOrDefault(s => s.ProfessionalId == keys.SecundaryKey && s.Code == keys.PrimaryKey); return dbEntity != null; } } }