示例#1
0
        public ActionResult Cadastrar(CadastrarVeiculoViewModel viewModel)
        {
            if (!ModelState.IsValid)
            {
                return(this.ModelErrors());
            }

            using (DbApplication db = new DbApplication())
            {
                Agente agenteBanco = db
                                     .Agentes
                                     .ComMatricula(viewModel.Matricula)
                                     .SingleOrDefault();

                if (agenteBanco != null)
                {
                    return(this.ErrorMessage("Já existe um agente com essa matrícula"));
                }

                Agente agente = new Agente();

                agente.Matricula    = viewModel.Matricula;
                agente.NomeAgente   = viewModel.NomeAgente;
                agente.Efetivacao   = viewModel.Efetivacao;
                agente.TempoServico = viewModel.TempoServico;

                db.RegistrarNovo(agente);
                db.Salvar();

                return(this.Message("Agente cadastrado com sucesso."));
            }
        }
示例#2
0
        public ActionResult Atualizar(AtualizarViewModel viewModel)
        {
            if (!ModelState.IsValid)
            {
                return(this.ModelErrors());
            }

            using (DbApplication db = new DbApplication())
            {
                Agente agenteBanco = db
                                     .Agentes
                                     .ComMatricula(viewModel.Matricula)
                                     .SingleOrDefault();

                if (agenteBanco != null && agenteBanco.IdAgente != viewModel.IdAgente)
                {
                    return(this.ErrorMessage("Já existe um agente com essa matrícula"));
                }

                Agente agente = db
                                .Agentes
                                .ComId(viewModel.IdAgente)
                                .SingleOrDefault();

                agente.NomeAgente   = viewModel.NomeAgente;
                agente.TempoServico = viewModel.TempoServico;
                agente.Efetivacao   = viewModel.Efetivacao;

                db.RegistrarAlterado(agente);
                db.Salvar();
            }
            return(this.Message("Agente atualizado com sucesso"));
        }
示例#3
0
        public ActionResult RelatorioModelos(ModelosCadastradosRelatorioViewModel viewModel)
        {
            if (!ModelState.IsValid)
            {
                return(this.ModelErrors());
            }

            RelatorioModelosViewModel relatorioModelos = new RelatorioModelosViewModel();

            using (DbApplication db = new DbApplication())
            {
                IQueryable <Modelo> modelosQuery = db
                                                   .Modelos
                                                   .OndeDescricaoContem(viewModel.Descricao)
                                                   .OrderBy(a => a.IdModelo);

                ICollection <Modelo> modelos = modelosQuery
                                               .ToList();

                relatorioModelos.TotalModelos = modelos.Count;

                relatorioModelos.Modelos = new List <RelatorioModelosViewModel.Modelo>();

                foreach (Modelo modelo in modelos)
                {
                    relatorioModelos.Modelos.Add(new RelatorioModelosViewModel.Modelo
                    {
                        Descricao = modelo.Descricao
                    });
                }
                return(this.PdfView("~/Relatorios/Modelos/RelatorioModelos.cshtml", relatorioModelos));
            }
        }
示例#4
0
        public ActionResult Remover(IdAgenteViewModel viewModel)
        {
            if (!ModelState.IsValid)
            {
                return(this.ModelErrors());
            }

            using (DbApplication db = new DbApplication())
            {
                Agente agente = db
                                .Agentes
                                .ComId(viewModel.IdAgente)
                                .SingleOrDefault();

                if (agente == null)
                {
                    return(this.ErrorMessage("Agente não encontrado."));
                }

                db.RegistrarRemovido(agente);
                db.Salvar();

                return(this.Message("Agente removido com sucesso."));
            }
        }
