Un moyen reposant pour supprimer un tas d'éléments

Dans l' article wiki pour REST, il est indiqué que si vous utilisez http://example.com/resources DELETE, cela signifie que vous supprimez toute la collection.

Si vous utilisez http://example.com/resources/7HOU57Y DELETE, cela signifie que vous supprimez cet élément.

Je fais un SITE WEB, notez PAS DE SERVICE WEB.

J'ai une liste qui a 1 case à cocher pour chaque élément de la liste. Une fois que j'ai sélectionné plusieurs éléments à supprimer, je vais permettre aux utilisateurs d'appuyer sur un bouton appelé SUPPRIMER LA SÉLECTION. Si l'utilisateur appuie sur le bouton, une boîte de dialogue js apparaîtra pour demander à l'utilisateur de confirmer la suppression. si l'utilisateur confirme, tous les éléments sont supprimés.

Alors, comment dois-je gérer la suppression de plusieurs éléments de manière RESTFUL?

REMARQUE, actuellement pour DELETE dans une page Web, ce que je fais est d'utiliser la balise FORM avec POST comme action, mais j'inclus une méthode avec la valeur DELETE, car c'est ce qui a été indiqué par d'autres dans SO sur la façon de supprimer RESTful pour la page Web .

Je pense que la réponse de Rojoca est la meilleure à ce jour. Une légère variation pourrait être, pour supprimer la confirmation javascript sur la même page, et à la place, créer la sélection et la rediriger, en affichant un message de confirmation sur cette page. En d'autres termes:

De:
http://example.com/resources/

fait une

POST avec une sélection des ID à:
http://example.com/resources/selections

qui, en cas de succès, doit répondre par:

HTTP / 1.1 201 créé et un en-tête Location vers:
http://example.com/resources/selections/DF4XY7

Sur cette page, vous verrez alors une boîte de confirmation (javascript) qui, si vous confirmez, fera une demande de:

SUPPRIMER http://example.com/resources/selections/DF4XY7

qui, en cas de succès, devrait répondre avec: HTTP / 1.1 200 Ok (ou tout ce qui est approprié pour une suppression réussie)

Une option consiste à créer une "transaction" de suppression. Donc, vous POSTà quelque chose comme http://example.com/resources/deletesune nouvelle ressource consistant en une liste de ressources à supprimer. Ensuite, dans votre application, vous faites simplement la suppression. Lorsque vous faites la publication, vous devez renvoyer un emplacement de votre transaction créée, par exemple http://example.com/resources/deletes/DF4XY7. Un GETsur celui-ci pourrait renvoyer l'état de la transaction (terminée ou en cours) et / ou une liste de ressources à supprimer.

Voici ce qu'Amazon a fait avec son API S3 REST.

Demande de suppression individuelle:

DELETE /ObjectName HTTP/1.1
Host: BucketName.s3.amazonaws.com
Date: date
Content-Length: length
Authorization: authorization string (see Authenticating Requests (AWS Signature Version 4))

Demande de suppression multi-objets :

POST /?delete HTTP/1.1
Host: bucketname.s3.amazonaws.com
Authorization: authorization string
Content-Length: Size
Content-MD5: MD5

<?xml version="1.0" encoding="UTF-8"?>
<Delete>
    <Quiet>true</Quiet>
    <Object>
         <Key>Key</Key>
         <VersionId>VersionId</VersionId>
    </Object>
    <Object>
         <Key>Key</Key>
    </Object>
    ...
</Delete>           

Mais Facebook Graph API , Parse Server REST API et Google Drive REST API vont encore plus loin en vous permettant de «grouper» des opérations individuelles en une seule requête.

Voici un exemple de Parse Server.

Demande de suppression individuelle:

curl -X DELETE \
  -H "X-Parse-Application-Id: ${APPLICATION_ID}" \
  -H "X-Parse-REST-API-Key: ${REST_API_KEY}" \
  https://api.parse.com/1/classes/GameScore/Ed1nuqPvcm

Demande de lot:

