Ejemplo n.º 1
0
 public Compra(IWebDriver driver)
 {
     this.driver       = driver;
     compra            = new CompraModel();
     compra.Quantidade = 1;
     driverWait        = new WebDriverWait(this.driver, System.TimeSpan.FromSeconds(20));
 }
Ejemplo n.º 2
0
 public CompraModificarViewModel(CompraModel _Model)
 {
     Compra       = _Model;
     Comentario   = Compra.Comentario;
     Sincronizado = Compra.Sincronizado;
     IsEnabled    = true;
 }
Ejemplo n.º 3
0
        public ActionResult FinalizaCompra()
        {
            CompraModel cm = new CompraModel();

            cm.ListagemProdutosCompra = (List <ProdutoDto>)Session["Lista"];

            Compra c = new Compra();

            c.Preco    = cm.Acumulador();
            c.DataHora = DateTime.Now;

            CompraDados cd = new CompraDados();

            cd.Inserir(c);

            ProdCompra      pc      = new ProdCompra();
            ProdCompraDados pcDados = new ProdCompraDados();

            foreach (ProdutoDto p in cm.ListagemProdutosCompra)
            {
                pc.Compra     = c;
                pc.Produto    = p.Produto;
                pc.Quantidade = p.Quantidade;
                pcDados.Inserir(pc);
            }

            return(RedirectToAction("ArmazenamentoCompra"));
        }
Ejemplo n.º 4
0
 public ActionResult <ComprasDTO> Post([FromBody] CompraModel comprasModel)
 {
     comprasModel.titulo    = comprasModel.titulo.Trim(' ');
     comprasModel.descricao = comprasModel.descricao.Trim(' ');
     if (!ValidaCompraCadastro(comprasModel))
     {
         var Compra = new ComprasEntity()
         {
             cod_categoria = comprasModel.cod_categoria,
             cod_status    = 1,
             cod_usuario   = comprasModel.cod_usuario,
             titulo        = comprasModel.titulo,
             descricao     = comprasModel.descricao,
             data_abertura = DateTime.Now
         };
         var NewCompra = _comprasRepository.Add(Compra);
         comprasModel.Cod_compra = NewCompra.cod_compra;
         for (int i = 0; i < comprasModel.orcamentodtos.Count; i++)
         {
             comprasModel.orcamentodtos.ToArray()[i].cod_compra = NewCompra.cod_compra;
             var orcamento    = comprasModel.orcamentodtos[i];
             var NewOrcamento = _orcamentoRepository.Add(orcamento);
             comprasModel.orcamentodtos[i].cod_orcamento = NewOrcamento.cod_orcamento;
         }
         return(new OkObjectResult(comprasModel));
     }
     else
     {
         return(new BadRequestObjectResult("Erro no cadastro, campos inválidos."));
     }
 }
Ejemplo n.º 5
0
        public async Task <ActionResult <CompraModel> > PostCompraModel(CompraModel compraModel)
        {
            _context.CompraModel.Add(compraModel);
            await _context.SaveChangesAsync();

            return(CreatedAtAction("GetCompraModel", new { id = compraModel.IdCompra }, compraModel));
        }
Ejemplo n.º 6
0
        public void SolicitaReservaPacote()
        {
            try
            {
                var carrinhoBO_ = new CarrinhoBO();
                var compra      = new CompraModel {
                    SessionID = "mm21sadasdlasdjkahskjdAA"
                };

                var pacotesQuantidade = new List <PacoteReservaModel>
                {
                    new PacoteReservaModel {
                        PacoteID = 8979, Quantidade = 1
                    }
                };

                var retorno = carrinhoBO_.SolicitarReservaPacote(compra, pacotesQuantidade);
                Console.WriteLine(retorno.Mensagem);
                Console.WriteLine(retorno.Retorno);
                Console.WriteLine(retorno.Sucesso);
                Assert.AreNotEqual(null, retorno);
            }
            catch (Exception ex)
            {
                Assert.Fail(ex.Message);
            }
        }
