Cet article vous montre comment implémenter la pagination via l’API REST pour gérer facilement de grandes quantités de données à l’aide de la technique de pagination.

introduction

Offrez-vous l’exigence de pagination des enregistrements via l’API REST pour les grandes sources de données. Nous avons développé cette solution à l’aide de l’API REST et espérons qu’elle vous sera également utile dans vos efforts. Cet article est une extension de mon précédent article de pagination de datatable.net. Alors essayez de ne pas m’imposer des frais de plagiat. L’objectif était de réaliser des recherches spécifiques et multi-colonnes, le tri, le dimensionnement des pages dynamiques, une structure de code élégante, le moins d’effort de codage et, surtout, la performance.

conditions

Pour suivre cet article, vous devez être familiarisé avec MVC Framework. Si vous pensez avoir une expertise suffisante, il n’y a aucun problème à lire cet article sur.

abstraction

La solution utilise Swagger pour la documentation et le package LINQKit. Avec LINQKit, des requêtes flexibles et puissantes peuvent être créées.

demande du client

Nous utilisons homme de poste Pour interroger notre API REST, la structure de la requête json est la suivante:

{
  "CurrentPage": 1,
  "PageSize": 1,
  "SearchText": "",
  "SortColumn": "Id",
  "SortDirection": "Desc",
  "HasPagination": true,
  "Columns": [
  ]
}
propriété la description
CurrentPage Le numéro de page demandé doit être défini dans cette propriété, par ex. B. pour obtenir une réponse de tableau de 3environ Côté, alors 3 doivent être attribués.
PageSize Il définit la taille du retour arraylist Taille ou taille de page de la demande.
SearchText Afin de rechercher toutes les colonnes de texte, cette propriété doit être remplie, par ex. Département Dans ce cas, toutes les colonnes de texte sont recherchées. ContactPerson, Phone, City, Region et Country
SortColumn Avec quelle colonne nous devons trier nos données, par exemple pour trier par personne de contact, doit être la valeur transférée ContactPerson
SortDirection Pour trier par ordre croissant, Asc doit être passé et par ordre décroissant, Desc
HasPagination Afin de renvoyer toutes les données générées par cette requête en json, cela devait être le cas false, Sinon true devrait être adopté.

Columns[]

C’est une liste de tableaux JSON de colonnes pour une recherche spécifique, il contient un tableau de Column Objets.
Column

Cet objet JSON a deux propriétés: ColumnName et ColumnSearchText, Cette recherche offre une fonction de recherche de colonne spéciale, par ex. B.:

Exemple 1

{
     "ColumnName":"Balance",
     "ColumnSearchText":"<=,50"
}

Tous les clients avec un solde inférieur et égal seront retournés 50.

Exemple 2

{
    "ColumnName":"Country",
    "ColumnSearchText":"Pakistan"
}

Tous les clients du pays seront renvoyés Pakistan juste:

Exemple 3

Vous pouvez également rechercher plusieurs scénarios, par exemple B.:

   "Columns":[
   {
       "ColumnName":"Country",
       "ColumnSearchText":"Pakistan"
   }
   ,
   { 
        "ColumnName":"Balance",    
        "ColumnSearchText":"<=,50" 
   } 
]

La requête JSON ci-dessus est renvoyée customer avec un équilibre inférieur à égal 50 et pays du client Pakistan juste.

Consommez l’API REST via le client Postman

Pour utiliser cette API REST, nous utilisons Postman. Vous pouvez le télécharger sur leur site Web. Après avoir ouvert le client, définissez le type de demande sur Publier, Dans l’onglet Corps, sélectionnez cru comme sélectionné ci-dessous et configurer le type de contenu de l’exigence JSON est à l’extrême droite dans combobox.

Image 1

Les exigences API ci-dessus renverront les clients avec un solde de compte supérieur à 5000000 avec pagination pour 1st Page.

image 2

L’instantané montre tous les clients du pays oman.

image 3

L’instantané ci-dessus montre les enregistrements dans l’ordre décroissant par numéro d’identification du client.

Côté serveur API REST

Du côté du serveur, nous avons LINQKit pour permettre notre poursuite. L’une des méthodes d’action du contrôleur spécifiées PaginationRequest Objet qui serait passé par le client en tant qu’objet JSON défini dans nos exemples ci-dessus.

[HttpPost]
[SwaggerResponseExample(HttpStatusCode.OK, typeof(CustomerPaginationResponseExample))]
[SwaggerRequestExample(typeof(PaginationRequest<customerpaginationgridcolumns>),
typeof(CustomerPaginationRequestExample), jsonConverter: typeof(StringEnumConverter))]
[ResponseType(typeof(PaginationResponse<customerpaginationmodel>))]
[HelperMethods.DeflateCompression]
[ValidateModelState]
[CheckModelForNull]
[SwaggerConsumes("application/json")]
[SwaggerProduces("application/json")]
[SwaggerResponse(HttpStatusCode.NotFound,
"No customer found", typeof(GenericResponseModel))]
[Route("")]
public async Task<system.web.http.ihttpactionresult>
       Get(PaginationRequest<customerpaginationgridcolumns> request)
{
    BusinessLayer.Entity.Customer obj = new BusinessLayer.Entity.Customer(this);
    PaginationResponse<customerpaginationmodel> response = obj.Get(request).Result;

    if (response.Items == null)
    {
        return APIResponse(HttpStatusCode.InternalServerError,
                           $"Error: {obj.errorMessage}");
    }
    else
    if (response.Items.Count() == 0)
    {
        return APIResponse(HttpStatusCode.NotFound, $"No customer found");
    }
    return Ok(response);
}

