protected override ValideFiltre <T> ValideFiltre(KeyParam param)
        {
            ValideFiltre <T> v = null;

            if (param != null)
            {
                v = (T entité) => entité.Uid == param.Uid;
            }
            return(v);
        }
        protected virtual async Task <List <TVue> > CréeVues(ValideFiltre <T> valideT, ValideFiltre <TVue> valideVue)
        {
            IQueryable <T> ts         = valideT == null ? _dbSet : _dbSet.Where(t => valideT(t));
            IQueryable <T> tsComplets = _inclutRelations == null ? ts : _inclutRelations(ts);
            List <T>       données    = await tsComplets.ToListAsync();

            List <TVue> vues = await CréeVuesAsync(données);

            vues = valideVue == null ? vues : vues.Where(v => valideVue(v)).ToList();
            return(vues);
        }
        protected override ValideFiltre <T> ValideFiltre(KeyParam param)
        {
            ValideFiltre <T> v = null;

            if (param != null)
            {
                v = (T entité) => entité.Uid == param.Uid;
                if (param.Rno != null)
                {
                    v += (T entité) => entité.Rno == param.Rno;
                    if (param.No != null)
                    {
                        v += (T entité) => entité.No == param.No;
                    }
                }
            }
            return(v);
        }
Exemple #4
0
        protected override async Task <List <SiteVue> > CréeVues(ValideFiltre <Site> valideT, ValideFiltre <SiteVue> valideVue)
        {
            IQueryable <Site> sites = _context.Site;

            if (valideT != null)
            {
                sites = sites.Where(s => valideT(s));
            }
            var res1 = await sites.ToListAsync();

            IQueryable <NbDeSite> nbProduits = _context.Produit
                                               .GroupBy(p => new { p.Uid, p.Rno })
                                               .Select(eg => new NbDeSite {
                Uid = eg.Key.Uid, Rno = eg.Key.Rno, Nb = eg.Count(p => eg.Key.Uid == p.Uid && eg.Key.Rno == p.Rno)
            });
            var res2 = await nbProduits.ToListAsync();

            nbProduits = _context.Produit
                         .GroupBy(p => new { p.Uid, p.Rno })
                         .Select(eg => new NbDeSite {
                Uid = eg.Key.Uid, Rno = eg.Key.Rno, Nb = eg.Count(p => eg.Key.Uid == p.Uid && eg.Key.Rno == p.Rno && p.Prix > 0)
            });
            res2 = await nbProduits.ToListAsync();

            IQueryable <SiteVue> vues = sites.Join(nbProduits,
                                                   site => new { site.Uid, site.Rno },
                                                   nb => new { nb.Uid, nb.Rno },
                                                   (site, nb) => CréeVue(site, nb.Nb));

            if (valideVue != null)
            {
                vues = vues.Where(v => valideVue(v));
            }
            List <SiteVue> liste = await vues.ToListAsync();

            return(liste);
        }
 protected async Task <IActionResult> Liste(ValideFiltre <TVue> valide)
 {
     return(await Liste(() => __service.Liste(valide), null));
 }
 protected async Task <IActionResult> Liste(KeyParam param, ValideFiltre <TVue> valide)
 {
     return(await Liste(() => __service.Liste(param, valide), param));
 }
 public async Task <List <TVue> > Liste(ValideFiltre <TVue> valide)
 {
     return(await CréeVues(null, valide));
 }
 public async Task <List <TVue> > Liste(KeyParam param, ValideFiltre <TVue> valide)
 {
     return(await CréeVues(ValideFiltre(param), valide));
 }