Ejemplo n.º 7
0
        public void SolicitaReservaMesaFechada()
        {
            try
            {
                CarrinhoBO  CarrinhoBO = new CarrinhoBO();
                CompraModel compra     = new CompraModel();
                compra.SessionID = "1sadasdlasdjkahskjdAA";

                //Logado Maicon
                ClienteBO ClienteBO = new ClienteBO(1);
                //compra.Login = ClienteBO.ConsultarCPF("01259436012");

                RetornoModel <CompraModel> result = CarrinhoBO.SolicitarReservaMesaFechada(compra, 163464, 2199235, 1637525);

                Console.WriteLine(result.Mensagem);
                Console.WriteLine(result.Retorno);
                Console.WriteLine(result.Sucesso);

                Assert.AreNotEqual(null, result);
            }
            catch (Exception ex)
            {
                Assert.Fail(ex.Message);
            }
        }
Ejemplo n.º 8
0
        private bool ValidaCompraCadastro(CompraModel compra)
        {
            int cont = 0;
            var categoriaExistente = _categoriaRepository.GetNoTracking(compra.cod_categoria);
            var usuarioExistente   = _usuarioRepository.GetNoTracking(compra.cod_usuario);

            if (_baseValida.ValidaCampoNull(compra.descricao, compra.titulo) || categoriaExistente == null || usuarioExistente == null)
            {
                cont++;
            }



            for (int i = 0; i < compra.orcamentodtos.Count; i++)
            {
                if (_baseValida.ValidaCampoNull(compra.orcamentodtos[i].link, compra.orcamentodtos[i].nome)
                    | _baseValida.ValidaLink(compra.orcamentodtos[i].link))
                {
                    cont++;
                }
            }
            if (cont > 0)
            {
                return(true);
            }
            return(false);
        }
Ejemplo n.º 9
0
        public ActionResult Post([FromBody] CompraDto compraDto)
        {
            if (compraDto == null)
            {
                return(BadRequest());
            }

            if (!ModelState.IsValid)
            {
                return(UnprocessableEntity(ModelState));
            }

            var revendedora = _revendedoraService.Obter(compraDto.CpfRevendedor);

            if (revendedora == null)
            {
                return(NotFound("Revendedor(a) não encontrado(a)!"));
            }

            var compra = new CompraModel
            {
                CodigoCompra  = compraDto.CodigoCompra,
                CpfRevendedor = compraDto.CpfRevendedor,
                DataCompra    = compraDto.DataCompra,
                Valor         = compraDto.Valor,
                RevendedoraId = revendedora.Id
            };

            _compraService.Criar(compra);

            var created = Created($"/api/compra/{compra.Id}", compra);

            return(created);
        }
Ejemplo n.º 10
0
        public Task <HttpResponseMessage> CriarCompra(CompraModel model)
        {
            HttpResponseMessage response;

            try
            {
                var compra  = Mapper.Map <Compra>(model);
                var usuario = new Usuario
                {
                    UsuarioCodigo = ObterCodigoUsuarioLogado()
                };
                compra.Usuario = usuario;
                _compraService.CriarCompra(compra);
                response = ReturnSuccess();
            }
            catch (Exception ex)
            {
                response = ReturnError(ex);
            }

            var tsc = new TaskCompletionSource <HttpResponseMessage>();

            tsc.SetResult(response);
            return(tsc.Task);
        }
