Пример #1
0
        public async Task <IActionResult> Post(VendaDto vendaDto)
        {
            var venda          = _mapper.Map <Venda>(vendaDto);
            var vendaResultado = await _vendaService.AddAsync(venda);

            return(Ok(vendaResultado));
        }
        public Response ObterPorPeriodo(RequestVendaRangeData consultaVendaRangeData)
        {
            try
            {
                var listVendaDto = VendaDto.ListEmpty();

                if (consultaVendaRangeData.IsNotValid())
                {
                    return(Response.BuildBadRequest(ExceptionMessages.VendaRangeDatasInvalido));
                }

                var vendas = _vendaRepository.ObterComPaginacao(consultaVendaRangeData);

                if (!vendas.Any())
                {
                    return(Response.BuildBadRequest(ExceptionMessages.VendaNaoEncontrada));
                }

                foreach (var venda in vendas)
                {
                    listVendaDto.Add(_mapper.Map <VendaDto>(venda));
                }

                return(Response.BuildSuccess(listVendaDto));
            }
            catch (Exception ex)
            {
                return(Response.BuildInternalServerError(ex.Message));
            }
        }
        public Response ObterVendasPorCliente(int clienteId)
        {
            try
            {
                var listVendaDto = VendaDto.ListEmpty();
                var cliente      = _clienteRepository.ObterPorId(clienteId);

                if (cliente == null)
                {
                    return(Response.BuildBadRequest(ExceptionMessages.ClienteNaoEncontrado));
                }

                var vendas = _vendaRepository.ObterListaPorClienteId(clienteId);

                if (vendas == null)
                {
                    return(Response.BuildBadRequest(ExceptionMessages.ClienteSemVendas));
                }

                foreach (var venda in vendas)
                {
                    listVendaDto.Add(_mapper.Map <VendaDto>(venda));
                }

                return(Response.BuildSuccess(listVendaDto));
            }
            catch (Exception ex)
            {
                return(Response.BuildInternalServerError(ex.Message));
            }
        }
Пример #4
0
        public Venda Create(VendaDto vendaDto)
        {
            var veiculo = veiculoRepository.GetById(vendaDto.IdVeiculo);

            if (veiculo.TipoOperacao.Equals("Venda") && veiculo.Disponivel)
            {
                var result  = repository.Create(vendaDto);
                var imposto = 0.0;
                if (result.Valor > 300000.00)
                {
                    imposto = impostoRepository.Get("ImpostoAltoValor").Valor;
                }
                else
                {
                    imposto = impostoRepository.Get("ImpostoBaixoValor").Valor;
                }

                result.AddValor(imposto);
                veiculo.ChangeDisponibilidade();
                veiculoRepository.UpdateVeiculo(veiculo);
                return(result);
            }
            else
            {
                throw new InvalidOperationException();
            }
        }
Пример #5
0
        public async Task <VendaDto> Salvar(VendaDto vendaDto)
        {
            if (!Util.ValidarNumeroCartao(vendaDto.Cartao.Numero))
            {
                throw new Exception();
            }

            var produto = await _repositoryProduto.BuscarSingle(vendaDto.ProdutoId);

            if (!ValidarEstoque(produto, vendaDto.QtdeComprada))
            {
                throw new Exception();
            }

            var valorCompra = vendaDto.QtdeComprada * produto.ValorUnitario;

            await AutorizarPagamento(vendaDto.Cartao, valorCompra);

            var venda = new Venda
            {
                DataVenda    = DateTime.Now,
                IdProduto    = vendaDto.ProdutoId,
                QtdeComprada = vendaDto.QtdeComprada,
                ValorVenda   = produto.ValorUnitario,
            };

            await _repository.Salvar(venda);

            BaixarEstoque(produto, vendaDto.QtdeComprada);

            vendaDto.Id = venda.Id;

            return(vendaDto);
        }
Пример #6
0
        public Venda Create(VendaDto vendaDto)
        {
            var novaVenda = new Venda(vendaDto.IdVeiculo, vendaDto.Valor, vendaDto.NomeComprador);
            var result    = Insert(novaVenda);

            return(result);
        }
