public async Task <Entregador> Criar(Entregador entregador)
        {
            _context.Add(entregador);
            await _context.SaveChangesAsync();

            return(entregador);
        }
Exemple #2
0
 private void PopularFormulario(Entregador entregador)
 {
     this.entregador   = entregador;
     identregador.Text = entregador.Id.ToString();
     nome.Text         = entregador.Nome;
     telefone.Text     = entregador.Telefone;
 }
Exemple #3
0
        public ActionResult Login(Entregador u)
        {
            if (ModelState.IsValid)
            {
                using (var db = new Packed_Lunch_4_1Entities()) // Nome do entity localizado no Empresa.Context
                {
                    //var login = from a in db.empresas select a;
                    var v = db.Entregadors.Where(a => a.Login.Equals(u.Login) && a.Senha.Equals(u.Senha)).FirstOrDefault();
                    if (v != null)
                    {
                        if (v.Equals("Entregador"))
                        {
                            Session["IDUsuario"]        = v.Id_Entregador;
                            Session["CPFUsuarioLogado"] = v.Cpf.ToString();
                            Session["NomedaEmpresa"]    = v.Nome.ToString();
                            return(RedirectToAction("Details", "Entregadors"));
                        }
                        ////if (v.func.Equals("func"))
                        //{
                        //    Session["nomeUsuarioLogado"] = v.login.ToString();
                        //    return RedirectToAction("funcionario", "Usuario");
                        //}
                    }
                }
            }

            return(View(u));
        }
        public void SalvarCliente(Entregador entregador)
        {
            int id = ultimoID = +1;

            entregador.PessoaID = id;
            MeusEntregadores.Add(entregador);
        }
Exemple #5
0
        public ActionResult DeleteConfirmed(int id)
        {
            Entregador entregador = db.Entregador.Find(id);

            db.Entregador.Remove(entregador);
            db.SaveChanges();
            return(RedirectToAction("Index"));
        }
        public void ExcluirEndereco(int id)
        {
            Entregador end = ProcurarPorIDEntregador(id);

            if (end != null)
            {
                ListaEntregadores.Remove(end);
            }
        }
Exemple #7
0
        private EntregadorIntegration ConvertEntregador(Entregador entregador)
        {
            EntregadorIntegration entregadorIntegration = new EntregadorIntegration();

            entregadorIntegration.nome     = entregador.nome;
            entregadorIntegration.telefone = entregador.codigo;

            return(entregadorIntegration);
        }
Exemple #8
0
 public ActionResult Edit([Bind(Include = "Id_Entregador,Cpf,Nome,Login,Senha")] Entregador entregador)
 {
     if (ModelState.IsValid)
     {
         db.Entry(entregador).State = EntityState.Modified;
         db.SaveChanges();
         return(RedirectToAction("Index"));
     }
     return(View(entregador));
 }
        public int CadastrarEntregador(Entregador ent)
        {
            int id = ultimoID + 1;

            ultimoID = id;

            ent.enderecoID = id;
            ListaEntregadores.Add(ent);
            return(id);
        }
Exemple #10
0
        // GET: Entregadors/Details/5
        public ActionResult Details()
        {
            Entregador entregador = db.Entregadors.Find(Session["IDUsuario"]);

            if (Session["CPFUsuarioLogado"] != null && entregador != null)
            {
                return(View(entregador));
            }
            return(HttpNotFound());
        }
