Esempio n. 1
0
        public async Task <IActionResult> Edit(long id, [Bind("Id,IdUsuarioForeignKey,IdAcaoForeignKey,Quantidade,Tipo,ValorTotal")] AcaoUsuario acaoUsuario)
        {
            if (id != acaoUsuario.Id)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(acaoUsuario);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!AcaoUsuarioExists(acaoUsuario.Id))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            ViewData["IdAcaoForeignKey"]    = new SelectList(_context.Acao, "Id", "Nome", acaoUsuario.IdAcaoForeignKey);
            ViewData["IdUsuarioForeignKey"] = new SelectList(_context.Usuario, "Id", "Id", acaoUsuario.IdUsuarioForeignKey);
            return(View(acaoUsuario));
        }
        public async Task <IActionResult> Create([Bind("Id,IdUsuarioForeignKey,IdAcaoForeignKey,Quantidade")] AcaoUsuario acaoUsuario)
        {
            if (ModelState.IsValid)
            {
                var usuario    = _context.Usuario.First(u => u.Id == acaoUsuario.IdUsuarioForeignKey);
                var acao       = _context.Acao.First(a => a.Id == acaoUsuario.IdAcaoForeignKey);
                var valorTotal = acao.Preco * acaoUsuario.Quantidade;
                if (valorTotal > usuario.Saldo)
                {
                    //não pode realizar a compra
                    return(RedirectToAction(nameof(Index)));
                }
                else
                {
                    acaoUsuario.ValorTotal = valorTotal;
                    usuario.Saldo          = usuario.Saldo - valorTotal;
                }
                _context.Add(acaoUsuario);
                await _context.SaveChangesAsync();

                return(RedirectToAction(nameof(Index)));
            }
            ViewData["IdAcaoForeignKey"]    = new SelectList(_context.Acao, "Id", "Nome", acaoUsuario.IdAcaoForeignKey);
            ViewData["IdUsuarioForeignKey"] = new SelectList(_context.Usuario, "Id", "Nome", acaoUsuario.IdUsuarioForeignKey);
            return(View(acaoUsuario));
        }
Esempio n. 3
0
        public void Permitir(DadosFixos dadosFixos, AcaoUsuario enumerador, string tabela)
        {
            if (enumerador == AcaoUsuario.Incluir)
            {
                if (dadosFixos.Permissoes.Any(x => x.Tabela == tabela && x.Inc == "N"))
                {
                    throw new Exception(MensagensPadrao.UsuarioSemPermissao);
                }
            }

            if (enumerador == AcaoUsuario.Alterar)
            {
                if (dadosFixos.Permissoes.Any(x => x.Tabela == tabela && x.Alt == "N"))
                {
                    throw new Exception(MensagensPadrao.UsuarioSemPermissao);
                }
            }

            if (enumerador == AcaoUsuario.Excluir)
            {
                if (dadosFixos.Permissoes.Any(x => x.Tabela == tabela && x.Exc == "N"))
                {
                    throw new Exception(MensagensPadrao.UsuarioSemPermissao);
                }
            }

            if (enumerador == AcaoUsuario.Consultar)
            {
                if (dadosFixos.Permissoes.Any(x => x.Tabela == tabela && x.Con == "N"))
                {
                    throw new Exception(MensagensPadrao.UsuarioSemPermissao);
                }
            }
        }
        /// <summary>
        /// Obtém as notas de compra por usuário
        /// </summary>
        /// <param name="idUsuario">Id do usuário</param>
        /// <param name="datainicial">data inicial de pesquisa</param>
        /// <param name="dataFinal">data final da pesquisa</param>
        /// <param name="tokenCancelamento">O token de cancelamento para a operação assíncrona/param>
        /// <returns>Uma lista de notas de compras acrescida da ação do usuário</returns>
        public async Task <NotaDeCompraPaginaModel> ObterDadosAsync(long idUsuario, DateTime datainicial, DateTime dataFinal, CancellationToken tokenCancelamento = default)
        {
            UsuarioModel usuario = await usuarioServices.ObterAsync(idUsuario);

            AcaoUsuario acaoUsuario = usuario.Papel == "V" ? AcaoUsuario.Vistar : AcaoUsuario.Aprovar;

            List <NotaDeCompra> notaDeComprasTemp = await unitOfWork.NotaDeCompraRepositorio
                                                    .Todos(predicado : x => x.DataEmissao.Date >= datainicial &&
                                                           x.DataEmissao.Date <= dataFinal &&
                                                           x.ValorTotal >= usuario.ValorMinimo &&
                                                           x.ValorTotal <= usuario.ValorMaximo &&
                                                           x.Status == false,
                                                           carregamentoAntecipado : x => x.Include(v => v.HistoricoAprovacoes)
                                                           .ThenInclude(u => u.Usuario))
                                                    .ToListAsync(tokenCancelamento);

            List <NotaDeCompraModel> notaDeCompras = new List <NotaDeCompraModel>();

            notaDeComprasTemp.ForEach(x =>
            {
                if (!x.HistoricoAprovacoes.Any(h => h.Usuario.Id == idUsuario))
                {
                    StatusNotaDeCompra statusNotaDeCompra = ValidarStatusNotaDeCompra(x);
                    if (usuario.Papel == "V" && statusNotaDeCompra == StatusNotaDeCompra.Pendente)
                    {
                        notaDeCompras.Add(mapper.Map <NotaDeCompraModel>(x));
                    }
                    else if (usuario.Papel == "A" && statusNotaDeCompra == StatusNotaDeCompra.AguardandoAprovacao)
                    {
                        notaDeCompras.Add(mapper.Map <NotaDeCompraModel>(x));
                    }
                }
            });

            NotaDeCompraPaginaModel notaDeCompraPaginaModel = new NotaDeCompraPaginaModel
            {
                AcaoUsuario        = acaoUsuario,
                NotaDeCompraModels = notaDeCompras
            };

            return(notaDeCompraPaginaModel);
        }