示例#5
0
        public ActionResult Cadastrar(CadastrarLogradouroViewModel viewModel)
        {
            if (!ModelState.IsValid)
            {
                return(this.ModelErrors());
            }

            using (DbApplication db = new DbApplication())
            {
                Logradouro logradouroBanco = db
                                             .Logradouros
                                             .ComCep(viewModel.Cep)
                                             .SingleOrDefault();

                if (logradouroBanco != null)
                {
                    return(this.ErrorMessage("Já existe um logradouro com esse cep"));
                }

                Logradouro logradouro = new Logradouro();

                logradouro.Cidade        = viewModel.Cidade;
                logradouro.Bairro        = viewModel.Bairro;
                logradouro.Estado        = viewModel.Estado;
                logradouro.Rua           = viewModel.Rua;
                logradouro.Cep           = viewModel.Cep;
                logradouro.VelocidadeMax = viewModel.VelocidadeMax;

                db.RegistrarNovo(logradouro);
                db.Salvar();

                return(this.Message("Logradouro cadastrado com sucesso."));
            }
        }
示例#6
0
        public ActionResult Remover(IdCategoriaViewModel viewModel)
        {
            if (!ModelState.IsValid)
            {
                this.ModelErrors();
            }

            using (DbApplication db = new DbApplication())
            {
                Categoria categoria = db
                                      .Categorias
                                      .Include(c => c.Produtos)
                                      .ComId(viewModel.Id)
                                      .SingleOrDefault();

                if (categoria == null)
                {
                    return(this.ErrorMessage("Categoria não encontrada."));
                }
                if (categoria.Produtos.Count > 0)
                {
                    return(this.ErrorMessage("A Categoria está associada a um produto."));
                }
                db.RegistrarRemovido(categoria);
                db.Salvar();

                return(this.Message("Categoria removida com sucesso."));
            }
        }
示例#7
0
        public ActionResult Todos()
        {
            using (DbApplication db = new DbApplication())
            {
                ICollection <Agente> agentes = db
                                               .Agentes
                                               .OrderBy(a => a.NomeAgente)
                                               .ToList();

                List <dynamic> agentesJson = new List <dynamic>();

                foreach (Agente agente in agentes)
                {
                    agentesJson.Add(new
                    {
                        idAgente   = agente.IdAgente,
                        matricula  = agente.Matricula,
                        nomeAgente = agente.NomeAgente
                    });
                }
                return(Json(new
                {
                    agentes = agentesJson
                }));
            }
        }
示例#8
0
        public ActionResult Cadastrar(CadastrarModeloViewModel viewModel)
        {
            if (!ModelState.IsValid)
            {
                return(this.ModelErrors());
            }

            using (DbApplication db = new DbApplication())
            {
                Modelo modeloBanco = db.Modelos
                                     .ComDescricao(viewModel.Descricao)
                                     .SingleOrDefault();

                if (modeloBanco != null)
                {
                    return(this.ErrorMessage("Já existe um modelo cadastrado com essa descrição."));
                }

                Modelo modelo = new Modelo();
                modelo.Descricao = viewModel.Descricao;

                db.RegistrarNovo(modelo);
                db.Salvar();
            }

            return(this.Message("Modelo cadastrado com sucesso."));
        }
示例#9
0
        public ActionResult Cadastrar(CadastrarProdutoViewModel viewModel)
        {
            if (!ModelState.IsValid)
            {
                return(this.ModelErrors());
            }
            using (DbApplication db = new DbApplication())
            {
                Produto produtoBanco = db.Produtos
                                       .ComNome(viewModel.Nome).SingleOrDefault();

                if (produtoBanco != null)
                {
                    return(this.ErrorMessage("Já existe um produto cadastrado com esse nome."));
                }

                Produto produto = new Produto();

                produto.IdCategoria = viewModel.IdCategoria;
                produto.Nome        = viewModel.Nome;
                produto.Preco       = viewModel.Preco;
                db.RegistrarNovo(produto);
                db.Salvar();

                return(this.Message("Produto cadastrado com sucesso."));
            }
        }
示例#10
0
        public ActionResult Remover(IdModeloViewModel viewModel)
        {
            if (!ModelState.IsValid)
            {
                return(this.ModelErrors());
            }

            using (DbApplication db = new DbApplication())
            {
                Modelo modelo = db
                                .Modelos
                                .Include(m => m.Veiculos)
                                .ComId(viewModel.IdModelo)
                                .SingleOrDefault();

                if (modelo == null)
                {
                    return(this.ErrorMessage("Modelo não encontrado."));
                }
                if (modelo.Veiculos.Count > 0)
                {
                    return(this.ErrorMessage("O modelo está associado a um veículo"));
                }

                db.RegistrarRemovido(modelo);
                db.Salvar();

                return(this.Message("Modelo removido com sucesso."));
            }
        }