Ejemplo n.º 11
0
        public bool Guardar(CompraModel model, List <CompraDetalleModel> ListaDetalle)
        {
            if (model.PKSQLite == 0)
            {
                Settings.IdCompra  = Settings.IdCompra == "0.0" ? "0" : Settings.IdCompra;
                model.IdCompra     = Convert.ToDecimal(Settings.IdCompra);
                model.Codigo       = string.IsNullOrEmpty(Settings.IdCompra) ? "0" : Convert.ToDecimal(Settings.IdCompra).ToString("000000000");
                Settings.IdCompra  = (Convert.ToDecimal(string.IsNullOrEmpty(Settings.IdCompra) ? "0" : Settings.IdCompra) + 1).ToString("n0");
                model.PKSQLite     = GetId();
                model.Dispositivo  = CrossDeviceInfo.Current.Id;
                model.Fecha        = DateTime.Now.Date;
                model.Sincronizado = false;
                this.connection.Insert(model);

                foreach (var item in ListaDetalle)
                {
                    item.IdCompra = model.IdCompra;
                    item.PKSQLite = GetSecuencia();
                    this.connection.Insert(item);
                }
            }
            else
            {
                var Entity = this.connection.Table <CompraModel>().ToList().Where(q => q.PKSQLite == model.PKSQLite).FirstOrDefault();
                if (Entity != null)
                {
                    Entity.Comentario   = model.Comentario;
                    Entity.Sincronizado = model.Sincronizado;
                    this.connection.Update(Entity);
                }
            }
            return(true);
        }
Ejemplo n.º 12
0
        public void CotaBO_ValidarCotas()
        {
            CarrinhoBO  carrinhoBO = new CarrinhoBO();
            CompraModel compra     = new CompraModel();

            compra.Login         = new Login();
            compra.CarrinhoItens = carrinhoBO.Listar("02kfpvahztwniota0ugz2nnv", IRCore.DataAccess.Model.Enumerator.enumCarrinhoStatus.reservado);
            compra                 = carrinhoBO.CalcularValores(compra);
            compra.SessionID       = "02kfpvahztwniota0ugz2nnv";
            compra.Login.ClienteID = 3465690;
            compra                 = cotaBO.CarregarCotaInformacao(compra);
            tDonoIngresso dono = new DonoIngressoBO().Consultar(2);

            foreach (var item in compra.CarrinhoItens)
            {
                item.CotaItemObject.DonoIngresso                          = new tDonoIngresso();
                item.CotaItemObject.DonoIngresso.ID                       = dono.ID;
                item.CotaItemObject.DonoIngresso.ClienteID                = dono.ClienteID;
                item.CotaItemObject.DonoIngresso.Nome                     = dono.Nome;
                item.CotaItemObject.DonoIngresso.CPF                      = dono.CPF;
                item.CotaItemObject.DonoIngresso.NomeResponsavel          = dono.NomeResponsavel;
                item.CotaItemObject.DonoIngresso.CPFResponsavel           = dono.CPFResponsavel;
                item.CotaItemObject.DonoIngresso.Telefone                 = dono.Telefone;
                item.CotaItemObject.DonoIngresso.RG                       = dono.RG;
                item.CotaItemObject.DonoIngresso.DataNascimentoAsDateTime = new DateTime(1990, 01, 01);
                item.CotaItemObject.DonoIngresso.Email                    = dono.Email;
            }
            compra = cotaBO.ValidarCotas(compra).Retorno;
            Assert.AreEqual(true, compra.CarrinhoItens[0].CotaItemObject.NominalAsBool || compra.CarrinhoItens[0].CotaItemObject.ValidaBinAsBool);
        }
Ejemplo n.º 13
0
        public ActionResult Create(CompraModel compraModel)
        {
            if (!ModelState.IsValid)
            {
                CarregarCombos();
                return(View(compraModel));
            }

            try
            {
                var compra = Mapper.Map <Compra>(compraModel);
                _compraApplicationService.Salvar(compra);
            }
            catch (Exception ex)
            {
                CarregarCombos();
                ModelState.AddModelError("Erro", ex.Message);
                return(View(compraModel));

                //Caso fosse ajax, o método poderia ser void e exibir o erro assim:
                //Response.StatusCode = (int)HttpStatusCode.BadRequest;
                //Response.Write(ex.Message);
            }

            return(RedirectToAction("Index"));
        }
