SieveFramework Télécharger - SieveFramework Téléchargement du code source

SieveFramework

Autres catégories

1.0.0

Télécharger

Cadre de tamis

Filtrage | Tri | Fanfaronnade

Objectif et description

SieveFramework est un framework hautement personnalisable qui permet d'intégrer plus facilement les filtres, les tris et la pagination à votre projet avec un niveau d'abstraction suffisant. Sous le capot se trouve System.Linq.Expressions qui permet de réaliser toutes les opérations avec les collections et d'obtenir une prise en charge native des requêtes.

Projet	Description
`SieveFramework`	Projet de base avec fonctionnalités de base
`SieveFramework.AspNetCore`	Dépendances requises pour intégrer Sieve aux projets ASP.Net Core
`SieveFramework.AspNetCore.Swashbuckle`	Dépendances requises pour intégrer Sieve au framework Swagger

Conception

Le fournisseur principal est SieveProvider . Il contient simplement une collection de ModelProvider qui conserve les informations sur un modèle concret :

quelles propriétés peuvent être triées
quelles propriétés peuvent être filtrées
quel type de modèle
toute méta-information

Le fournisseur principal fonctionne avec des prédicats - des collections d'actions sous une ressource interrogeable. Chaque prédicat ne peut effectuer qu'un seul type d'action de requête sous ressource :

FilterPredicate - Où()
SortPredicate - OrderBy(), OrderByDesc()
TakePredicate - Prendre()
SauterPrédicat - Sauter()
[n'importe lequel]

Cette conception permet de déléguer le même type d'opérations à un seul exécuteur et de contrôler une direction des opérations dans le pipeline.

Noyau ASP.Net

Interrogation

Format de filtre présenté par les analyseurs et utilisé pour effectuer une liaison à partir d'une requête de requête à l'aide d'un classeur de modèle personnalisé.
[!] Les données du corps de la requête seront liées aux classeurs de modèles ASP.Net natifs.

Configuration de l'analyseur natif par défaut :

Alias	Description
`~`	`NODE_DELIMITER` - utilisé pour diviser les valeurs à l'intérieur du nœud
`&`	`OPERATION_DELIMITER` - utilisé pour diviser différentes opérations (séparateur de requêtes par défaut)
`filter=`	`FILTER` - le paramètre de requête contient un filtre
`sort=`	`SORT` - le paramètre de requête contient des tris
`take=`	`TAKE` - le paramètre de requête contient la taille de la sélection
`skip=`	`SKIP` - le paramètre de requête contient la taille du saut

La fonctionnalité prévue est le format DeepObject swagger pour désérialiser le modèle à interroger.

Filtration

Simple

Structure : Property NODE_DELIMITER Alias NODE_DELIMITER Value

Alias (natif)	Alias (DeepObject)	Description
`eq`	FAIRE	Égal à
`neq`	FAIRE	Pas égal à
`gt`	FAIRE	Plus grand que
`gte`	FAIRE	Supérieur ou égal
`lt`	FAIRE	Moins que
`lte`	FAIRE	Inférieur ou égal

Complexe

Structure : Filter NODE_DELIMITER Alias NODE_DELIMITER Filter

Alias (natif)	Alias (DeepObject)	Description
`and`	FAIRE	Concatène les filtres par et la logique
`or`	FAIRE	Concatène les filtres par ou logique

Filtre dérivé d'abord par or condition de sorte que node ~ and ~ node ~ or ~ node sera ( node ~ and ~ node )~ or ~ node .

Tri

Structure : Property NODE_DELIMITER Alias

Alias (natif)	Alias (DeepObject)	Description
`asc`	FAIRE	Trier par ordre croissant
`desc`	FAIRE	Trier par ordre décroissant

Les nœuds de tri peuvent être concaténés uniquement avec and la logique :
node ~ and ~ node

Configuration

Enregistrer les services requis

 public void ConfigureServices ( IServiceCollection services )
{
    services . AddSieveProvider ( config =>
    {
        // WithParser - Add custom Query parser. [NativeQueryParser] is default, no need to register them it's just an example
        config . WithParser < NativeQueryParser > ( )
        // ForAssemblies - Add assemblies to scan models by attributes [CanSort / CanFilter]
              . ForAssemblies ( .. . )
        // Fluent models registration
              . ConfigureProvider ( provider =>
              {
                  provider . AddModel < TestModel > ( builder =>
                  {
                      builder . CanSort ( p => p . TestProperty ) ;
                      builder . CanFilter ( p => p . TestProperty ) ;
                  } ) ;
              } ) ;
    } ) ;
    services . AddControllers ( ) ;
}

Contrôleur de configuration

 public class WeatherForecastController : ControllerBase
{
    // [1] Accept processor through DI 
    private readonly ISieveProvider _sieve ;

    public WeatherForecastController ( ISieveProvider sieve )
    {
        _sieve = sieve ;
    }

    // [2] Wrap processed model's resource with [Sieve] - It will be maped automaticly
    [ HttpGet ]
    public ActionResult GetCustom ( Sieve < WeatherForecast > model )
    {
        var rng = new Random ( ) ;
        var query = Enumerable . Range ( 1 , 5 ) . Select ( index => new WeatherForecast
        {
            Date = DateTime . Now . AddDays ( index ) ,
            TemperatureC = rng . Next ( - 20 , 55 ) ,
            Summary = "Summary" + index
        } ) . AsQueryable ( ) ;

        // [3] Apply filter to resource
        var result = _sieve . Apply ( query , model ) . ToArray ( ) ;

        return Ok ( new
        {
            origin = query . ToArray ( ) ,
            result = result
        } ) ;
    }
}

Fanfaronnade

Configurer SwaggerGen

 public void ConfigureServices ( IServiceCollection services )
{
    // [1] Must be registered before swagger
    services . AddSieveProvider ( ) ;
    services . AddControllers ( ) ;

    services . AddSwaggerGen ( builder =>
    {
        // [2] Add configuration for swagger 
        services . AddSieveDescription ( builder ) ;
        builder . SwaggerDoc ( "v1" , new OpenApiInfo
        {
            Title = "Test" ,
            Version = "v1"
        } ) ;
    } ) ;
}

Les descriptions des tamis remplissent le schéma swagger avec le modèle du tamis à typage fort et la liste des propriétés autorisées au tri et au filtrage pour chaque action de l'API.