示例#11
0
        public ActionResult Atualizar(AtualizarVeiculoViewModel viewModel)
        {
            if (!ModelState.IsValid)
            {
                return(this.ModelErrors());
            }

            using (DbApplication db = new DbApplication())
            {
                Veiculo veiculoBanco = db.Veiculos
                                       .ComPlaca(viewModel.Placa)
                                       .SingleOrDefault();
                if (veiculoBanco != null && veiculoBanco.IdVeiculo != viewModel.IdVeiculo)
                {
                    return(this.ErrorMessage("Já existe um veiculo com essa placa"));
                }

                Veiculo veiculo = db.Veiculos
                                  .ComId(viewModel.IdVeiculo)
                                  .SingleOrDefault();

                veiculo.Placa          = viewModel.Placa;
                veiculo.Uf             = viewModel.Uf;
                veiculo.IdInfracao     = viewModel.IdInfracao;
                veiculo.IdModelo       = viewModel.IdModelo;
                veiculo.IdProprietario = viewModel.IdProprietario;

                db.RegistrarAlterado(veiculo);
                db.Salvar();
            }
            return(this.Message("Veiculo atualizado com sucesso."));
        }
示例#12
0
        public ActionResult Remover(IdProdutoViewModel viewModel)
        {
            if (!ModelState.IsValid)
            {
                this.ModelErrors();
            }

            using (DbApplication db = new DbApplication())
            {
                Produto produto = db
                                  .Produtos
                                  .ComId(viewModel.IdProduto)
                                  .SingleOrDefault();
                if (produto == null)
                {
                    return(this.ErrorMessage("Produto não encontrado."));
                }

                //produto.DataDeletado = DateTime.Now;

                db.RegistrarAlterado(produto);
                db.Salvar();

                return(this.Message("Produto removido com sucesso"));
            }
        }
        public ActionResult Todos()
        {
            using (DbApplication db = new DbApplication())
            {
                ICollection <Proprietario> proprietarios = db.Proprietarios
                                                           .OrderBy(p => p.NomeProprietario)
                                                           .ToList();

                List <dynamic> proprietariosJson = new List <dynamic>();

                foreach (Proprietario proprietario in proprietarios)
                {
                    proprietariosJson.Add(new
                    {
                        idProprietario   = proprietario.IdProprietario,
                        nomeProprietario = proprietario.NomeProprietario,
                        cpfProprietario  = proprietario.CpfProprietario
                    });
                }

                return(Json(new
                {
                    proprietarios = proprietariosJson
                }));
            }
        }
        public ActionResult Remover(IdProprietarioViewModel viewModel)
        {
            if (!ModelState.IsValid)
            {
                this.ModelErrors();
            }

            using (DbApplication db = new DbApplication())
            {
                Proprietario proprietario = db
                                            .Proprietarios
                                            .Include(p => p.Veiculos)
                                            .ComId(viewModel.IdProprietario)
                                            .SingleOrDefault();

                if (proprietario == null)
                {
                    return(this.ErrorMessage("Proprietário não encontrado"));
                }
                if (proprietario.Veiculos.Count > 0)
                {
                    return(this.ErrorMessage("O proprietário está associado a um veículo"));
                }

                db.RegistrarRemovido(proprietario);
                db.Salvar();

                return(this.Message("Proprietário removido com sucesso."));
            }
        }
        public ActionResult Cadastrar(CadastrarInfracaoViewModel viewModel)
        {
            if (!ModelState.IsValid)
            {
                return(this.ModelErrors());
            }

            using (DbApplication db = new DbApplication())
            {
                Infracao infracaoBanco = db
                                         .Infracoes
                                         .ComDescricao(viewModel.Descricao)
                                         .SingleOrDefault();

                if (infracaoBanco != null)
                {
                    return(this.ErrorMessage("Já existe uma infração cadastrada com esse id."));
                }

                Infracao infracao = new Infracao();

                infracao.Descricao    = viewModel.Descricao;
                infracao.Velocidade   = viewModel.Velocidade;
                infracao.IdVeiculo    = viewModel.IdVeiculo;
                infracao.IdLogradouro = viewModel.IdLogradouro;
                infracao.IdAgente     = viewModel.IdAgente;

                db.RegistrarNovo(infracao);
                db.Salvar();

                return(this.Message("Infração registrada com sucesso."));
            }
        }
        public ActionResult Atualizar(AtualizarProprietarioViewModel viewModel)
        {
            if (!ModelState.IsValid)
            {
                return(this.ModelErrors());
            }

            using (DbApplication db = new DbApplication())
            {
                Proprietario proprietarioBanco = db
                                                 .Proprietarios
                                                 .ComCpf(viewModel.CpfProprietario)
                                                 .SingleOrDefault();
                if (proprietarioBanco != null && proprietarioBanco.IdProprietario != viewModel.IdProprietario)
                {
                    return(this.ErrorMessage("Já existe um Proprietário com esse cpf"));
                }
                Proprietario proprietario = db.Proprietarios
                                            .ComId(viewModel.IdProprietario)
                                            .SingleOrDefault();

                proprietario.IdProprietario   = viewModel.IdProprietario;
                proprietario.NomeProprietario = viewModel.NomeProprietario;
                proprietario.CpfProprietario  = viewModel.CpfProprietario;
                proprietario.DataNascimento   = viewModel.DataNascimento;
                proprietario.Telefone         = viewModel.Telefone;

                db.RegistrarAlterado(proprietario);
                db.Salvar();
            }

            return(this.Message("Proprietário atualizado com sucesso."));
        }
        public ActionResult Cadastrar(CadastrarProprietarioViewModel viewModel)
        {
            if (!ModelState.IsValid)
            {
                return(this.ModelErrors());
            }
            using (DbApplication db = new DbApplication())
            {
                Proprietario proprietarioBanco = db.Proprietarios
                                                 .ComCpf(viewModel.CpfProprietario)
                                                 .SingleOrDefault();

                if (proprietarioBanco != null)
                {
                    return(this.ErrorMessage("Já existe um proprietário cadastrado com esse cpf."));
                }
                Proprietario proprietario = new Proprietario();

                proprietario.NomeProprietario = viewModel.NomeProprietario;
                proprietario.CpfProprietario  = viewModel.CpfProprietario;
                proprietario.DataNascimento   = viewModel.DataNascimento;
                proprietario.Telefone         = viewModel.Telefone;

                db.RegistrarNovo(proprietario);
                db.Salvar();

                return(this.Message("Proprietário Cadastrado com sucesso."));
            }
        }