Ejemplo n.º 14
0
        public async Task <IActionResult> PutCompraModel(int id, CompraModel compraModel)
        {
            if (id != compraModel.IdCompra)
            {
                return(BadRequest());
            }

            _context.Entry(compraModel).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!CompraModelExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(NoContent());
        }
Ejemplo n.º 15
0
 public CompraViewModel()
 {
     IsEnabled = true;
     Compra = new CompraModel();
     Height = 0;
     Cantidad = 0;
     Fecha = DateTime.Now.Date;
 }
Ejemplo n.º 16
0
 public IHttpActionResult CrearCompra(CompraModel compraModel)
 {
     if (compraModel == null || compraModel.Compra == null)
     {
         return(Json(Mensaje <Compra> .MensajeJson(Constants.IS_ERROR, "Objecto no puede estar vacio", Constants.COMPRA_FAIL)));
     }
     return(Json(compraModel.Comprar(compraModel.Compra)));
 }
Ejemplo n.º 17
0
        public ActionResult ConsultaCompra()
        {
            CompraModel cm = new CompraModel();

            cm.ListagemProdutosCompra = (List <ProdutoDto>)Session["Lista"];

            return(View(cm));
        }
Ejemplo n.º 18
0
        public void EntregaBO_ListarEntregasComMensageiroAgendadoESedex()
        {
            ClienteBO   clienteBO = new ClienteBO(1);
            CompraModel compra    = new CompraModel();

            compra.Login         = clienteBO.Consultar(1);
            compra.CarrinhoItens = carrinhoBO.Listar("ev004", enumCarrinhoStatus.reservado);
            compra = entregaBO.Carregar(compra);
            Assert.AreEqual(true, compra.Login.Cliente.EnderecoList.Count == 3 && compra.EntregaControles.Count > 0);
        }
Ejemplo n.º 19
0
        public void EntregaBO_ListarEntregasEventosEntregasDiferentes()
        {
            ClienteBO   clienteBO = new ClienteBO(1);
            CompraModel compra    = new CompraModel();

            compra.Login         = clienteBO.Consultar(1);
            compra.CarrinhoItens = carrinhoBO.Listar("ev005", enumCarrinhoStatus.reservado);
            compra = entregaBO.Carregar(compra);
            Assert.AreEqual(true, compra.Login.Cliente.EnderecoList.Count == 0 && compra.EntregaControles.Count == 0);
        }
Ejemplo n.º 20
0
        /// <summary>
        /// Método que remove um vale ingresso de uma compra e retorna a compra com valor recalculado.
        /// </summary>
        /// <param name="compra"></param>
        /// <param name="valeIngresso"></param>
        /// <returns></returns>
        public CompraModel RemoverValeIngresso(CompraModel compra, tValeIngresso valeIngresso)
        {
            CarrinhoBO carrinhoBO = new CarrinhoBO(ado);

            if (compra.ValeIngressos != null && valeIngresso != null)
            {
                compra.ValeIngressos.RemoveAll(x => x.ID == valeIngresso.ID);
                compra = carrinhoBO.CalcularValores(compra);
            }
            return(compra);
        }
