public Task <DataResult <DTOCustomerExchange> > EditCustomerExchangeAsync(DTOCustomerExchange customerDTO)
        {
            return(Task.Run(() => {
                var originalCustomerExchangeEntity = _mapper.Map <CustomerExchange>(customerDTO);

                var edittedCustomerExchange = customerExchangeRepository.Update(originalCustomerExchangeEntity);
                _unitOfWork.SaveChanges();

                return new DataResult <DTOCustomerExchange> {
                    Errors = new List <ErrorDescriber>(), Target = _mapper.Map <DTOCustomerExchange>(edittedCustomerExchange)
                };
            }));
        }
        public async Task <IHttpActionResult> CreateCustomerExchange([FromBody] DTOCustomerExchange customerExchangeDTO)
        {
            var result = await _customerExchangeService.CreateAsync(customerExchangeDTO);

            if (!result.HasErrors)
            {
                var successResult = SuccessResult(result.Target);
                return(Ok(successResult));
            }

            var errorResult = ErrorResult(result.Errors);

            return(Content(HttpStatusCode.InternalServerError, errorResult));
        }
        public Task <DataResult <DTOCustomerExchange> > CreateAsync(DTOCustomerExchange customerDTO)
        {
            return(Task.Run(() => {
                var createdCustomerExhangeDTO = new DTOCustomerExchange();
                var customerExchangeEntity = _mapper.Map <CustomerExchange>(createdCustomerExhangeDTO);

                if (!customerExchangeRepository.ExistByCondition(x => ((x.CustomerId == customerExchangeEntity.CustomerId && x.CarId == customerExchangeEntity.CarId) ||
                                                                       (x.CustomerId == customerExchangeEntity.CustomerId)) &&
                                                                 x.Transferred != null && !string.IsNullOrEmpty(x.TransfereeId) &&
                                                                 !string.IsNullOrEmpty(x.Transferee) && x.TransferDate.HasValue))
                {
                    var createdCustomerExhangeEntity = customerExchangeRepository.Insert(customerExchangeEntity);
                    _unitOfWork.SaveChanges();

                    createdCustomerExhangeDTO = _mapper.Map <DTOCustomerExchange>(createdCustomerExhangeEntity);
                }

                return new DataResult <DTOCustomerExchange> {
                    Errors = new List <ErrorDescriber>(), Target = createdCustomerExhangeDTO
                };
            }));
        }
        public Task <DataResult <DTOCustomerExchange> > GetCustomerWithOwnedCarAsync(string customerId)
        {
            return(Task.Run(() => {
                var customerExchangeDTO = new DTOCustomerExchange();

                Expression <Func <CustomerExchange, object> >[] includes =
                {
                    x => x.Car,
                    x => x.Customer,
                    x => x.Customer.Branch,
                    x => x.Customer.CustomerType
                };
                var customerExchange = customerExchangeRepository.GetFirstOrDefault(x => x.CustomerId == customerId && !string.IsNullOrEmpty(x.CarId), includes: includes);
                if (customerExchange != null)
                {
                    customerExchangeDTO = _mapper.Map <DTOCustomerExchange>(customerExchange);
                }

                return new DataResult <DTOCustomerExchange> {
                    Errors = new List <ErrorDescriber>(), Target = customerExchangeDTO
                };
            }));
        }