示例#18
0
        public ActionResult Cadastrar(CadastrarCategoriaViewModel viewModel)
        {
            if (!ModelState.IsValid)
            {
                return(this.ModelErrors());
            }

            using (DbApplication db = new DbApplication())
            {
                Categoria categoriaBanco = db.Categorias
                                           .ComDescricao(viewModel.Descricao).SingleOrDefault();

                if (categoriaBanco != null)
                {
                    return(this.ErrorMessage("Já existe uma Categoria cadastrada com esta descrição."));
                }

                Categoria categoria = new Categoria();
                categoria.Descricao = viewModel.Descricao;

                db.RegistrarNovo(categoria);
                db.Salvar();
            }

            return(this.Message("Categoria cadastrada com sucesso."));
        }
示例#19
0
        public ActionResult Cadastrar(CadastrarVeiculoViewModel viewModel)
        {
            if (!ModelState.IsValid)
            {
                return(this.ModelErrors());
            }
            using (DbApplication db = new DbApplication())
            {
                Veiculo veiculoBanco = db.Veiculos
                                       .ComPlaca(viewModel.Placa)
                                       .SingleOrDefault();
                if (veiculoBanco != null)
                {
                    return(this.ErrorMessage("Já existe veiculo com essa placa."));
                }

                Veiculo veiculo = new Veiculo();

                veiculo.Placa          = viewModel.Placa;
                veiculo.Uf             = viewModel.Uf;
                veiculo.IdInfracao     = viewModel.IdInfracao;
                veiculo.IdModelo       = viewModel.IdModelo;
                veiculo.IdProprietario = viewModel.IdProprietario;

                db.RegistrarNovo(veiculo);
                db.Salvar();

                return(this.Message("Veiculo cadastrado com sucesso."));
            }
        }
