public async Task <IActionResult> PutOpcao(int id, Opcao opcao) { if (id != opcao.OpcaoId) { return(BadRequest()); } _context.Entry(opcao).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!OpcaoExists(id)) { return(NotFound()); } else { throw; } } return(NoContent()); }
public async Task <ActionResult> Create([Bind(Include = "Id,Placa,Frota,Ano,DataAquisicao,FuncionarioId,CategoriaId")] Veiculo veiculo) { var placa = db.Veiculos.Where(v => v.Placa == veiculo.Placa).ToList(); var frota = db.Veiculos.Where(v => v.Frota == veiculo.Frota).ToList(); if (placa.Count > 0) { ModelState.AddModelError("Placa", "Placa já cadastrada!"); } if (frota.Count > 0) { ModelState.AddModelError("Frota", "Frota já cadastrada!"); } if (ModelState.IsValid) { db.Veiculos.Add(veiculo); await db.SaveChangesAsync(); return(RedirectToAction("Index")); } ViewBag.Categoria = new SelectList(db.Categorias, "Id", "Descricao", veiculo.CategoriaId); ViewBag.Funcionario = new SelectList(db.Funcionarios, "Id", "Nome", veiculo.FuncionarioId); return(View(veiculo)); }
public async Task <IActionResult> PutAdquirente(int id, Adquirente adquirente) { if (id != adquirente.Id) { return(BadRequest()); } _context.Entry(adquirente).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!AdquirenteExists(id)) { return(NotFound()); } else { throw; } } return(NoContent()); }
public async Task <ActionResult <MovimentoOpcao> > PutMovimentoOpcao(int id, MovimentoOpcao movimentoOpcao) { if (id != movimentoOpcao.MovimentoOpcaoId) { return(BadRequest()); } _context.Entry(movimentoOpcao).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!MovimentoOpcaoExists(id)) { return(NotFound()); } else { throw; } } return(movimentoOpcao); }
[Authorize(Roles = "Administrador")] // Somente administradores tem acesso a essa consulta public async Task <IActionResult> PutUsuario(long id, Usuario usuario) { usuario.IsAdministrador = true; usuario.IsAtivo = true; if (id != usuario.UsuarioId) { return(BadRequest()); } _context.Entry(usuario).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!UsuarioExists(id)) { return(NotFound()); } else { throw; } } return(NoContent()); }
public async Task <ActionResult <dash> > Putdash(int id, dash dash) { if (id != dash.dashId) { return(BadRequest()); } _context.Entry(dash).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!dashExists(id)) { return(NotFound()); } else { throw; } } return(dash); }
[Authorize(Roles = "Administrador")] // Somente administradores tem acesso a esse cadastro public async Task <ActionResult <Filme> > PostFilme(Filme filme) { _context.Filmes.Add(filme); await _context.SaveChangesAsync(); return(CreatedAtAction("GetFilme", new { id = filme.FilmeId }, filme)); }
public async Task <IActionResult> PutBandeira(int id, Bandeira bandeira) { if (id != bandeira.Id) { return(BadRequest()); } _context.Entry(bandeira).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!BandeiraExists(id)) { return(NotFound()); } else { throw; } } return(NoContent()); }
public async Task <IHttpActionResult> PutPropostaSubmetida(int id, PropostaSubmetida propostaSubmetida) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } if (id != propostaSubmetida.id_proposta_submetida) { return(BadRequest()); } db.Entry(propostaSubmetida).State = EntityState.Modified; try { await db.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!PropostaSubmetidaExists(id)) { return(NotFound()); } else { throw; } } return(StatusCode(HttpStatusCode.NoContent)); }
public async Task <IActionResult> PutTarjetaCredito(int id, TarjetaCredito tarjetaCredito) { if (id != tarjetaCredito.Id) { return(BadRequest()); } _context.Entry(tarjetaCredito).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!TarjetaCreditoExists(id)) { return(NotFound()); } else { throw; } } return(NoContent()); }
public async Task <IHttpActionResult> PutUsuario(int id, Usuario usuario) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } if (id != usuario.idUsuario) { return(BadRequest()); } db.Entry(usuario).State = EntityState.Modified; try { await db.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!UsuarioExists(id)) { return(NotFound()); } else { throw; } } return(StatusCode(HttpStatusCode.NoContent)); }
public async Task <IHttpActionResult> PutMessenger(int id, Messenger messenger) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } if (id != messenger.id_messsenger) { return(BadRequest()); } db.Entry(messenger).State = EntityState.Modified; try { await db.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!MessengerExists(id)) { return(NotFound()); } else { throw; } } return(StatusCode(HttpStatusCode.NoContent)); }
public async Task <ActionResult <Serie> > PutSerie(int id, Serie serie) { if (id != serie.SerieId) { return(BadRequest()); } _context.Entry(serie).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!SerieExists(id)) { return(NotFound()); } else { throw; } } return(serie); }
public async Task <IActionResult> PutTransacoes(int id, Transacoes transacoes) { if (id != transacoes.ID) { return(BadRequest()); } _context.Entry(transacoes).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!TransacoesExists(id)) { return(NotFound()); } else { throw; } } return(NoContent()); }
public async Task <IActionResult> Create([Bind("Nome,Data_de_Nascimento,Sexo,Id")] Aluno aluno) { if (ModelState.IsValid) { _context.Add(aluno); await _context.SaveChangesAsync(); return(RedirectToAction(nameof(Index))); } return(View(aluno)); }
public async Task <IActionResult> Create([Bind("Id,Codigo,Descricao")] Bandeira bandeira) { if (ModelState.IsValid) { _context.Add(bandeira); await _context.SaveChangesAsync(); return(RedirectToAction(nameof(Index))); } return(View(bandeira)); }
public async Task <IActionResult> Create([Bind("ProdutoID,Nome,Preco")] Produto produto) { if (ModelState.IsValid) { _context.Add(produto); await _context.SaveChangesAsync(); return(RedirectToAction(nameof(Index))); } return(View(produto)); }
public async Task <IActionResult> Create([Bind("Id,Description,Quantity,Points,Period,SelectedVerificationType")] CreateActivityRequests createActivityRequests) { if (ModelState.IsValid) { createActivityRequests.Id = Guid.NewGuid(); _context.Add(createActivityRequests); await _context.SaveChangesAsync(); return(RedirectToAction(nameof(Index))); } return(View(createActivityRequests)); }
public async Task Update(TEntity e) { try { _db.Set <TEntity>().Update(e); await _db.SaveChangesAsync(); } catch (Exception ex) { ex.InnerException.ToString(); } }
public async Task <ActionResult> Create([Bind(Include = "Id,Nome")] Funcionario funcionario) { if (ModelState.IsValid) { db.Funcionarios.Add(funcionario); await db.SaveChangesAsync(); return(RedirectToAction("Index")); } return(View(funcionario)); }
public async Task <ActionResult> Create([Bind(Include = "Id,Descricao")] Categoria categoria) { if (ModelState.IsValid) { db.Categorias.Add(categoria); await db.SaveChangesAsync(); return(RedirectToAction("Index")); } return(View(categoria)); }
public async Task <IActionResult> Create([Bind("ID,AdquirenteId,CodigoCliente,DataTransacao,HoraTransacao,NumeroCartao,CodigoAutorizacao,NSU,BandeiraId,ValorBruto,TaxaAdmin,ValorLiquido")] Transacoes transacoes) { if (ModelState.IsValid) { _context.Add(transacoes); await _context.SaveChangesAsync(); return(RedirectToAction(nameof(Index))); } ViewData["AdquirenteId"] = new SelectList(_context.Set <Adquirente>(), "Id", "Id", transacoes.AdquirenteId); ViewData["BandeiraId"] = new SelectList(_context.Set <Bandeira>(), "Id", "Id", transacoes.BandeiraId); return(View(transacoes)); }
public async Task <bool> Criar(CriarTransferenciaCommand command) { DadosTransacao pagador = new DadosTransacao(command.Pagador.Nome, command.Pagador.Banco, command.Pagador.Agencia, command.Pagador.Conta); DadosTransacao beneficiario = new DadosTransacao(command.Beneficiario.Nome, command.Beneficiario.Banco, command.Beneficiario.Agencia, command.Beneficiario.Conta); Transferencia nova = new Transferencia(command.UsuarioId, pagador, beneficiario, command.Valor); await _context.Transferencias.AddAsync(nova); var registros = await _context.SaveChangesAsync(); return(registros > 0); }
public async Task<bool> sincronizarAcoes () { //var ativos = new List<string> { "PETR4","" }; var ativos = _context.acao.Select (c => c.Codigo + c.Numero).ToList (); foreach (var ativo in ativos) { var valorAcao = await _acaoService.pegarValorAcao (ativo); var update = _context.acao.Where (c => (c.Codigo + c.Numero) == ativo).FirstOrDefault (); if (update != null) { update.ValorCompra = valorAcao; _context.Entry (update).State = EntityState.Modified; await _context.SaveChangesAsync (); } } return true; }
public async Task <ActionResult <MovimentoOpcao> > Postexercicio(Exercicio exercicio) { var movimentoOpcao = _context.movimentoOpcao.Find(exercicio.MovimentoOpcaoId); var movimentoAcao = _context.movimentoAcao.Find(movimentoOpcao.MovimentoAcaoId); movimentoOpcao.finalizado = true; movimentoOpcao.exerceu = exercicio.Exerceu ? true : false; _context.Entry(movimentoOpcao).State = EntityState.Modified; if (exercicio.Exerceu) { movimentoAcao.ValorVenda = movimentoOpcao.Opcao.ValorStrike; int mesVencimento = movimentoOpcao.Opcao.serie.Mes; var dataInicial = new DateTime(DateTime.Now.Year, mesVencimento, 1); var contadorSegunda = dataInicial.DayOfWeek == DayOfWeek.Monday ? 1 : 0; for (var x = 1; x <= DateTime.DaysInMonth(DateTime.Now.Year, mesVencimento); x++) { if (dataInicial.AddDays(x).DayOfWeek == DayOfWeek.Monday && contadorSegunda < 3) { contadorSegunda++; } if (contadorSegunda == 3) { movimentoAcao.DataVenda = dataInicial.AddDays(x); break; } } movimentoAcao.Vendido = true; _context.Entry(movimentoAcao).State = EntityState.Modified; } // _context.exercicio.Add(exercicio); await _context.SaveChangesAsync(); return(movimentoOpcao); //return CreatedAtAction ("Getexercicio", new { id = exercicio.exercicioId }, exercicio); }
public async Task <SALDO> EditSaldo(string id, int qnt) { var saldo = await GetSaldo(id); saldo.SaldoAtual += qnt; await _context.SaveChangesAsync(); return(saldo); }
public async Task <IActionResult> Cadastro(Produto produto) { if (produto.Id == 0) { _db.Produtos.Add(produto); TempData["AlertaTipo"] = "success"; TempData["AlertaMsg"] = "Cadastro realizado com sucesso!"; } else { _db.Produtos.Update(produto); TempData["AlertaTipo"] = "success"; TempData["AlertaMsg"] = "Cadastro alterado com sucesso!"; } await _db.SaveChangesAsync(); return(RedirectToAction("Index")); }
public async Task <IActionResult> PutUsuario(long id, Usuario usuario) { var usuarioId = Convert.ToInt64(User.FindFirst(ClaimTypes.NameIdentifier)?.Value); // Usuário só deve poder editar ele mesmo if (usuarioId == id) { usuario.IsAdministrador = false; usuario.IsAtivo = true; if (id != usuario.UsuarioId) { return(BadRequest()); } _context.Entry(usuario).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!UsuarioExists(id)) { return(NotFound()); } else { throw; } } return(NoContent()); } return(NoContent()); }
public async Task <IActionResult> Create(Fatura fatura) { if (fatura.Data_Emissao > fatura.Data_Vencimento) { ViewBag.Erro = "Data de emissão não pode ser posterior a data de vencimento."; ViewBag.Clientes = new SelectList(_context.Clientes.Where(x => x.Visivel).ToList(), "Cod_Cliente", "Nome"); return(View()); } await _context.AddAsync(fatura); int result = await _context.SaveChangesAsync(); if (result > 0)//caso tudo OK { return(RedirectToAction(nameof(Index))); } ViewBag.Erro = "Ocorreu um erro !"; ViewBag.Clientes = new SelectList(_context.Clientes.Where(x => x.Visivel).ToList(), "Cod_Cliente", "Nome", fatura.Cod_Cliente); return(View()); }
public async Task AddConnectionId(Usuario usuario) { var connectionIdCorrente = Context.ConnectionId; var usuarioDb = _banco.Usuarios.Find(usuario.Id); List <string> lista = null; if (usuarioDb.ConnectionId != null && usuarioDb.ConnectionId.Length > 0) { lista = new List <string>(); lista = JsonConvert.DeserializeObject <List <string> >(usuarioDb.ConnectionId); if (!lista.Contains(connectionIdCorrente)) { lista.Add(connectionIdCorrente); } usuarioDb.IsOnLine = true; } else { lista = new List <string>(); lista.Add(connectionIdCorrente); } usuarioDb.ConnectionId = JsonConvert.SerializeObject(lista); _banco.Usuarios.Update(usuarioDb); await _banco.SaveChangesAsync(); //TODO Adicionar ao grupo de conversa dos usuarios var grupos = _banco.Grupos.Where(x => x.Usuarios.Contains(usuarioDb.Email)); foreach (var connectionId in lista) { foreach (var grupo in grupos) { await Groups.AddToGroupAsync(connectionId, grupo.Nome); } } await NotificarMudancaNaListaDeUsuario(); }