Esempio n. 1
0
        public List <TEntidade> Filtrar(
            List <ExpressaoDeConsulta <TEntidade> > expressoesDeConsulta,
            Func <IQueryable <TEntidade>, IIncludableQueryable <TEntidade, object> > expressaoDeInclusao,
            List <ExpressaoDeOrdenacao <TEntidade> > expressoesDeOrdenacao,
            string propriedadeDeOrdenacao,
            TipoOrdem ordem,
            int pagina,
            int itensPorPagina)
        {
            var retorno = Set().AsQueryable();

            if (expressoesDeConsulta != null && expressoesDeConsulta.Count > 0 && expressoesDeConsulta.Count(x => x.Consultar == true) > 0)
            {
                foreach (var expressaoDeConsulta in expressoesDeConsulta.Where(x => x.Consultar == true))
                {
                    retorno = retorno.Where(expressaoDeConsulta.Expressao);
                }
            }

            if (expressaoDeInclusao != null)
            {
                retorno = expressaoDeInclusao(retorno);
            }

            if (expressoesDeOrdenacao != null && expressoesDeOrdenacao.Count > 0 && expressoesDeOrdenacao.Count(x => x.Ordenar == true) > 0)
            {
                var primeiraExpressaoDeOrdenacaoValida = expressoesDeOrdenacao.First(x => x.Ordenar == true).Expressoes;
                retorno = ordem == TipoOrdem.Decrescente
                    ? retorno.OrderByDescending(primeiraExpressaoDeOrdenacaoValida[0])
                    : retorno.OrderBy(primeiraExpressaoDeOrdenacaoValida[0]);
                if (primeiraExpressaoDeOrdenacaoValida.Count > 1)
                {
                    for (int i = 1; i < primeiraExpressaoDeOrdenacaoValida.Count; i++)
                    {
                        retorno = ordem == TipoOrdem.Decrescente
                            ? (retorno as IOrderedQueryable <TEntidade>).ThenByDescending(primeiraExpressaoDeOrdenacaoValida[i])
                            : (retorno as IOrderedQueryable <TEntidade>).ThenBy(primeiraExpressaoDeOrdenacaoValida[i]);
                    }
                }
            }
            else if (!string.IsNullOrEmpty(propriedadeDeOrdenacao))
            {
                ParameterExpression paramterExpression = Expression.Parameter(typeof(TEntidade));
                Expression          orderByProperty    = Expression.Property(paramterExpression, propriedadeDeOrdenacao);
                LambdaExpression    lambda             = Expression.Lambda(orderByProperty, paramterExpression);
                MethodInfo          genericMethod      = ordem == TipoOrdem.Decrescente
                    ? OrderByDescendingMethod.MakeGenericMethod(typeof(TEntidade), orderByProperty.Type)
                    : OrderByMethod.MakeGenericMethod(typeof(TEntidade), orderByProperty.Type);
                object retornoOrdenado = genericMethod.Invoke(null, new object[] { retorno, lambda });
                retorno = (IQueryable <TEntidade>)retornoOrdenado;
            }

            if (pagina > 0 && itensPorPagina > 0)
            {
                var skip = (pagina - 1) * itensPorPagina;
                retorno = retorno.Skip(skip).Take(itensPorPagina);
            }

            return(retorno.ToList());
        }
Esempio n. 2
0
        static void Main(string[] args)
        {
            //Console.Write("Digite o código do ativo: ");
            string codigoNegociacao = "PETR4";
            string descricaoAtivo   = "Petroleo Brasileiro SA";
            string cnpj             = "33.000.167/0001-01";

            Ativo pret4 = new Ativo(codigoNegociacao, descricaoAtivo, cnpj);

            DateTime  data   = DateTime.Now;
            TipoOrdem compra = TipoOrdem.Compra;
            TipoOrdem venda  = TipoOrdem.Venda;

            int    quantidade = 100;
            double precoTotal = 2000.00;

            Ordem ordem1 = new Ordem(data, compra, pret4, quantidade, precoTotal);
            Ordem ordem2 = new Ordem(data, venda, pret4, quantidade, precoTotal);
            Ordem ordem3 = new Ordem(data, venda, pret4, quantidade, precoTotal);
            Ordem ordem4 = new Ordem(data, compra, pret4, quantidade, precoTotal);

            Posicao posicao = new Posicao(pret4);

            posicao.AdicionarOrdem(ordem1);
            posicao.AdicionarOrdem(ordem2);
            posicao.AdicionarOrdem(ordem3);
            posicao.AdicionarOrdem(ordem4);

            Carteira carteira = new Carteira("Minha Carteira");

            carteira.AdicionarPosicao(posicao);

            carteira.ImprimePosicoesAbertas();
        }
Esempio n. 3
0
        public async Task <IActionResult> Edit(int id, [Bind("Nome,Id")] TipoOrdem tipoOrdem)
        {
            if (id != tipoOrdem.Id)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    this.uof.TipoOrdemRepository.Update(tipoOrdem, tipoOrdem.Id);
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!TipoOrdemExists(tipoOrdem.Id))
                    {
                        return(NotFound());
                    }
                    throw;
                }

                return(RedirectToAction(nameof(Index)));
            }

            return(View(tipoOrdem));
        }
Esempio n. 4
0
 public Ordem(DateTime data, TipoOrdem tipo, Ativo ativo, int quantidade, double valor)
 {
     Data       = data;
     Tipo       = tipo;
     Ativo      = ativo;
     Quantidade = quantidade;
     Valor      = valor;
 }
Esempio n. 5
0
        public async Task <IActionResult> Create([Bind("Nome,Id")] TipoOrdem tipoOrdem)
        {
            if (ModelState.IsValid)
            {
                this.uof.TipoOrdemRepository.Add(tipoOrdem);
                return(RedirectToAction(nameof(Index)));
            }

            return(View(tipoOrdem));
        }
Esempio n. 6
0
 public OrdemDeVenda(TipoOrdem tipo)
 {
     Tipo = TipoOrdem.Venda;
 }
Esempio n. 7
0
        public async Task <TipoOrdem> Update(TipoOrdem TipoOrdem, int id)
        {
            var updated = await this.tipoOrdemRepository.UpdateAsyn(TipoOrdem, id);

            return(updated);
        }
Esempio n. 8
0
        public async Task <TipoOrdem> Add(TipoOrdem TipoOrdem)
        {
            await this.tipoOrdemRepository.AddAsyn(TipoOrdem);

            return(TipoOrdem);
        }
Esempio n. 9
0
 public OrdemDeCompra(TipoOrdem tipo)
 {
     Tipo = TipoOrdem.Compra;
 }