示例#20
0
        public ActionResult Cadastradas(CategoriasCadastradasViewModel viewModel)
        {
            using (DbApplication db = new DbApplication())
            {
                IQueryable <Categoria> categoriasQuery = db.Categorias
                                                         .OndeDescricaoContem(viewModel.Descricao)
                                                         .OrderBy(d => d.Descricao);

                ICollection <Categoria> categorias = categoriasQuery
                                                     .Skip(viewModel.Paginacao.Inicio)
                                                     .Take(viewModel.Paginacao.Limite)
                                                     .ToList();

                viewModel.Paginacao.TotalRegistros = categoriasQuery.Count();

                List <dynamic> categoriasJson = new List <dynamic>();

                foreach (Categoria categoria in categorias)
                {
                    categoriasJson.Add(new
                    {
                        id        = categoria.IdCategoria,
                        descricao = categoria.Descricao,
                    });
                }
                return(Json(new
                {
                    categorias = categoriasJson,
                    paginacao = viewModel.Paginacao.Json()
                }));
            }
        }
示例#21
0
        public ActionResult Atualizar(AtualizarProdutoViewModel viewModel)
        {
            if (!ModelState.IsValid)
            {
                return(this.ModelErrors());
            }

            using (DbApplication db = new DbApplication())
            {
                Produto produtoBanco = db.
                                       Produtos
                                       .ComNome(viewModel.Nome)
                                       .SingleOrDefault();

                if (produtoBanco != null && produtoBanco.IdProduto != viewModel.IdProduto)
                {
                    return(this.ErrorMessage("Já existe um produto  cadastrado com esta descrição."));
                }
                Produto produto = db.Produtos
                                  .ComId(viewModel.IdProduto)
                                  .SingleOrDefault();

                produto.IdCategoria = viewModel.IdCategoria;
                produto.Nome        = viewModel.Nome;
                produto.Preco       = viewModel.Preco;

                db.RegistrarAlterado(produto);
                db.Salvar();
            }

            return(this.Message("Produto atualizado com sucesso."));
        }
示例#22
0
        public ActionResult Cadastrados(ModelosCadastradosViewModel viewModel)
        {
            using (DbApplication db = new DbApplication())
            {
                IQueryable <Modelo> modelosQuery = db.Modelos
                                                   .OndeDescricaoContem(viewModel.Descricao)
                                                   .OrderBy(d => d.Descricao);
                ICollection <Modelo> modelos = modelosQuery
                                               .Skip(viewModel.Paginacao.Inicio)
                                               .Take(viewModel.Paginacao.Limite)
                                               .ToList();

                viewModel.Paginacao.TotalRegistros = modelosQuery.Count();

                List <dynamic> modelosJson = new List <dynamic>();

                foreach (Modelo modelo in modelos)
                {
                    modelosJson.Add(new
                    {
                        idModelo  = modelo.IdModelo,
                        descricao = modelo.Descricao,
                    });
                }

                return(Json(new{
                    modelos = modelosJson,
                    paginacao = viewModel.Paginacao.Json()
                }));
            }
        }
