Dojo.store.Observable, JSON REST, and queryEngine

Question

Does anyone know how to use the JsonRest repository in dojo with an observable order, for example in dojo.store.Observable?

What do I need, the server side, to implement the store and make it work as an observable? How about the client side? The documentation says http://dojotoolkit.org/reference-guide/1.7/dojo/store/Observable.html

If you use server-side storage, such as JsonRest storage, you need to provide queryEngine so that update objects are correctly included or excluded from requests. If queryEngine is not available, the observer will be called with an undefined index.

But I have no idea what they mean. I never created a store myself, and I don’t know 100% with queryEngine (to be honest, I find it a bit confusing). Why do you need an Engine request? What is the meaning of the "undefined index" document? And how do you write queryEngine for the JsonRest store? Should I use any kind of web socket for REST observable storage, as other users can also modify the data?

Confused!

Answer 1

I understand that this quesiton is a bit outdated, but here is some information for future reference. Since this is a multi-part question, I am breaking it into separate parts:

1) Server implementation of JsonRest

There is a pretty decent record about the server side implementation in the JsonRest Store . It shows which JsonRest headers will generate and what content will be included in the rest. This helps build a mental model of how the JsonRest api translates to HTTP.

2) Engine Engine

Earlier on the same page how query () works on the client side . In principle, the query() function should be able to retrieve the object literal (ex: {title:'Learning Dojo',categoryid:5} ) and return the objects to the store that meet these conditions. “In store” means that it is already loaded into memory on the client, not on the server.

Depending on what you are trying to do, there is no need to write your own Engine query anyway - just use the built-in SimpleQueryEngine if you create your own store. The mechanism just needs to pass an object literal, and it will add the whole dojo query () api for you.

3) Observed

I understand that the client side of the Observables monitor changes in a collection of objects (for example: adding or removing a result) or even within a specific object (for example: post 5 changed its name). It does NOT track changes that occur on the server side. It simply provides a mechanism for notifying other aspects of the client application that the data has changed, so that all aspects of the page remain synchronized.

Everything is written there using Observables under the headings “Binding collection data” and “Binding object data: dojo / Stateful”,

4) Concurrency

There you have to do two things to synchronize the data on the client side with the data on the server side: a) polling for changes from other users on the server, b) using transactions to send data to the server.

a) To query for changes in data, you want the object store to track the active request in a variable. Then use setTimeout() or setInterval() to re-run the query in the background so often. Make sure widgets or other aspects of your application use Observables to monitor changes in the query result set on which they depend. Thus, changes on the server by other users will be automatically reflected in the entire application.

b) Use transactions to combine actions that need to be combined. Then make sure the server sends HTTP 200 HTTP codes (which means "It Worked!"). If transactions return HTTP status in the 400s, then for some reason it does not work, and you need to request data because something has changed to the backend. For example, the record you want to update has been deleted, so you cannot update it. There record transactions also under the heading Transactional