La méthode de la couche métier de notre demande est structurée comme suit. La requête est créée dynamiquement avec LINQKit et Entity Framework en tant qu’ORM. Il analyse toutes les colonnes associées à cette entité métier et compose dynamiquement la requête tout en implémentant la pagination.

public async Task<paginationresponse<customerpaginationmodel>>
Get(PaginationRequest<common.enum.customerpaginationgridcolumns> paginationRequest)
    {
        try
        {
            BusinessEntity.CustomerDBEntities obj =
                           new BusinessEntity.CustomerDBEntities();

            records = (from cus in obj.customers.AsNoTracking()
                       
                       
                       select new CustomerPaginationModel
                       {
                           Id = cus.customerID,
                           ContactPerson = cus.contactPerson,
                           Phone = cus.phone,
                           Fax = cus.phone,
                           City = cus.city,
                           Region = cus.region,
                           Country = cus.countryName,
                           CountryId = cus.countryId,
                           Balance = cus.balance
                       }).AsQueryable();

            if (paginationRequest.SortColumn != CustomerPaginationGridColumns.None)
            {
                InitSorting(paginationRequest);
            }
            else
            {
                paginationRequest.SortColumn = CustomerPaginationGridColumns.Id;
                InitSorting(paginationRequest);
            }

            genericSearchText = paginationRequest.SearchText == null ?
                                null : paginationRequest.SearchText.Trim(); 
                                                                            

            ColumnParameter<common.enum.customerpaginationgridcolumns> column =
                                 new ColumnParameter<customerpaginationgridcolumns>() { };

            
            
            
            foreach (CustomerPaginationGridColumns columnParse in Enum.GetValues
                    (typeof(CustomerPaginationGridColumns)))
            {

                if (!string.IsNullOrEmpty(genericSearchText))
                {
                    
                    if (paginationRequest.Columns.Where
                       (x => x.ColumnName == columnParse).Count() == 0)
                    {
                        column = new ColumnParameter<customerpaginationgridcolumns>()
                                  { ColumnName = columnParse, ColumnSearchText = "" };
                    }
                    else
                    {
                        column = paginationRequest.Columns.Where
                                 (x => x.ColumnName == columnParse).FirstOrDefault();
                    }
                }
                else
                {
                    column = paginationRequest.Columns.Where
                             (x => x.ColumnName == columnParse).FirstOrDefault();
                }

                if (column == null)
                {
                    continue;
                }

                searchColumnText =
                (column.ColumnSearchText ?? "").Trim();      
                                                             

                switch (column.ColumnName)
                {
                    case Common.Enum.CustomerPaginationGridColumns.Balance:
                        EvaluateNumericComparisonFilter(paginationRequest, column,
                           searchColumnText,
                           "Balance",
                           x => x.Balance
                       );
                        break;
                    case Common.Enum.CustomerPaginationGridColumns.City:
                        EvaluateFilter(paginationRequest, column,
                            x => x.City.StartsWith(searchColumnText),
                            x => x.City.StartsWith(genericSearchText),
                            x => x.City
                            );
                        break;
                    case Common.Enum.CustomerPaginationGridColumns.ContactPerson:
                        EvaluateFilter(paginationRequest, column,
                            x => x.ContactPerson.StartsWith(searchColumnText),
                            x => x.ContactPerson.StartsWith(genericSearchText),
                            x => x.ContactPerson
                            );
                        break;
                    case Common.Enum.CustomerPaginationGridColumns.Country:
                        EvaluateFilter(paginationRequest, column,
                            x => x.Country.StartsWith(searchColumnText),
                            x => x.Country.StartsWith(genericSearchText),
                            x => x.Country
                            );
                        break;
                    case Common.Enum.CustomerPaginationGridColumns.CountryId:
                        if (!IsNumber(searchColumnText))
                        {
                            continue;
                        }

                        string type = searchColumnText;

                        EvaluateFilter(paginationRequest, column,
                            x => x.CountryId == type,
                            null,
                            x => x.CountryId
                            );
                        break;
                    case Common.Enum.CustomerPaginationGridColumns.Fax:
                        EvaluateFilter(paginationRequest, column,
                            x => x.Fax.StartsWith(searchColumnText),
                            x => x.Fax.StartsWith(genericSearchText),
                            x => x.Fax
                            );
                        break;
                    case Common.Enum.CustomerPaginationGridColumns.Phone:
                        EvaluateFilter(paginationRequest, column,
                            x => x.Phone.StartsWith(searchColumnText),
                            x => x.Phone.StartsWith(genericSearchText),
                            x => x.Phone
                            );
                        break;
                    case Common.Enum.CustomerPaginationGridColumns.Region:
                        EvaluateFilter(paginationRequest, column,
                            x => x.Region.StartsWith(searchColumnText),
                            x => x.Region.StartsWith(genericSearchText),
                            x => x.Region
                            );
                        break;
                }
            }

            PaginationResponse<customerpaginationmodel> response =
                                 new PaginationResponse<customerpaginationmodel>();

            IQueryable<customerpaginationmodel> countQuery = records;
            response.Items = ForgeGridData(paginationRequest, x => x.ContactPerson).Result;
            response.RecordsTotal = totalRows;

            
            return response;
        }
        catch (Exception exp)
        {
            CompileExceptionHandleMessage(exp);
            return new PaginationResponse<customerpaginationmodel>() { Items = null };
        }
        finally
        {
            records = null;
        }
    }

En cas d’erreur dans la solution

Si le code source de la solution ne se compile pas, reconstruisez la solution. Si vous rencontrez ensuite une erreur d’exécution, exécutez la commande suivante dans la console de gestion des packages de votre projet principal.

Update-Package Microsoft.CodeDom.Providers.DotNetCompilerPlatform -r

l’histoire

  • 16e Mars 2021: première version



Source link

Recent Posts