示例#23
0
        public ActionResult Cadastrados(VeiculosCadastradosViewModel viewModel)
        {
            using (DbApplication db = new DbApplication())
            {
                IQueryable <Veiculo> veiculosQuery = db.Veiculos
                                                     .OndePlacaContem(viewModel.Placa)
                                                     .Include(v => v.Modelo)
                                                     .Include(v => v.Infracoes)
                                                     .Include(v => v.Proprietario)
                                                     .OrderBy(v => v.IdVeiculo);


                ICollection <Veiculo> veiculos = veiculosQuery
                                                 .Skip(viewModel.Paginacao.Inicio)
                                                 .Take(viewModel.Paginacao.Limite)
                                                 .ToList();

                viewModel.Paginacao.TotalRegistros = veiculosQuery.Count();
                List <dynamic> veiculosJson = new List <dynamic>();
                foreach (Veiculo veiculo in veiculos)
                {
                    List <dynamic> infracoesJson = new List <dynamic>();

                    foreach (Infracao infracao in veiculo.Infracoes)
                    {
                        infracoesJson.Add(new
                        {
                            idInfracao         = infracao.IdInfracao,
                            descricaoInfracao  = infracao.Descricao,
                            velocidadeInfracao = infracao.Velocidade,
                            localInfracao      = infracao.IdLogradouro,
                            agenteInfracao     = infracao.IdAgente,
                            veiculoInfracao    = infracao.Veiculo.Placa
                        });
                    }
                    veiculosJson.Add(new
                    {
                        descricaoModelo = veiculo.Modelo.Descricao,
                        cpfProprietario = veiculo.Proprietario.CpfProprietario,
                        placa           = veiculo.Placa,
                        uf                = veiculo.Uf,
                        idVeiculo         = veiculo.IdVeiculo,
                        infracoesVeiculos = infracoesJson

                                            //proprietario = new
                                            //{
                                            //    nome = veiculo.Proprietario.NomeProprietario,
                                            //    cpf = veiculo.Proprietario.CpfProprietario
                                            //}
                    });
                }

                return(Json(new
                {
                    veiculos = veiculosJson,
                    paginacao = viewModel.Paginacao.Json()
                }));
            }
        }