Exemple #11
0
        public List <OrdemServicoIntegration> ListarOrdensPendentes(String phone, long lastpackage, long newpackage, String securitykey)
        {
            var          listaRetorno = new List <OrdemServicoIntegration>();
            ParserHelper parser       = new ParserHelper();

            DateTime data_atual = new DateTime(DateTime.Now.Year, DateTime.Now.Month, DateTime.Now.Day, 23, 59, 59);
            DateTime data_corte = data_atual.AddDays(-1);

            //Retona as OSs pendentes de sincronização com o device
            var listaOS = db.Solicitacao.Where(s =>
                                               s.Celular == phone &&
                                               (s.IDStatus == 1001 || s.IDStatus == 1002 || s.IDStatus == 1004) &&
                                               (s.LastPackageSent < lastpackage || s.LastPackageSent == null || s.LastPackageSent == 0) &&
                                               (s.DataOrigem > data_corte) &&
                                               (s.RECUPERAR_WEB == false || !s.RECUPERAR_WEB.HasValue)).ToList();

            //Atualiza o lastpackagesent
            foreach (var os in listaOS)
            {
                try
                {
                    List <Produtos> listaProdutos = db.Produtos.Where(p => p.idSolicitacao == os.IDSolicitacao).OrderBy(o => o.indice).ToList();

                    //Convertendo pro objeto usado na integracao com o device
                    OrdemServicoIntegration order = ConvertSolicitacao(os);
                    order.produtos = new List <ProdutoIntegration>();
                    order.produtos = parser.ParseProducts(os.CodMensagem, listaProdutos);

                    Entregador entregador = db.Entregador.FirstOrDefault(e => e.codigo == phone);

                    if (entregador != null)
                    {
                        order.concorrencia = (entregador.concorrencia.HasValue ? entregador.concorrencia.Value : false);
                        order.is_vip       = entregador.isVip.HasValue ? entregador.isVip.Value : false;
                    }

                    listaRetorno.Add(order);
                }
                catch (Exception ex)
                {
                    logger.Error("Repository.ListarOrdensPendentes : *** ERR [ codmensagem : " + os.CodMensagem + " / erro: " + ex.Message + " / " + ex.StackTrace + " ]");
                }

                os.SecurityKeyMobile = securitykey;
                os.LastPackageSent   = newpackage;
            }

            //Se houver atualização efetua as alterações na base
            if (listaOS.Count > 0)
            {
                db.SaveChanges();
            }

            return(listaRetorno);
        }
Exemple #12
0
        public ActionResult Create([Bind(Include = "Id_Entregador,Cpf,Nome,Login,Senha")] Entregador entregador)
        {
            if (ModelState.IsValid)
            {
                db.Entregador.Add(entregador);
                db.SaveChanges();
                return(RedirectToAction("Index"));
            }

            return(View(entregador));
        }
//metodos
    public void cadastrarEntregador(Entregador entre)
    {
        for (int x = 0; x < entregadores.Length; x++)
        {
            if (entregadores[x] == null)
            {
                entregadores[x] = entre;
                break;
            }
        }
    }
Exemple #14
0
        private async Task <bool> ValidarEntregador(Entregador entregador)
        {
            var invalido = await _entregadorRepository.Existe(x => x.Id != entregador.Id && x.Email.Equals(entregador.Email));

            if (invalido)
            {
                AdicionarErro("Já existe um entregador com esse email");
                return(false);
            }
            return(true);
        }
Exemple #15
0
 public override void OnNavigatedTo(NavigationParameters parameters)
 {
     if (parameters != null && parameters.ContainsKey("entregador"))
     {
         Entregador = parameters["entregador"] as Entregador;
     }
     else
     {
         EscondeOpcaoRemover();
         Entregador = new Entregador();
     }
 }
        public Entregador EditarFornecedor(int id)
        {
            Entregador c = ProcurarPorIDEntregador(id);

            if (c != null)
            {
                return(c);
            }
            else
            {
                return(null);
            }
        }
        public Boolean ExcluirEntregador(int ID)
        {
            Entregador entregador = BuscarEntregadorPorID(ID);

            if (entregador != null)
            {
                MeusEntregadores.Remove(entregador);
                return(true);
            }
            else
            {
                return(false);
            }
        }
Exemple #18
0
        // GET: Entregadors/Delete/5
        public ActionResult Delete(int?id)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }
            Entregador entregador = db.Entregador.Find(id);

            if (entregador == null)
            {
                return(HttpNotFound());
            }
            return(View(entregador));
        }
    public static void Main(string[] args)
    {
        cliente Daniel = new cliente();

        Daniel.nome     = "Daniel da Silva";
        Daniel.endereço = "Avenida Região Sudeste,N 400";


        Roupa CalçaJeans = new Roupa();

        CalçaJeans.Setnome("Calça Black Jeans Slim");
        CalçaJeans.setcaracteristicas("Preto");
        CalçaJeans.Setpreço(100);
        Roupa Camisa = new Roupa();

        Camisa.Setnome("Camisa Social");
        Camisa.setcaracteristicas("Branco");
        Camisa.Setpreço(150);
        Roupa Bermuda = new Roupa();

        Bermuda.Setnome("Bermuda de Moletom");
        Bermuda.setcaracteristicas("Cinza");
        Bermuda.Setpreço(120);
        Entregador Dados = new Entregador();

        Dados.setnome_entregador("Carlinhos");
        Dados.setpacote_recebido("Sim");
        Dados.tempo_de_entrega = 7;


        Daniel.Dados_do_Cliente("Daniel da Silva", "Avenida Região Sudeste,N 400");
        Daniel.Adcionado_no_Carrinho("Calça Black Jeans Slim", 2, 200);
        Daniel.Adcionado_no_Carrinho("Camisa Social", 4, 600);
        Daniel.Adcionado_no_Carrinho("Bermuda de Moletom", 2, 240);
        Daniel.Pagar("Calça Black Jeans(2)/Camisa Social(4)/Bermuda de Moletom(2)", 2, 520);


        Daniel.Dados_da_Entrega("Carlos", "Sim", 7);
    }
