Un modo riposante per eliminare un mucchio di oggetti

Nell'articolo wiki per REST è indicato che se usi http://example.com/resources DELETE, significa che stai eliminando l'intera raccolta.

Se utilizzi http://example.com/resources/7HOU57Y DELETE, significa che stai eliminando quell'elemento.

Sto realizzando un SITO WEB, nota NON SERVIZIO WEB.

Ho un elenco che ha 1 casella di controllo per ogni elemento nell'elenco. Dopo aver selezionato più elementi per l'eliminazione, consentirò agli utenti di premere un pulsante chiamato ELIMINA SELEZIONE. Se l'utente preme il pulsante, verrà visualizzata una finestra di dialogo js che chiede all'utente di confermare l'eliminazione. se l'utente conferma, tutti gli elementi vengono eliminati.

Quindi come dovrei provvedere all'eliminazione di più elementi in modo RESTFUL?

NOTA, attualmente per DELETE in una pagina Web, quello che faccio è utilizzare il tag FORM con POST come azione ma includere un _method con il valore DELETE poiché questo è ciò che è stato indicato da altri in SO su come eseguire l'eliminazione RESTful per la pagina Web .

Penso che la risposta di Rojoca sia la migliore finora. Una leggera variazione potrebbe essere quella di eliminare la conferma javascript sulla stessa pagina e, invece, creare la selezione e reindirizzare ad essa, mostrando un messaggio di conferma su quella pagina. In altre parole:

Da:
http://example.com/resources/

fare un

POST con una selezione di ID a:
http://example.com/resources/selections

che, in caso di successo, dovrebbe rispondere con:

HTTP / 1.1 201 creato e un'intestazione Location a:
http://example.com/resources/selections/DF4XY7

In questa pagina vedrai quindi una casella di conferma (javascript), che se confermi farà una richiesta di:

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

che, in caso di successo, dovrebbe rispondere con: HTTP / 1.1 200 Ok (o qualsiasi cosa sia appropriata per una cancellazione riuscita)

Un'opzione è creare una "transazione" di cancellazione. Quindi POSTa qualcosa di simile a http://example.com/resources/deletesuna nuova risorsa composta da un elenco di risorse da eliminare. Quindi nella tua applicazione fai solo l'eliminazione. Quando esegui il post, devi restituire una posizione della transazione creata, ad es http://example.com/resources/deletes/DF4XY7. Una GETsu questa potrebbe restituire lo stato della transazione (completata o in corso) e / o un elenco di risorse da eliminare.

Ecco cosa ha fatto Amazon con la sua API REST S3.

Richiesta di eliminazione individuale:

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))

Richiesta di eliminazione di più oggetti :

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>           

Ma l' API Graph di Facebook , l' API REST di Parse Server e l' API REST di Google Drive vanno ancora oltre, consentendo di "raggruppare" singole operazioni in un'unica richiesta.

Ecco un esempio da Parse Server.

Richiesta di eliminazione individuale:

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

Richiesta batch:

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

Direi DELETE http://example.com/resources/id1,id2,id3,id4 o DELETE http://example.com/resources/id1+id2+id3+id4 . Poiché "REST è un'architettura (...) [non] protocollo", per citare questo articolo di wikipedia, non esiste, credo, un solo modo per farlo.

Sono consapevole che quanto sopra non è possibile senza JS con HTML ma ho la sensazione che REST fosse:

• Creato senza pensare a dettagli minori come le transazioni. Chi avrebbe bisogno di operare su più di un singolo articolo? Questo è in qualche modo giustificato nel protocollo HTTP in quanto non era destinato a servire attraverso di esso nient'altro che le pagine web statiche.
• Non è necessario adattarsi bene ai modelli attuali, anche del puro HTML.

È interessante notare che penso che lo stesso metodo si applichi al PATCH di più entità e richiede di pensare a cosa intendiamo con il nostro URL, parametri e metodo REST.

1. restituisce tutti gli elementi 'foo':

   [GET] api/foo

2. restituisce elementi 'foo' con filtri per ID specifici:

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

In che senso l'URL e il filtro determinano "con quali elementi abbiamo a che fare?", E il metodo REST (in questo caso "GET") dice "cosa fare con quegli elementi?"

1. Quindi PATCH più record per contrassegnarli come letti

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

..con i dati foo [read] = 1

1. Infine, per eliminare più record, questo endpoint è il più logico:

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

Per favore, capisci che non credo che ci siano "regole" su questo - per me "ha senso"

Come dice la risposta di Decent Dabbler e la risposta di rojocas , il più canonico è usare le risorse virtuali per eliminare una selezione di risorse, ma penso che non sia corretto dal punto di vista REST, perché l'esecuzione di DELETE http://example.com/resources/selections/DF4XY7dovrebbe rimuovere la risorsa di selezione stessa, non le risorse selezionate.

Prendendo la risposta di Maciej Piechotka o la risposta di fezfox , ho solo un'obiezione: esiste un modo più canonico per passare un array di ID e sta usando l'operatore di array:

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

In questo modo stai attaccando l'endpoint Delete Collection ma filtrando l'eliminazione con una stringa di query nel modo giusto.

Poiché non esiste un modo "corretto" per farlo, ciò che ho fatto in passato è:

invia DELETE a http://example.com/qualcosa con dati codificati xml o json nel corpo.

quando ricevi la richiesta, controlla DELETE, se vero, quindi leggi il corpo per quelli da eliminare.

Ho avuto la stessa situazione per eliminare più elementi. Questo è quello che ho finito per fare. Ho usato l'operazione DELETE e gli ID degli elementi che dovevano essere eliminati facevano parte dell'intestazione HTTP.