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."));
}
}
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"));
}
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));
}
}
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."));
}
}
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."));
}
}
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."));
}
}
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
}));
}
}
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."));
}
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."));
}
}
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."));
}
}
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."));
}
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."));
}
}
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."));
}
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."));
}
}
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()
}));
}
}
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."));
}
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()
}));
}
}
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()
}));
}
}
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));
}
}
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));
}
}
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()
}));
}
}
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));
}
}