Exemple #20
0
 public void Atualizar(Entregador entregador)
 {
     _context.Update(entregador);
 }
Exemple #21
0
        static void Main(string[] args)
        {
            clientes.Add(new Cliente("José Ninguém", 11112222, "Rua Sem Nome, S/N", "Perto da loja Sem Nome", 1, 1, 1900));
            clientes.Add(new Cliente("Fulano de Tal", 33334444, "Rua da Esquina, S/N", "Perto da loja da Esquina", 2, 2, 1901));

            produtos.Add(new Produto(1001, "Pizza de Calabresa", "massa, molho, mussarela, calabresa, cebola", char.Parse("M"), 45));
            produtos.Add(new Produto(1002, "Pizza Romeu e Julieta", "massa, mussarela, goiabada", char.Parse("P"), 35));

            entregadores.Add(new Entregador("Sicrano de Tal", 11122233344, 1112223, 55556666));
            entregadores.Add(new Entregador("João Ninguém", 55566677788, 55566677, 77778888));

            ConsoleKeyInfo opcao = new ConsoleKeyInfo('A', ConsoleKey.A, false, false, false);

            while (opcao.Key != ConsoleKey.D0)
            {
                Console.Clear();
                Tela.mostrarMenu();

                opcao = Console.ReadKey();

                switch (opcao.Key)
                {
                case ConsoleKey.D1:
                    Produto.mostrarProdutos();
                    break;

                case ConsoleKey.D2:
                    Produto.cadastrarProduto();
                    break;

                case ConsoleKey.D3:
                    Cliente.mostrarClientes();
                    break;

                case ConsoleKey.D4:
                    Cliente.cadastrarCliente();
                    break;

                case ConsoleKey.D5:
                    Entregador.mostrarEntregadores();
                    break;

                case ConsoleKey.D6:
                    Entregador.cadastrarEntregador();
                    break;

                case ConsoleKey.D7:
                    Pedido.consultarPedido();
                    break;

                case ConsoleKey.D8:
                    Pedido.cadastrarPedido();
                    break;

                case ConsoleKey.D9:
                    Pedido.mudaStatusPedido();
                    break;

                case ConsoleKey.D0:
                    Tela.sair();
                    break;

                default:
                    Tela.opcaoInvalida();
                    break;
                }
            }
        }
Exemple #22
0
 public EntregadoresEditPage(Entregador entregador)
 {
     InitializeComponent();
     PopularFormulario(entregador);
 }
        public async Task <IActionResult> Excluir(Entregador entregador)
        {
            await _entregadorRepository.Excluir(entregador.Id);

            return(NoContent());
        }
Exemple #24
0
 public void Remove(Entregador entregador)
 {
     this.Entregadores.Remove(entregador);
 }
Exemple #25
0
 public void Update(Entregador entregador)
 {
     this.Entregadores[this.Entregadores.IndexOf(entregador)] = entregador;
 }
 public async Task Atualizar(Entregador entregador)
 {
     _context.Entry(entregador).State = EntityState.Modified;
     await _context.SaveChangesAsync();
 }
 public void AddEntregador(Entregador item)
 {
     Entregadores.Add(item);
 }
Exemple #28
0
 public void Remover(Entregador entregador)
 {
     _context.Entregadores.Remove(entregador);
 }
Exemple #29
0
 public void Add(Entregador entregador)
 {
     this.Entregadores.Add(entregador);
 }
Exemple #30
0
        public Entregador Cadastrar(Entregador entregador)
        {
            var entidade = _context.Entregadores.Add(entregador).Entity;

            return(entidade);
        }