Пример #7
0
        public void CreateWithVeiculoWithValueLesserThan3000ShouldReturnVendaWhenTipoOperacaoIsVenda()
        {
            // Arrange
            var vendaDto = new VendaDto
            {
                IdVeiculo     = 1,
                Valor         = 100000.00,
                NomeComprador = "Comprador"
            };

            var imposto = new Imposto
            {
                Id        = 1,
                Descricao = "Imposto teste",
                Nome      = "NomeImposto",
                Valor     = 1250.00
            };

            var veiculo = new Veiculo("IKG6861", "Verde", 100.00, true, true, "Hyundai", "HB20", TipoVeiculo.Carro, "Venda");

            var venda = new Venda(1, 300000.00, "Comprador");

            vendaRepository.Create(vendaDto).Returns(venda);
            impostoRepository.Get(Arg.Any <string>()).Returns(imposto);
            veiculoRepository.GetById(venda.IdVeiculo).Returns(veiculo);
            veiculoRepository.UpdateVeiculo(veiculo).Returns(veiculo);

            // Act
            var result = service.Create(vendaDto);

            // Assert
            result.Should().NotBeNull();
            result.Should().Equals(venda);
            vendaRepository.Received().Create(vendaDto);
        }
Пример #8
0
        public async Task <IActionResult> GetAll([FromQuery] VendaRequestAllDto requestDto)
        {
            var lista = new ListDto <VendaDto>();

            try
            {
                var response = await _appService.GetAllVendaAsync(requestDto);
            }
            catch (Exception ex)
            {
                var v = new VendaDto()
                {
                    Id      = new Guid("0D4090B2-5687-4938-ABDF-A8DA016EE645"),
                    Product = new Dto.Product.ProductDto()
                    {
                        Id = new Guid("0D4090B2-5687-4938-ABDF-A8DA016EE645"), Description = ex.ToString()
                    },
                    ProductId  = new Guid("0D4090B2-5687-4938-ABDF-A8DA016EE645"),
                    Quantidade = 5
                };

                lista.Items.Add(v);
            }
            return(CreateResponseOnGetAll(lista, _name));
        }
Пример #9
0
        //Método para listar todos as vendas por um intervalo de datas
        public List <VendaDto> ListarVendas(DateTime DataInicio, DateTime DataTermino)
        {
            try
            {
                //LINQ -> Language Integrated Query
                //linguagem de consultas nativa do C# aplicada a SQL
                var query = from v in Con.Venda
                            join l in Con.Loja
                            on v.IdLojaFK equals l.IdLoja
                            where v.DataVenda >= DataInicio &&
                            v.DataVenda <= DataTermino
                            select v;

                List <VendaDto> lista = new List <VendaDto>(); //lista vazia

                foreach (var registro in query.ToList())       //varrendo a query
                {
                    VendaDto dto = new VendaDto()
                    {
                        Codigo = registro.IdVenda,
                        Data   = registro.DataVenda,
                        Valor  = registro.Valor,
                        Loja   = registro.Loja.Nome
                    };

                    lista.Add(dto); //adiciono na lista
                }

                return(lista); //retornar a lista
            }
            catch (Exception e)
            {
                throw new Exception("Erro ao consultar: " + e.Message);
            }
        }
Пример #10
0
        public async Task <ActionResult> Salvar(VendaDto venda)
        {
            try
            {
                var Venda = await _vendaService.Salvar(venda);

                return(Ok("Venda Realizada Com Sucesso"));
            }
            catch
            {
                return(BadRequest("Ocorreu um erro desconhecido."));
            }
        }
Пример #11
0
        public IVendaDto Salvar(VendaDto vendaDto)
        {
            if (vendaDto == null)
            {
                return(new VendaDto());
            }
            var venda = CriarParaSalvar(vendaDto);

            Context.Vendas.Add(venda);
            Context.SaveChanges();

            return(vendaDto);
        }
Пример #12
0
        public IVendaDto Excluir(VendaDto vendaDto)
        {
            if (vendaDto == null)
            {
                return(new VendaDto());
            }

            var venda = CriarParaExcluir(vendaDto);

            Context.Entry(venda).State = EntityState.Modified;
            Context.SaveChanges();

            return(vendaDto);
        }
Пример #13
0
        public VendaDomain CriarParaSalvar(VendaDto vendaDto)
        {
            var venda = new VendaBuilder()
                        .WithId(Guid.NewGuid())
                        .WithCliente(vendaDto.Cliente)
                        .WithClienteId(vendaDto.ClienteId)
                        .WithFormaDePagamento(vendaDto.FormaDePagamento)
                        .WithFormaDePagamentoId(vendaDto.FormaDePagamentoId)
                        .WithUsuario(vendaDto.Usuario)
                        .WithUsuarioId(vendaDto.UsuarioId)
                        .WithValorTotal(vendaDto.ValorTotal)
                        .Build();

            return(venda);
        }