Ejemplo n.º 21
0
        public RetornoModel <CompraModel> ValidarCotasPorQuantidade(CompraModel compra, List <Carrinho> carrinhoItensValidar)
        {
            RetornoModel <CompraModel> retorno = new RetornoModel <CompraModel>();

            List <IngressoRapido.Lib.CotaItemValidar> cotaItemValidarList = new List <IngressoRapido.Lib.CotaItemValidar>();

            IngressoRapido.Lib.CarrinhoLista carrinhoItens = new IngressoRapido.Lib.CarrinhoLista().CarregarDadosPorClienteID(compra.ClienteID, compra.SessionID, IngressoRapido.Lib.CarrinhoLista.Status.Reservado, 0);

            foreach (var item in carrinhoItensValidar.Where(x => x.CotaItemObject != null && !(x.CotaVerificada ?? false)))
            {
                var CotaItemValidar = new IngressoRapido.Lib.CotaItemValidar()
                {
                    IngressoID    = item.IngressoID.Value,
                    Nominal       = item.CotaItemObject.NominalAsBool,
                    Quantidade    = item.CotaItemObject.QuantidadeAsBool,
                    TemParceiro   = item.CotaItemObject.Parceiro != null,
                    Codigo        = item.CotaItemObject.CodigoPromocional,
                    ClienteExiste = item.ClienteID > 0,
                    Mensagem      = item.CotaItemObject.Mensagem,
                    Dono          = new EstruturaDonoIngressoSite()
                };

                item.CotaVerificada = item.CotaItemObject.QuantidadeAsBool && (!item.CotaItemObject.NominalAsBool && !item.CotaItemObject.ValidaBinAsBool && !item.CotaItemObject.ValidaCodigoPromocional);

                cotaItemValidarList.Add(CotaItemValidar);
            }

            //Chama a verificação do IRLib
            cotaItemValidarList = carrinhoItens.VerificarCotaPorQuantidade(cotaItemValidarList);

            //seta os valores do carrinho com os valores retornados da validação da cota
            foreach (var item in carrinhoItensValidar.Where(x => x.CotaItemObject != null))
            {
                var cotaValidada = cotaItemValidarList.Where(x => x.IngressoID == item.IngressoID).FirstOrDefault();
                if (cotaValidada != null)
                {
                    item.CotaVerificada = item.CotaItemObject.Verificado && cotaValidada.TipoRetorno == 0;
                    item.CotaItemObject.QuantidadeValidada = cotaValidada.TipoRetorno == 0;
                    item.CotaItemObject.Mensagem           = cotaValidada.Mensagem;
                    item.DonoID  = cotaValidada.DonoID;
                    item.DonoCPF = cotaValidada.Dono.CPF;
                }
            }

            var cotaItemObjects = carrinhoItensValidar.Select(s => s.CotaItemObject).ToList();

            var cotasErro          = cotaItemObjects.Where(w => !string.IsNullOrEmpty(w.Mensagem)).ToList();
            var mensagensCotasErro = string.Join <string>(" ", cotasErro.Select(s => s.Mensagem).Distinct());

            retorno.Retorno  = AtualizarStatusPendente(compra);
            retorno.Sucesso  = cotaItemObjects.All(x => (x.QuantidadeValidada));
            retorno.Mensagem = retorno.Sucesso ? "OK" : mensagensCotasErro;
            return(retorno);
        }
Ejemplo n.º 22
0
        public void ValeIngressoBO_VerificarCompraSemVales()
        {
            CarrinhoBO  carrinhoBO = new CarrinhoBO();
            CompraModel compra     = new CompraModel();

            compra.CarrinhoItens = carrinhoBO.Listar("0003zo4qtrvb2ckt4c2qdy00", IRCore.DataAccess.Model.Enumerator.enumCarrinhoStatus.reservado);
            compra = carrinhoBO.CalcularValores(compra);
            RetornoModel <CompraModel> retorno = valeIngressoBO.VerificarCompra(compra);

            Assert.AreEqual(true, retorno.Sucesso);
        }
