+ setup_update_query: function(query, records)
+ {
+ // We don't prepare an update query if the result has more than 1 entry
+ if (records.length != 1)
+ return;
+ var query_ext = manifold.query_store.find_query_ext(query.query_uuid);
+
+ var record = records[0];
+
+ var update_query_ext = query_ext.update_query_ext;
+ var update_query = update_query_ext.query;
+ var update_query_ext = query_ext.update_query_ext;
+ var update_query_orig = query_ext.update_query_orig_ext.query;
+
+ // Testing whether the result has subqueries (one level deep only)
+ // iif the query has subqueries
+ var count = 0;
+ var obj = query.analyzed_query.subqueries;
+ for (method in obj) {
+ if (obj.hasOwnProperty(method)) {
+ var key = manifold.metadata.get_key(method);
+ if (!key)
+ continue;
+ if (key.length > 1)
+ continue;
+ key = key[0];
+ var sq_keys = [];
+ var subrecords = record[method];
+ if (!subrecords)
+ continue
+ $.each(subrecords, function (i, subrecord) {
+ sq_keys.push(subrecord[key]);
+ });
+ update_query.params[method] = sq_keys;
+ update_query_orig.params[method] = sq_keys.slice();
+ count++;
+ }
+ }
+
+ if (count > 0) {
+ update_query_ext.disabled = false;
+ update_query_orig_ext.disabled = false;
+ }
+ },
+
+ process_get_query_records: function(query, records)
+ {
+ this.setup_update_query(query, records);
+
+ /* Publish full results */
+ tmp_query = manifold.find_query(query.query_uuid);
+ manifold.publish_result_rec(tmp_query.analyzed_query, records);
+ },
+
+ /**
+ *
+ * What we need to do when receiving results from an update query:
+ * - differences between what we had, what we requested, and what we obtained
+ * . what we had : update_query_orig (simple fields and set fields managed differently)
+ * . what we requested : update_query
+ * . what we received : records
+ * - raise appropriate events
+ *
+ * The normal process is that results similar to Get will be pushed in the
+ * pubsub mechanism, thus repopulating everything while we only need
+ * diff's. This means we need to move the publish functionalities in the
+ * previous 'process_get_query_records' function.
+ */
+ process_update_query_records: function(query, records)
+ {
+ // First issue: we request everything, and not only what we modify, so will will have to ignore some fields
+ var query_uuid = query.query_uuid;
+ var query_ext = manifold.query_store.find_analyzed_query_ext(query_uuid);
+ var update_query = query_ext.main_query_ext.update_query_ext.query;
+ var update_query_orig = query_ext.main_query_ext.update_query_orig_ext.query;
+
+ // Since we update objects one at a time, we can get the first record
+ var record = records[0];
+
+ // Let's iterate over the object properties
+ for (var field in record) {
+ switch (this.get_type(record[field])) {
+ case TYPE_VALUE:
+ // Did we ask for a change ?
+ var update_value = update_query[field];
+ if (!update_value)
+ // Not requested, if it has changed: OUT OF SYNC
+ // How we can know ?
+ // We assume it won't have changed
+ continue;
+
+ var result_value = record[field];
+ if (!result_value)
+ throw "Internal error";
+
+ data = {
+ request: FIELD_REQUEST_CHANGE,
+ key : field,
+ value : update_value,
+ status: (update_value == result_value) ? FIELD_REQUEST_SUCCESS : FIELD_REQUEST_FAILURE,
+ }
+ manifold.raise_record_event(query_uuid, FIELD_STATE_CHANGED, data);
+
+ break;
+ case TYPE_RECORD:
+ throw "Not implemented";
+ break;
+
+ case TYPE_LIST_OF_VALUES:
+ // Same as list of records, but we don't have to extract keys
+ var result_keys = record[field]
+
+ // The rest of exactly the same (XXX factorize)
+ var update_keys = update_query_orig.params[field];
+ var query_keys = update_query.params[field];
+ var added_keys = $.grep(query_keys, function (x) { return $.inArray(x, update_keys) == -1 });
+ var removed_keys = $.grep(update_keys, function (x) { return $.inArray(x, query_keys) == -1 });
+
+
+ $.each(added_keys, function(i, key) {
+ if ($.inArray(key, result_keys) == -1) {
+ data = {
+ request: FIELD_REQUEST_ADD,
+ key : field,
+ value : key,
+ status: FIELD_REQUEST_FAILURE,
+ }
+ } else {
+ data = {
+ request: FIELD_REQUEST_ADD,
+ key : field,
+ value : key,
+ status: FIELD_REQUEST_SUCCESS,
+ }
+ }
+ manifold.raise_record_event(query_uuid, FIELD_STATE_CHANGED, data);
+ });
+ $.each(removed_keys, function(i, key) {
+ if ($.inArray(key, result_keys) == -1) {
+ data = {
+ request: FIELD_REQUEST_REMOVE,
+ key : field,
+ value : key,
+ status: FIELD_REQUEST_SUCCESS,
+ }
+ } else {
+ data = {
+ request: FIELD_REQUEST_REMOVE,
+ key : field,
+ value : key,
+ status: FIELD_REQUEST_FAILURE,
+ }
+ }
+ manifold.raise_record_event(query_uuid, FIELD_STATE_CHANGED, data);
+ });
+
+
+ break;
+ case TYPE_LIST_OF_RECORDS:
+ // example: slice.resource
+ // - update_query_orig.params.resource = resources in slice before update
+ // - update_query.params.resource = resource requested in slice
+ // - keys from field = resources obtained
+ var key = manifold.metadata.get_key(field);
+ if (!key)
+ continue;
+ if (key.length > 1) {
+ throw "Not implemented";
+ continue;
+ }
+ key = key[0];
+
+ /* XXX should be modified for multiple keys */
+ var result_keys = $.map(record[field], function(x) { return x[key]; });
+
+ var update_keys = update_query_orig.params[field];
+ var query_keys = update_query.params[field];
+ var added_keys = $.grep(query_keys, function (x) { return $.inArray(x, update_keys) == -1 });
+ var removed_keys = $.grep(update_keys, function (x) { return $.inArray(x, query_keys) == -1 });
+
+
+ $.each(added_keys, function(i, key) {
+ if ($.inArray(key, result_keys) == -1) {
+ data = {
+ request: FIELD_REQUEST_ADD,
+ key : field,
+ value : key,
+ status: FIELD_REQUEST_FAILURE,
+ }
+ } else {
+ data = {
+ request: FIELD_REQUEST_ADD,
+ key : field,
+ value : key,
+ status: FIELD_REQUEST_SUCCESS,
+ }
+ }
+ manifold.raise_record_event(query_uuid, FIELD_STATE_CHANGED, data);
+ });
+ $.each(removed_keys, function(i, key) {
+ if ($.inArray(key, result_keys) == -1) {
+ data = {
+ request: FIELD_REQUEST_REMOVE,
+ key : field,
+ value : key,
+ status: FIELD_REQUEST_SUCCESS,
+ }
+ } else {
+ data = {
+ request: FIELD_REQUEST_REMOVE,
+ key : field,
+ value : key,
+ status: FIELD_REQUEST_FAILURE,
+ }
+ }
+ manifold.raise_record_event(query_uuid, FIELD_STATE_CHANGED, data);
+ });
+
+
+ break;
+ }
+ }
+
+ // XXX Now we need to adapt 'update' and 'update_orig' queries as if we had done a get
+ this.setup_update_query(query, records);
+ },
+
+ process_query_records: function(query, records)
+ {
+ if (query.action == 'get') {
+ this.process_get_query_records(query, records);
+ } else if (query.action == 'update') {
+ this.process_update_query_records(query, records);
+ }
+ },
+