public ClientDto[] FetchAllClients()
        {
            IRepository<Client> clientRepository = unitOfWork.GetRepository<Client>();
            var mapper = new ClientDtoMapper();

            return clientRepository.Select(mapper.Expression).ToArray();
        }
Beispiel #2
0
        public async Task <ClientDto> GettById(int id)
        {
            var client = await dbContext.Clients
                         .Include(x => x.Address)
                         .Include(x => x.Rate)
                         .Where(x => x.Id == id)
                         .FirstAsync();

            return(ClientDtoMapper.Map(client));
        }
Beispiel #3
0
        public async Task <ClientDto> Create(ClientDto dto)
        {
            var client = ClientMapper.Map(dto);

            await this.dbContext.Clients.AddAsync(client);

            await this.dbContext.SaveChangesAsync();

            return(ClientDtoMapper.Map(client));
        }
Beispiel #4
0
        public async Task <ClientDto> Update(ClientDto dto)
        {
            var client = await dbContext.Clients
                         .Include(x => x.Address)
                         .Include(x => x.Rate)
                         .Where(x => x.Id == dto.Id)
                         .FirstAsync();

            ClientMapper.MapUpdate(client, dto);
            await dbContext.SaveChangesAsync();

            return(ClientDtoMapper.Map(client));
        }
 public ClientDto[] GetByIds(Guid[] ids)
 {
     try
     {
         using (var transactionScope = new TransactionScope())
         {
             var clientDtos = new ClientDtoMapper().Map(_clientRepository.GetByIds(ids.ToArray()).ToArray());
             transactionScope.Complete();
             return(clientDtos);
         }
     }
     finally
     {
         _sessionProvider.CloseCurrent();
     }
 }
 public ClientDto GetById(Guid id)
 {
     try
     {
         using (var transactionScope = new TransactionScope())
         {
             var clientDto = new ClientDtoMapper().Map(_clientRepository.GetById(id));
             transactionScope.Complete();
             return(clientDto);
         }
     }
     finally
     {
         _sessionProvider.CloseCurrent();
     }
 }
Beispiel #7
0
        private async Task HandleShowDto(
            ShowDto showDto,
            bool reset,
            CancellationToken cancellationToken,
            Action <Show> showAddedAction)
        {
            var addShow = reset || await _dbContext.Show.AllAsync(x => x.Id != showDto.Id, cancellationToken);

            if (!addShow)
            {
                return;
            }
            var castDtos = await _client.ListCast(showDto.Id, cancellationToken);

            var show      = ClientDtoMapper.MapToShow(showDto, castDtos);
            var showDbDto = DbDtoMapper.MapToShowDto(show);

            _dbContext.Show.Add(showDbDto);
            await _dbContext.SaveChangesAsync(cancellationToken);

            _dbContext.Entry(showDbDto).State = EntityState.Detached;
            showAddedAction?.Invoke(show);
        }