Una forma tranquila de eliminar un montón de elementos.

En el artículo wiki para REST se indica que si usa http://example.com/resources DELETE, eso significa que está eliminando toda la colección.

Si usa http://example.com/resources/7HOU57Y DELETE, eso significa que está eliminando ese elemento.

Estoy haciendo un SITIO WEB, tenga en cuenta que NO ES SERVICIO WEB.

Tengo una lista que tiene 1 casilla de verificación para cada elemento de la lista. Una vez que seleccione varios elementos para eliminarlos, permitiré a los usuarios presionar un botón llamado ELIMINAR SELECCIÓN. Si el usuario presiona el botón, aparecerá un cuadro de diálogo js pidiéndole al usuario que confirme la eliminación. si el usuario confirma, se eliminan todos los elementos.

Entonces, ¿cómo debo ocuparme de eliminar varios elementos de una manera RESTABLECIDA?

NOTA, actualmente para DELETE en una página web, lo que hago es usar la etiqueta FORM con POST como acción pero incluyo un _method con el valor DELETE ya que esto es lo que otros indicaron en SO sobre cómo hacer una eliminación RESTful para la página web .

Creo que la respuesta de rojoca es la mejor hasta ahora. Una ligera variación podría ser eliminar la confirmación de JavaScript en la misma página y, en cambio, crear la selección y redirigirla, mostrando un mensaje de confirmación en esa página. En otras palabras:

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

hacer un

ENVÍE con una selección de ID para:
http://example.com/resources/selections

que, si tiene éxito, debería responder con:

HTTP / 1.1 201 creado y un encabezado de ubicación para:
http://example.com/resources/selections/DF4XY7

En esta página, verá un cuadro de confirmación (javascript), que si confirma, hará una solicitud de:

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

que, si tiene éxito, debería responder con: HTTP / 1.1 200 Ok (o lo que sea apropiado para una eliminación exitosa)

Una opción es crear una "transacción" de eliminación. Entonces, POSTa algo así como http://example.com/resources/deletesun nuevo recurso que consiste en una lista de recursos que se eliminarán. Luego, en su aplicación, simplemente haga la eliminación. Cuando lo haga la entrada que debe devolver una ubicación de su transacción creada por ejemplo, http://example.com/resources/deletes/DF4XY7. A GETsobre esto podría devolver el estado de la transacción (completa o en curso) y / o una lista de recursos que se eliminarán.

Esto es lo que hizo Amazon con su API REST S3.

Solicitud de eliminación individual:

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

Solicitud de eliminación de varios objetos :

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>           

Pero Facebook Graph API , Parse Server REST API y Google Drive REST API van aún más lejos al permitirle realizar operaciones individuales "por lotes" en una sola solicitud.

Aquí hay un ejemplo de Parse Server.

Solicitud de eliminación individual:

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

Solicitud de lote:

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

Yo diría DELETE http://example.com/resources/id1,id2,id3,id4 o DELETE http://example.com/resources/id1+id2+id3+id4 . Como "REST es una arquitectura (...) [no] un protocolo", para citar este artículo de wikipedia, creo que no hay una única forma de hacerlo.

Soy consciente de que lo anterior no es posible sin JS con HTML, pero tengo la sensación de que REST fue:

• Creado sin pensar en detalles menores como transacciones. ¿Quién necesitaría operar en más de un artículo? Esto se justifica de alguna manera en el protocolo HTTP, ya que no estaba destinado a servir a través de él nada más que páginas web estáticas.
• No es necesario que se ajuste bien a los modelos actuales, incluso de HTML puro.

Curiosamente, creo que se aplica el mismo método que para PATCHAR varias entidades, y requiere pensar en lo que queremos decir con nuestra URL, parámetros y método REST.

1. devolver todos los elementos 'foo':

   [GET] api/foo

2. devolver elementos 'foo' con filtrado para identificadores específicos:

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

En el sentido de que la URL y el filtro determinan "¿con qué elementos estamos tratando?", Y el método REST (en este caso "GET") dice "¿qué hacer con esos elementos?"

1. Por lo tanto, PATCH múltiples registros para marcarlos como leídos

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

..con los datos foo [leer] = 1

1. Finalmente, para eliminar varios registros, este punto final es más lógico:

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

Por favor, comprenda que no creo que haya ninguna "regla" sobre esto; para mí, simplemente "tiene sentido"

Como dice la respuesta de Decent Dabbler y la respuesta de rojocas , lo más canónico es usar recursos virtuales para eliminar una selección de recursos, pero creo que eso es incorrecto desde una perspectiva REST, porque ejecutar un DELETE http://example.com/resources/selections/DF4XY7debería eliminar el recurso de selección en sí, no los recursos seleccionados.

Tomando el anwser Maciej Piechotka o el respuesta de fezfox , solo tengo una objeción: hay una forma más canónica de pasar una matriz de identificadores, y está usando el operador de matriz:

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

De esta manera, está atacando el punto final Delete Collection pero filtrando la eliminación con una cadena de consulta de la manera correcta.

Como no existe una forma 'adecuada' de hacer esto, lo que hice en el pasado es:

envíe DELETE a http://example.com/something con datos codificados xml o json en el cuerpo.

cuando reciba la solicitud, verifique DELETE, si es verdadero, luego lea el cuerpo de los que se eliminarán.

Tuve la misma situación al eliminar varios elementos. Esto es lo que terminé haciendo. Usé la operación DELETE y los identificadores de los elementos que se eliminarían eran parte del encabezado HTTP.