示例#24
0
        public ActionResult Cadastrados(PedidosCadastradosViewModel viewModel)
        {
            if (!ModelState.IsValid)
            {
                return(this.ErrorMessage("Data pesquisada está fora do intervalo permitido."));
            }

            using (DbApplication db = new DbApplication())
            {
                IQueryable <Pedido> pedidosQuery = db.Pedidos
                                                   .DataInicio(viewModel.DataInicio)
                                                   .DataFinal(viewModel.DataFinal)
                                                   .Include(pe => pe.Itens)
                                                   .Include(pe => pe.Itens.Select(p => p.Produto))
                                                   .OrderBy(pe => pe.DataPedido);


                ICollection <Pedido> pedidos = pedidosQuery
                                               .Skip(viewModel.Paginacao.Inicio)
                                               .Take(viewModel.Paginacao.Limite)
                                               .ToList();
                viewModel.Paginacao.TotalRegistros = pedidosQuery.Count();
                List <dynamic> pedidosJson = new List <dynamic>();
                foreach (Pedido pedido in pedidos)
                {
                    List <dynamic> itensJson = new List <dynamic>();

                    foreach (Item item in pedido.Itens)
                    {
                        itensJson.Add(new
                        {
                            produto    = item.Produto.Nome,
                            idItem     = item.IdItem,
                            idProduto  = item.IdProduto,
                            idPedido   = item.IdPedido,
                            quantidade = item.Quantidade,
                            subtotal   = item.Subtotal
                        });
                    }

                    pedidosJson.Add(new
                    {
                        idPedido   = pedido.IdPedido,
                        itens      = itensJson,
                        dataPedido = pedido.DataPedido.ToString("dd/MM/yyyy"),
                        total      = pedido.Total
                    });
                }
                return(Json(new
                {
                    pedidos = pedidosJson,
                    paginacao = viewModel.Paginacao.Json()
                }));
            }
        }
        public ActionResult Cadastrados(ProprietariosCadastradosViewModel viewModel)
        {
            using (DbApplication db = new DbApplication())
            {
                IQueryable <Proprietario> proprietariosQuery = db.Proprietarios
                                                               .ContemCpf(viewModel.CpfProprietario)
                                                               .Include(p => p.Veiculos)
                                                               .OrderBy(p => p.NomeProprietario);

                ICollection <Proprietario> proprietarios = proprietariosQuery
                                                           .Skip(viewModel.Paginacao.Inicio)
                                                           .Take(viewModel.Paginacao.Limite)
                                                           .ToList();

                viewModel.Paginacao.TotalRegistros = proprietariosQuery.Count();
                List <dynamic> proprietariosJson = new List <dynamic>();

                foreach (Proprietario proprietario in proprietarios)
                {
                    List <dynamic> veiculosJson = new List <dynamic>();

                    foreach (Veiculo veiculo in proprietario.Veiculos)
                    {
                        veiculosJson.Add(new
                        {
                            idVeiculo = veiculo.IdVeiculo,
                            placa     = veiculo.Placa,
                            uf        = veiculo.Uf
                        });
                    }
                    proprietariosJson.Add(new
                    {
                        idProprietario   = proprietario.IdProprietario,
                        nomeProprietario = proprietario.NomeProprietario,
                        cpfProprietario  = proprietario.CpfProprietario,
                        dataNascimento   = proprietario.DataNascimento.ToString("dd/MM/yyyy"),
                        telefone         = proprietario.Telefone,
                        veiculos         = veiculosJson
                    });
                }

                return(Json(new
                {
                    proprietarios = proprietariosJson,
                    paginacao = viewModel.Paginacao.Json()
                }));
            }
        }
        public ActionResult Cadastradas(ProdutosCadastradosViewModel viewModel)
        {
            using (DbApplication db = new DbApplication())
            {
                IQueryable <Infracao> infracoesQuery = db
                                                       .Infracoes
                                                       .OndeDescricaoContem(viewModel.Descricao)
                                                       .Include(i => i.Agente)
                                                       .Include(i => i.Logradouro)
                                                       .Include(i => i.Veiculo)
                                                       .OrderBy(i => i.Descricao);
                ICollection <Infracao> infracoes = infracoesQuery
                                                   .Skip(viewModel.Paginacao.Inicio)
                                                   .Take(viewModel.Paginacao.Limite)
                                                   .ToList();

                viewModel.Paginacao.TotalRegistros = infracoesQuery.Count();

                List <dynamic> infracoesJson = new List <dynamic>();

                foreach (Infracao infracao in infracoes)
                {
                    infracoesJson.Add(new
                    {
                        nomeAgente      = infracao.Agente.NomeAgente,
                        matriculaAgente = infracao.Agente.Matricula,
                        cepLogradouro   = infracao.Logradouro.Cep,
                        idInfracao      = infracao.IdInfracao,
                        velocidade      = infracao.Velocidade,
                        descricao       = infracao.Descricao,
                        placaVeiculo    = infracao.Veiculo.Placa
                    });
                }

                return(Json(new
                {
                    infracoes = infracoesJson,
                    paginacao = viewModel.Paginacao.Json()
                }));
            }
        }
        public ActionResult RelatorioInfracoes(InfracoesCadastradasRelatorioViewModel viewModel)
        {
            if (!ModelState.IsValid)
            {
                return(this.ModelErrors());
            }

            RelatorioInfracoesViewModel relatorioInfracoes = new RelatorioInfracoesViewModel();

            using (DbApplication db = new DbApplication())
            {
                IQueryable <Infracao> infracoesQuery = db
                                                       .Infracoes
                                                       .Include(v => v.Veiculo)
                                                       .Include(a => a.Agente)
                                                       .Include(l => l.Logradouro)
                                                       .OndeDescricaoContem(viewModel.Descricao)
                                                       .OrderBy(a => a.IdInfracao);

                ICollection <Infracao> infracoes = infracoesQuery
                                                   .ToList();

                relatorioInfracoes.TotalInfracoes = infracoes.Count;

                relatorioInfracoes.Infracoes = new List <RelatorioInfracoesViewModel.Infracao>();

                foreach (Infracao infracao in infracoes)
                {
                    relatorioInfracoes.Infracoes.Add(new RelatorioInfracoesViewModel.Infracao
                    {
                        Descricao  = infracao.Descricao,
                        Velocidade = infracao.Velocidade,
                        Veiculo    = infracao.Veiculo.Placa,
                        Agente     = infracao.Agente.Matricula,
                        Logradouro = infracao.Logradouro.Cep
                    });
                }
                return(this.PdfView("~/Relatorios/Infracoes/RelatorioInfracoes.cshtml", relatorioInfracoes));
            }
        }