Ejemplo n.º 23
0
        /// <summary>
        /// Método que Verifica se pode ser inserido um valeIngresso em uma compra.
        /// </summary>
        /// <param name="compra"></param>
        /// <param name="valeIngresso"></param>
        /// <returns></returns>
        public RetornoModel <CompraModel> VerificarCompra(CompraModel compra, tValeIngresso valeIngresso = null)
        {
            RetornoModel <CompraModel> retorno = new RetornoModel <CompraModel>();

            retorno.Sucesso  = true;
            retorno.Mensagem = "Vale Ingresso pode ser inserido.";
            retorno.Retorno  = compra;
            //
            if (compra.CarrinhoItens != null && compra.CarrinhoItens.Count(x => x.CotaItemObject != null && x.CotaItemObject.ValidaBinAsBool) != 0)
            {
                retorno.Sucesso  = false;
                retorno.Mensagem = "O carrinho possui um item com cota bin, por isso não podem ser adicionados VIRs.";
            }
            //Teste de valor
            else if (compra.Total == null || compra.Total.ValorTotal == 0)
            {
                retorno.Sucesso  = false;
                retorno.Mensagem = "O carrinho está com valor total 0, por isso não podem ser adicionados VIRs.";
            }
            //teste que veirifica se existe um vale não acumulativo inserido
            else if (compra.ValeIngressos != null && compra.ValeIngressos.Count(x => !(x.ValeIngressoTipo.AcumulativoAsBool)) > 0)
            {
                retorno.Sucesso  = false;
                retorno.Mensagem = "A compra possui um vale ingresso não acumulativo, por isso não podem se adicionados VIRs.";
            }

            else if (valeIngresso != null)
            {
                //verifica se o VIR é não acumulativo e se já tem VIRs na compra
                if (!(valeIngresso.ValeIngressoTipo.AcumulativoAsBool) && compra.ValeIngressos.Count > 0)
                {
                    retorno.Sucesso  = false;
                    retorno.Mensagem = "A compra possui um ou mais vale(s) ingresso(s) e o vale ingresso que está sendo inserido não é acumulativo, por isso não pode ser adicionado.";
                }
                //Faz uma cópia do objeto compra adicionando o vale ingresso passado no parametro. Se o VIR adicionado não afetar o valor da compra não deixa inserir
                else
                {
                    CarrinhoBO  carrinhoBO = new CarrinhoBO(ado);
                    CompraModel compraAux  = new CompraModel();
                    compraAux.CopyFrom(compra);
                    compraAux.ValeIngressos = compra.ValeIngressos.ToList();
                    compraAux.ValeIngressos.Add(valeIngresso);
                    carrinhoBO.CalcularValores(compraAux);
                    if (compra.Total.ValorTotal == compraAux.Total.ValorTotal)
                    {
                        retorno.Sucesso  = false;
                        retorno.Mensagem = "O VIR que está sendo adicionado não altera o valor total da compra, por isso ele não pode ser adicionado.";
                    }
                }
            }

            return(retorno);
        }
Ejemplo n.º 24
0
 public CompraConfirmacionPopUpViewModel(CompraModel _Model, List <CompraDetalleModel> _Lista)
 {
     _Compra      = _Model;
     Cantidad     = _Model.Cantidad;
     Precio       = _Model.Precio;
     Total        = Cantidad * Precio;
     Calificacion = _Model.Calificacion;
     Proveedor    = _Model.ProvNombre;
     IdUsuario    = Settings.IdUsuario;
     IsEnabled    = true;
     Lista        = _Lista;
 }
Ejemplo n.º 25
0
        public void ValeIngressoBO_VerificarCompraValeNaoAcumulativo()
        {
            CarrinhoBO  carrinhoBO = new CarrinhoBO();
            CompraModel compra     = new CompraModel();

            compra.CarrinhoItens = carrinhoBO.Listar("0003zo4qtrvb2ckt4c2qdy00", IRCore.DataAccess.Model.Enumerator.enumCarrinhoStatus.reservado);
            compra.ValeIngressos = new List <tValeIngresso>();
            compra.ValeIngressos.Add(valeIngressoBO.ValidarCodigo("abc123teste2"));
            compra = carrinhoBO.CalcularValores(compra);
            RetornoModel <CompraModel> retorno = valeIngressoBO.VerificarCompra(compra);

            Assert.AreEqual(true, !retorno.Sucesso && retorno.Mensagem.Equals("A compra possui um vale ingresso não acumulativo, por isso não podem se adicionados VIRs."));
        }
