X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=manifold%2Fjs%2Fmanifold.js;h=bae00c7c012a9e005bd5320b313a60eeef8e2083;hb=e256853ef256809864927b91deb42e713baea769;hp=f6c4f56372e45a8e0a1ef18dbbeed1db0e83b4c9;hpb=a627b9a4b0193193e8a05ae030a25c913d742ea0;p=myslice.git diff --git a/manifold/js/manifold.js b/manifold/js/manifold.js index f6c4f563..bae00c7c 100644 --- a/manifold/js/manifold.js +++ b/manifold/js/manifold.js @@ -25,6 +25,19 @@ function debug_query (msg, query) { */ var manifold = { + spin_presets: {}, + + spin: function(locator, active /*= true */) { + active = typeof active !== 'undefined' ? active : true; + try { + if (active) { + $(locator).spin(manifold.spin_presets); + } else { + $locator.spin(false); + } + } catch (err) { messages.debug("Cannot turn spins on/off " + err); } + }, + /*! * Associative array storing the set of queries active on the page * \memberof Manifold @@ -42,7 +55,7 @@ var manifold = { if (query.analyzed_query == null) { query.analyze_subqueries(); } - manifold.all_queries[query.query_uuid]=query; + manifold.all_queries[query.query_uuid]=query; }, /*! @@ -60,6 +73,17 @@ var manifold = { asynchroneous_debug : true, + /** + * \brief We use js function closure to be able to pass the query (array) + * to the callback function used when data is received + */ + success_closure: function(query, publish_uuid, callback /*domid*/) + { + return function(data, textStatus) { + manifold.asynchroneous_success(data, query, publish_uuid, callback /*domid*/); + } + }, + // Executes all async. queries // input queries are specified as a list of {'query_uuid': , 'id': } asynchroneous_exec : function (query_publish_dom_tuples) { @@ -69,13 +93,8 @@ var manifold = { try { if (manifold.asynchroneous_debug) messages.debug("Turning on spin with " + jQuery(".need-spin").length + " matches for .need-spin"); - jQuery('.need-spin').spin(spin_presets); + jQuery('.need-spin').spin(manifold.spin_presets); } catch (err) { messages.debug("Cannot turn on spins " + err); } - - // We use js function closure to be able to pass the query (array) to the - // callback function used when data is received - var success_closure = function(query, publish_uuid, domid) { - return function(data, textStatus) {manifold.asynchroneous_success(data, query, publish_uuid, domid);}}; // Loop through input array, and use publish_uuid to publish back results jQuery.each(query_publish_dom_tuples, function(index, tuple) { @@ -90,16 +109,85 @@ var manifold = { } // not quite sure what happens if we send a string directly, as POST data is named.. // this gets reconstructed on the proxy side with ManifoldQuery.fill_from_POST - jQuery.post(manifold.proxy_url, {'json':query_json} , success_closure(query, publish_uuid, tuple.domid)); + jQuery.post(manifold.proxy_url, {'json':query_json} , manifold.success_closure(query, publish_uuid, tuple.callback /*domid*/)); }) }, + /** + * \brief Forward a query to the manifold backend + * \param query (dict) the query to be executed asynchronously + * \param callback (function) the function to be called when the query terminates + * Deprecated: + * \param domid (string) the domid to be notified about the results (null for using the pub/sub system + */ + forward: function(query, callback /*domid*/) { + var query_json = JSON.stringify(query); + $.post(manifold.proxy_url, {'json': query_json} , manifold.success_closure(query, query.query_uuid, callback/*domid*/)); + }, + + /*! + * Returns whether a query expects a unique results. + * This is the case when the filters contain a key of the object + * \fn query_expects_unique_result(query) + * \memberof Manifold + * \param ManifoldQuery query Query for which we are testing whether it expects a unique result + */ + query_expects_unique_result: function(query) { + /* XXX we need functions to query metadata */ + //var keys = MANIFOLD_METADATA[query.object]['keys']; /* array of array of field names */ + /* TODO requires keys in metadata */ + return true; + }, + + /*! + * Publish result + * \fn publish_result(query, results) + * \memberof Manifold + * \param ManifoldQuery query Query which has received results + * \param array results results corresponding to query + */ + publish_result: function(query, result) { + /* Publish an update announce */ + var channel="/results/" + query.query_uuid + "/changed"; + if (manifold.asynchroneous_debug) + messages.debug("publishing result on " + channel); + if (typeof result === 'undefined') + result = []; + jQuery.publish(channel, [result, query]); + }, + + /*! + * Recursively publish result + * \fn publish_result_rec(query, result) + * \memberof Manifold + * \param ManifoldQuery query Query which has received result + * \param array result result corresponding to query + */ + publish_result_rec: function(query, result) { + /* If the result is not unique, only publish the top query; + * otherwise, publish the main object as well as subqueries + * XXX how much recursive are we ? + */ + if (manifold.query_expects_unique_result(query)) { + /* Also publish subqueries */ + jQuery.each(query.subqueries, function(object, subquery) { + manifold.publish_result_rec(subquery, result[0][object]); + /* TODO remove object from result */ + }); + } + manifold.publish_result(query, result); + }, + // if set domid allows the result to be directed to just one plugin // most of the time publish_uuid will be query.query_uuid - // however in some cases we wish to publish the results under a different uuid - // e.g. an updater wants to publish its results as if from the original (get) query - asynchroneous_success : function (data, query, publish_uuid, domid) { + // however in some cases we wish to publish the result under a different uuid + // e.g. an updater wants to publish its result as if from the original (get) query + asynchroneous_success : function (data, query, publish_uuid, callback /*domid*/) { // xxx should have a nicer declaration of that enum in sync with the python code somehow + + /* If a callback has been specified, we redirect results to it */ + if (!!callback) { callback(data); return; } + if (data.code == 2) { // ERROR alert("Your session has expired, please log in again"); window.location="/logout/"; @@ -111,18 +199,22 @@ var manifold = { jQuery.publish("/results/" + publish_uuid + "/failed", [data.code, data.description] ); } // once everything is checked we can use the 'value' part of the manifoldresult - var value=data.value; - if (value) { - if (!!domid) { - /* Directly inform the requestor */ - if (manifold.asynchroneous_debug) messages.debug("directing results to " + domid); - jQuery('#' + domid).trigger('results', [value]); - } else { - /* Publish an update announce */ - var channel="/results/" + publish_uuid + "/changed"; - if (manifold.asynchroneous_debug) messages.debug("publishing results on " + channel); - jQuery.publish(channel, [value, query]); - } + var result=data.value; + if (result) { + //if (!!callback /* domid */) { + // /* Directly inform the requestor */ + // if (manifold.asynchroneous_debug) messages.debug("directing result to callback"); + // callback(result); + // //if (manifold.asynchroneous_debug) messages.debug("directing result to " + domid); + // //jQuery('#' + domid).trigger('results', [result]); + //} else { + /* XXX Jordan XXX I don't need publish_uuid here... What is it used for ? */ + /* query is the query we sent to the backend; we need to find the + * corresponding analyezd_query in manifold.all_queries + */ + tmp_query = manifold.find_query(query.query_uuid); + manifold.publish_result_rec(tmp_query.analyzed_query, result); + //} } },