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