_id
stringlengths 2
6
| title
stringlengths 0
58
| partition
stringclasses 3
values | text
stringlengths 52
373k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q52000
|
_send
|
train
|
function _send(data){
data.jsonrpc = "2.0";
pub.down.outgoing(serializer.stringify(data));
}
|
javascript
|
{
"resource": ""
}
|
q52001
|
_createMethod
|
train
|
function _createMethod(definition, method){
var slice = Array.prototype.slice;
return function(){
var l = arguments.length, callback, message = {
method: method
};
if (l > 0 && typeof arguments[l - 1] === "function") {
//with callback, procedure
if (l > 1 && typeof arguments[l - 2] === "function") {
// two callbacks, success and error
callback = {
success: arguments[l - 2],
error: arguments[l - 1]
};
message.params = slice.call(arguments, 0, l - 2);
}
else {
// single callback, success
callback = {
success: arguments[l - 1]
};
message.params = slice.call(arguments, 0, l - 1);
}
_callbacks["" + (++_callbackCounter)] = callback;
message.id = _callbackCounter;
}
else {
// no callbacks, a notification
message.params = slice.call(arguments, 0);
}
if (definition.namedParams && message.params.length === 1) {
message.params = message.params[0];
}
// Send the method request
_send(message);
};
}
|
javascript
|
{
"resource": ""
}
|
q52002
|
_executeMethod
|
train
|
function _executeMethod(method, id, fn, params){
if (!fn) {
if (id) {
_send({
id: id,
error: {
code: -32601,
message: "Procedure not found."
}
});
}
return;
}
var success, error;
if (id) {
success = function(result){
success = emptyFn;
_send({
id: id,
result: result
});
};
error = function(message, data){
error = emptyFn;
var msg = {
id: id,
error: {
code: -32099,
message: message
}
};
if (data) {
msg.error.data = data;
}
_send(msg);
};
}
else {
success = error = emptyFn;
}
// Call local method
if (!isArray(params)) {
params = [params];
}
try {
var result = fn.method.apply(fn.scope, params.concat([success, error]));
if (!undef(result)) {
success(result);
}
}
catch (ex1) {
error(ex1.message);
}
}
|
javascript
|
{
"resource": ""
}
|
q52003
|
train
|
function(instanceId) {
if (_apps[instanceId] && _apps[instanceId].socket) {
_apps[instanceId].socket.destroy();
}
delete _apps[instanceId];
}
|
javascript
|
{
"resource": ""
}
|
|
q52004
|
train
|
function(instanceId) {
if (!_isInit()) {
F2.log('F2.init() must be called before F2.removeApp()');
return;
}
if (_apps[instanceId]) {
F2.AppHandlers.__trigger(
_sAppHandlerToken,
F2.Constants.AppHandlers.APP_DESTROY_BEFORE,
_apps[instanceId] // the app instance
);
F2.AppHandlers.__trigger(
_sAppHandlerToken,
F2.Constants.AppHandlers.APP_DESTROY,
_apps[instanceId] // the app instance
);
F2.AppHandlers.__trigger(
_sAppHandlerToken,
F2.Constants.AppHandlers.APP_DESTROY_AFTER,
_apps[instanceId] // the app instance
);
if (_apps[instanceId].config.isSecure) {
F2.Rpc.destroy(instanceId);
}
delete _apps[instanceId];
}
}
|
javascript
|
{
"resource": ""
}
|
|
q52005
|
parseBamHeader
|
train
|
function parseBamHeader(r) {
if (!r) {
return callback(null, "Couldn't access BAM");
}
var unc = unbgzf(r, r.byteLength);
var uncba = new Uint8Array(unc);
var magic = readInt(uncba, 0);
if (magic != BAM_MAGIC) {
return callback(null, "Not a BAM file, magic=0x" + magic.toString(16));
}
var headLen = readInt(uncba, 4);
var header = '';
for (var i = 0; i < headLen; ++i) {
header += String.fromCharCode(uncba[i + 8]);
}
var nRef = readInt(uncba, headLen + 8);
var p = headLen + 12;
bam.chrToIndex = {};
bam.indexToChr = [];
for (var i = 0; i < nRef; ++i) {
var lName = readInt(uncba, p);
var name = '';
for (var j = 0; j < lName-1; ++j) {
name += String.fromCharCode(uncba[p + 4 + j]);
}
var lRef = readInt(uncba, p + lName + 4);
bam.chrToIndex[name] = i;
if (name.indexOf('chr') == 0) {
bam.chrToIndex[name.substring(3)] = i;
} else {
bam.chrToIndex['chr' + name] = i;
}
bam.indexToChr.push(name);
p = p + 8 + lName;
}
if (bam.indices) {
return callback(bam);
}
}
|
javascript
|
{
"resource": ""
}
|
q52006
|
train
|
function() {
while (i < tb.seqCount) {
var ns = ba[p];
if (p + ns + 2 + (tb.version == 0 ? 4 : 8) >= ba.length) {
headerBlocksFetched += headerBlockSize;
headerBlockSize = Math.max(HEADER_BLOCK_SIZE,Math.floor(headerBlocksFetched*tb.seqCount/i));
return tb.data.slice(o + p, headerBlockSize).fetch(function (r) {
o += p;
p = 0;
ba = new Uint8Array(r);
parseSeqInfo();
});
} else {
++p;
var name = '';
for (var j = 1; j <= ns; ++j) {
name += String.fromCharCode(ba[p++]);
}
if (tb.version == 0) {
var offset = tb.readInt(ba, p);
p += 4;
} else {
var offset = tb.readInt64(ba, p);
p += 8;
}
tb.seqDict[name] = new TwoBitSeq(tb, offset);
++i;
}
}
return cnt(tb);
}
|
javascript
|
{
"resource": ""
}
|
|
q52007
|
alignSeqUsingCigar
|
train
|
function alignSeqUsingCigar(rawseq, rawquals, cigar) {
var ops = parseCigar(cigar);
var seq = [];
var quals = [];
var cursor = 0;
for (var ci = 0; ci < ops.length; ++ci) {
var co = ops[ci];
if (co.op == 'M') {
seq.push(rawseq.substr(cursor, co.cnt));
quals.push(rawquals.substr(cursor, co.cnt));
cursor += co.cnt;
} else if (co.op == 'D') {
for (var oi = 0; oi < co.cnt; ++oi) {
seq.push('-');
quals.push('Z');
}
} else if (co.op == 'I') {
cursor += co.cnt;
} else if (co.op == 'S') {
cursor += co.cnt;
} else {
console.log('unknown cigop' + co.op);
}
}
var processedSeq = {seq: seq.join(''), quals: quals.join('')};
return processedSeq;
}
|
javascript
|
{
"resource": ""
}
|
q52008
|
getRefSeq
|
train
|
function getRefSeq(currentSequence, min, max) {
var refSeq = [];
if (currentSequence) {
var csStart = currentSequence.start|0;
var csEnd = currentSequence.end|0;
if (csStart <= max && csEnd >= min) {
var sfMin = Math.max(min, csStart);
var sfMax = Math.min(max, csEnd);
for (var i = 0; i < sfMin - min; i++)
refSeq.push('N');
refSeq.push(currentSequence.seq.substr(sfMin - csStart, sfMax - sfMin + 1));
for (var i = 0; i < max - sfMax; i++)
refSeq.push('N');
}
}
return refSeq.join('');
}
|
javascript
|
{
"resource": ""
}
|
q52009
|
train
|
function () {
if ((i = x.getLowestSetBit()) > 0) {
x.rShiftTo(i, x);
}
if ((i = y.getLowestSetBit()) > 0) {
y.rShiftTo(i, y);
}
if (x.compareTo(y) >= 0) {
x.subTo(y, x);
x.rShiftTo(1, x);
} else {
y.subTo(x, y);
y.rShiftTo(1, y);
}
if (!(x.signum() > 0)) {
if (g > 0) y.lShiftTo(g, y);
setTimeout(function () {
callback(y)
}, 0); // escape
} else {
setTimeout(gcda1, 0);
}
}
|
javascript
|
{
"resource": ""
}
|
|
q52010
|
b64tohex
|
train
|
function b64tohex(s) {
var ret = ""
var i;
var k = 0; // b64 state, 0-3
var slop;
for (i = 0; i < s.length; ++i) {
if (s.charAt(i) == b64pad) break;
v = b64map.indexOf(s.charAt(i));
if (v < 0) continue;
if (k == 0) {
ret += int2char(v >> 2);
slop = v & 3;
k = 1;
}
else if (k == 1) {
ret += int2char((slop << 2) | (v >> 4));
slop = v & 0xf;
k = 2;
}
else if (k == 2) {
ret += int2char(slop);
ret += int2char(v >> 2);
slop = v & 3;
k = 3;
}
else {
ret += int2char((slop << 2) | (v >> 4));
ret += int2char(v & 0xf);
k = 0;
}
}
if (k == 1)
ret += int2char(slop << 2);
return ret;
}
|
javascript
|
{
"resource": ""
}
|
q52011
|
train
|
function (key) {
// Call the super constructor.
RSAKey.call(this);
// If a key key was provided.
if (key) {
// If this is a string...
if (typeof key === 'string') {
this.parseKey(key);
}
else if (
this.hasPrivateKeyProperty(key) ||
this.hasPublicKeyProperty(key)
) {
// Set the values for the key.
this.parsePropertiesFrom(key);
}
}
}
|
javascript
|
{
"resource": ""
}
|
|
q52012
|
DASSequence
|
train
|
function DASSequence(name, start, end, alpha, seq) {
this.name = name;
this.start = start;
this.end = end;
this.alphabet = alpha;
this.seq = seq;
}
|
javascript
|
{
"resource": ""
}
|
q52013
|
flamegraph
|
train
|
function flamegraph(arr, opts) {
var profile
if (!Array.isArray(arr)) throw new TypeError('First arg needs to be an array of lines.')
opts = opts || {}
try {
profile = cpuprofilify().convert(arr, opts.profile)
} catch (err) {
// not a valid input to cpuprofilify -- maybe it's an actual cpuprofile already?
try {
profile = JSON.parse(arr.join('\n'))
} catch (parseErr) {
// if not throw the original cpuprofilify error
throw err
}
}
// at this point we have a cpuprofile
return fromCpuProfile(profile, opts)
}
|
javascript
|
{
"resource": ""
}
|
q52014
|
fromStream
|
train
|
function fromStream(stream, opts) {
opts = opts || {}
var out = through()
function ondata(res) {
try {
var svg = flamegraph(res.toString().split('\n'), opts)
out.write(svg)
} catch (err) {
out.emit('error', err)
}
}
// Once memory becomes an issue we need to make this truly streaming
stream.pipe(concatStream(ondata))
return out
}
|
javascript
|
{
"resource": ""
}
|
q52015
|
httpRequest
|
train
|
function httpRequest(url) {
var deferred = Q.defer();
request(url, function(err, response, body) {
if (err) {
deferred.reject(new Error(err));
} else if (!err && response.statusCode !== 200) {
deferred.reject(new Error(response.statusCode));
} else {
deferred.resolve(body);
}
});
return deferred.promise;
}
|
javascript
|
{
"resource": ""
}
|
q52016
|
toJson
|
train
|
function toJson(xml) {
var deferred = Q.defer();
xml2js.parseString(xml, function(err, result) {
if (err) {
deferred.reject(new Error(err));
} else {
deferred.resolve(result);
}
});
return deferred.promise;
}
|
javascript
|
{
"resource": ""
}
|
q52017
|
toQueryString
|
train
|
function toQueryString(params, id) {
var paramsString = '';
for (var key in params) {
if (params.hasOwnProperty(key)) {
paramsString += '&' + key + '=' + encodeURIComponent(params[key]);
}
}
return 'zws-id=' + id + paramsString;
}
|
javascript
|
{
"resource": ""
}
|
q52018
|
checkParams
|
train
|
function checkParams(params, reqParams) {
if ( reqParams.length < 1 ) {
return;
}
if ( (_.isEmpty(params) || !params) && (reqParams.length > 0) ) {
throw new Error('Missing parameters: ' + reqParams.join(', '));
}
var paramsKeys = _.keys(params);
_.each(reqParams, function(reqParam) {
if ( paramsKeys.indexOf(reqParam) === -1 ) {
throw new Error('Missing parameter: ' + reqParam);
}
});
}
|
javascript
|
{
"resource": ""
}
|
q52019
|
Reader
|
train
|
function Reader(buf, filePath) {
// Allow instantiating without `new`
if (!(this instanceof Reader)) {
return new Reader(buf);
}
// Allow passing either a path to a file or a raw buffer
if (typeof buf === 'string') {
filePath = buf;
buf = fs.readFileSync(buf);
}
// LRU cache that'll hold objects we read from the data section.
// 5000 seems to be roughly the sweet spot between mem vs hit-rate
this._pointerCache = new LRU(LRU_SIZE);
this._buf = buf;
// Stash the file path for if we want to reload it later
this.filePath = filePath;
this.setup();
}
|
javascript
|
{
"resource": ""
}
|
q52020
|
changeCfgOption
|
train
|
function changeCfgOption(options, key) {
if (expectKey(options, key, typeof cfg[key])) {
cfg[key] = options[key]
}
}
|
javascript
|
{
"resource": ""
}
|
q52021
|
expectKey
|
train
|
function expectKey(options, key, type) {
if (key in options) {
if (typeof options[key] === type) {
return true
}
// eslint-disable-next-line no-console
console.warn(`Ignoring options key '${key}' - ` +
`expected type '${type}', received '${typeof options[key]}'`)
}
return false
}
|
javascript
|
{
"resource": ""
}
|
q52022
|
startScan
|
train
|
function startScan(stateChange, error) {
if (!node.scanning) {
// send status message
var msg = {
statusUpdate: true,
error: error,
stateChange: stateChange,
state: noble.state
};
node.send(msg);
// start the scan
noble.startScanning(node.uuids, node.duplicates, function() {
node.log("Scanning for BLEs started. UUIDs: " + node.uuids + " - Duplicates allowed: " + node.duplicates);
node.status({fill:"green",shape:"dot",text:"started"});
node.scanning = true;
});
}
}
|
javascript
|
{
"resource": ""
}
|
q52023
|
stopScan
|
train
|
function stopScan(stateChange, error) {
if (node.scanning) {
// send status message
var msg = {
statusUpdate: true,
error: error,
stateChange: stateChange,
state: noble.state
};
node.send(msg);
// stop the scan
noble.stopScanning(function() {
node.log('BLE scanning stopped.');
node.status({fill:"red",shape:"ring",text:"stopped"});
node.scanning = false;
});
if (error) {
node.warn('BLE scanning stopped due to change in adapter state.');
}
}
}
|
javascript
|
{
"resource": ""
}
|
q52024
|
query
|
train
|
function query (mode) {
var exercise = this
function send (stream) {
var input = through2()
input
.pipe(stream)
.on('error', function(err) {
exercise.emit(
'fail',
exercise.__('fail.never_read_stdin')
)
})
input.write('wow. such wow.');
input.end();
}
send(exercise.submissionChild.stdin)
if (mode == 'verify')
send(exercise.solutionChild.stdin)
}
|
javascript
|
{
"resource": ""
}
|
q52025
|
getFieldsForModelTemplate
|
train
|
function getFieldsForModelTemplate(fields) {
var lg = fields.length - 1;
var modelFields = '{' + os.EOL;
fields.forEach(function(field, index, array) {
modelFields += '\t\'' + field.name + '\' : '+ (field.isArray ? '[' : '') + (allowedFieldsTypes[field.type]).name + (field.isArray ? ']' : '');
modelFields += (lg > index) ? ',' + os.EOL : os.EOL;
if (field.reference) {
modelFields = modelFields.replace(/{ref}/, field.reference);
}
});
modelFields += '}';
return modelFields;
}
|
javascript
|
{
"resource": ""
}
|
q52026
|
generateModel
|
train
|
function generateModel(path, modelName, modelFields, generateMethod, ts, cb) {
var fields = formatTools.getFieldsForModelTemplate(modelFields);
var schemaName = modelName + 'Schema';
var extension = (ts) ? 'ts' : 'js';
var model = ft.loadTemplateSync('model.' + extension);
model = model.replace(/{modelName}/, modelName);
model = model.replace(/{schemaName}/g, schemaName);
model = model.replace(/{fields}/, fields);
if (generateMethod === 't') {
ft.createDirIfIsNotDefined(path, 'models', function () {
ft.writeFile(path + '/models/' + modelName + 'Model.' + extension, model, null, cb);
});
} else {
ft.createDirIfIsNotDefined(path, modelName, function () {
ft.writeFile(path + '/' + modelName + '/' + modelName + 'Model.' + extension, model, null, cb);
});
}
}
|
javascript
|
{
"resource": ""
}
|
q52027
|
generateRouter
|
train
|
function generateRouter(path, modelName, generateMethod, ts, cb) {
var extension = (ts) ? 'ts' : 'js';
var router = ft.loadTemplateSync('router.' + extension);
router = router.replace(/{controllerName}/g, modelName + 'Controller');
if (generateMethod === 't') {
ft.createDirIfIsNotDefined(path, 'routes', function () {
router = router.replace(/{controllerPath}/g, '\'../controllers/' + modelName + 'Controller.' + extension + '\'');
ft.writeFile(path + '/routes/' + modelName + 'Routes.' + extension, router, null, cb);
});
} else {
ft.createDirIfIsNotDefined(path, modelName, function () {
router = router.replace(/{controllerPath}/g, '\'./' + modelName + 'Controller.' + extension + '\'');
ft.writeFile(path + '/' + modelName + '/' + modelName + 'Routes.' + extension, router, null, cb);
});
}
}
|
javascript
|
{
"resource": ""
}
|
q52028
|
createDirIfIsNotDefined
|
train
|
function createDirIfIsNotDefined(dirPath, dirName, cb) {
if (!fs.existsSync(dirPath + '/' + dirName)){
fs.mkdirSync(dirPath + '/' + dirName);
console.info(cliStyles.cyan + '\tcreate' + cliStyles.reset + ': ' + dirPath + '/' + dirName);
}
cb();
}
|
javascript
|
{
"resource": ""
}
|
q52029
|
createAuthKey
|
train
|
function createAuthKey(callback, channel) {
flow.retryUntilIsDone(callback, null,
function (callback) {
flow.runSeries([
require('./request-pq'),
require('./request-dh-params'),
require('./set-client-dh-params')
], callback, channel);
});
}
|
javascript
|
{
"resource": ""
}
|
q52030
|
requestPQ
|
train
|
function requestPQ(callback, channel) {
// Create a nonce for the client
var clientNonce = utility.createNonce(16);
mtproto.service.req_pq({
props: {
nonce: clientNonce
},
channel: channel,
callback: function (ex, resPQ) {
if (clientNonce === resPQ.nonce) {
var context = {
resPQ: resPQ,
channel: channel
};
callback(null, context);
} else {
callback(createError('Nonce mismatch.', 'ENONCE'));
}
}
});
}
|
javascript
|
{
"resource": ""
}
|
q52031
|
findPAndQ
|
train
|
function findPAndQ(context) {
var pqFinder = new security.PQFinder(context.resPQ.pq);
if (logger.isDebugEnabled()) {
logger.debug('Start finding P and Q, with PQ = %s', pqFinder.getPQPairNumber());
}
var pq = pqFinder.findPQ();
if (logger.isDebugEnabled()) {
logger.debug('Found P = %s and Q = %s', pq[0], pq[1]);
}
context.pBuffer = pqFinder.getPQAsBuffer()[0];
context.qBuffer = pqFinder.getPQAsBuffer()[1];
return context;
}
|
javascript
|
{
"resource": ""
}
|
q52032
|
findPublicKey
|
train
|
function findPublicKey(context) {
var fingerprints = context.resPQ.server_public_key_fingerprints.getList();
if (logger.isDebugEnabled()) {
logger.debug('Public keys fingerprints from server: %s', fingerprints);
}
for (var i = 0; i < fingerprints.length; i++) {
var fingerprint = fingerprints[i];
if (logger.isDebugEnabled()) {
logger.debug('Searching fingerprint %s in store', fingerprint);
}
var publicKey = security.PublicKey.retrieveKey(fingerprint);
if (publicKey) {
if (logger.isDebugEnabled()) {
logger.debug('Fingerprint %s found in keyStore.', fingerprint);
}
context.fingerprint = fingerprint;
context.publicKey = publicKey;
return context;
}
}
throw createError('Fingerprints from server not found in keyStore.', 'EFINGERNOTFOUND');
}
|
javascript
|
{
"resource": ""
}
|
q52033
|
createMessageId
|
train
|
function createMessageId() {
var logger = getLogger('utility.createMessageId');
// Constants
// Take the time and sum the time-offset with the server clock
var time = new BigInteger((require('./time').getLocalTime()).toString());
// Divide the time by 1000 `result[0]` and take the fractional part `result[1]`
var result = time.divideAndRemainder(thousand);
// Prepare lower 32 bit using the fractional part of the time
var lower = result[1].multiply(lowerMultiplier);
// Create the message id
var messageId = result[0].shiftLeft(32).add(lower);
if (logger.isDebugEnabled()) {
logger.debug('MessageId(%s) was created with time = %s, lower = %s, messageID binary = %s',
messageId.toString(16), time, lower, messageId.toString(2));
}
return '0x' + messageId.toString(16);
}
|
javascript
|
{
"resource": ""
}
|
q52034
|
createSHAHash
|
train
|
function createSHAHash(buffer, algorithm) {
var logger = getLogger('utility.createSHA1Hash');
var sha1sum = crypto.createHash(algorithm || 'sha1');
if (require('util').isArray(buffer)) {
if (logger.isDebugEnabled()) {
logger.debug('It\'s an Array of buffers');
}
for (var i = 0; i < buffer.length; i++) {
sha1sum.update(buffer[i]);
}
} else {
if (logger.isDebugEnabled()) {
logger.debug('It\'s only one buffer');
}
sha1sum.update(buffer);
}
return sha1sum.digest();
}
|
javascript
|
{
"resource": ""
}
|
q52035
|
xor
|
train
|
function xor(buffer1, buffer2) {
var length = Math.min(buffer1.length, buffer2.length);
var retBuffer = new Buffer(length);
for (var i = 0; i < length; i++) {
retBuffer[i] = buffer1[i] ^ buffer2[i];
}
return retBuffer;
}
|
javascript
|
{
"resource": ""
}
|
q52036
|
createPQInnerData
|
train
|
function createPQInnerData(context) {
var resPQ = context.resPQ;
var newNonce = utility.createNonce(32);
var pqInnerData = new mtproto.type.P_q_inner_data({
props: {
pq: resPQ.pq,
p: context.pBuffer,
q: context.qBuffer,
nonce: resPQ.nonce,
server_nonce: resPQ.server_nonce,
new_nonce: newNonce
}
}).serialize();
context.pqInnerData = pqInnerData;
context.newNonce = newNonce;
return context;
}
|
javascript
|
{
"resource": ""
}
|
q52037
|
encryptPQInnerDataWithRSA
|
train
|
function encryptPQInnerDataWithRSA(context) {
// Create the data with hash to be encrypt
var hash = utility.createSHAHash(context.pqInnerData);
var dataWithHash = Buffer.concat([hash, context.pqInnerData]);
if (logger.isDebugEnabled()) {
logger.debug('Data to be encrypted contains: hash(%s), pqInnerData(%s), total length %s',
hash.length, context.pqInnerData.length, dataWithHash.length);
}
// Encrypt data with RSA
context.encryptedData = security.cipher.rsaEncrypt(dataWithHash, context.publicKey);
return context;
}
|
javascript
|
{
"resource": ""
}
|
q52038
|
requestDHParams
|
train
|
function requestDHParams(callback, context) {
var resPQ = context.resPQ;
mtproto.service.req_DH_params({
props: {
nonce: resPQ.nonce,
server_nonce: resPQ.server_nonce,
p: context.pBuffer,
q: context.qBuffer,
public_key_fingerprint: context.fingerprint,
encrypted_data: context.encryptedData
},
channel: context.channel,
callback: function (ex, serverDHParams, duration) {
if (ex) {
logger.error(ex);
if (callback) {
callback(ex);
}
} else {
if (serverDHParams.instanceOf('mtproto.type.Server_DH_params_ok')) {
if (logger.isDebugEnabled()) {
logger.debug('\'Server_DH_params_ok\' received from Telegram.');
}
context.serverDHParams = serverDHParams;
context.reqDHDuration = duration;
callback(null, context);
} else if (serverDHParams.instanceOf('mtproto.type.Server_DH_params_ko')) {
logger.warn('\'Server_DH_params_ko\' received from Telegram!');
callback(createError(JSON.stringify(serverDHParams), 'EDHPARAMKO'));
} else {
var msg = 'Unknown error received from Telegram!';
logger.error(msg);
callback(createError(msg, 'EUNKNOWN'));
}
}
}
});
}
|
javascript
|
{
"resource": ""
}
|
q52039
|
decryptDHParams
|
train
|
function decryptDHParams(context) {
var newNonce = utility.string2Buffer(context.newNonce, 32);
var serverNonce = utility.string2Buffer(context.resPQ.server_nonce, 16);
if (logger.isDebugEnabled()) {
logger.debug('newNonce = %s, serverNonce = %s', newNonce.toString('hex'), serverNonce.toString('hex'));
}
var hashNS = utility.createSHAHash([newNonce, serverNonce]);
var hashSN = utility.createSHAHash([serverNonce, newNonce]);
var hashNN = utility.createSHAHash([newNonce, newNonce]);
if (logger.isDebugEnabled()) {
logger.debug('hashNS = %s, hashSN = %s, hashNN = %s',
hashNS.toString('hex'), hashSN.toString('hex'), hashNN.toString('hex'));
}
// Create the AES key
context.aes = {
key: Buffer.concat([hashNS, hashSN.slice(0, 12)]),
iv: Buffer.concat([Buffer.concat([hashSN.slice(12), hashNN]), newNonce.slice(0, 4)]),
toPrintable: tl.utility.toPrintable
};
if (logger.isDebugEnabled()) {
logger.debug('aesKey = %s', context.aes.toPrintable());
}
// Decrypt the message
var answerWithHash = security.cipher.aesDecrypt(
context.serverDHParams.encrypted_answer,
context.aes.key,
context.aes.iv
);
context.decryptedDHParams = answerWithHash;
return context;
}
|
javascript
|
{
"resource": ""
}
|
q52040
|
deserializeDHInnerData
|
train
|
function deserializeDHInnerData(context) {
var decryptedDHParamsWithHash = context.decryptedDHParams;
if (logger.isDebugEnabled()) {
logger.debug('decryptedDHParamsWithHash(%s) = %s', decryptedDHParamsWithHash.length, decryptedDHParamsWithHash.toString('hex'));
}
var decryptedDHParams = decryptedDHParamsWithHash.slice(20, 564 + 20);
if (logger.isDebugEnabled()) {
logger.debug('decryptedDHParams(%s) = %s', decryptedDHParams.length, decryptedDHParams.toString('hex'));
}
var serverDHInnerData = new mtproto.type.Server_DH_inner_data({
buffer: decryptedDHParams
}).deserialize();
if (logger.isDebugEnabled()) {
logger.debug('serverDHInnerData = %s obtained in %sms', serverDHInnerData.toPrintable(), context.reqDHDuration);
}
// Check if the nonces are consistent
if (serverDHInnerData.nonce !== context.serverDHParams.nonce) {
throw createError('Nonce mismatch %s != %s', context.serverDHParams.nonce, serverDHInnerData.nonce);
}
if (serverDHInnerData.server_nonce !== context.serverDHParams.server_nonce) {
throw createError('ServerNonce mismatch %s != %s', context.serverDHParams.server_nonce, serverDHInnerData.server_nonce);
}
// Synch the local time with the server time
mtproto.time.timeSynchronization(serverDHInnerData.server_time, context.reqDHDuration);
context.serverDHInnerData = serverDHInnerData;
return context;
}
|
javascript
|
{
"resource": ""
}
|
q52041
|
aesDecrypt
|
train
|
function aesDecrypt(msg, key, iv) {
var logger = getLogger('security.cipher.aesDecrypt');
var encryptedMsg = buffer2WordArray(msg);
var keyWordArray = buffer2WordArray(key);
var ivWordArray = buffer2WordArray(iv);
if (logger.isDebugEnabled()) {
logger.debug('encryptedMsg = %s\nkeyWordArray = %s\nivWordArray = %s',
JSON.stringify(encryptedMsg), JSON.stringify(keyWordArray), JSON.stringify(ivWordArray));
}
var decryptedWordArray = CryptoJS.AES.decrypt({ciphertext: encryptedMsg}, keyWordArray, {
iv: ivWordArray,
padding: CryptoJS.pad.NoPadding,
mode: CryptoJS.mode.IGE
});
if (logger.isDebugEnabled()) {
logger.debug('decryptedWordArray = %s', JSON.stringify(decryptedWordArray));
}
return wordArray2Buffer(decryptedWordArray);
}
|
javascript
|
{
"resource": ""
}
|
q52042
|
aesEncrypt
|
train
|
function aesEncrypt(msg, key, iv) {
var logger = getLogger('security.cipher.aesEncrypt');
// Check if padding is needed
var padding = msg.length % 16;
if (padding > 0) {
var paddingBuffer = utility.createRandomBuffer(16 - padding);
msg = Buffer.concat([msg, paddingBuffer]);
}
// Convert buffers to wordArrays
var plainMsg = buffer2WordArray(msg);
var keyWordArray = buffer2WordArray(key);
var ivWordArray = buffer2WordArray(iv);
if (logger.isDebugEnabled()) {
logger.debug('plainMsg = %s\nkeyWordArray = %s\nivWordArray = %s',
JSON.stringify(plainMsg), JSON.stringify(keyWordArray), JSON.stringify(ivWordArray));
}
// Encrypt plain message
var encryptedWordArray = CryptoJS.AES.encrypt(plainMsg, keyWordArray, {
iv: ivWordArray,
padding: CryptoJS.pad.NoPadding,
mode: CryptoJS.mode.IGE
}).ciphertext;
if (logger.isDebugEnabled()) {
logger.debug('encryptedWordArray = %s', JSON.stringify(encryptedWordArray));
}
// Return the encrypted buffer
return wordArray2Buffer(encryptedWordArray);
}
|
javascript
|
{
"resource": ""
}
|
q52043
|
timeSynchronization
|
train
|
function timeSynchronization(serverTime, requestDuration) {
var logger = getLogger('time.timeSynchronization');
var localTime = Math.floor(new Date().getTime() / 1000);
var response = requestDuration / 2;
if (logger.isDebugEnabled()) {
logger.debug('ServerTime %ss - LocalTime %ss - Response in %sms',
serverTime, localTime, response);
}
if (lastResponse > response) {
lastResponse = response;
response = Math.floor(response / 1000);
timeOffset = ((serverTime + response) - localTime);
if (logger.isDebugEnabled()) {
logger.debug('time-synchronization: (ServerTime %ss + server-response %ss) - LocalTime %ss = timeOffset %ss',
serverTime, response, localTime, timeOffset);
}
} else {
if (logger.isDebugEnabled()) {
logger.debug('NO time-synchronization: the server-response (%s) took more time than the previous one (%s)',
response, lastResponse);
}
}
}
|
javascript
|
{
"resource": ""
}
|
q52044
|
encryptClientDHInnerDataWithAES
|
train
|
function encryptClientDHInnerDataWithAES(context) {
var hash = utility.createSHAHash(context.clientDHInnerData);
var dataWithHash = Buffer.concat([hash, context.clientDHInnerData]);
if (logger.isDebugEnabled()) {
logger.debug('Data to be encrypted contains: hash(%s), clientDHInnerData(%s), total length %s',
hash.length, context.clientDHInnerData.length, dataWithHash.length);
}
context.encryptClientDHInnerData = security.cipher.aesEncrypt(
dataWithHash,
context.aes.key,
context.aes.iv
);
if (logger.isDebugEnabled()) {
logger.debug('encryptClientDHInnerData(%s) = %s',
context.encryptClientDHInnerData.length, context.encryptClientDHInnerData.toString('hex'));
}
return context;
}
|
javascript
|
{
"resource": ""
}
|
q52045
|
setClientDHParams
|
train
|
function setClientDHParams(callback, context) {
mtproto.service.set_client_DH_params({
props: {
nonce: context.resPQ.nonce,
server_nonce: context.resPQ.server_nonce,
encrypted_data: context.encryptClientDHInnerData
},
channel: context.channel,
callback: function (ex, setClientDHParamsAnswer) {
if (ex) {
logger.error(ex);
if (callback) {
callback(ex);
}
} else {
if (setClientDHParamsAnswer.instanceOf('mtproto.type.Dh_gen_ok')) {
if (logger.isDebugEnabled()) {
logger.debug('\'Dh_gen_ok\' received from Telegram.');
}
context.setClientDHParamsAnswer = setClientDHParamsAnswer;
flow.runSeries([
calculateAuthKeyValue,
createAuthKeyID,
checkNonceMatch,
createAuthKey
], callback, context);
} else if (setClientDHParamsAnswer.instanceOf('mtproto.type.Dh_gen_retry')) {
logger.warn('\'Dh_gen_retry\' received from Telegram!');
callback(createError(JSON.stringify(setClientDHParamsAnswer), 'EDHPARAMRETRY'));
} else if (setClientDHParamsAnswer.instanceOf('mtproto.type.Dh_gen_fail')) {
logger.warn('\'Dh_gen_fail\' received from Telegram!');
callback(createError(JSON.stringify(setClientDHParamsAnswer), 'EDHPARAMFAIL'));
} else {
var msg = 'Unknown error received from Telegram!';
logger.error(msg);
callback(createError(msg, 'EUNKNOWN'));
}
}
}
});
}
|
javascript
|
{
"resource": ""
}
|
q52046
|
calculateAuthKeyValue
|
train
|
function calculateAuthKeyValue(context) {
var ga = context.serverDHInnerData.g_a;
var b = context.b;
var dhPrime = context.serverDHInnerData.dh_prime;
var authKeyValue = utility.modPow(ga, b, dhPrime);
if (logger.isDebugEnabled()) {
logger.debug('authKeyValue(%s) = %s', authKeyValue.length, authKeyValue.toString('hex'));
}
context.authKeyValue = authKeyValue;
return context;
}
|
javascript
|
{
"resource": ""
}
|
q52047
|
createAuthKeyID
|
train
|
function createAuthKeyID(context) {
var authKeyHash = utility.createSHAHash(context.authKeyValue);
var authKeyAuxHash = authKeyHash.slice(0, 8);
var authKeyID = authKeyHash.slice(-8);
if (logger.isDebugEnabled()) {
logger.debug('authKeyID(%s) = %s', authKeyID.length, authKeyID.toString('hex'));
}
context.authKeyID = authKeyID;
context.authKeyAuxHash = authKeyAuxHash;
return context;
}
|
javascript
|
{
"resource": ""
}
|
q52048
|
checkNonceMatch
|
train
|
function checkNonceMatch(context) {
var newNonce1 = Buffer.concat([utility.string2Buffer(context.newNonce, 32), new Buffer([1]), context.authKeyAuxHash]);
var newNonceHash = utility.buffer2String(utility.createSHAHash(newNonce1).slice(-16));
var serverNewNonceHash = context.setClientDHParamsAnswer.new_nonce_hash1;
if (logger.isDebugEnabled()) {
logger.debug('newNonceHash = %s, new_nonce_hash1 = %s', newNonceHash.toString(), serverNewNonceHash.toString());
}
if (newNonceHash !== serverNewNonceHash) {
logger.warn('\'dh_gen_ok.new_nonce_hash1\' check fails!');
throw createError(newNonceHash + ' != ' + serverNewNonceHash, 'EREPLAYATTACK');
}
return context;
}
|
javascript
|
{
"resource": ""
}
|
q52049
|
createAuthKey
|
train
|
function createAuthKey(context) {
// Extract the nonces
var newNonce = utility.string2Buffer(context.newNonce, 32);
var serverNonce = utility.string2Buffer(context.resPQ.server_nonce, 16);
// Create the serverSalt
var serverSalt = utility.xor(newNonce.slice(0, 8), serverNonce.slice(0, 8));
if (logger.isDebugEnabled()) {
logger.debug('serverSalt(%s) = %s', serverSalt.length, serverSalt.toString('hex'));
}
// Create the AuthKey
var authKey = new AuthKey(context.authKeyID, context.authKeyValue);
if (logger.isDebugEnabled()) {
logger.debug('authKey = %s', authKey.toString());
}
return {
key: authKey,
serverSalt: serverSalt,
toPrintable: tl.utility.toPrintable
};
}
|
javascript
|
{
"resource": ""
}
|
q52050
|
PublicKey
|
train
|
function PublicKey(params) {
this._fingerprint = params.fingerprint;
this._modulus = params.modulus;
this._exponent = params.exponent;
}
|
javascript
|
{
"resource": ""
}
|
q52051
|
train
|
function (error, order, recvMsg) {
if (error) {
me_order.client.MsgEndDialog(function (error2, recvMsg2) {
if (error2) {
me_order.client.log.con.error({
error: error2
}, 'Connection close failed after error.')
} else {
me_order.client.log.con.debug('Connection closed okay, after error.')
}
})
}
cb(error, order, recvMsg)
}
|
javascript
|
{
"resource": ""
}
|
|
q52052
|
createServiceHandler
|
train
|
function createServiceHandler(handlers = {}, options = {}, shortcutType) {
const errorHandler = options.errorHandler || defaultErrorHandler;
const middleware = options.middleware || Array.isArray(options) && options || [];
const mode = options.mode || FUNCTION_MODE;
const checkArity = options.checkArity === undefined || Boolean(options.checkArity);
const type = shortcutType || options.type || (process.env.LAMBDA_TASK_ROOT && AWS_TYPE)
|| (process.env.AzureWebJobsStorage && AZURE_TYPE) || GCLOUD_TYPE;
if (type === AWS_TYPE) {
// return handler function with fn(event, context, callback) signature
return (event, context, callback) => {
// if AWS Lambda request, convert event and context to request and response
const req = new AWSRequest(event, context);
const res = new AWSResponse(req, callback);
// handle request
handleRequest(middleware, handlers, mode, checkArity, req, res, errorHandler);
};
} else if (type === AZURE_TYPE) {
// return handler function with fn(context) signature
return (context) => {
// if Azure request, convert context to request and response
const req = new AzureRequest(context.req);
const res = new AzureResponse(req, context);
// handle request
handleRequest(middleware, handlers, mode, checkArity, req, res, errorHandler);
};
} else if (type === GCLOUD_TYPE) {
// return handler function with fn(req, res) signature
return (req, res) => {
// handle request
handleRequest(middleware, handlers, mode, checkArity, req, res, errorHandler);
};
} else {
throw new Error('Invalid type: ' + type)
}
}
|
javascript
|
{
"resource": ""
}
|
q52053
|
handleRequest
|
train
|
function handleRequest(middleware, handlers, mode, checkArity, req, res, errorHandler) {
const done = err => err && setImmediate(errorHandler, err, req, res);
// run global middleware first, then start handling request
// this is important to allow loggers for example to kick-in regardless
runMiddlewareStack(middleware, req, res, (err) => {
if (err) {
done(err);
return;
}
// try to apply supplied handlers to the requested operation
handleOperation(handlers, mode, checkArity, req, res, done);
});
}
|
javascript
|
{
"resource": ""
}
|
q52054
|
handleOperation
|
train
|
function handleOperation(handlers, mode, checkArity, req, res, done) {
// parse path:
// - first part is the operation name
// - the following components of the path are used as arguments
const parsedParts = parsePath(req);
if (parsedParts[0].length === 0) {
done(new ModofunError(403, 'NoOperation', 'Operation must be specified!'));
return;
}
const [operation, ...args] = parsedParts;
if (operation && handlers.hasOwnProperty(operation)) {
// the stack of operation specific middleware
let operationMiddleware = [];
// operation handler
let operationHandler = handlers[operation];
if (Array.isArray(operationHandler)) {
// if an array is passed, add operation specific middleware
// last item in the array should be the operation handler
operationMiddleware = operationHandler.slice(0, -1);
operationHandler = operationHandler[operationHandler.length-1];
} else if (typeof operationHandler !== 'function') {
// otherwise return internal error
done(new ModofunError(500, 'InvalidConfig', 'Handler must be a function or array'));
return;
}
// call middleware stack with same req/res context
runMiddlewareStack(operationMiddleware, req, res, (err) => {
if (err) {
done(err);
return;
}
try {
// call handler function
if (mode === FUNCTION_MODE) {
invokeFunctionHandler(operationHandler, args, checkArity, req, res, done);
} else {
invokeHTTPHandler(operationHandler, args, req, res, done);
}
} catch(err) {
done(err);
}
});
} else {
// fail if requested operation cannot be resolved
done(new ModofunError(404, 'NotFound', `No handler for: ${operation}`));
return;
}
}
|
javascript
|
{
"resource": ""
}
|
q52055
|
invokeHTTPHandler
|
train
|
function invokeHTTPHandler(handler, args, req, res, done) {
// inject parsed parameters into request
req.params = args;
// call handler with typical HTTP request/response parameters
let result = handler(req, res);
// handle results that are not a trusted Promise with Promise.resolve()
// which also supports other then-ables
if (result instanceof Promise === false) {
result = Promise.resolve(result);
}
return result.then(() => done()).catch(done);
}
|
javascript
|
{
"resource": ""
}
|
q52056
|
invokeFunctionHandler
|
train
|
function invokeFunctionHandler(handler, args, checkArity, req, res, done) {
// check if number of arguments provided matches the handler function arity
if (checkArity && args.length < handler.length) { // < due to possible optionals
done(new ModofunError(400, 'InvalidInput',
`This operation requires ${handler.length} parameters. Received ${args.length}.`));
return;
}
// set this in function call to the remaining relevant request data
// could consider pushing the whole request object instead?
// for now prefer to keep it to minimum to allow maximum flexibility
const thisArg = {
method: req.method,
headers: req.headers,
body: req.body,
query: req.query,
user: req.user
};
// call handler function with
let result = handler.apply(thisArg, args);
// handle results that are not a trusted Promise with Promise.resolve()
// which also supports other then-ables
if (result instanceof Promise === false) {
result = Promise.resolve(result);
}
return result
.then(value => {
if (value === null) {
done(new ModofunError(404, 'NullResponse', `${req.path} resource was not found`));
return;
}
if (value === undefined || value === '') {
res.status(204).end();
} else {
res.status(200).json(value);
}
done();
})
.catch(done);
}
|
javascript
|
{
"resource": ""
}
|
q52057
|
defaultErrorHandler
|
train
|
function defaultErrorHandler(err, req, res) {
if (err.name === 'UnauthorizedError') { // authentication is expected to be a common use-case
res.status(401).end();
} else {
if (!err.status || err.status >= 500) {
console.error(err.stack || err.toString());
}
res.status(err.status || 500).json({message: err.message})
}
}
|
javascript
|
{
"resource": ""
}
|
q52058
|
parsePath
|
train
|
function parsePath(req) {
// get path if preprocessed or otherwise separate path from query string
const path = req.path || (req.url && req.url.split('?')[0]) || '';
// ignore start and end slashes, and split the path
return path.replace(/^\/|\/$/g, '').split('/');
}
|
javascript
|
{
"resource": ""
}
|
q52059
|
arity
|
train
|
function arity(min, max = Number.MAX_SAFE_INTEGER) {
return (req, res, next) => {
const foundArity = parsePath(req).length-1;
if (foundArity < min ) {
next(new ModofunError(400, 'InvalidInput',
`This operation requires ${min} parameters. Received ${foundArity}.`));
} else if (foundArity > max ) {
next(new ModofunError(400, 'InvalidInput',
`This operation doesn't accept more than ${max} parameters. Received ${foundArity}.`));
} else {
next();
}
}
}
|
javascript
|
{
"resource": ""
}
|
q52060
|
run
|
train
|
function run (N, op, init) {
var stats = null, value
for(var j = 0; j < 100; j++) {
if(init) value = init(j)
var start = Date.now()
for(var i = 0; i < N; i++) op(value, i)
stats = Stats(stats, N/((Date.now() - start)))
}
return stats
}
|
javascript
|
{
"resource": ""
}
|
q52061
|
train
|
function (config) {
if (config) {
if (config.element) {
this.expect.element(config.element).to.not.be.visible;
} else {
throw new Error('adminUIApp:must specify an element!');
}
} else {
throw new Error('adminUIApp:invalid config specification!');
}
return this;
}
|
javascript
|
{
"resource": ""
}
|
|
q52062
|
train
|
function (config) {
if (config) {
if (config.element) {
this.expect.element(config.element).to.be.present;
} else {
throw new Error('adminUIApp:must specify an element!');
}
} else {
throw new Error('adminUIApp:invalid config specification!');
}
return this;
}
|
javascript
|
{
"resource": ""
}
|
|
q52063
|
train
|
function (config) {
if (config) {
if (config.element && config.text) {
this.expect.element(config.element).text.to.equal(config.text);
} else {
throw new Error('adminUIApp:must specify an element and text!');
}
} else {
throw new Error('adminUIApp:invalid config specification!');
}
return this;
}
|
javascript
|
{
"resource": ""
}
|
|
q52064
|
train
|
function (config) {
if (config) {
if (config.element && config.text) {
this.expect.element(config.element).text.to.contain(config.text);
} else {
throw new Error('adminUIApp:must specify an element and text!');
}
} else {
throw new Error('adminUIApp:invalid config specification!');
}
return this;
}
|
javascript
|
{
"resource": ""
}
|
|
q52065
|
train
|
function (config) {
if (config) {
if (config.element && config.attribute && config.value) {
this.expect.element(config.element).to.have.attribute(config.attribute).which.contains(config.value);
} else {
throw new Error('adminUIApp:must specify a config element, attribute, and value!');
}
} else {
throw new Error('adminUIApp:invalid config specification!');
}
return this;
}
|
javascript
|
{
"resource": ""
}
|
|
q52066
|
train
|
function (config) {
var _config = objectAssign({}, { wait: true }, config);
this.navigate();
if (_config.wait) this.waitForSigninScreen();
return this;
}
|
javascript
|
{
"resource": ""
}
|
|
q52067
|
train
|
function (config) {
var _config = objectAssign({}, { wait: true }, config);
this.navigate();
if (_config.wait) this.waitForHomeScreen();
return this;
}
|
javascript
|
{
"resource": ""
}
|
|
q52068
|
train
|
function (config) {
var _config = objectAssign({}, { wait: true }, config);
if (_config.section && _config.list) {
this.clickPrimaryNavbar({ section: _config.section })
.waitForForSecondaryNavbar()
.clickSecondaryNavbar({ list: _config.list });
} else {
throw new Error('adminUIApp:must specify a navbar section and a list!');
}
if (_config.wait) this.waitForListScreen();
return this;
}
|
javascript
|
{
"resource": ""
}
|
|
q52069
|
train
|
function (config) {
var _config = objectAssign({}, { wait: true }, config);
if (_config.section) {
this.click(this.getPrimaryNavbarSectionElement({ section: _config.section }));
} else {
throw new Error('adminUIApp:must specify a navbar section!');
}
if (_config.wait) this.waitForForSecondaryNavbar();
return this;
}
|
javascript
|
{
"resource": ""
}
|
|
q52070
|
train
|
function (config) {
var _config = objectAssign({}, { wait: true }, config);
if (_config.list) {
this.click(this.getSecondaryNavbarListElement({ list: _config.list }));
} else {
throw new Error('adminUIApp:must specify a navbar list!');
}
if (_config.wait) this.waitForListScreen();
return this;
}
|
javascript
|
{
"resource": ""
}
|
|
q52071
|
train
|
function (config) {
var _config = objectAssign({}, { timeout: this.api.globals.waitForConditionTimeout }, config);
this.waitForElementVisible('@signinScreen', _config.timeout);
this.api.pause(self.screenTransitionTimeout);
return this;
}
|
javascript
|
{
"resource": ""
}
|
|
q52072
|
train
|
function (config) {
return this.expect.element(this.getPrimaryNavbarSectionElement({ section: config.section })).to.be.visible;
}
|
javascript
|
{
"resource": ""
}
|
|
q52073
|
train
|
function (config) {
return this.expect.element(this.getSecondaryNavbarListElement({ list: config.list })).to.be.visible;
}
|
javascript
|
{
"resource": ""
}
|
|
q52074
|
train
|
function (cb) {
if (argv.env === 'default' && argv['selenium-in-background']) {
process.env.KNE_SELENIUM_START_PROCESS = false;
runSeleniumInBackground(cb);
} else if (argv.env === 'default') {
process.env.KNE_SELENIUM_START_PROCESS = true;
cb();
} else {
process.env.KNE_SELENIUM_START_PROCESS = false;
cb();
}
}
|
javascript
|
{
"resource": ""
}
|
|
q52075
|
train
|
function (cb) {
if (argv.env === 'saucelabs-travis' || (argv.env === 'saucelabs-local' && argv['sauce-username'] && argv['sauce-access-key'])) {
startSauceConnect(cb);
} else {
if (argv.env === 'saucelabs-local') {
console.error([moment().format('HH:mm:ss:SSS')] + ' kne: You must specify --sauce-username and --sauce-access-key when using: --' + argv.env);
cb(new Error('kne: You must specify --sauce-username and --sauce-access-key when using: --' + argv.env));
} else {
cb();
}
}
}
|
javascript
|
{
"resource": ""
}
|
|
q52076
|
train
|
function (cb) {
Nightwatch.runner(argv, function (status) {
var err = null;
if (status) {
console.log([moment().format('HH:mm:ss:SSS')] + ' kne: tests passed');
} else {
console.log([moment().format('HH:mm:ss:SSS')] + ' kne: tests failed');
err = new Error('kne: nightwatch runner returned an error status code');
}
cb(err);
});
}
|
javascript
|
{
"resource": ""
}
|
|
q52077
|
startSauceConnect
|
train
|
function startSauceConnect (done) {
console.log([moment().format('HH:mm:ss:SSS')] + ' kne: Starting Sauce Connect');
var default_options = {
username: process.env.SAUCE_USERNAME,
accessKey: process.env.SAUCE_ACCESS_KEY,
connectRetries: 5,
connectRetryTimeout: 60000,
logger: sauceConnectLog,
readyFileId: process.env.TRAVIS_JOB_NUMBER,
};
var custom_options = process.env.TRAVIS_JOB_NUMBER
? {
tunnelIdentifier: process.env.TRAVIS_JOB_NUMBER,
} : {
};
var options = _.extend({}, default_options, custom_options);
sauceConnectLauncher(options, function (err, sauceConnectProcess) {
if (err) {
console.error([moment().format('HH:mm:ss:SSS')] + ' kne: There was an error starting Sauce Connect');
done(err);
} else {
console.log([moment().format('HH:mm:ss:SSS')] + ' kne: Sauce Connect Ready');
sauceConnection = sauceConnectProcess;
sauceConnectionRunning = true;
setTimeout(done, 5000);
}
});
}
|
javascript
|
{
"resource": ""
}
|
q52078
|
checkKeystoneReady
|
train
|
function checkKeystoneReady (keystone, done) {
async.retry({
times: 10,
interval: 3000,
}, function (done, result) {
console.log([moment().format('HH:mm:ss:SSS')] + ' kne: checking if KeystoneJS ready for request');
request
.get('http://' + keystone.get('host') + ':' + keystone.get('port') + '/keystone')
.end(done);
}, function (err, result) {
if (!err) {
console.log([moment().format('HH:mm:ss:SSS')] + ' kne: KeystoneJS Ready!');
done();
} else {
console.log([moment().format('HH:mm:ss:SSS')] + ' kne: KeystoneJS does not appear ready!');
done(err);
}
});
}
|
javascript
|
{
"resource": ""
}
|
q52079
|
train
|
function (config) {
var _config = objectAssign({}, { user: 'user@test.e2e', password: 'test', wait: true }, config);
this
.setValue('@email', _config.user)
.setValue('@password', _config.password)
.click('@submitButton');
if (_config.wait) this.api.page.adminUIApp().waitForHomeScreen();
return this;
}
|
javascript
|
{
"resource": ""
}
|
|
q52080
|
train
|
function(model, options) {
Backbone.Model.apply(this, arguments);
var defaults = _.result(this, 'defaults');
// Apply defaults only after first sync.
this.once('sync', function() {
this.set(_.defaults(this.toJSON(), defaults));
});
this.autoSync = Backbone.Firebase._determineAutoSync(this, options);
switch (typeof this.url) {
case 'string':
this.firebase = Backbone.Firebase._determineRef(this.url);
break;
case 'function':
this.firebase = Backbone.Firebase._determineRef(this.url());
break;
case 'object':
this.firebase = Backbone.Firebase._determineRef(this.url);
break;
default:
Backbone.Firebase._throwError('url parameter required');
}
if(!this.autoSync) {
OnceModel.apply(this, arguments);
_.extend(this, OnceModel.protoype);
} else {
_.extend(this, SyncModel.protoype);
SyncModel.apply(this, arguments);
}
}
|
javascript
|
{
"resource": ""
}
|
|
q52081
|
train
|
function(snap) {
var newModel = Backbone.Firebase._checkId(snap);
if (typeof newModel === 'object' && newModel !== null) {
var diff = _.difference(_.keys(this.attributes), _.keys(newModel));
_.each(diff, _.bind(function(key) {
this.unset(key);
}, this));
}
// check to see if it needs an id
this._setId(snap);
return newModel;
}
|
javascript
|
{
"resource": ""
}
|
|
q52082
|
train
|
function(model) {
var modelObj = model.changedAttributes();
_.each(model.changed, function(value, key) {
if (typeof value === 'undefined' || value === null) {
if (key == 'id') {
delete modelObj[key];
} else {
modelObj[key] = null;
}
}
});
return modelObj;
}
|
javascript
|
{
"resource": ""
}
|
|
q52083
|
train
|
function(cb) {
var method = cb ? 'on' : 'off';
this[method]('change', function(model) {
var newModel = this._updateModel(model);
if(_.isFunction(cb)){
cb.call(this, newModel);
}
}, this);
}
|
javascript
|
{
"resource": ""
}
|
|
q52084
|
train
|
function(model, options) {
model.id = Backbone.Firebase._getKey(this.firebase.push());
options = _.extend({ autoSync: false }, options);
return Backbone.Collection.prototype.create.apply(this, [model, options]);
}
|
javascript
|
{
"resource": ""
}
|
|
q52085
|
train
|
function(options) {
options = options ? _.clone(options) : {};
if (options.parse === void 0) { options.parse = true; }
var success = options.success;
var collection = this;
options.success = function(resp) {
var arr = [];
var keys = _.keys(resp);
_.each(keys, function(key) {
arr.push(resp[key]);
});
var method = options.reset ? 'reset' : 'set';
collection[method](arr, options);
if (success) { success(collection, arr, options); }
options.autoSync = false;
options.url = this.url;
collection.trigger('sync', collection, arr, options);
};
return this.sync('read', this, options);
}
|
javascript
|
{
"resource": ""
}
|
|
q52086
|
train
|
function(snap) {
var model = Backbone.Firebase._checkId(snap);
var item = _.find(this.models, function(child) {
return child.id == model.id;
});
if (!item) {
// TODO: Investigate: what is the right way to handle this case?
//throw new Error('Could not find model with ID ' + model.id);
this._childAdded(snap);
return;
}
this._preventSync(item, true);
item._remoteAttributes = model;
// find the attributes that have been deleted remotely and
// unset them locally
var diff = _.difference(_.keys(item.attributes), _.keys(model));
_.each(diff, function(key) {
item.unset(key);
});
item.set(model);
// fire sync since this is a response from the server
this.trigger('sync', this);
this._preventSync(item, false);
}
|
javascript
|
{
"resource": ""
}
|
|
q52087
|
train
|
function(snap) {
var model = Backbone.Firebase._checkId(snap);
if (this._suppressEvent === true) {
this._suppressEvent = false;
Backbone.Collection.prototype.remove.apply(
this, [model], {silent: true}
);
} else {
// trigger sync because data has been received from the server
this.trigger('sync', this);
Backbone.Collection.prototype.remove.apply(this, [model]);
}
}
|
javascript
|
{
"resource": ""
}
|
|
q52088
|
train
|
function(model) {
var remoteAttributes;
var localAttributes;
var updateAttributes;
var ref;
// if the model is already being handled by listeners then return
if (model._remoteChanging) {
return;
}
remoteAttributes = model._remoteAttributes || {};
localAttributes = model.toJSON();
// consolidate the updates to Firebase
updateAttributes = this._compareAttributes(remoteAttributes, localAttributes);
ref = this.firebase.ref().child(model.id);
// if '.priority' is present setWithPriority
// else do a regular update
if (_.has(updateAttributes, '.priority')) {
this._setWithPriority(ref, localAttributes);
} else {
this._updateToFirebase(ref, localAttributes);
}
}
|
javascript
|
{
"resource": ""
}
|
|
q52089
|
train
|
function(remoteAttributes, localAttributes) {
var updateAttributes = {};
var union = _.union(_.keys(remoteAttributes), _.keys(localAttributes));
_.each(union, function(key) {
if (!_.has(localAttributes, key)) {
updateAttributes[key] = null;
} else if (localAttributes[key] != remoteAttributes[key]) {
updateAttributes[key] = localAttributes[key];
}
});
return updateAttributes;
}
|
javascript
|
{
"resource": ""
}
|
|
q52090
|
train
|
function(ref, item) {
var priority = item['.priority'];
delete item['.priority'];
ref.setWithPriority(item, priority);
return item;
}
|
javascript
|
{
"resource": ""
}
|
|
q52091
|
train
|
function(data, param) {
var eol = getEol(data,param);
var lines = data.split(eol);
var partial = lines.pop();
return {lines: lines, partial: partial};
}
|
javascript
|
{
"resource": ""
}
|
|
q52092
|
rowSplit
|
train
|
function rowSplit(rowStr, param) {
if (rowStr === "") {
return { cols: [], closed: true };
}
var quote = param.quote;
var trim = param.trim;
var escape = param.escape;
if (param.delimiter instanceof Array || param.delimiter.toLowerCase() === "auto") {
param.delimiter = getDelimiter_1(rowStr, param);
}
var delimiter = param.delimiter;
var rowArr = rowStr.split(delimiter);
if (quote === "off") {
return { cols: rowArr, closed: true };
}
var row = [];
var inquote = false;
var quoteBuff = '';
for (var i = 0, rowLen = rowArr.length; i < rowLen; i++) {
var e = rowArr[i];
if (!inquote && trim) {
e = e.trim();
}
var len = e.length;
if (!inquote) {
if (isQuoteOpen(e, param)) { //quote open
e = e.substr(1);
if (isQuoteClose(e, param)) { //quote close
e = e.substring(0, e.length - 1);
e = _escapeQuote(e, quote, escape);
row.push(e);
continue;
} else {
inquote = true;
quoteBuff += e;
continue;
}
} else {
row.push(e);
continue;
}
} else { //previous quote not closed
if (isQuoteClose(e, param)) { //close double quote
inquote = false;
e = e.substr(0, len - 1);
quoteBuff += delimiter + e;
quoteBuff = _escapeQuote(quoteBuff, quote, escape);
if (trim) {
quoteBuff = quoteBuff.trimRight();
}
row.push(quoteBuff);
quoteBuff = "";
} else {
quoteBuff += delimiter + e;
}
}
}
if (!inquote && param._needFilterRow) {
row = filterRow(row, param);
}
return { cols: row, closed: !inquote };
// if (param.workerNum<=1){
// }else{
// if (inquote && quoteBuff.length>0){//for multi core, quote will be closed at the end of line
// quoteBuff=_escapeQuote(quoteBuff,quote,escape);;
// if (trim){
// quoteBuff=quoteBuff.trimRight();
// }
// row.push(quoteBuff);
// }
// return {cols:row,closed:true};
// }
}
|
javascript
|
{
"resource": ""
}
|
q52093
|
train
|
function(lines, param) {
var csvLines = [];
var left = "";
while (lines.length) {
var line = left + lines.shift();
var row = rowSplit(line, param);
if (row.closed) {
csvLines.push(row.cols);
left = "";
} else {
left = line + (getEol(line, param) || "\n"); // if unable to getEol from data, assume "\n"
}
}
return {lines: csvLines, partial: left};
}
|
javascript
|
{
"resource": ""
}
|
|
q52094
|
train
|
function(fileLine, params) {
var lines = fileLine.lines;
var csvLines = csvline(lines,params);
return {
lines: csvLines.lines,
partial: csvLines.partial + fileLine.partial
};
}
|
javascript
|
{
"resource": ""
}
|
|
q52095
|
train
|
function (lines, params, idx) {
if (params._needParseJson) {
if (!params._headers) {
params._headers = [];
}
if (!params.parseRules) {
var row = params._headers;
params.parseRules = parserMgr.initParsers(row, params);
}
return processRows(lines, params, idx);
} else {
return justReturnRows(lines, params, idx);
}
}
|
javascript
|
{
"resource": ""
}
|
|
q52096
|
_initConverter
|
train
|
function _initConverter(){
var csvConverter = new Converter_1();
var started = false;
var writeStream = process.stdout;
csvConverter.on("record_parsed",function(rowJSON){
if (started){
writeStream.write(",\n");
}
writeStream.write(JSON.stringify(rowJSON)); //write parsed JSON object one by one.
if (started === false){
started = true;
}
});
writeStream.write("[\n"); //write array symbol
csvConverter.on("end_parsed",function(){
writeStream.write("\n]"); //end array symbol
});
csvConverter.on("error",function(err){
console.error(err);
process.exit(-1);
});
return csvConverter;
}
|
javascript
|
{
"resource": ""
}
|
q52097
|
loadCSVURI
|
train
|
async function loadCSVURI(filepath, options) {
const reqMethod = (filepath.search('https', 'gi') > -1) ? get : get;
return new Promise((resolve, reject) => {
const csvData = [];
const config = Object.assign({ checkType: true, }, options);
const req = reqMethod(filepath, res => {
csvtojson(config).fromStream(res)
.on('json', jsonObj => {
csvData.push(jsonObj);
})
.on('error', err => {
return reject(err);
})
.on('done', error => {
if (error) {
return reject(error);
} else {
return resolve(csvData);
}
});
});
req.on('error', reject);
});
}
|
javascript
|
{
"resource": ""
}
|
q52098
|
loadCSV
|
train
|
async function loadCSV(filepath, options) {
if (validUrl.isUri(filepath)) {
return loadCSVURI(filepath, options);
} else {
return new Promise((resolve, reject) => {
const csvData = [];
const config = Object.assign({ checkType: true, }, options);
csvtojson(config).fromFile(filepath)
.on('json', jsonObj => {
csvData.push(jsonObj);
})
.on('error', err => {
return reject(err);
})
.on('done', error => {
if (error) {
return reject(error);
} else {
return resolve(csvData);
}
});
});
}
}
|
javascript
|
{
"resource": ""
}
|
q52099
|
loadTSV
|
train
|
async function loadTSV(filepath, options) {
const tsvOptions = Object.assign({
checkType: true,
}, options, {
delimiter: '\t',
});
return loadCSV(filepath, tsvOptions);
}
|
javascript
|
{
"resource": ""
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.