Ejemplo n.º 26
0
        public void CotaBO_VerificarCota()
        {
            CarrinhoBO  carrinhoBO = new CarrinhoBO();
            CompraModel compra     = new CompraModel();

            compra.Login         = new Login();
            compra.CarrinhoItens = carrinhoBO.Listar("02kfpvahztwniota0ugz2nnv", IRCore.DataAccess.Model.Enumerator.enumCarrinhoStatus.reservado);
            compra                 = carrinhoBO.CalcularValores(compra);
            compra.SessionID       = "02kfpvahztwniota0ugz2nnv";
            compra.Login.ClienteID = 3465690;
            compra                 = cotaBO.CarregarCotaInformacao(compra);
            Assert.AreEqual(true, compra.CarrinhoItens[0].CotaItemObject.NominalAsBool || compra.CarrinhoItens[0].CotaItemObject.ValidaBinAsBool);
        }
Ejemplo n.º 27
0
        public void ValeIngressoBO_VerificarCompraComValorZerado()
        {
            CarrinhoBO  carrinhoBO = new CarrinhoBO();
            CompraModel compra     = new CompraModel();

            compra.CarrinhoItens = carrinhoBO.Listar("0003zo4qtrvb2ckt4c2qdy00", IRCore.DataAccess.Model.Enumerator.enumCarrinhoStatus.reservado);
            compra.ValeIngressos = new List <tValeIngresso>();
            compra.ValeIngressos.Add(valeIngressoBO.ValidarCodigo("abc123teste1"));
            compra = carrinhoBO.CalcularValores(compra);
            RetornoModel <CompraModel> retorno = valeIngressoBO.VerificarCompra(compra);

            Assert.AreEqual(false, retorno.Sucesso && retorno.Mensagem.Equals("O carrinho está com valor total 0, por isso não podem ser adicionados VIRs."));
        }
Ejemplo n.º 28
0
        public ActionResult ArmazenamentoCompra()
        {
            if (Session["Lista"] != null)
            {
                CompraModel cm = new CompraModel();
                cm.ListagemProdutosCompra = (List <ProdutoDto>)Session["Lista"];

                return(View(cm));
            }
            else
            {
                return(RedirectToAction("InstanciaConsulta"));
            }
        }
        private void removeCompraButton_Click(object sender, RoutedEventArgs e)
        {
            string delCompra = delCpfTxtBox.Text;
            int index = Convert.ToInt32(delCompra);

            CompraController cTrl = new CompraController();
            CompraModel compra = new CompraModel();

            compra = cTrl.findInfo(index);
            cTrl.deleteInfo(compra);

            var db = new Contexto();
            this.CompraDataGrid.ItemsSource = db.Compra.ToList();
        }
Ejemplo n.º 30
0
        public ActionResult IndexVenta()
        {
            CompraModel modeloCompras = new CompraModel();

            List <Models.Request.CategoriaModel>     datosCategoria    = new List <Models.Request.CategoriaModel>();
            List <Models.Request.SubCategoriasModel> datosSubCategoria = new List <Models.Request.SubCategoriasModel>();
            List <Models.Request.ProductRequest>     datosProducto     = new List <Models.Request.ProductRequest>();

            modeloCompras.listaCategorias    = new SelectList(datosCategoria, "Cod_Cat", "Nom_Cat");
            modeloCompras.listaSubCategorias = new SelectList(datosSubCategoria, "Cod_Scat", "Nom_Sbcat");
            modeloCompras.listaProducto      = new SelectList(datosProducto, "Cod_Produc", "Nombre_Produc");

            return(View(modeloCompras));
        }
