checkDepositionType: function checkDepositionType() {
var that = this;
this.deposition_type = this.$deposition_type.val();
var $not_type_related_fields = {};
var $type_related_fields = {};
for (var name in this.$field_list) {
if (name !== this.deposition_type && this.$field_list.hasOwnProperty(name)) {
$not_type_related_fields[name] = this.$field_list[name];
}
if (name === this.deposition_type && this.$field_list.hasOwnProperty(name)) {
$type_related_fields[name] = this.$field_list[name];
}
}
// Slide Up
$.when.apply(this, $.map($not_type_related_fields, function(value, key) {
return that.slideUpFields(value.not('.hidden'));
})).done(function() {
that.slideUpPanel();
});
// Slide Down
$.when.apply(this, $.map($type_related_fields, function(value, key) {
return that.slideDownFields(value.not('.hidden'));
})).done(function() {
that.slideDownPanel();
});
},
changeEncryption_: function(fn) {
var models = this.models;
var dfds = [];
var attrs;
var model;
for (var i = 0; i < models.length; i++) {
model = models[i];
attrs = model.toJSON();
fn.call(encryptor, attrs);
// Defer triggering events until after all of the notes have been
// processed.
dfds.push(model.save(attrs, { silent: true }));
}
dfds = $.when.apply($, dfds);
dfds.done(function() {
// Trigger a reset event once all of the encryption / decryption
// operations have completed.
this.trigger('reset', this);
}.bind(this));
return dfds.promise();
}
BiolinksViewer.prototype.updateDistribution = function() {
var viewer = this;
var path = viewer.options.paths[viewer.selectedContent.label];
var topics = viewer.options.topics[viewer.selectedContent.label];
var articles = viewer.options.articles[viewer.selectedContent.label]
var prefix = viewer.selectedContent.prefix;
viewer.topicArticles = _.filter(articles, function(art) {
return art.topic === viewer.selectedTopic;
});
viewer.topicArticleIds = _.pluck(viewer.topicArticles, 'id');
viewer.topicArticleAltIds = _.pluck(viewer.topicArticles, 'altId');
if (viewer.refresh === true) {
var distData = viewer.parser.calculateDistribution(viewer.annotatedArticles, viewer.groupFilter,
viewer.options.noLambda);
viewer.topicDistribution.setData(distData);
viewer.topicDistribution.setPrefix(viewer.selectedContent.prefix);
viewer.topicDistribution.setAlternativePrefix(viewer.selectedContent.altPrefix);
viewer.topicDistribution.render();
hideSimilarityGroup(viewer);
hideAnnotationGroup(viewer);
viewer.topicDistribution.selectById(viewer.refreshReferenceId);
viewer.refreshReferenceId = undefined;
} else {
loadAnnotations(viewer);
jQuery.when.apply(null, viewer.loaders)
.then(function() {
var distData = viewer.parser.calculateDistribution(viewer.annotatedArticles, undefined,
viewer.options.noLambda);
viewer.allDistData = distData;
viewer.topicDistribution.setData(distData);
viewer.topicDistribution.setPrefix(viewer.selectedContent.prefix);
viewer.topicDistribution.setAlternativePrefix(viewer.selectedContent.altPrefix);
viewer.topicDistribution.render();
if (viewer.articleTitle !== undefined) {
if (viewer.topicArticles.length >= 2) {
viewer.annotSectionTitle
.text('Top ' + viewer.options.maxTerms + ' Semantic annotations for selected reference and compared articles');
viewer.annotSectionCaption.style('display', 'block');
viewer.articleTitle.text('Click on any column in the distribution matrix to select an article ' +
'and display similarity network');
} else {
viewer.annotSectionTitle
.text('Top ' + viewer.options.maxTerms + ' Semantic annotations for selected reference article');
viewer.annotSectionCaption.style('display', 'none');
viewer.articleTitle.text('Click on any column in the distribution matrix to select an article ' +
'and display annotations');
}
hideSimilarityGroup(viewer);
hideAnnotationGroup(viewer);
}
}
);
}
};
const getCustomColumnData = (url, params, cb, customColumnsDfd, waitForDfds) => {
const customColumnDataLoaded = $.Deferred();
let customColumnDataDfds;
// waitForDfds ensures that custom column data is loaded *last*
$.when.apply($, waitForDfds).then(() => {
customColumnsDfd.then(customColumns => {
customColumnDataDfds = customColumns.map(col => getDataForColumn(col, url, params, cb));
});
});
$.when.apply($, customColumnDataDfds)
.then(() => customColumnDataLoaded.resolve());
return customColumnDataLoaded;
};
// Converts all the blob URLs (e.g. "blob:http://examples.com/abc-def-ghi") in `htmlString` to data URLs.
// Async function, returns $.Deferred instance that will be resolved with the final HTML.
export default function replaceBlobsWithDataURLs (htmlString) {
const deferred = new $.Deferred()
const blobURLs = htmlString.match(/["']blob:.*?["']/gi)
if (blobURLs === null) {
// Nothing to do.
deferred.resolve(htmlString)
return deferred
}
const blobRequests = blobURLs
// .slice(1, -1) removes " or ' from the URI.
.map(blobURLWithQuotes => blobURLWithQuotes.slice(1, -1))
.map(blobURL => convertBlobToDataURL(blobURL))
$.when.apply($, blobRequests).done(function () {
// Convert arguments to real Array instance.
const mappings = Array.prototype.slice.call(arguments)
let newHtmlString = htmlString
mappings.forEach(mapping => {
newHtmlString = newHtmlString.replace(mapping.blobURL, mapping.dataURL)
})
deferred.resolve(newHtmlString)
})
return deferred
}
initialize: function (options) {
var promises, self;
self = this;
this._deferredInit();
this.built = $.Deferred();
options = options || {};
this.processOptions(options);
this.initDataGrid(options);
promises = [this.built.promise()];
// run related builders
_.each(options.builders, function (module) {
var built = $.Deferred();
promises.push(built.promise());
require([module], _.partial(runBuilder, built, options));
});
$.when.apply($, promises).always(function () {
$(options.el).html(options.$el.children());
self.subComponents = _.compact(arguments);
self._resolveDeferredInit();
});
},
removeSelectedPubsFromCategory: function() {
var self = this;
var selectedFilter = first(getFilters(this.model).listId);
var serviceUrl = window.CONFIG.scriptRoot + '/manager/services/lists/' + selectedFilter;
var selectedPubs = this.collection.filter(function(model) {
return model.has('selected') && model.get('selected');
});
// get publication ids from selectedPubs
var selectedPubIds = map(selectedPubs, 'id');
// execute the delete requests
var removeDeferreds = [];
if (selectedPubIds.length === 0) {
this.warningDialogView.show(
'Select Publications',
'You must select at least one publication to remove from the current filter list.'
);
} else {
removeDeferreds = map(selectedPubIds, function(selectedPubId) {
var targetUrl = serviceUrl + '/pubs/' + selectedPubId;
return $.ajax({
url: targetUrl,
method: 'DELETE'
});
});
}
$.when.apply(this, removeDeferreds)
.done(function() {
self.alertView.showSuccessAlert('Selected publications successfully removed from the current list.');
})
.fail(function() {
self.alertView.showDangerAlert('Error: Unable to remove the selected publications from the current list.');
});
},
getTimeEntryRange = function(spentOn, noOfDays) {
var firstDay = spentOn.weekday(0);
var deferred = $.Deferred(),
promises = [];
for (var i = 0; i < noOfDays; i++) {
var day = firstDay.clone().day(i);
promises.push(this.serviceAccessor.getTimeEntries(day));
}
$.when.apply($, promises).done(function () {
var data = [],
count = 0;
for (var i = 0; i < noOfDays; i++) {
var day = firstDay.clone().day(i);
data.push({
day: day,
data: arguments[count].time_entries
});
count++;
}
deferred.resolve(data);
}.bind(this)).fail(function () {
deferred.reject();
}.bind(this));
return deferred.promise();
};
processDatagridOptions: function(deferred, options) {
if (tools.isMobile() || !options.metadata.inline_editing || !options.metadata.inline_editing.enable) {
deferred.resolve();
return;
}
var promises = this.preparePlugin(options)
.concat(this.prepareColumns(options));
$.when.apply($, promises).done(function() {
if (!options.metadata.plugins) {
options.metadata.plugins = [];
}
options.metadata.plugins.push({
constructor: options.metadata.inline_editing.plugin,
options: options
});
deferred.resolve();
}).fail(function(e) {
if (console && console.error) {
console.log(e);
console.error('Inline editing loading failed. Reason: ' + e.message);
} else {
throw e;
}
deferred.resolve();
});
},
init: function(value, bindingContext){
this.callParent(value, bindingContext);
/*History.prototype.constructor.apply(this, arguments);*/
var me = this;
this.$el = $(this.domNode);
var m = this.getModel(),
xids = [],
promises = [];
$('>.x-contents-content', this.$el).each(function(){
xids.push($(this).attr('xid'));
});
justep.Array.each(xids, function(xid){
promises.push(m.componentPromise(xid));
});
var loadedDtd = m.getLoadedDeferred();
$.when.apply($, promises).done(function(){
me.to(me.active,function(){
me.beginInterval();
loadedDtd.resolve();
});
me.inited();
});
if(this.swipe){
this.supportContentsTouchMove();
}
if(this.swipe || this.slidable){
$(this.domNode).addClass('slidable');
this.optimizePerformanceForKeyboard();
}
this.optimizePerformance();
this.fixWebkitBug();
return {dependence: true};
},
whenValid: function ({force = false, value, group, _refreshed} = {}) {
// Recompute options and rebind constraints to have latest changes
if (!_refreshed)
this.refreshConstraints();
// do not validate a field if not the same as given validation group
if (group && !this._isInGroup(group))
return;
this.validationResult = true;
// A field without constraint is valid
if (!this.hasConstraints())
return $.when();
// Value could be passed as argument, needed to add more power to 'parsley:field:validate'
if ('undefined' === typeof value || null === value)
value = this.getValue();
if (!this.needsValidation(value) && true !== force)
return $.when();
var groupedConstraints = this._getGroupedConstraints();
var promises = [];
$.each(groupedConstraints, (_, constraints) => {
// Process one group of constraints at a time, we validate the constraints
// and combine the promises together.
var promise = $.when(
...$.map(constraints, constraint => this._validateConstraint(value, constraint))
);
promises.push(promise);
if (promise.state() === 'rejected')
return false; // Interrupt processing if a group has already failed
});
return $.when.apply($, promises);
},
/**
* @param {String|Array|Object} options
* @param {Function} cb
*
* @return {Promise}
*/
function load ( options, cb ) {
var dfd = $.Deferred();
options = constructOptions(options);
$.when
.apply(window, bundledDfds(options.url, { cache: options.cache } ))
.done(function () {
var args = normalizeArgs(arguments);
dfd.resolve.apply(window, args);
if ( cb ) {
cb.apply(window, args);
}
if ( options.success ) {
options.success.apply(window, args);
}
})
.fail(function () {
dfd.reject.apply(window, arguments);
if ( options.error ) {
options.error.apply(window, arguments);
}
});
return dfd.promise();
}
globals_keys.fetch({'success': function(global_keys, response_global_keys, options_global_keys){
if( global_keys.length == 0 ){
syncWebService(cb_ok,cb_error);
}else{
var fetch = function(_items,_key){
return _items.fetch({'success': function(fetched_items, response_items, options_items){
app.globals[_key] = fetched_items;
//Backbone's fetch returns jQuery ajax deferred object > works with $.when
}});
};
var fetches = [];
global_keys.each(function(value, key, list){
var global_id = value.get('id');
var items = new Items.Items({global:global_id});
fetches.push(fetch(items,global_id));
});
$.when.apply($, fetches).done(function () {
if( app.globals.length == 0 ){
syncWebService(cb_ok,cb_error);
}else{
Utils.log('Global items retrieved from local storage.',{globals:app.globals});
// @TODO: find a better way to do this?
addFavoritesToGlobals();
cb_ok();
}
});
}
}});
syncDelayed: function(){
var models = this.getDelayedModels();
var sync = _.map(models, function(model){
return model.remoteSync(null, model);
});
return $.when.apply(this, sync);
},
return function (options) {
var deferred, promises;
options.$el = $(document.createDocumentFragment());
options.gridName = options.metadata.options.gridName;
// run grid builders
deferred = $.Deferred();
options.gridPromise = deferred.promise();
promises = [options.gridPromise];
runBuilder(deferred, options, gridBuilder);
// run gridViews builder
deferred = $.Deferred();
promises.push(deferred.promise());
runBuilder(deferred, options, gridViewsBuilder);
// run other builders
_.each(options.builders, function (module) {
var deferred = $.Deferred();
promises.push(deferred.promise());
require([module], _.partial(runBuilder, deferred, options));
});
$.when.apply($, promises).always(function () {
$(options.el).html(options.$el.children());
});
return promises;
};
.then(function(response) {
const info = response.data;
if (!info) return;
if (info.type === 'file' || info.type === 'link') {
return this.fetchFileSummary(this.props.uuid, '/').then(function(blob) {
this.setState({ fileContents: blob, stdout: null, stderr: null });
});
} else if (info.type === 'directory') {
// Get stdout/stderr (important to set things to null).
let fetchRequests = [];
let stateUpdate = {
fileContents: null,
};
['stdout', 'stderr'].forEach(
function(name) {
if (info.contents.some((entry) => entry.name === name)) {
fetchRequests.push(
this.fetchFileSummary(this.props.uuid, '/' + name).then(
function(blob) {
stateUpdate[name] = blob;
},
),
);
} else {
stateUpdate[name] = null;
}
}.bind(this),
);
$.when.apply($, fetchRequests).then(() => {
this.setState(stateUpdate);
});
return $.when(fetchRequests);
}
})
$.when.apply($, loads).always(function () {
var initializes = _.flatten(_.toArray(arguments), true);
$.when.apply($, initializes).always(function () {
var components = _.compact(_.flatten(_.toArray(arguments), true));
initialized.resolve(components);
});
});
moveLayer: function (d) {
var from = d.from;
var to = d.to;
var movingLayer = layerDefinitionsCollection.at(from);
layerDefinitionsCollection.remove(movingLayer, {silent: true});
layerDefinitionsCollection.add(movingLayer, {at: to, parse: false, silent: true});
var saveAnalysisPromises = layerDefinitionsCollection
.chain()
.map(function (layerDefModel) {
var nodeDefModel = layerDefModel.getAnalysisDefinitionNodeModel();
if (nodeDefModel) {
return analysisDefinitionsCollection.saveAnalysisForLayer(layerDefModel);
}
})
.compact()
.value();
$.when.apply($, saveAnalysisPromises).done(function () { // http://api.jquery.com/jQuery.when/
layerDefinitionsCollection.save({
success: function () {
layerDefinitionsCollection.trigger('layerMoved', movingLayer, from, to);
}
});
});
},
initialize: function(options) {
if (!options.enableFilters) {
options.builders = _.reject(options.builders, function(module) {
return module === 'orofilter/js/datafilter-builder';
});
}
options.builders.push('orodatagrid/js/inline-editing/builder');
var self = this;
this._deferredInit();
this.built = $.Deferred();
options = options || {};
this.fixStates(options);
this.processOptions(options);
this.initDataGrid(options);
var promises = [this.built.promise()];
// run related builders
_.each(options.builders, function(module) {
var built = $.Deferred();
promises.push(built.promise());
require([module], _.partial(runBuilder, built, options));
});
$.when.apply($, promises).always(function() {
self.subComponents = _.compact(arguments);
self._resolveDeferredInit();
self.$componentEl.find('.view-loading').remove();
self.$el.show();
self.grid.trigger('shown');
});
},
Validator.prototype.isFormValid = function() {
var _this = this;
var formValidity = this.validateForm();
var triggerValid = function(type) {
_this.$element.trigger(type + '.validator.amui');
};
if (formValidity.async) {
var masterDfd = new $.Deferred();
$.when.apply(null, formValidity.promises).then(function() {
masterDfd.resolve();
triggerValid('valid');
}, function() {
masterDfd.reject();
triggerValid('invalid');
});
return masterDfd.promise();
} else {
if (!formValidity.valid) {
formValidity.$invalidFields.first().focus();
triggerValid('invalid');
return false;
}
triggerValid('valid');
return true;
}
};
this.built.then(function() {
/**
* #3. Run builders
*/
var buildersReadyPromises = [];
function throwNoInitMethodError() {
throw new TypeError('Builder does not have init method');
}
// run related builders
for (var i = 0; i < builderImpl.length; i++) {
var builder = builderImpl[i];
var built = $.Deferred();
buildersReadyPromises.push(built.promise());
if (!_.has(builder, 'init') || !$.isFunction(builder.init)) {
built.resolve();
_.defer(throwNoInitMethodError);
continue;
}
builder.init(built, options);
}
$.when.apply($, buildersReadyPromises).always(function() {
/**
* #4. Done
*/
self.subComponents = _.compact(arguments);
self._resolveDeferredInit();
self.$componentEl.find('.view-loading').remove();
self.$el.show();
self.grid.shown = true;
self.grid.trigger('shown');
});
});
loadAllQueryGeometryModels: function (callback) {
var promises = this.filter(function (layerDefModel) {
return layerDefModel.isDataLayer();
}).map(function (layerDefModel) {
var queryGeometryModel = layerDefModel.getAnalysisDefinitionNodeModel().queryGeometryModel;
var status = queryGeometryModel.get('status');
var deferred = new $.Deferred();
if (queryGeometryModel.isFetched()) {
deferred.resolve();
} else if (queryGeometryModel.canFetch()) {
if (status !== 'fetching') {
queryGeometryModel.fetch({
success: function () {
deferred.resolve();
},
error: function () {
deferred.reject();
}
});
} else {
deferred.resolve();
}
} else {
deferred.reject();
}
return deferred.promise();
}, this);
$.when.apply($, promises).done(callback);
},
parseIdsVersion: function(results){
var that = this;
var d = $.Deferred();
var promises = [];
results.forEach(function(ModelSimple, index){
var tmpD = $.Deferred();
promises.push(tmpD.promise());
// ModelSimple: _id and _version
var newModel = new that.model({
_id: ModelSimple._id
});
// "hasFetched" doesn't matter, just if the version numbers match!
if(newModel.hasFetched){
if(newModel.get('__v') == ModelSimple.__v){
// equal!
// - resolve promise
results[index] = newModel.toJSON();
tmpD.resolve();
} else {
// Not equal, need to update the model to current version!
newModel.fetch({
success: function(resp){
// resolve, finally, for collection
results[index] = resp;
tmpD.resolve();
}
});
}
} else {
// Fetch
newModel.populated().then(function(){
// resolve promise for this model
results[index] = newModel.toJSON();
tmpD.resolve();
});
newModel.fetch({prefill: true});
}
});
$.when.apply(this, promises).then(function(schemas) {
console.log('results');
console.log(results);
d.resolve(results);
}, function(e) {
console.log("My ajax failed");
});
return d.promise();
},
IDBStore.prototype.select = function(meta, filters) {
var def = new $.Deferred();
try {
var promises = [];
var transaction = this.db.transaction([meta.name], 'readonly');
var store = transaction.objectStore(meta.name);
//case - filter provided
if (filters && filters.data && filters.data.length > 0) {
//use the index to fetch the data
var index = filters.index ? store.index(filters.index) : undefined;
for (var i = 0; i < filters.data.length; i = i + 1) {
var request = index ? index.openCursor(filters.data[i]) : store.openCursor(filters.data[i]);
//for each filter query we associate a cursor reader, which appends the data
//to the promise data array and returns the same on the promise resolution
var deferred = new $.Deferred();
deferred.data = [];
request.onsuccess = cursorReader.bind(deferred);
request.onerror = deferred.reject;
promises.push(deferred.promise());
}
} else {
//case - select - no filter
var allDataReq;
//if index is provided iterate over the index
if (meta.index) {
allDataReq = store.index(meta.index).openCursor();
} else {
allDataReq = store.openCursor();
}
//cursor reads, and which appends the data
//to the promise data array and returns the same on the promise resolution
var deferredForReq = new $.Deferred();
deferredForReq.data = [];
allDataReq.onsuccess = cursorReader.bind(deferredForReq);
allDataReq.onerror = deferredForReq.reject;
promises.push(deferredForReq.promise());
}
//grouping all data read by different filter cursors
$.when.apply($, promises).then(function() {
var data = [];
for (var i = 0; i < arguments.length; i = i + 1) {
data = data.concat(arguments[i]);
}
def.resolve(data);
}).fail(function(error) {
def.reject(error);
});
} catch (e) {
def.reject(e);
}
return def.promise();
};
sendMessage = function(messages, tags, user_uid) {
messages = utils.forceArray(messages);
tags = utils.forceArray(tags);
user_uid = utils.forceString(user_uid);
all_deferreds = [];
if( tags.length && messages.length && user_uid ) {
_(messages).each(function(text){
var message = JSON.stringify({'text': text,
'message_uid': genUID.token(),
'user_uid': user_uid});
_(tags).each(function(channel){
if( channel && message ) {
var deferred = $.Deferred();
all_deferreds.push(deferred);
Backendless
.Messaging
.publish(
channel,
message,
null,
null,
new Backendless.Async(
function(response) {
deferred.resolve(response);
}, function(error) {
deferred.reject(error);
}
));
}
});
});
}
return $.when.apply($, all_deferreds);
};
compiler.compile_to_doc_str = function(inputs) {
var d = $.Deferred();
var compiling = _.map(inputs, function(input) {
return compiler.compile(input);
});
$.when.apply(null, compiling).done(function() {
var locals = _.reduce(arguments, function(memo, value) {
memo[value.panel] = _.pick(value, 'mode', 'output');
return memo;
}, {});
if (_.has(locals, 'script')) {
locals.script.output =
locals.script.output.replace(/<\/script>/g, '<\\/script>');
}
template_fn_p.done(function(template_fn) {
var html = template_fn(locals);
d.resolve(html);
});
}).fail(d.reject);
return d.promise();
};
activate: function(){
// fail or reject allDone according to our defStack
$.when.apply($,defStack)
.done(function(){allDone.resolve();})
.fail(function(){allDone.reject();});
return allDone.promise();
},
module.exports = function (id_array) {
var _lang = URL.getKeyValue('lang') || '';
var fields = {
lang: _lang,
format: 'json'
};
// указваем, сколько id нужно отправить за раз
var query_limit = 25;
/**
* Генерим адреса для запросов
*
* Приводим к типу массив (мало ли что там прилетело)
* Разбиваем на пачки, делаем из них правильные адреса для запросов
*/
var paths = _.chain(id_array)
.toArray()
.compact()
.chunk(query_limit)
.map(function (ids_list) {
return '/products_by_id/'+ ids_list.join() +'.json';
})
.value();
// собираем задачи
var promises = $.map(paths, function (path) {
return $.getJSON(path, fields).then(function (response) {
return response;
});
});
/**
* Склеиваем ответы.
*
* Проходимся по всем получившимся промисам, дергаем их
*/
return $.when.apply(this, promises)
.then(function () {
/**
* Получаем ответы ото ВСЕХ промисов.
* Приводим к типу массив, на случай если ответы все кривые и там - пустота
* Вытаскиваем массив с продуктами, склеиваем все массивы и выдаем наружу
*/
return _.chain(arguments)
.toArray()
.map(function (response) {
return response.products;
})
.flatten()
.union()
.forEach(function (product) {
if (product && _lang) {
product.url += '?lang='+ _lang;
}
})
.value()
});
};
patch: function() {
this.emit('patch');
var promises = this.map(function(model) {
return model.patch.apply(model, arguments);
});
return $.when.apply($, promises).then(this.emits('patched'));
},
save: function() {
this.emit('save');
var promises = this.map(function(model) {
return model.save();
});
return $.when.apply($, promises).then(this.emits('saved'));
},