Appending to a resource's attribute RESTfully_问答_开发者

This is a开发者_StackOverflow社区 follow up to Updating a value RESTfully with Post

How do I simply append to a resource's attribute using REST. Imagine I have customer.balance and balance is an int. Let' say I just want to tell the server to append 5 to whatever the current balance is. Can I do this restfully? If so, how?

Keep in mind that the client doesn't know the customer's existing balance, so it can't just

get customer
customer.balance += 5
post customer

(there would also be concurrency issues with the above.)

Simple, slightly ugly:

This is a simpler variation of my answer to your other question.

I think you're still within the constraints of REST if you do the following. However, I'm curious about what others think about this situation as well, so I hope to hear from others.

Your URI will be:

/customer/21/credits

You POST a credit resource (maybe <credit>5</credit>) to the URI, the server can then take the customer's balance and += it with the provided value. Additionally, you can support negative credits (e.g. <credit>-10</credit>);

Note that /customer/21/credits doesn't have to support all methods. Supporting POST only is perfectly acceptable.

However, this gets a little weird if credits aren't a true resource within your system. The HTTP spec says:

If a resource has been created on the origin server, the response SHOULD be 201 (Created) and contain an entity which describes the status of the request and refers to the new resource, and a Location header.

Technically you're not creating a resource here, you're appending to the customer's balance (which is really an aggregate of all previous credits in the system). Since you're not keeping the credit around (presumably), you wouldn't really be able to return a reference to the newly "created" credit resource. You could probably return the customer's balance, or the <customer> itself, but that's a bit unintuitive to clients. This is why I think treating each credit as a new resource in the system is easier to work with (see below).

My preferred solution:

This is adapted from my answer in your other question. Here I'll try to approach it from the perspective of what the client/server are doing:

Client:
1. Builds a new credit resource:
```
<credit>
  <amount>5</amount>
</credit>
```
2. POSTs resource to /customer/21/credits
  
  POSTing here means, "append this new <credit> I'm providing to the list of <credit>s for this customer.
Server:
1. Receives POST to /customer/21/credits
2. Takes the amount from the request and +=s it to the customer's balance
3. Saves the credit and its information for later retrieval
4. Sends response to client:
```
<credit href="/customer/21/credits/credit-id-4321234">
  <amount>5</amount>
  <date>2009-10-16 12:00:23</date>
  <ending-balance>45.03</ending-balance>
</credit>
```

This gives you the following advantages:

Credits can be accessed at a later date by id (with GET /customer/21/credits/[id])
You have a complete audit trail of credit history
Clients can, if you support it, update or remove credits by id (with PUT or DELETE)

Clients can retrieve an ordered list of credits, if you support it; e.g. GET /customer/21/credits might return:

<credits href="/customer/21/credits">
   <credit href="/customer/21/credits/credit-id-7382134">
     <amount>13</amount>
     ...
   </credit>
   <credit href="/customer/21/credits/credit-id-134u482">
     ...
   </credit>
   ...
</credits>

Makes sense, since the customer's balance is really the end result of all credits applied to that customer.

To think about this in a REST-ful way, you would need to think about the action itself as a resource. For example, if this was banking, and you wanted to update the balance on an account, you would create a deposit resource, and then add one of those. The consequence of this would be to update the customer's balance

This also helps deal with concurrency issues, because you would be submitting a +5 action rather than requiring prior knowledge of the customer's balance. And, you would also be able to recall that resource (say deposit/51 for deposit with an ID of 51) and see other details about it (ie. Reason for deposit, date of deposit etc.).

EDIT: Realised that using an id of 5 for the deposit actually confuses the issue, so changed it to 51.

Well, there is alternative other than @Rob-Hruska 's solution.

The fundamental idea is the same: to think each credit/debit operation as a standalone transaction. However I once used a backend which supports storing schema-less data in json, so that I end up with defining the API as PUT with dynamic field names. Something like this:

PUT /customer/21

{"transaction_yyyymmddHHMMSS": 5}

I know this is NOT appropriate in the "credit/debit" context because an active account could have growing transaction records. But in my context I am using such tactics to store finite data (actually I was storing different batches of GPS way points during a driving trip).

Cons: This api style has heavy dependence on backend behavior's schema-less feature.

Pros: At least my approach is fully RESTful from the semantic point of view.

By contrast, @Rob-Hruska 's "Simple, slightly ugly" solution 1 does not have a valid Location header to return in the "201 Created" response, which is not a common RESTful behavior. (Or perhaps, we can let @Rob-Hruska's solution 1 to also return a dummy Location header, which points to a "410 Gone" or "404 Not Found" page. Is this more RESTful? Comments are welcome!)