public async Task <IActionResult> Put(int estacionamentoId, Estacionamento estacionamento)
{
try
{
var estacionamentoCadastrado = await _repositorio.GetEstacionamentoAsyncById(estacionamentoId, true, true);
if (estacionamentoCadastrado == null)
{
return(NotFound());
}
CalculoValorTotalEstacionamentoServico calcular = new CalculoValorTotalEstacionamentoServico();
estacionamento.ValorTotal = calcular.CalculoValorTotal(estacionamento);
_repositorio.Update(estacionamento);
if (await _repositorio.SaveChangesAsync())
{
return(Ok(estacionamento));
}
}
catch (Exception ex)
{
return(BadRequest($"Erro ao editar Estacionamento: {ex.Message}"));
}
return(BadRequest());
}
public void Atualizar(EstacionamentoTO to)
{
_Contexto = ControladorAcesso.ObterContexto();
if (to.Identificador == 0 || to == null)
{
to.Valido = false;
to.Mensagem = Mensagem.Atualizacao("Estacionamento", false);
return;
}
Estacionamento entidade = _Contexto.Estacionamento.FirstOrDefault(x => x.Identificador == to.Identificador);
if (entidade == null)
{
to.Valido = false;
to.Mensagem = Mensagem.Obter("Estacionamento", false);
return;
}
to.PreencherEntidade(entidade);
_Contexto.SaveChanges();
to.PreencherTO(entidade);
to.Valido = true;
to.Mensagem = Mensagem.Atualizacao("Estacionamento", true);
return;
}
public ActionResult Semanal(FormCollection formCollection)
{
DateTime data = DateTime.Parse(formCollection["dataRelatorio"]);
bool incluiEstacionados = MakeBoolean(formCollection["incluiEstacionado"]);
int estacionamentoID = 1;
EstacionamentoDAO estacionamentoDAO = new EstacionamentoDAO(conn);
Estacionamento est = estacionamentoDAO.BuscarItem("vagas", estacionamentoID);
if (est != null)
{
Semana semana = new Semana(data, DayOfWeek.Sunday);
Relatorio relatorio = new Relatorio(semana, est);
RegistroDAO registroDAO = new RegistroDAO(conn);
relatorio.Registros = registroDAO.GeraRelatorio(relatorio);
relatorio.View = GerarDadosRelatorio(relatorio);
relatorio.VeiculosFrequentes = (List <Veiculo>)relatorio.Registros.GroupBy(x => x.Veiculo.Placa).Where(x => x.Count() > 1).Select(x => x.FirstOrDefault().Veiculo).ToList();
ViewData.Model = relatorio;
return(View());
}
return(RedirectToAction("Index", "Gerencia"));
}
public IActionResult Salvar(EstacionamentoDTO estacionamentoDTO)
{
if (!ModelState.IsValid)
{
return(View("../Estacionamento/MarcarEntrada"));
}
var placa = estacionamentoDTO.Placa.ToUpper();
var veiculo = _estacionamentoRepository.getVeiculoPelaPlaca(placa);
if (veiculo == null)
{
Veiculo novoVeiculo = new Veiculo();
novoVeiculo.Placa = placa;
_estacionamentoRepository.SalvarVeiculo(novoVeiculo);
veiculo = _estacionamentoRepository.getVeiculoPelaPlaca(placa);
}
Estacionamento estacionamento = new Estacionamento();
estacionamento.Veiculo = veiculo;
estacionamento.HoraChegada = DateTime.Now;
_estacionamentoRepository.SalvarVeiculoNoEstacionamento(estacionamento);
return(RedirectToAction("Index", "Home"));
}
public static IEnumerable <string> ValidarParaSair(EstacionamentoSaidaRequest request, IQueryable <Estacionamento> estacionamento)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
if (request.Id == 0)
{
yield return(Mensagem.ParametroObrigatorio.Formatar(Termo.Id));
}
if (string.IsNullOrWhiteSpace(request.HorarioSaida))
{
yield return(Mensagem.ParametroObrigatorio.Formatar(Termo.HorarioSaida));
}
else if (!DateTime.TryParse(request.HorarioSaida, out _))
{
yield return(Mensagem.ParametroInvalido.Formatar(Termo.HorarioSaida));
}
Estacionamento model = estacionamento.FirstOrDefault(e => e.Id == request.Id);
if (model == null)
{
yield return(Mensagem.EntidadeNaoEncontrada.Formatar(Termo.Placa));
}
else if (DateTime.Compare(model.HorarioChegada, DateTime.Now) > 0)
{
yield return(Mensagem.HorarioChegadaMaiorQueHorarioSaida.Formatar(Termo.HorarioChegada, Termo.HorarioSaida));
}
}
public IActionResult UpdateEstacionamento(Guid id, [FromBody] Estacionamento estacionamento)
{
try
{
if (estacionamento.IsObjectNull())
{
return(BadRequest(ESTACIONAMENTO_NULL_OBJECT));
}
if (!ModelState.IsValid)
{
return(BadRequest(ESTACIONAMENTO_INVALID_OBJECT));
}
var dbEstacionamento = _repoWrapper.Estacionamento.GetEstacionamentoById(id);
if (dbEstacionamento.IsEmptyObject())
{
return(NotFound());
}
_repoWrapper.Estacionamento.UpdateEstacionamento(dbEstacionamento, estacionamento);
return(NoContent());
}
catch (Exception ex)
{
return(StatusCode(500, INTERNAL_SERVER_MESSAGE + ex.Message));
}
}
public IActionResult Edit(long id)
{
Estacionamento estacionamento = this.db.Estacionamentos
.Include(m => m.Cupom)
.Where(x => x.Id == id)
.FirstOrDefault();
if (estacionamento == null)
{
return(NotFound());
}
EstacionamentoVM vm = new EstacionamentoVM();
vm.Nome = estacionamento.Nome;
vm.Descricao = estacionamento.Descricao;
var cupons = db.Cupons.ToList();
foreach (var cupon in cupons)
{
vm.Cupons.Add(new SelectListItem
{
Value = cupon.Id.ToString(),
Text = cupon.Nome
});
}
return(View(vm));
}
public void Update(Estacionamento est)
{
var vagaOriginal = context.Estacionamentos.Find(est.EstacionamentoId);
vagaOriginal = est;
context.SaveChanges();
}
public IActionResult Create(EstacionamentoVM vm)
{
if (ModelState.IsValid)
{
Estacionamento estacionamento = new Estacionamento();
estacionamento.Nome = vm.Nome;
estacionamento.Descricao = vm.Descricao;
estacionamento.CaminhoImagem = this.UploadImagem(vm.Imagem);
estacionamento.Cupom = db.Cupons.Find(vm.IdCursoSelecionado);
this.db.Estacionamentos.Add(estacionamento);
this.db.SaveChanges();
return(RedirectToAction("Index"));
}
var cupons = db.Cupons.ToList();
foreach (var cupon in cupons)
{
vm.Cupons.Add(new SelectListItem
{
Value = cupon.Id.ToString(),
Text = cupon.Nome
});
}
return(View(vm));
}
public static void Map(this Estacionamento dbEstacionamento, Estacionamento estacionamento)
{
dbEstacionamento.Nome = estacionamento.Nome;
dbEstacionamento.Telefone = estacionamento.Telefone;
dbEstacionamento.TotalVagasCarro = estacionamento.TotalVagasCarro;
dbEstacionamento.TotalVagasMoto = estacionamento.TotalVagasMoto;
}
public async Task <IActionResult> Post(Estacionamento estacionamento)
{
try
{
var vigenciaCadastrada = await _repositorio.GetPrecoByVigencia(estacionamento.DataEntrada);
if (vigenciaCadastrada == null)
{
return(BadRequest("Uma Vigencia deve ser cadastrada!"));
}
estacionamento.PrecoId = vigenciaCadastrada.Id;
_repositorio.Add(estacionamento);
if (await _repositorio.SaveChangesAsync())
{
return(Ok(estacionamento));
}
}
catch (Exception ex)
{
return(BadRequest($"Erro: {ex.Message}"));
}
return(BadRequest());
}
public async Task <IActionResult> PutEstacionamento([FromRoute] int id, [FromBody] Estacionamento estacionamento)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != estacionamento.EstacionamentoID)
{
return(BadRequest());
}
_context.Entry(estacionamento).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!EstacionamentoExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public MainPage()
{
this.InitializeComponent();
EstacionamentoSuperior = new Estacionamento(80, 50, 300);
EstacionamentoInferior = new Estacionamento(40, 30, 200);
Monitor mSup = new Monitor {
Estacionamento = EstacionamentoSuperior, Descricao = "Monitor da Entrada Superior"
};
Monitor mInf = new Monitor {
Estacionamento = EstacionamentoInferior, Descricao = "Monitor da Entrada Inferior"
};
MonitorGeral mGeral = new MonitorGeral();
mGeral.Estacionamentos.Add(EstacionamentoSuperior);
mGeral.Estacionamentos.Add(EstacionamentoInferior);
EstacionamentoSuperior.Anexar(mSup);
EstacionamentoInferior.Anexar(mInf);
EstacionamentoSuperior.Anexar(mGeral);
EstacionamentoInferior.Anexar(mGeral);
Debug.WriteLine("===========================================================");
Debug.WriteLine("Iniciando os Estacionamentos");
Debug.WriteLine("Estacionamento Superior:");
Debug.WriteLine(EstacionamentoSuperior);
Debug.WriteLine("Estacionamento Inferior:");
Debug.WriteLine(EstacionamentoInferior);
Debug.WriteLine("===========================================================");
}
static void Main(string[] args)
{
/* Um estacionamento deseja controlar a entrada de carros no estacionamento.
* - Deve ser registrado o modelo do carro, a placa, a hora de entrada e a hora de saída.
* - A placa deve ser a chave de pesquisa para o carro.
* - Quando registrar a entrada do carro a hora de saída ficará nula;
* - Quando o veículo sair do estacionamento, deve ser alterado a hora de saída;
*
* - Listar todos os registros onde não ocorreu a saída;
* - Listar todos os registros;
* - Listar um registro pesquisando pela placa.
*
* Criar a classe com os métodos de entrada, saída do estacionamento e listagem em um projeto
* e a aplicação para cadastrar os carros entrando no estacionamento em outro projeto. */
Estacionamento metodo = new Estacionamento();
metodo.EntradaCarro();
metodo.SaidaCarro();
metodo.ListarCarros();
metodo.ListarCarrosEstacionados();
Console.ReadKey();
}
public Cancela()
{
vaga = new Estacionamento();
bcg = new BarCodeGeneratorTM();
estacionamento = new InteracaoEstacionamentoComCFG();
clock = new GeradorDeDataTM();
}
public async Task <IActionResult> Put(int estacionamentoId, Estacionamento estacionamento)
{
try
{
var estacionamentoCadastrado = await _repositorio.GetEstacionamentoAsyncById(estacionamentoId);
if (estacionamentoCadastrado == null)
{
return(NotFound());
}
estacionamento.DataSaida = DateTime.Now;
estacionamento.ValorTotal = this._calculoServico.CalcularValor(estacionamentoCadastrado);
_repositorio.Update(estacionamento);
if (await _repositorio.SaveChangesAsync())
{
return(Ok(estacionamento));
}
}
catch (Exception ex)
{
return(BadRequest($"Erro: {ex.Message}"));
}
return(BadRequest());
}
public IActionResult Retirar(int id)
{
var email = User.Identity.Name;
if (email != null)
{
Estacionar estacionado = _estacionarDAO.BuscarPorId(id);
int entrada = estacionado.CriadoEm.Hour;
int saida = DateTime.Now.Hour;
int tempo = saida - entrada;
int est = estacionado.EstacionamentoId;
Estacionamento estacionamento = _estacionamentoDAO.BuscarPorId(est);
double valor = estacionamento.Preco;
if (tempo <= 1)
{
ViewBag.Preco = valor;
return(View(estacionado));
}
else if (tempo > 1 && tempo <= 5)
{
ViewBag.Preco = valor * 2;
return(View(estacionado));
}
else if (tempo > 5)
{
ViewBag.Preco = valor * 4;
}
ViewBag.Preco = valor;
return(View(estacionado));
}
return(RedirectToAction("Login", "Usuario"));
}
public double CalculoValorTotal(Estacionamento estacionamento)
{
quantidadeHoras = estacionamento.Saida.Hour - estacionamento.Entrada.Hour;
//umaHora = quantidadeHoras - 1;
quantidadeMinutos = estacionamento.Saida.Minute - estacionamento.Entrada.Minute;
valorHora = estacionamento.TabelaPreco.ValorHora;
meiaHora = valorHora / 2;
if (quantidadeHoras == 0 && quantidadeMinutos < 31)
{
return(meiaHora);
}
else
if (quantidadeHoras == 1)
{
return(estacionamento.TabelaPreco.ValorHora);
}
else
{
if (quantidadeMinutos > 10)
{
return(valorHora + ((quantidadeHoras - 1) * meiaHora) + meiaHora);
}
return(valorHora + ((quantidadeHoras - 1) * meiaHora));
}
}
public async Task <ResponseViewModel <List <Solicitantes> > > GetSolicitacoesEmAberto(string idUsuario)
{
try
{
int valor = int.Parse(idUsuario);
List <Solicitantes> solicitacao = new List <Solicitantes>();
solicitacao = await db.Solicitacoes.Include("Cliente").Include("Estacionamento").Include("Estacionamento.Proprietario")
.Where(x => x.Estacionamento.IdPessoa.Equals(valor) && x.Status.Equals(2))
.Select(cl => new Solicitantes
{
InsereAlerta = !cl.Estacionamento.TemEstacionamento,
Nickname = cl.Estacionamento.Proprietario.Nome,
NomeCliente = cl.Cliente.Nome,
IdCliente = cl.IdCliente,
IdSolicitacao = cl.Id,
Status = cl.Status,
PeriodoDe = null,
PeriodoAte = null
}).ToListAsync();
foreach (var item in solicitacao)
{
Carro carro = CarroCliente(item.IdCliente);
item.Carro = carro.Modelo;
item.PlacaCarro = carro.Placa;
}
if (solicitacao.Count == 0)
{
Estacionamento estacionamento = db.Estacionamentos.Include("Proprietario").FirstOrDefault(x => x.IdPessoa == valor);
Solicitantes solicitantes = new Solicitantes
{
InsereAlerta = !estacionamento.TemEstacionamento,
Nickname = estacionamento.Proprietario.Nome
};
solicitacao.Add(solicitantes);
}
ResponseViewModel <List <Solicitantes> > response = new ResponseViewModel <List <Solicitantes> >
{
Data = solicitacao,
Mensagem = "Dados retornados com sucesso!",
Serializado = true,
Sucesso = true
};
return(response);
}
catch (Exception e)
{
return(new ResponseViewModel <List <Solicitantes> >()
{
Data = null,
Serializado = true,
Sucesso = false,
Mensagem = "Não foi possivel atender a sua solicitação: " + e.Message
});
}
}
public ActionResult Endereco()
{
EnderecoEstacionamento enderecoEstacionamento = new EnderecoEstacionamento();
List <Solicitantes> solicitacoes = new List <Solicitantes>();
List <Solicitantes> solicitacoes2 = new List <Solicitantes>();
ViewBag.Status = "";
ViewBag.Cidade = Helpers.GetSelectList("Cidades") as SelectList;
ViewBag.Estado = Helpers.GetSelectList("Estados") as SelectList;
Estacionamento retorno = new Estacionamento();
var task = Task.Run(async() => {
using (BaseController <Estacionamento> bUsuario = new BaseController <Estacionamento>())
{
var valorRetorno = await bUsuario.GetObjectAsyncWithToken("Estacionamentos/EstacionamentoPorPessoa?IdPessoa=" + GetIdPessoa(), await GetToken());
retorno = valorRetorno.Data;
}
using (BaseController <List <Solicitantes> > bUsuario = new BaseController <List <Solicitantes> >())
{
var valorRetorno = await bUsuario.GetObjectAsyncWithToken("Solicitacao/GetSolicitacoesEmAberto?idUsuario=" + GetIdPessoa(), await GetToken());
solicitacoes = valorRetorno.Data;
}
using (BaseController <List <Solicitantes> > bUsuario = new BaseController <List <Solicitantes> >())
{
var valorRetorno = await bUsuario.GetObjectAsyncWithToken("Solicitacao/GetSolicitacoesParaFinalizar?idUsuario=" + GetIdPessoa(), await GetToken());
solicitacoes2 = valorRetorno.Data;
}
});
task.Wait();
if (retorno.IdEnderecoEstabelecimento > 0)
{
enderecoEstacionamento = new EnderecoEstacionamento
{
Bairro = retorno.EnderecoEstacionamento.Bairro,
CEP = retorno.EnderecoEstacionamento.CEP,
Complemento = retorno.EnderecoEstacionamento.Complemento,
IdCidade = retorno.EnderecoEstacionamento.IdCidade,
IdEstado = retorno.EnderecoEstacionamento.IdEstado,
Numero = retorno.EnderecoEstacionamento.Numero,
Rua = retorno.EnderecoEstacionamento.Rua
};
ViewBag.Status = "Atualizar";
}
else
{
ViewBag.Status = "Cadastrar";
}
ViewBag.Cadastrar = "Você precisa cadastrar um endereco para seu estacionamento. clique aqui.";
ViewBag.Nickname = retorno.Proprietario.Nome;
ViewBag.InsereAlerta = !retorno.TemEstacionamento;
ViewBag.InsereAlerta2 = solicitacoes.Count > 0 && solicitacoes.First().NomeCliente != null ? true : false;
ViewBag.InsereAlerta3 = solicitacoes2.Count > 0 && solicitacoes2.First().NomeCliente != null ? true : false;
ViewBag.Level = 1;
return(View(enderecoEstacionamento));
}
public ActionResult DeleteConfirmed(int id)
{
Estacionamento estacionamento = db.Estacionamento.Find(id);
db.Estacionamento.Remove(estacionamento);
db.SaveChanges();
return(RedirectToAction("Index"));
}
static void EntradaID(Estacionamento cr)
{
Console.WriteLine("Digite o ID do veículo:");
int.TryParse(Console.ReadLine(), out int id);
cr.Entrada(id);
Console.WriteLine("Operação realizada com sucesso\n");
Console.WriteLine("Pressione ENTER para voltar ao menu principal");
Console.ReadLine();
}
private static void Gravar()
{
Estacionamento e = new Estacionamento();
using (var repo = new SistemaEstacionamentosContext())
{
repo.Estacionamentos.Add(e);
repo.SaveChanges();
}
}
public void nLiberaTicket(Estacionamento vaga)
{
var vagaOriginal = context.Estacionamentos.Find(vaga.EstacionamentoId);
if (vagaOriginal != null)
{
vagaOriginal.Liberado = false;
context.SaveChanges();
}
}
public void liberacaoEspecial(Estacionamento vaga, string motivo)
{
var vagaOriginal = context.Estacionamentos.Find(vaga.EstacionamentoId);
if (vagaOriginal != null)
{
vagaOriginal.liberacao_especial = motivo;
context.SaveChanges();
}
}
public void modificarValorAPagar(Estacionamento vaga, double valor)
{
var vagaOriginal = context.Estacionamentos.Find(vaga.EstacionamentoId);
if (vagaOriginal != null)
{
vagaOriginal.valor_pago = valor;
context.SaveChanges();
}
}
public void mudarHoraDeSaida(Estacionamento vaga, DateTime saida)
{
var vagaOriginal = context.Estacionamentos.Find(vaga.EstacionamentoId);
if (vagaOriginal != null)
{
vagaOriginal.dt_hr_saida = saida;
context.SaveChanges();
}
}
public void emitidoPor(Estacionamento vaga, string emissor)
{
var vagaOriginal = context.Estacionamentos.Find(vaga.EstacionamentoId);
if (vagaOriginal != null)
{
vagaOriginal.emitido_por = emissor;
context.SaveChanges();
}
}
public void AddTest()
{
Estacionamento esTest = new Estacionamento {
ticket = bcg.generateCode(), dt_hr_entrada = DateTime.Parse(tm.now(), new CultureInfo("en-US")), emitido_por = "teste", valor_pago = 0.0, liberacao_especial = "teste"
};
var logica = estdao.Add(esTest);
Console.WriteLine(logica);
Console.WriteLine(intercfg.getVagasDisponiveis());
//Assert.Fail();
}
public IActionResult Delete(long id, Estacionamento estacionamento)
{
Estacionamento estacionamentoDb = this.db.Estacionamentos
.Include(m => m.Cupom)
.Where(x => x.Id == id)
.FirstOrDefault();
db.Estacionamentos.Remove(estacionamentoDb);
db.SaveChanges();
return(RedirectToAction("Index"));
}