Пример #14
0
        public async Task <VendaDto> CreateVendaAsync(VendaDto dto)
        {
            if (!ValidateDto <VendaDto>(dto))
            {
                return(null);
            }

            var builder = Venda.Create(Notification)
                          .WithId(dto.Id)
                          .WithProductId(dto.ProductId)
                          .WithQuantidade(dto.Quantidade);

            var venda = await _service.InsertAndSaveChangesAsync(builder);

            return(venda.MapTo <VendaDto>());
        }
Пример #15
0
        public async Task <VendaDto> UpdateVendaAsync(Guid id, VendaDto dto)
        {
            if (!ValidateDtoAndId(dto, id))
            {
                return(null);
            }

            var builder = Venda.Create(Notification)
                          .WithId(id)
                          .WithProductId(dto.ProductId)
                          .WithQuantidade(dto.Quantidade);

            await _service.UpdateAsync(builder);

            dto.Id = id;
            return(dto);
        }
Пример #16
0
        public void CreateShouldReturnVenda()
        {
            // Arrange
            var vendaDto = new VendaDto
            {
                IdVeiculo     = 1,
                Valor         = 300000.00,
                NomeComprador = "Comprador"
            };

            var venda = new Venda(1, 300000.00, "Comprador");

            // Act
            var result = repository.Create(vendaDto);

            // Assert
            result.Should().NotBeNull();
            result.Should().Equals(venda);
        }
Пример #17
0
        public ActionResult Create(VendaDto dto)
        {
            if (dto.IdCliente != 0)
            {
                //_wcf.New(servico);
                return(RedirectToAction("", "Servico"));
            }

            var comboboxCliente   = _wcf.FindAllComboboxCliente();
            var comboboxPrestador = _wcf.FindAllComboboxPrestador();
            var produtos          = _wcf.FindAllProdutos();
            var servicos          = _wcf.FindAllServicos();

            ViewBag.Produtos            = new List <Produto>(produtos);
            ViewBag.Servicos            = new List <Servico>(servicos);
            ViewBag.ComboboxClientes    = new SelectList(comboboxCliente, "Id", "Valor");
            ViewBag.ComboboxPrestadores = new SelectList(comboboxPrestador, "Id", "Valor");

            return(View(dto));
        }
Пример #18
0
        public VendaDomain CriarParaAlterar(VendaDto vendaDto)
        {
            var _venda = Context.Vendas.FirstOrDefault(x => x.Id == vendaDto.Id);

            if (_venda == null)
            {
                throw new ArgumentNullException(nameof(_venda));
            }

            var venda = new VendaBuilder()
                        .WithId(_venda.Id)
                        .WithCliente(_venda.Cliente)
                        .WithClienteId(_venda.ClienteId)
                        .WithFormaDePagamento(_venda.FormaDePagamento)
                        .WithFormaDePagamentoId(_venda.FormaDePagamentoId)
                        .WithUsuario(_venda.Usuario)
                        .WithUsuarioId(_venda.UsuarioId)
                        .WithValorTotal(_venda.ValorTotal)
                        .Build();

            return(venda);
        }
Пример #19
0
        public void CreateShouldThowExceptionWhenTipoOperacaoIsAluguel()
        {
            // Arrange
            var veiculo = new Veiculo("IKG6861", "Verde", 100.00, true, true, "Hyundai", "HB20", TipoVeiculo.Carro, "Aluguel");

            var vendaDto = new VendaDto
            {
                IdVeiculo     = 1,
                Valor         = 300000.00,
                NomeComprador = "Comprador"
            };

            var venda = new Venda(1, 300000.00, "Comprador");

            veiculoRepository.GetById(venda.IdVeiculo).Returns(veiculo);

            // Act
            Action act = () => service.Create(vendaDto);

            // Assert
            act.Should().Throw <InvalidOperationException>();
            veiculoRepository.Received().GetById(venda.IdVeiculo);
        }
Пример #20
0
        public async Task <IActionResult> Post([FromBody] VendaDto VendaDto)
        {
            VendaDto = await _appService.CreateVendaAsync(VendaDto);

            return(CreateResponseOnPost(VendaDto, _name));
        }
Пример #21
0
        public IActionResult Create([FromBody] VendaDto vendaDto)
        {
            var result = service.Create(vendaDto);

            return(Ok(result));
        }
Пример #22
0
        public async Task <IActionResult> Put(Guid id, [FromBody] VendaDto VendaDto)
        {
            VendaDto = await _appService.UpdateVendaAsync(id, VendaDto);

            return(CreateResponseOnPut(VendaDto, _name));
        }