Ejemplo n.º 31
0
        /// <summary>
        /// Método que lista as entregas disponiveis para um objeto compra
        /// </summary>
        /// <param name="compra"></param>
        /// <returns></returns>
        public CompraModel Carregar(CompraModel compra)
        {
            LogUtil.Debug(string.Format("##EntregaBO.Carregar## SESSION {0}", compra.SessionID));

            compra.EntregaControles = ListarCarrinho(compra.CarrinhoItens);
            if (compra.Login != null)
            {
                compra.Login = CarregarEnderecos(compra.EntregaControles, compra.Login);
            }
            compra.EntregaComEndereco = (compra.EntregaControles.Any(t => t.Entrega.TipoAsEnum == enumEntregaTipo.entregaEmCasaNormal || t.Entrega.TipoAsEnum == enumEntregaTipo.entregaEmCasaAgendada));

            LogUtil.Debug(string.Format("##EntregaBO.Carregar.SUCCESS## SESSION {0}, ENTREGAS {1}, ENTR_COM_END '{2}'", compra.SessionID, compra.EntregaControles.Count, compra.EntregaComEndereco));
            return(compra);
        }
        private void newCompraButton_Click(object sender, RoutedEventArgs e)
        {
            //passa lista de itens comprados com as informações para a tabela Compra e Itens Comprados

            FuncionarioController f2 = new FuncionarioController();
            ClienteControler c2 = new ClienteControler();
            CompraModel compra = new CompraModel();

            compra.Funcionario = f2.findInfo(1);
            compra.FK_Funcionario = 1;
            compra.FK_Cliente = Convert.ToInt32(this.CpfTxtBox.Text);
            compra.Cliente = c2.findInfo(1);
            compra.Data = this.DataTxtBox.Text;
            compra.FormaPagamento = this.FormaPagamentTxtBox.Text;
            compra.PrecoTotal = _precoTotal;

            if (String.IsNullOrEmpty(this.CpfTxtBox.Text) || String.IsNullOrEmpty(this.DataTxtBox.Text) || String.IsNullOrEmpty(this.FormaPagamentTxtBox.Text) || String.IsNullOrEmpty(this.PrecoTotalTxtBox.Text))
            {
                MessageBox.Show("Preencha todos os campos!");
            }
            else
            {
                CompraController cCtrl = new CompraController();

                cCtrl.saveInfo(compra);

                MessageBox.Show("Nova Compra Cadastrada!");

                //var db = new Contexto();
                //CompraModel ultimo = db.Compra.Last();
                ////coloca na tabela Itens Comprados
                //foreach (string o in ListaItensComprados)
                //{
                //    ItensCompradosModel item = new ItensCompradosModel();
                //    LivroController livroCtrl = new LivroController();
                //    LivroModel livro = new LivroModel();
                //    livro.Isbn = Convert.ToInt32(o);

                //    item.FK_Compra = ultimo.ID_Compra;
                //    item.FK_Livro = Convert.ToInt32(o);
                //    cCtrl.saveItem(item);
                //}

                this.NavigationService.Navigate(new ConsultaClientePage());
            }

            this.NavigationService.Navigate(new HomePage());
        }
Ejemplo n.º 33
0
        public void saveInfo(CompraModel c)
        {
            CompraModel compra = new CompraModel();
            compra = c;

            try
            {
                using (var db = new Contexto())
                {
                    db.Compra.Add(compra);
                    db.SaveChanges();
                }
            }
            catch
            {
                MessageBox.Show("Erro na inserção");
            }
        }
Ejemplo n.º 34
0
        //public CompraModel findInfo(string cpf)
        public CompraModel findInfo(int index)
        {
            CompraModel c1 = new CompraModel();

            try
            {
                using (var db = new Contexto())
                {
                    c1 = db.Compra.Find(index);

                    return c1;
                }
            }
            catch
            {
                MessageBox.Show("Erro na remoção");
                return c1;
            }
        }
Ejemplo n.º 35
0
        public void deleteInfo(CompraModel c)
        {
            CompraModel compra = new CompraModel();

            compra = c;

            try
            {
                using (var db = new Contexto())
                {
                    var entry = db.Entry(compra);
                    if (entry.State == EntityState.Detached)
                        db.Compra.Attach(compra);
                    db.Compra.Remove(compra);
                    db.SaveChanges();
                }
            }
            catch
            {
                MessageBox.Show("Erro na remoção");
            }
        }