示例#28
0
        public ActionResult RelatorioVeiculos(VeiculosCadastradosRelatorioViewModel viewModel)
        {
            if (!ModelState.IsValid)
            {
                return(this.ModelErrors());
            }

            RelatorioVeiculosViewModel relatorioVeiculos = new RelatorioVeiculosViewModel();

            using (DbApplication db = new DbApplication())
            {
                IQueryable <Veiculo> veiculosQuery = db
                                                     .Veiculos
                                                     .Include(m => m.Modelo)
                                                     .Include(p => p.Proprietario)
                                                     .Include(i => i.Infracoes)
                                                     .OndePlacaContem(viewModel.Placa)
                                                     .OrderBy(a => a.IdVeiculo);

                ICollection <Veiculo> veiculos = veiculosQuery
                                                 .ToList();

                relatorioVeiculos.TotalVeiculos = veiculos.Count;

                relatorioVeiculos.Veiculos = new List <RelatorioVeiculosViewModel.Veiculo>();

                foreach (Veiculo veiculo in veiculos)
                {
                    relatorioVeiculos.Veiculos.Add(new RelatorioVeiculosViewModel.Veiculo
                    {
                        Placa        = veiculo.Placa,
                        Uf           = veiculo.Uf,
                        Infracao     = veiculo.IdInfracao == 0 ? 0 : (int)veiculo.IdInfracao,
                        Modelo       = veiculo.Modelo.Descricao,
                        Proprietario = veiculo.Proprietario.CpfProprietario
                    });
                }
                return(this.PdfView("~/Relatorios/Veiculos/RelatorioVeiculos.cshtml", relatorioVeiculos));
            }
        }
示例#29
0
        public ActionResult Cadastrados(LogradourosCadastradosViewModel viewModel)
        {
            using (DbApplication db = new DbApplication())
            {
                IQueryable <Logradouro> logradourosQuery = db
                                                           .Logradouros
                                                           .OndeCepContem(viewModel.Cep)
                                                           .OrderBy(l => l.Estado);

                ICollection <Logradouro> logradouros = logradourosQuery
                                                       .Skip(viewModel.Paginacao.Inicio)
                                                       .Take(viewModel.Paginacao.Limite)
                                                       .ToList();

                viewModel.Paginacao.TotalRegistros = logradourosQuery.Count();

                List <dynamic> logradourosJson = new List <dynamic>();

                foreach (Logradouro logradouro in logradouros)
                {
                    logradourosJson.Add(new
                    {
                        idLogradouro  = logradouro.IdLogradouro,
                        rua           = logradouro.Rua,
                        bairro        = logradouro.Bairro,
                        cidade        = logradouro.Cidade,
                        estado        = logradouro.Estado,
                        cep           = logradouro.Cep,
                        velocidadeMax = logradouro.VelocidadeMax
                    });
                }

                return(Json(new
                {
                    logradouros = logradourosJson,
                    paginacao = viewModel.Paginacao.Json()
                }));
            }
        }
示例#30
0
        public ActionResult RelatorioLogradouros(LogradourosCadastradosRelatorioViewModel viewModel)
        {
            if (!ModelState.IsValid)
            {
                return(this.ModelErrors());
            }

            RelatorioLogradourosViewModel relatorioLogradouros = new RelatorioLogradourosViewModel();

            using (DbApplication db = new DbApplication())
            {
                IQueryable <Logradouro> logradourosQuery = db
                                                           .Logradouros
                                                           .OndeCepContem(viewModel.Cep)
                                                           .OrderBy(a => a.IdLogradouro);

                ICollection <Logradouro> logradouros = logradourosQuery
                                                       .ToList();

                relatorioLogradouros.TotalLogradouros = logradouros.Count;

                relatorioLogradouros.Logradouros = new List <RelatorioLogradourosViewModel.Logradouro>();

                foreach (Logradouro logradouro in logradouros)
                {
                    relatorioLogradouros.Logradouros.Add(new RelatorioLogradourosViewModel.Logradouro
                    {
                        Rua           = logradouro.Rua,
                        Bairro        = logradouro.Bairro,
                        Cidade        = logradouro.Cidade,
                        Estado        = logradouro.Estado,
                        Cep           = logradouro.Cep,
                        VelocidadeMax = logradouro.VelocidadeMax
                    });
                }
                return(this.PdfView("~/Relatorios/Logradouros/RelatorioLogradouros.cshtml", relatorioLogradouros));
            }
        }