.success(function (results) {
if (results && (results.length > 0)) {
d.resolve(results[0]);
} else {
d.resolve()
}
})
board.on("ready", function() {
//Blue
leftWrist = new five.Motor({
pin: 5
});
//White
rightWrist = new five.Motor({
pin: 6
});
//Red
leftFoot = new five.Motor({
pin: 10
});
//Green
rightFoot = new five.Motor({
pin: 11
});
board.repl.inject({
leftWrist: leftWrist ,
rightWrist: rightWrist,
leftFoot: leftFoot ,
rightFoot: rightFoot
});
//Test
Motors.shakeLeftWrist(500,255);
Motors.shakeRightWrist(500,255);
Motors.shakeLeftFoot(500,255);
Motors.shakeRightFoot(500,255);
return isInitiated.resolve();
});
SignalR.prototype.start = function(options, callback) {
var connection = this,
config = {
transport: "auto"
},
promise = new Deferred();
if (this.transport) {
// Already started
util.log("Already started");
promise.resolve(connection);
return;
}
if ($.type(options) === "function") {
callback = options;
} else if ($.type(options) === "object") {
$.extend(config, options);
if ($.type(config.callback) === "function") {
callback = config.callback;
}
}
this.on(SignalrEvents.onStart, function (e, data) {
if ($.type(callback) === "function") {
callback.call(connection);
}
promise.resolve(connection);
});
// we need to negotiate
// with the server
negotiate(this, promise, config);
return promise;
};
findFilterForEmail: function (user_id, email) {
var self = this,
d = new Deferred(),
filter_id,
itTest, seriesDone;
itTest = function (query, callback) {
query.success(function (results) {
filter_id = results && (results.length > 0) && (results[0].filter_id || results[0].id);
callback(filter_id);
}).error(function (err) { logger.error('Filter.findFilterForEmail error', err) })
};
seriesDone = function (result) {
d.resolve(result && filter_id);
};
if (email.from) {
async.detectSeries(
[
Models.FilterEmail.lookupPrivateFilterByEmail(user_id, email.from),
self.lookupBestDomain(email.from),
Models.FilterDomain.lookupBestDomain(email.from)
], itTest, seriesDone);
}
else {
d.resolve();
}
return d.promise();
}
tRepository.findById(doc_id, function(err, doc) {
if (doc == null) {
throw new Error("Couldn't find the document for doc_id: " + doc_id);
}
store[doc_id] = doc;
def.resolve(doc);
});
findFilterForEmail: function (user_id, email) {
var self = this,
d = new Deferred(),
itTest, resultFilter;
itTest = function (promise, callback) {
promise
.done(function (filter) {
resultFilter = filter;
callback(filter);
})
.fail(function (err) {
logger.error('Filter.findFilterForEmail error', err);
callback();
});
};
if (email.from) {
async.detectSeries(
[
models.ExtensionUserPrivateFilter.findByEmail(user_id, email.from),
self.lookupBestDomain(email.from),
models.FilterDomain.lookupBestDomain(email.from)
],
itTest,
function () { d.resolve(resultFilter) }
);
}
else {
d.resolve();
}
return d.promise();
}
lookupBestDomain: function (from) {
var searches, sql, d = new Deferred(), domains = this.splitDomainIntoParts(from, false);
if (domains.length > 0) {
searches = domains.map(function (domain) {
return 'SELECT id, name, {index} sort FROM filters WHERE primary_domain = "{domain}" AND user_id IS NULL'.assign({
index: domains.indexOf(domain),
domain: domain
});
});
sql = searches.join(' UNION ') + ' ORDER BY sort ASC';
sequelize.query(sql, models.Filter)
.success(function (results) {
if (results && (results.length > 0)) {
d.resolve(results[0]);
} else {
d.resolve()
}
})
.error(function (err) {
logger.error('Filter.lookupBestDomain error', err);
d.reject(err);
});
} else {
logger.warn('sender domains not found - from: ' + from);
d.resolve();
}
return d.promise();
},
deferred.map(packages, function(arg){
var parsedArg = parseArg(arg);
if (parsedArg.valid){
return pkg.install(parsedArg, options);
} else {
return deferred.resolve(parsedArg);
}
}).then(function(pkgList){
module.exports.toJquery = function (string) {
var dfd = new Deferred();
try {
dfd.resolve(cheerio.load(string));
} catch (e) {
dfd.reject(e);
}
return dfd.promise();
};
setTimeout(function() {
if (vals.a === 15 && count === 0) {
assert.ok(true);
} else {
assert.ok(false);
}
count++;
deferred.resolve();
},1500);
module.exports.toJSON = function (string) {
var dfd = new Deferred();
try {
dfd.resolve(JSON.parse(string));
} catch (e) {
dfd.reject(e);
}
return dfd.promise();
};
_updateResolvedDeferred(): void {
if (this._isSettled() && !this._resolvedDeferred.isSettled()) {
if (this._errors.length) {
this._resolvedDeferred.reject(this._errors[0]);
} else {
this._resolvedDeferred.resolve(undefined);
}
}
}
.done(function(cached) {
if (!cached) {
this.requestAndCache(url, acceptNotOnlyHttpStatus200)
.fail(deferred.reject)
.done(deferred.resolve);
} else {
deferred.resolve(cached);
}
}.bind(this));
.done(function(user) {
if (user) {
deferred.resolve(user);
} else {
this.insert(userToFind)
.fail(deferred.reject)
.done(callWithFirstInArray(deferred.resolve));
}
}.bind(this));
.done(function() {
this.$('.fn-portlet').html(this.template(this.collection.toJSON()));
if (this.options.config.viewType === 'imagelistview') {
this._renderWebContents();
} else {
this._addScrollers();
}
res.resolve();
}.bind(this))
module.exports.JSONtoString = function (json) {
var dfd = new Deferred();
var string;
try {
string = JSON.stringify(json);
dfd.resolve(string);
} catch (e) {
dfd.reject(e);
}
return dfd.promise();
};
callback = function(minResult) {
var result = maximizeHubResponse(minResult);
$.extend(self.state, result.State);
if (result.Error) {
if (result.StackTrace) {
self.connection.log(result.Error + "\n" + result.StackTrace);
}
d.reject(result.Error, false);
} else {
d.resolve(result.Result);
}
};
function(response){
try{
results = utils.parseXmlSearchResult(response);
}catch(e){
results = [];
}
dfd.resolve(results);
scope.emit.call(scope, "search", results);
});
fs.read(fd, buffer, 0, length, start, function(err, num) {
if(err){ dfd.resolve(new Long()); }
/// get the number of bytes readed
buffer = buffer.slice(0, num);
/// sum the
var hNumber = new Long();
for(var i=0; i<buffer.length; i+=8){
var low = buffer.readUInt32LE(i, true);
var high = buffer.readUInt32LE(i+4, true);
var n = new Long(low, high);
hNumber = hNumber.add(n);
}
dfd.resolve(hNumber);
});
function(tail){
// sum all values
var sum = head
.add(tail)
.add(new Long(size));
// convert value to unsigned
var sumHex = sum.toUnsigned().toString(16);
dfd.resolve(sumHex);
}
function(response){
try{
var token = utils.parseXmlLoginResult(response);
// resolve with token
dfd.resolve(token);
scope.emit.call(scope, "login", token);
}catch(e){
scope.emit.call(scope, "error", e);
}
});
loadAssets.then(function(assets) {
var content = '';
content += searchInput;
content += renderMessages(evaluationResult.errors, 'errors');
content += renderScripts(evaluationResult.scripts, 'scripts');
content += renderScripts(evaluationResult.scriptsFlattened, 'scriptsFlattened');
content += renderScripts(evaluationResult.scriptsInverted, 'scriptsInverted');
content += renderMessages(evaluationResult.information, 'information');
var output = template(htmlTemplate, {
css: renderCss(assets),
javascript: renderJavaScript(assets),
header: headerHtml,
content: content
});
deferred.resolve(output);
});
function(requestData){
var postData = Mustache.render(requestData, { token: token });
dfd.resolve(postData);
});
function(requestData){
var postData = Mustache.render(requestData, { token: token, lang: lang, tag: filename });
dfd.resolve(postData);
});
function(requestData){
var postData = Mustache.render(requestData, { token: token, lang: lang, moviehash: moviehash, moviebytesize: moviebytesize, tag: filename });
dfd.resolve(postData);
});
function(requestData){
var postData = Mustache.render(requestData, { token: token, query: query, lang: lang });
dfd.resolve(postData);
});
function(requestData){
dfd.resolve(requestData);
});
function (err, data) {
dfd.resolve(data);
});
function (error, response, body) {
dfd.resolve(body);
});
fs.stat(filename, function(err, stats){
dfd.resolve(fd, stats.size);
});