curl -X POST \
  -H "X-Parse-Application-Id: ${APPLICATION_ID}" \
  -H "X-Parse-REST-API-Key: ${REST_API_KEY}" \
  -H "Content-Type: application/json" \
  -d '{
        "requests": [
          {
            "method": "POST",
            "path": "/1/classes/GameScore",
            "body": {
              "score": 1337,
              "playerName": "Sean Plott"
            }
          },
          {
            "method": "POST",
            "path": "/1/classes/GameScore",
            "body": {
              "score": 1338,
              "playerName": "ZeroCool"
            }
          }
        ]
      }' \
  https://api.parse.com/1/batch

Je dirais DELETE http://example.com/resources/id1,id2,id3,id4 ou DELETE http://example.com/resources/id1+id2+id3+id4 . Comme "REST est une architecture (...) [pas] un protocole" pour citer cet article de wikipedia, il n'y a, je crois, pas une seule façon de faire cela.

Je suis conscient que ci-dessus n'est pas possible sans JS avec HTML mais j'ai le sentiment que REST était:

• Créé sans penser aux détails mineurs comme les transactions. Qui aurait besoin d'opérer sur plus d'un seul article? Ceci est en quelque sorte justifié dans le protocole HTTP car il n'était pas destiné à servir à travers lui autre chose que des pages Web statiques.
• Pas nécessaire de bien s'adapter aux modèles actuels - même en HTML pur.

Fait intéressant, je pense que la même méthode s'applique au PATCHing de plusieurs entités et nécessite de réfléchir à ce que nous entendons par notre URL, nos paramètres et notre méthode REST.

1. renvoie tous les éléments 'foo':

   [GET] api/foo

2. renvoie des éléments 'foo' avec filtrage pour des identifiants spécifiques:

   [GET] api/foo?ids=3,5,9

En quoi l'URL et le filtre déterminent-ils "quels éléments nous traitons-nous?", Et la méthode REST (dans ce cas "GET") dit "que faire de ces éléments?"

1. Par conséquent, PATCH plusieurs enregistrements pour les marquer comme lus

   [PATCH] api/foo?ids=3,5,9

..avec les données toto [lecture] = 1

1. Enfin, pour supprimer plusieurs enregistrements, ce point de terminaison est le plus logique:

   [DELETE] api/foo?ids=3,5,9

S'il vous plaît, comprenez que je ne pense pas qu'il y ait de "règles" à ce sujet - pour moi, cela "a du sens"

Comme le dit la réponse de Decent Dabbler et la réponse rojocas , le plus canonique consiste à utiliser des ressources virtuelles pour supprimer une sélection de ressources, mais je pense que c'est incorrect du point de vue REST, car l'exécution d'un DELETE http://example.com/resources/selections/DF4XY7devrait supprimer la ressource de sélection elle-même, pas les ressources sélectionnées.

En prenant la réponse Maciej Piechotka ou la réponse fezfox , je n'ai qu'une objection: il existe une manière plus canonique de transmettre un tableau d'identifiants, et utilise l'opérateur de tableau:

DELETE /api/resources?ids[]=1a2b3c4d-5e6f-7a8b-9c0d-1e2f3a4b5c6d&ids[]=7e8f9a0b-1c2d-3e4f-5a6b-7c8d9e0f1a2b

De cette façon, vous attaquez le point de terminaison Supprimer la collection mais en filtrant la suppression avec une chaîne de requête de la bonne manière.

Comme il n'y a pas de moyen `` approprié '' de faire cela, ce que j'ai fait dans le passé est:

envoyer DELETE à http://example.com/something avec des données codées xml ou json dans le corps.

lorsque vous recevez la demande, vérifiez DELETE, si vrai, puis lisez le corps pour ceux à supprimer.

J'ai eu la même situation pour supprimer plusieurs éléments. C'est ce que j'ai fini par faire. J'ai utilisé l'opération DELETE et les identifiants des éléments qui devaient être supprimés faisaient partie de l'en-tête HTTP.