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());
}
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();
}
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));
}
public Ordem(DateTime data, TipoOrdem tipo, Ativo ativo, int quantidade, double valor)
{
Data = data;
Tipo = tipo;
Ativo = ativo;
Quantidade = quantidade;
Valor = valor;
}
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));
}
public OrdemDeVenda(TipoOrdem tipo)
{
Tipo = TipoOrdem.Venda;
}
public async Task <TipoOrdem> Update(TipoOrdem TipoOrdem, int id)
{
var updated = await this.tipoOrdemRepository.UpdateAsyn(TipoOrdem, id);
return(updated);
}
public async Task <TipoOrdem> Add(TipoOrdem TipoOrdem)
{
await this.tipoOrdemRepository.AddAsyn(TipoOrdem);
return(TipoOrdem);
}
public OrdemDeCompra(TipoOrdem tipo)
{
Tipo = TipoOrdem.Compra;
}
