_id
stringlengths 2
6
| title
stringlengths 0
58
| partition
stringclasses 3
values | text
stringlengths 52
373k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q44700
|
train
|
function (header) {
if (!(header && header.key)) { return; } // if no valid header is provided, do nothing
var existing = this.headers.find({ key: header.key });
if (!existing) {
return this.headers.add(header);
}
existing.value = header.value;
}
|
javascript
|
{
"resource": ""
}
|
|
q44701
|
train
|
function () {
var contentLength = this.headers.get(CONTENT_LENGTH),
requestTarget = this.url.getPathWithQuery(),
bodyString,
sizeInfo = {
body: 0,
header: 0,
total: 0,
source: SIZE_SOURCE.computed
};
// if 'Content-Length' header is present, we take body as declared by
// the client(postman-request or user-defined). else we need to compute the same.
if (contentLength && util.isNumeric(contentLength)) {
sizeInfo.body = parseInt(contentLength, 10);
sizeInfo.source = SIZE_SOURCE.contentLength;
}
// otherwise, if body is defined, we calculate the length of the body
else if (this.body) {
// @note body.toString() returns E for formdata or file mode
bodyString = this.body.toString();
sizeInfo.body = supportsBuffer ? Buffer.byteLength(bodyString) : bodyString.length;
}
// https://tools.ietf.org/html/rfc7230#section-3
// HTTP-message = start-line (request-line / status-line)
// *( header-field CRLF )
// CRLF
// [ message-body ]
// request-line = method SP request-target SP HTTP-version CRLF
sizeInfo.header = (this.method + SP + requestTarget + SP + HTTP_X_X + CRLF + CRLF).length +
this.headers.contentSize();
// compute the approximate total body size by adding size of header and body
sizeInfo.total = (sizeInfo.body || 0) + (sizeInfo.header || 0);
return sizeInfo;
}
|
javascript
|
{
"resource": ""
}
|
|
q44702
|
train
|
function () {
var obj = PropertyBase.toJSON(this);
// remove header array if blank
if (_.isArray(obj.header) && !obj.header.length) {
delete obj.header;
}
return obj;
}
|
javascript
|
{
"resource": ""
}
|
|
q44703
|
train
|
function (excludeDisabled, caseSensitive) {
// if the scope has no layers, we simply export the contents of primary store
if (!this._layers) {
return this.values.toObject(excludeDisabled, caseSensitive);
}
var mergedLayers = {};
_.forEachRight(this._layers, function (layer) {
_.assign(mergedLayers, layer.toObject(excludeDisabled, caseSensitive));
});
return _.assign(mergedLayers, this.values.toObject(excludeDisabled, caseSensitive));
}
|
javascript
|
{
"resource": ""
}
|
|
q44704
|
train
|
function (key) {
var variable = this.values.oneNormalizedVariable(key),
i,
ii;
// if a variable does not exist in local scope, we search all the layers and return the first occurrence.
if (!(variable || !this._layers)) {
for (i = 0, ii = this._layers.length; i < ii; i++) {
variable = this._layers[i].oneNormalizedVariable(key);
if (variable && !variable.disabled) { break; }
}
}
return (variable && !variable.disabled) ? variable.valueOf() : undefined;
}
|
javascript
|
{
"resource": ""
}
|
|
q44705
|
train
|
function (key, value, type) {
var variable = this.values.oneNormalizedVariable(key),
update = { // create an object that will be used as setter
key: key,
value: value
};
_.isString(type) && (update.type = type);
// If a variable by the name key exists, update it's value and return.
// @note adds new variable if existing is disabled. Disabled variables are not updated.
if (variable && !variable.disabled) {
variable.update(update);
}
else {
this.values.add(update);
}
// track the change if mutation tracking is enabled
this._postman_enableTracking && this.mutations.track(MUTATIONS.SET, key, value);
}
|
javascript
|
{
"resource": ""
}
|
|
q44706
|
train
|
function (key) {
var lastDisabledVariable;
this.values.remove(function (variable) {
// bail out if variable name didn't match
if (variable.key !== key) {
return false;
}
// don't delete disabled variables
if (variable.disabled) {
lastDisabledVariable = variable;
return false;
}
// delete all enabled variables
return true;
});
// restore the reference with the last disabled variable
if (lastDisabledVariable) {
this.values.reference[key] = lastDisabledVariable;
}
// track the change if mutation tracking is enabled
this._postman_enableTracking && this.mutations.track(MUTATIONS.UNSET, key);
}
|
javascript
|
{
"resource": ""
}
|
|
q44707
|
train
|
function () {
var obj = PropertyBase.toJSON(this);
// @todo - remove this when pluralisation is complete
if (obj.value) {
obj.values = obj.value;
delete obj.value;
}
// ensure that the concept of layers is not exported as JSON. JSON cannot retain references and this will end up
// being a pointless object post JSONification.
if (obj._layers) {
delete obj._layers;
}
// ensure that tracking flag is not serialized
// otherwise, it is very easy to let tracking trickle to many instances leading to a snowball effect
if (obj._postman_enableTracking) {
delete obj._postman_enableTracking;
}
return obj;
}
|
javascript
|
{
"resource": ""
}
|
|
q44708
|
train
|
function () {
if (!this._details || this._details.code !== this.code) {
this._details = _.clone(httpReasons.lookup(this.code));
this._details.code = this.code;
this._details.standardName = this._details.name;
}
return _.clone(this._details);
}
|
javascript
|
{
"resource": ""
}
|
|
q44709
|
train
|
function () {
var sizeInfo = {
body: 0,
header: 0,
total: 0
},
contentEncoding = this.headers.get(CONTENT_ENCODING),
contentLength = this.headers.get(CONTENT_LENGTH),
isCompressed = false,
byteLength;
// if server sent encoded data, we should first try deriving length from headers
if (_.isString(contentEncoding)) {
// desensitise case of content encoding
contentEncoding = contentEncoding.toLowerCase();
// eslint-disable-next-line lodash/prefer-includes
isCompressed = (contentEncoding.indexOf('gzip') > -1) || (contentEncoding.indexOf('deflate') > -1);
}
// if 'Content-Length' header is present and encoding is of type gzip/deflate, we take body as declared by
// server. else we need to compute the same.
if (contentLength && isCompressed && util.isNumeric(contentLength)) {
sizeInfo.body = _.parseInt(contentLength, 10);
}
// if there is a stream defined which looks like buffer, use it's data and move on
else if (this.stream) {
byteLength = this.stream.byteLength;
sizeInfo.body = util.isNumeric(byteLength) ? byteLength : 0;
}
// otherwise, if body is defined, we try get the true length of the body
else if (!_.isNil(this.body)) {
sizeInfo.body = supportsBuffer ? Buffer.byteLength(this.body.toString()) : this.body.toString().length;
}
// size of header is added
// https://tools.ietf.org/html/rfc7230#section-3
// HTTP-message = start-line (request-line / status-line)
// *( header-field CRLF )
// CRLF
// [ message-body ]
// status-line = HTTP-version SP status-code SP reason-phrase CRLF
sizeInfo.header = (HTTP_X_X + SP + this.code + SP + this.reason() + CRLF + CRLF).length +
this.headers.contentSize();
// compute the approximate total body size by adding size of header and body
sizeInfo.total = (sizeInfo.body || 0) + (sizeInfo.header || 0);
return sizeInfo;
}
|
javascript
|
{
"resource": ""
}
|
|
q44710
|
train
|
function () {
var contentEncoding = this.headers.get(CONTENT_ENCODING),
body = this.stream || this.body,
source;
if (contentEncoding) {
source = HEADER;
}
// if the encoding is not found, we check
else if (body) { // @todo add detection for deflate
// eslint-disable-next-line lodash/prefer-matches
if (body[0] === 0x1F && body[1] === 0x8B && body[2] === 0x8) {
contentEncoding = GZIP;
}
if (contentEncoding) {
source = BODY;
}
}
return {
format: contentEncoding,
source: source
};
}
|
javascript
|
{
"resource": ""
}
|
|
q44711
|
train
|
function (response, cookies) {
return new Response({
cookie: cookies,
body: response.body.toString(),
stream: response.body,
header: response.headers,
code: response.statusCode,
status: response.statusMessage,
responseTime: response.elapsedTime
});
}
|
javascript
|
{
"resource": ""
}
|
|
q44712
|
train
|
function (timings) {
// bail out if timing information is not provided
if (!(timings && timings.offset)) {
return;
}
var phases,
offset = timings.offset;
// REFER: https://github.com/postmanlabs/postman-request/blob/v2.88.1-postman.5/request.js#L996
phases = {
prepare: offset.request,
wait: offset.socket - offset.request,
dns: offset.lookup - offset.socket,
tcp: offset.connect - offset.lookup,
firstByte: offset.response - offset.connect,
download: offset.end - offset.response,
process: offset.done - offset.end,
total: offset.done
};
if (offset.secureConnect) {
phases.secureHandshake = offset.secureConnect - offset.connect;
phases.firstByte = offset.response - offset.secureConnect;
}
return phases;
}
|
javascript
|
{
"resource": ""
}
|
|
q44713
|
getErrorSource
|
train
|
function getErrorSource(error) {
var match = /\n at [^(]+ \((.*):(\d+):(\d+)\)/.exec(error.stack);
if (match) {
var source = match[1];
var line = +match[2];
var column = +match[3];
// Support the inline sourceContents inside the source map
var contents = fileContentsCache[source];
// Support files on disk
if (!contents && fs && fs.existsSync(source)) {
try {
contents = fs.readFileSync(source, 'utf8');
} catch (er) {
contents = '';
}
}
// Format the line from the original source code like node does
if (contents) {
var code = contents.split(/(?:\r\n|\r|\n)/)[line - 1];
if (code) {
return source + ':' + line + '\n' + code + '\n' +
new Array(column).join(' ') + '^';
}
}
}
return null;
}
|
javascript
|
{
"resource": ""
}
|
q44714
|
train
|
function() {
appsink.pull(function(buf, caps) {
if (caps) {
//console.log("CAPS", caps);
mimeType = caps['name'];
}
if (buf) {
//console.log("BUFFER size",buf.length);
for( c in clients ) {
// write header contained in caps
clients[c].write('--'+boundary+'\r\n');
clients[c].write('Content-Type: ' + mimeType + '\r\n' +
'Content-Length: ' + buf.length + '\r\n');
clients[c].write('\r\n');
/* debug to ensure the jpeg is good
if(bOnce == 1) {
fs.writeFile("buffer.jpeg", buf);
bOnce = 0;
}
*/
clients[c].write(buf, 'binary');
clients[c].write('\r\n');
}
pull();
} else {
setTimeout(pull, 500);
}
});
}
|
javascript
|
{
"resource": ""
}
|
|
q44715
|
strbuf
|
train
|
function strbuf(str) {
var b = new ByteBuffer(str.length + 4);
b.setUint16 (0, str.length, true);
for (var i = 0; i < str.length; i += 2) {
b.setUint16 (i + 2, str.getUint16 (i), true);
}
b.setUint16 (b.length - 2, 0, true);
return b;
}
|
javascript
|
{
"resource": ""
}
|
q44716
|
startWatchIPCServer
|
train
|
function startWatchIPCServer(callback, configIndices) {
ipc.config.id = serverName;
ipc.config.retry = 3;
ipc.config.silent = true;
ipc.serve(
function() {
ipc.server.on(
'done',
watchDoneHandler.bind(this, callback, ipc, configIndices)
);
}
);
ipc.server.start();
}
|
javascript
|
{
"resource": ""
}
|
q44717
|
run
|
train
|
function run(configPath, options, callback) {
var config,
argvBackup = process.argv,
farmOptions = assign({}, options);
options = options || {};
if(options.colors === undefined) {
options.colors = chalk.supportsColor;
}
if(!options.argv) {
options.argv = [];
}
options.argv.unshift(process.execPath, 'parallel-webpack');
try {
process.argv = options.argv;
config = loadConfigurationFile(configPath);
process.argv = argvBackup;
} catch(e) {
process.argv = argvBackup;
return Promise.reject(new Error(
chalk.red('[WEBPACK]') + ' Could not load configuration file ' + chalk.underline(configPath) + "\n"
+ e
));
}
if (!validate(farmOptions)) {
return Promise.reject(new Error(
'Options validation failed:\n' +
validate.errors.map(function(error) {
return 'Property: "options' + error.dataPath + '" ' + error.message;
}).join('\n')
));
}
var workers = workerFarm(farmOptions, require.resolve('./src/webpackWorker'));
var shutdownCallback = function() {
if (notSilent(options)) {
console.log(chalk.red('[WEBPACK]') + ' Forcefully shutting down');
}
workerFarm.end(workers);
};
function keepAliveAfterFinishCallback(cb){
if(options.keepAliveAfterFinish){
setTimeout(cb, options.keepAliveAfterFinish);
} else {
cb();
}
}
function finalCallback(){
workerFarm.end(workers);
process.removeListener("SIGINT", shutdownCallback);
}
process.on('SIGINT', shutdownCallback);
var startTime = Date.now();
var farmPromise = startFarm(
config,
configPath,
options,
Promise.promisify(workers),
callback
).error(function(err) {
if(notSilent(options)) {
console.log('%s Build failed after %s seconds', chalk.red('[WEBPACK]'), chalk.blue((Date.now() - startTime) / 1000));
}
return Promise.reject(err);
}).then(function (results) {
if(notSilent(options)) {
console.log('%s Finished build after %s seconds', chalk.blue('[WEBPACK]'), chalk.blue((Date.now() - startTime) / 1000));
}
results = results.filter(function(result) {
return result;
});
if(results.length) {
return results;
}
}).finally(function() {
keepAliveAfterFinishCallback(finalCallback);
});
if (!options.watch) {
farmPromise.asCallback(callback);
}
return farmPromise;
}
|
javascript
|
{
"resource": ""
}
|
q44718
|
StatePermissionMap
|
train
|
function StatePermissionMap(state) {
var toStateObject = state.$$permissionState();
var toStatePath = toStateObject.path;
angular.forEach(toStatePath, function (state) {
if (areSetStatePermissions(state)) {
var permissionMap = new PermPermissionMap(state.data.permissions);
this.extendPermissionMap(permissionMap);
}
}, this);
}
|
javascript
|
{
"resource": ""
}
|
q44719
|
handleOnBeforeWebHook
|
train
|
function handleOnBeforeWebHook(transition) {
setTransitionProperties(transition);
var statePermissionMap = new PermStatePermissionMap(PermTransitionProperties.toState);
return PermStateAuthorization
.authorizeByPermissionMap(statePermissionMap)
.catch(function (rejectedPermission) {
return statePermissionMap
.resolveRedirectState(rejectedPermission)
.then(function (redirect) {
return transition.router.stateService.target(redirect.state, redirect.params, redirect.options);
});
});
/**
* Updates values of `PermTransitionProperties` holder object
* @method
* @private
*/
function setTransitionProperties(transition) {
PermTransitionProperties.toState = transition.to();
PermTransitionProperties.toParams = transition.params('to');
PermTransitionProperties.fromState = transition.from();
PermTransitionProperties.fromParams = transition.params('from');
PermTransitionProperties.options = transition.options();
}
}
|
javascript
|
{
"resource": ""
}
|
q44720
|
handleAuthorizedState
|
train
|
function handleAuthorizedState() {
PermTransitionEvents.broadcastPermissionAcceptedEvent();
// Overwrite notify option to broadcast it later
var transitionOptions = angular.extend({}, PermTransitionProperties.options, {
notify: false,
location: true
});
$state
.go(PermTransitionProperties.toState.name, PermTransitionProperties.toParams, transitionOptions)
.then(function () {
PermTransitionEvents.broadcastStateChangeSuccessEvent();
});
}
|
javascript
|
{
"resource": ""
}
|
q44721
|
$permission
|
train
|
function $permission() {
'ngInject';
var defaultOnAuthorizedMethod = 'showElement';
var defaultOnUnauthorizedMethod = 'hideElement';
var suppressUndefinedPermissionWarning = false;
/**
* Methods allowing to alter default directive onAuthorized behaviour in permission directive
* @methodOf permission.permissionProvider
*
* @param onAuthorizedMethod {String} One of permission.PermPermissionStrategies method names
*/
this.setDefaultOnAuthorizedMethod = function (onAuthorizedMethod) { // jshint ignore:line
defaultOnAuthorizedMethod = onAuthorizedMethod;
};
/**
* Methods allowing to alter default directive onUnauthorized behaviour in permission directive
* @methodOf permission.permissionProvider
*
* @param onUnauthorizedMethod {String} One of permission.PermPermissionStrategies method names
*/
this.setDefaultOnUnauthorizedMethod = function (onUnauthorizedMethod) { // jshint ignore:line
defaultOnUnauthorizedMethod = onUnauthorizedMethod;
};
/**
* When set to true hides permission warning for undefined roles and permissions
* @methodOf permission.permissionProvider
*
* @param value {Boolean}
*/
this.suppressUndefinedPermissionWarning = function (value) { // jshint ignore:line
suppressUndefinedPermissionWarning = value;
};
this.$get = function () { // jshint ignore:line
return {
defaultOnAuthorizedMethod: defaultOnAuthorizedMethod,
defaultOnUnauthorizedMethod: defaultOnUnauthorizedMethod,
suppressUndefinedPermissionWarning: suppressUndefinedPermissionWarning
};
};
}
|
javascript
|
{
"resource": ""
}
|
q44722
|
onAuthorizedAccess
|
train
|
function onAuthorizedAccess() {
if (angular.isFunction(permission.onAuthorized)) {
permission.onAuthorized()($element);
} else {
var onAuthorizedMethodName = $permission.defaultOnAuthorizedMethod;
PermPermissionStrategies[onAuthorizedMethodName]($element);
}
}
|
javascript
|
{
"resource": ""
}
|
q44723
|
onUnauthorizedAccess
|
train
|
function onUnauthorizedAccess() {
if (angular.isFunction(permission.onUnauthorized)) {
permission.onUnauthorized()($element);
} else {
var onUnauthorizedMethodName = $permission.defaultOnUnauthorizedMethod;
PermPermissionStrategies[onUnauthorizedMethodName]($element);
}
}
|
javascript
|
{
"resource": ""
}
|
q44724
|
handleStateChangeStartEvent
|
train
|
function handleStateChangeStartEvent(event, toState, toParams, fromState, fromParams, options) {
if (!isAuthorizationFinished()) {
setStateAuthorizationStatus(true);
setTransitionProperties();
if (!PermTransitionEvents.areEventsDefaultPrevented()) {
PermTransitionEvents.broadcastPermissionStartEvent();
event.preventDefault();
var statePermissionMap = new PermStatePermissionMap(PermTransitionProperties.toState);
PermStateAuthorization
.authorizeByPermissionMap(statePermissionMap)
.then(function () {
handleAuthorizedState();
})
.catch(function (rejectedPermission) {
handleUnauthorizedState(rejectedPermission, statePermissionMap);
})
.finally(function () {
setStateAuthorizationStatus(false);
});
} else {
setStateAuthorizationStatus(false);
}
}
/**
* Updates values of `PermTransitionProperties` holder object
* @method
* @private
*/
function setTransitionProperties() {
PermTransitionProperties.toState = toState;
PermTransitionProperties.toParams = toParams;
PermTransitionProperties.fromState = fromState;
PermTransitionProperties.fromParams = fromParams;
PermTransitionProperties.options = options;
}
/**
* Sets internal state `$$finishedAuthorization` variable to prevent looping
* @method
* @private
*
* @param status {boolean} When true authorization has been already preceded
*/
function setStateAuthorizationStatus(status) {
angular.extend(toState, {'$$isAuthorizationFinished': status});
}
/**
* Checks if state has been already checked for authorization
* @method
* @private
*
* @returns {boolean}
*/
function isAuthorizationFinished() {
return toState.$$isAuthorizationFinished;
}
/**
* Handles redirection for authorized access
* @method
* @private
*/
function handleAuthorizedState() {
PermTransitionEvents.broadcastPermissionAcceptedEvent();
// Overwrite notify option to broadcast it later
var transitionOptions = angular.extend({}, PermTransitionProperties.options, {notify: false, location: true});
$state
.go(PermTransitionProperties.toState.name, PermTransitionProperties.toParams, transitionOptions)
.then(function () {
PermTransitionEvents.broadcastStateChangeSuccessEvent();
});
}
/**
* Handles redirection for unauthorized access
* @method
* @private
*
* @param rejectedPermission {String} Rejected access right
* @param statePermissionMap {permission.ui.PermPermissionMap} State permission map
*/
function handleUnauthorizedState(rejectedPermission, statePermissionMap) {
PermTransitionEvents.broadcastPermissionDeniedEvent();
statePermissionMap
.resolveRedirectState(rejectedPermission)
.then(function (redirect) {
$state.go(redirect.state, redirect.params, redirect.options);
});
}
}
|
javascript
|
{
"resource": ""
}
|
q44725
|
set_prefixed_value_css
|
train
|
function set_prefixed_value_css(element, property, value, extra) {
property += ':';
element.style.cssText = (property + prefixes.join(value + ';' + property)).slice(0, -property.length) + (extra || '');
}
|
javascript
|
{
"resource": ""
}
|
q44726
|
set_prefixed_property_css
|
train
|
function set_prefixed_property_css(element, property, value, extra) {
element.style.cssText = prefixes.join(property + ':' + value + ';') + (extra || '');
}
|
javascript
|
{
"resource": ""
}
|
q44727
|
webforms
|
train
|
function webforms(){
// Run through HTML5's new input attributes to see if the UA understands any.
// We're using f which is the <input> element created early on
// Mike Taylr has created a comprehensive resource for testing these attributes
// when applied to all input types:
// http://miketaylr.com/code/input-type-attr.html
// spec: http://www.whatwg.org/specs/web-apps/current-work/multipage/the-input-element.html#input-type-attr-summary
ret['input'] = (function(props) {
for (var i = 0,len=props.length;i<len;i++) {
attrs[ props[i] ] = !!(props[i] in f);
}
return attrs;
})('autocomplete autofocus list placeholder max min multiple pattern required step'.split(' '));
// Run through HTML5's new input types to see if the UA understands any.
// This is put behind the tests runloop because it doesn't return a
// true/false like all the other tests; instead, it returns an object
// containing each input type with its corresponding true/false value
// Big thanks to @miketaylr for the html5 forms expertise. http://miketaylr.com/
ret['inputtypes'] = (function(props) {
for (var i = 0, bool, len=props.length ; i < len ; i++) {
f.setAttribute('type', props[i]);
bool = f.type !== 'text';
// Chrome likes to falsely purport support, so we feed it a textual value;
// if that doesnt succeed then we know there's a custom UI
if (bool){
f.value = smile;
if (/^range$/.test(f.type) && f.style.WebkitAppearance !== undefined){
docElement.appendChild(f);
var defaultView = doc.defaultView;
// Safari 2-4 allows the smiley as a value, despite making a slider
bool = defaultView.getComputedStyle &&
defaultView.getComputedStyle(f, null).WebkitAppearance !== 'textfield' &&
// Mobile android web browser has false positive, so must
// check the height to see if the widget is actually there.
(f.offsetHeight !== 0);
docElement.removeChild(f);
} else if (/^(search|tel)$/.test(f.type)){
// Spec doesnt define any special parsing or detectable UI
// behaviors so we pass these through as true
// Interestingly, opera fails the earlier test, so it doesn't
// even make it here.
} else if (/^(url|email)$/.test(f.type)) {
// Real url and email support comes with prebaked validation.
bool = f.checkValidity && f.checkValidity() === false;
} else {
// If the upgraded input compontent rejects the :) text, we got a winner
bool = f.value != smile;
}
}
inputs[ props[i] ] = !!bool;
}
return inputs;
})('search tel url email datetime date month week time datetime-local number range color'.split(' '));
}
|
javascript
|
{
"resource": ""
}
|
q44728
|
mw
|
train
|
function mw(store) {
if (savedStore && savedStore !== store) {
throw new Error('cannot assign logicMiddleware instance to multiple stores, create separate instance for each');
}
savedStore = store;
return next => {
savedNext = next;
const { action$, sub, logicCount: cnt } =
applyLogic(arrLogic, savedStore, savedNext,
logicSub, actionSrc$, deps, logicCount,
monitor$);
actionEnd$ = action$;
logicSub = sub;
logicCount = cnt;
return action => {
debug('starting off', action);
monitor$.next({ action, op: 'top' });
actionSrc$.next(action);
return action;
};
};
}
|
javascript
|
{
"resource": ""
}
|
q44729
|
naming
|
train
|
function naming(logic, idx) {
if (logic.name) { return logic; }
return {
...logic,
name: `L(${stringifyType(logic.type)})-${idx}`
};
}
|
javascript
|
{
"resource": ""
}
|
q44730
|
findDuplicates
|
train
|
function findDuplicates(arrLogic) {
return arrLogic.reduce((acc, x1, idx1) => {
if (arrLogic.some((x2, idx2) => (idx1 !== idx2 && x1 === x2))) {
acc.push(idx1);
}
return acc;
}, []);
}
|
javascript
|
{
"resource": ""
}
|
q44731
|
formatMessage
|
train
|
function formatMessage(message) {
return message
// Make some common errors shorter:
.replace(
// Babel syntax error
'Module build failed: SyntaxError:',
friendlySyntaxErrorLabel
)
.replace(
// Webpack file not found error
/Module not found: Error: Cannot resolve 'file' or 'directory'/,
'Module not found:'
)
// Internal stacks are generally useless so we strip them
.replace(/^\s*at\s.*:\d+:\d+[\s\)]*\n/gm, '') // at ... ...:x:y
// Webpack loader names obscure CSS filenames
.replace('./~/css-loader!./~/postcss-loader!', '');
}
|
javascript
|
{
"resource": ""
}
|
q44732
|
train
|
function(components) {
var fields = [];
FormioUtils.eachComponent(components, function(component) {
if (component.key && component.input && (component.type !== 'button') && component.key !== $scope.component.key) {
var comp = _clone(component);
if (!comp.label) {
comp.label = comp.key;
}
fields.push(comp);
}
});
return fields;
}
|
javascript
|
{
"resource": ""
}
|
|
q44733
|
train
|
function() {
if (!$scope.component.data.resource || ($scope.resources.length === 0)) {
return;
}
var selected = null;
$scope.resourceFields = [
{
property: '',
title: '{Entire Object}'
},
{
property: '_id',
title: 'Submission Id'
}
];
if ($scope.formio.projectId) {
$scope.component.data.project = $scope.formio.projectId;
}
for (var index in $scope.resources) {
if ($scope.resources[index]._id.toString() === $scope.component.data.resource) {
selected = $scope.resources[index];
break;
}
}
if (selected) {
var fields = getInputFields(selected.components);
for (var i in fields) {
var field = fields[i];
var title = field.label || field.key;
$scope.resourceFields.push({
property: 'data.' + field.key,
title: title
});
}
if (!$scope.component.valueProperty && $scope.resourceFields.length) {
$scope.component.valueProperty = $scope.resourceFields[0].property;
}
}
}
|
javascript
|
{
"resource": ""
}
|
|
q44734
|
train
|
function() {
jQuery(dropZone).removeClass('enabled');
dropZone.removeEventListener('dragover', dragOver, false);
dropZone.removeEventListener('drop', dragDrop, false);
}
|
javascript
|
{
"resource": ""
}
|
|
q44735
|
train
|
function(event) {
if (event.preventDefault) {
event.preventDefault();
}
if (event.stopPropagation) {
event.stopPropagation();
}
var dropOffset = jQuery(dropZone).offset();
var dragData = angular.copy(scope.formBuilderDraggable);
dragData.fbDropX = event.pageX - dropOffset.left;
dragData.fbDropY = event.pageY - dropOffset.top;
angular.element(dropZone).scope().$emit('fbDragDrop', dragData);
dragEnd();
return false;
}
|
javascript
|
{
"resource": ""
}
|
|
q44736
|
train
|
function(components, input) {
// Prebuild a list of existing components.
var existingComponents = {};
FormioUtils.eachComponent(components, function(component) {
// If theres no key, we cant compare components.
if (!component.key) return;
// A component is pre-existing if the key is unique, or the key is a duplicate and its not flagged as the new component.
if (
(component.key !== input.key) ||
((component.key === input.key) && (!!component.isNew !== !!input.isNew))
) {
existingComponents[component.key] = component;
}
}, true);
return existingComponents;
}
|
javascript
|
{
"resource": ""
}
|
|
q44737
|
train
|
function(key) {
if (!key.match(suffixRegex)) {
return key + '2';
}
return key.replace(suffixRegex, function(suffix) {
return Number(suffix) + 1;
});
}
|
javascript
|
{
"resource": ""
}
|
|
q44738
|
train
|
function(form, component) {
var isNew = component.isNew || false;
// Recurse into all child components.
FormioUtils.eachComponent([component], function(component) {
// Force the component isNew to be the same as the parent.
component.isNew = isNew;
// Skip key uniquification if this component doesn't have a key.
if (!component.key) {
return;
}
var memoization = findExistingComponents(form.components, component);
while (keyExists(memoization, component.key)) {
component.key = iterateKey(component.key);
}
}, true);
return component;
}
|
javascript
|
{
"resource": ""
}
|
|
q44739
|
systemSupportsUdev
|
train
|
function systemSupportsUdev() {
if (_systemSupportsUdev === undefined) {
try {
_systemSupportsUdev = fs.existsSync(UDEV_RULES_SYSTEM_PATH);
} catch (e) {
_systemSupportsUdev = false;
}
}
return _systemSupportsUdev;
}
|
javascript
|
{
"resource": ""
}
|
q44740
|
udevRulesInstalled
|
train
|
function udevRulesInstalled() {
if (_udevRulesInstalled !== undefined) {
return _udevRulesInstalled;
}
if (!systemSupportsUdev()) {
_udevRulesInstalled = false;
return false;
}
// Try to load the installed rules file
let current = null;
try {
current = fs.readFileSync(UDEV_RULES_SYSTEM_FILE);
} catch (e) {
_udevRulesInstalled = false;
return false;
}
// Compare the installed file with the file bundled with this app
const latest = fs.readFileSync(UDEV_RULES_ASSET_FILE);
_udevRulesInstalled = current.equals(latest);
return _udevRulesInstalled;
}
|
javascript
|
{
"resource": ""
}
|
q44741
|
installUdevRules
|
train
|
function installUdevRules() {
if (!systemSupportsUdev()) {
return when.reject(new Error('Not supported'));
}
return when.promise((resolve, reject) => {
const cmd = `sudo cp "${UDEV_RULES_ASSET_FILE}" "${UDEV_RULES_SYSTEM_FILE}"`;
console.log(cmd);
childProcess.exec(cmd, err => {
if (err) {
_udevRulesInstalled = undefined;
return reject(new VError(err, 'Could not install udev rules'));
}
_udevRulesInstalled = true;
resolve();
});
});
}
|
javascript
|
{
"resource": ""
}
|
q44742
|
promptAndInstallUdevRules
|
train
|
function promptAndInstallUdevRules(err = null) {
if (!systemSupportsUdev()) {
return when.reject(new Error('Not supported'));
}
if (udevRulesInstalled()) {
if (err) {
console.log(chalk.bold.red('Physically unplug and reconnect your Particle devices and try again.'));
return when.reject(err);
}
return when.resolve();
}
console.log(chalk.yellow('You are missing the permissions to access USB devices without root.'));
return prompt({
type: 'confirm',
name: 'install',
message: 'Would you like to install a udev rules file to get access?',
default: true
})
.then(r => {
if (!r.install) {
if (err) {
throw err;
}
throw new Error('Cancelled');
}
return installUdevRules();
})
.then(() => {
console.log('udev rules installed.');
if (err) {
console.log(chalk.bold.red('Physically unplug and reconnect your Particle devices and try again.'));
throw err;
}
});
}
|
javascript
|
{
"resource": ""
}
|
q44743
|
matchKey
|
train
|
function matchKey(needle, obj, caseInsensitive) {
needle = (caseInsensitive) ? needle.toLowerCase() : needle;
for (let key in obj) {
let keyCopy = (caseInsensitive) ? key.toLowerCase() : key;
if (keyCopy === needle) {
//return the original
return key;
}
}
return null;
}
|
javascript
|
{
"resource": ""
}
|
q44744
|
openUsbDevice
|
train
|
function openUsbDevice(usbDevice, { dfuMode = false } = {}) {
if (!dfuMode && usbDevice.isInDfuMode) {
return when.reject(new Error('The device should not be in DFU mode'));
}
return when.resolve().then(() => usbDevice.open())
.catch(e => handleDeviceOpenError(e));
}
|
javascript
|
{
"resource": ""
}
|
q44745
|
openUsbDeviceById
|
train
|
function openUsbDeviceById({ id, api, auth, dfuMode = false, displayName = null }) {
return when.resolve().then(() => {
if (isDeviceId(id)) {
// Try to open the device straight away
return openDeviceById(id).catch(e => {
if (!(e instanceof NotFoundError)) {
return handleDeviceOpenError(e);
}
});
}
})
.then(usbDevice => {
if (!usbDevice) {
return getDevice({ id, api, auth, displayName }).then(device => {
if (device.id === id) {
throw new NotFoundError();
}
return openDeviceById(device.id).catch(e => handleDeviceOpenError(e));
})
.catch(e => {
if (e instanceof NotFoundError) {
throw new Error(`Unable to connect to the device ${displayName || id}. Make sure the device is connected to the host computer via USB`);
}
throw e;
});
}
return usbDevice;
})
.then(usbDevice => {
if (!dfuMode && usbDevice.isInDfuMode) {
return usbDevice.close().then(() => {
throw new Error('The device should not be in DFU mode');
});
}
return usbDevice;
});
}
|
javascript
|
{
"resource": ""
}
|
q44746
|
createErrorHandler
|
train
|
function createErrorHandler(yargs) {
if (!yargs) {
yargs = Yargs;
}
return consoleErrorLogger.bind(undefined, console, yargs, true);
}
|
javascript
|
{
"resource": ""
}
|
q44747
|
parseParams
|
train
|
function parseParams(yargs, argv, path, params) {
let required = 0;
let optional = 0;
let variadic = false;
argv.params = {};
const extra = argv._.slice(path.length);
argv._ = argv._.slice(0, path.length);
params.replace(/(<[^>]+>|\[[^\]]+\])/g,
(match) => {
if (variadic) {
throw variadicParameterPositionError(variadic);
}
const isRequired = match[0] === '<';
const param = match
.slice(1, -1)
.replace(/(.*)\.\.\.$/, (m, param) => {
variadic = true;
return param;
});
let value;
if (isRequired) {
required++;
} else {
optional++;
}
if (variadic) {
variadic = param; // save the name
value = extra.slice(-1 + required + optional).map(String);
if (isRequired && !value.length) {
throw variadicParameterRequiredError(param);
}
} else {
if (isRequired && optional > 0) {
throw requiredParameterPositionError(param);
}
value = extra[-1 + required + optional];
if (value) {
value = String(value);
}
if (isRequired && typeof value === 'undefined') {
throw requiredParameterError(param);
}
}
const params = param.split('|');
params.forEach(p => {
argv.params[p] = value;
});
});
if (!variadic && required+optional < extra.length) {
throw unknownParametersError(extra.slice(required+optional));
}
}
|
javascript
|
{
"resource": ""
}
|
q44748
|
parse
|
train
|
function parse(command, args) {
Yargs.reset();
Yargs.wrap(Yargs.terminalWidth());
return command.parse(args, Yargs);
}
|
javascript
|
{
"resource": ""
}
|
q44749
|
getDevice
|
train
|
function getDevice({ id, api, auth, displayName = null, dontThrow = false }) {
const p = when.resolve().then(() => api.getDevice({ deviceId: id, auth }))
.then(r => r.body)
.catch(e => {
if (e.statusCode === 403 || e.statusCode === 404) {
if (dontThrow) {
return null;
}
throw new Error(`Device not found: ${displayName || id}`);
}
throw e;
});
return spin(p, 'Getting device information...');
}
|
javascript
|
{
"resource": ""
}
|
q44750
|
buildProofChain
|
train
|
function buildProofChain(later_mci, earlier_mci, unit, arrBalls, onDone){
if (earlier_mci === null)
throw Error("earlier_mci=null, unit="+unit);
if (later_mci === earlier_mci)
return buildLastMileOfProofChain(earlier_mci, unit, arrBalls, onDone);
buildProofChainOnMc(later_mci, earlier_mci, arrBalls, function(){
buildLastMileOfProofChain(earlier_mci, unit, arrBalls, onDone);
});
}
|
javascript
|
{
"resource": ""
}
|
q44751
|
buildProofChainOnMc
|
train
|
function buildProofChainOnMc(later_mci, earlier_mci, arrBalls, onDone){
function addBall(mci){
if (mci < 0)
throw Error("mci<0, later_mci="+later_mci+", earlier_mci="+earlier_mci);
db.query("SELECT unit, ball, content_hash FROM units JOIN balls USING(unit) WHERE main_chain_index=? AND is_on_main_chain=1", [mci], function(rows){
if (rows.length !== 1)
throw Error("no prev chain element? mci="+mci+", later_mci="+later_mci+", earlier_mci="+earlier_mci);
var objBall = rows[0];
if (objBall.content_hash)
objBall.is_nonserial = true;
delete objBall.content_hash;
db.query(
"SELECT ball FROM parenthoods LEFT JOIN balls ON parent_unit=balls.unit WHERE child_unit=? ORDER BY ball",
[objBall.unit],
function(parent_rows){
if (parent_rows.some(function(parent_row){ return !parent_row.ball; }))
throw Error("some parents have no balls");
if (parent_rows.length > 0)
objBall.parent_balls = parent_rows.map(function(parent_row){ return parent_row.ball; });
db.query(
"SELECT ball, main_chain_index \n\
FROM skiplist_units JOIN units ON skiplist_unit=units.unit LEFT JOIN balls ON units.unit=balls.unit \n\
WHERE skiplist_units.unit=? ORDER BY ball",
[objBall.unit],
function(srows){
if (srows.some(function(srow){ return !srow.ball; }))
throw Error("some skiplist units have no balls");
if (srows.length > 0)
objBall.skiplist_balls = srows.map(function(srow){ return srow.ball; });
arrBalls.push(objBall);
if (mci === earlier_mci)
return onDone();
if (srows.length === 0) // no skiplist
return addBall(mci-1);
var next_mci = mci - 1;
for (var i=0; i<srows.length; i++){
var next_skiplist_mci = srows[i].main_chain_index;
if (next_skiplist_mci < next_mci && next_skiplist_mci >= earlier_mci)
next_mci = next_skiplist_mci;
}
addBall(next_mci);
}
);
}
);
});
}
if (earlier_mci > later_mci)
throw Error("earlier > later");
if (earlier_mci === later_mci)
return onDone();
addBall(later_mci - 1);
}
|
javascript
|
{
"resource": ""
}
|
q44752
|
buildLastMileOfProofChain
|
train
|
function buildLastMileOfProofChain(mci, unit, arrBalls, onDone){
function addBall(_unit){
db.query("SELECT unit, ball, content_hash FROM units JOIN balls USING(unit) WHERE unit=?", [_unit], function(rows){
if (rows.length !== 1)
throw Error("no unit?");
var objBall = rows[0];
if (objBall.content_hash)
objBall.is_nonserial = true;
delete objBall.content_hash;
db.query(
"SELECT ball FROM parenthoods LEFT JOIN balls ON parent_unit=balls.unit WHERE child_unit=? ORDER BY ball",
[objBall.unit],
function(parent_rows){
if (parent_rows.some(function(parent_row){ return !parent_row.ball; }))
throw Error("some parents have no balls");
if (parent_rows.length > 0)
objBall.parent_balls = parent_rows.map(function(parent_row){ return parent_row.ball; });
db.query(
"SELECT ball \n\
FROM skiplist_units JOIN units ON skiplist_unit=units.unit LEFT JOIN balls ON units.unit=balls.unit \n\
WHERE skiplist_units.unit=? ORDER BY ball",
[objBall.unit],
function(srows){
if (srows.some(function(srow){ return !srow.ball; }))
throw Error("last mile: some skiplist units have no balls");
if (srows.length > 0)
objBall.skiplist_balls = srows.map(function(srow){ return srow.ball; });
arrBalls.push(objBall);
if (_unit === unit)
return onDone();
findParent(_unit);
}
);
}
);
});
}
function findParent(interim_unit){
db.query(
"SELECT parent_unit FROM parenthoods JOIN units ON parent_unit=unit WHERE child_unit=? AND main_chain_index=?",
[interim_unit, mci],
function(parent_rows){
var arrParents = parent_rows.map(function(parent_row){ return parent_row.parent_unit; });
if (arrParents.indexOf(unit) >= 0)
return addBall(unit);
async.eachSeries(
arrParents,
function(parent_unit, cb){
graph.determineIfIncluded(db, unit, [parent_unit], function(bIncluded){
bIncluded ? cb(parent_unit) : cb();
});
},
function(parent_unit){
if (!parent_unit)
throw Error("no parent that includes target unit");
addBall(parent_unit);
}
)
}
);
}
// start from MC unit and go back in history
db.query("SELECT unit FROM units WHERE main_chain_index=? AND is_on_main_chain=1", [mci], function(rows){
if (rows.length !== 1)
throw Error("no mc unit?");
var mc_unit = rows[0].unit;
if (mc_unit === unit)
return onDone();
findParent(mc_unit);
});
}
|
javascript
|
{
"resource": ""
}
|
q44753
|
composeTextJoint
|
train
|
function composeTextJoint(arrSigningAddresses, arrPayingAddresses, text, signer, callbacks){
composePaymentAndTextJoint(arrSigningAddresses, arrPayingAddresses, [{address: arrPayingAddresses[0], amount: 0}], text, signer, callbacks);
}
|
javascript
|
{
"resource": ""
}
|
q44754
|
train
|
function(cb){
if (!fnRetrieveMessages)
return cb();
console.log("will retrieve messages");
fnRetrieveMessages(conn, last_ball_mci, bMultiAuthored, arrPayingAddresses, function(err, arrMoreMessages, assocMorePrivatePayloads){
console.log("fnRetrieveMessages callback: err code = "+(err ? err.error_code : ""));
if (err)
return cb((typeof err === "string") ? ("unable to add additional messages: "+err) : err);
Array.prototype.push.apply(objUnit.messages, arrMoreMessages);
if (assocMorePrivatePayloads && Object.keys(assocMorePrivatePayloads).length > 0)
for (var payload_hash in assocMorePrivatePayloads)
assocPrivatePayloads[payload_hash] = assocMorePrivatePayloads[payload_hash];
cb();
});
}
|
javascript
|
{
"resource": ""
}
|
|
q44755
|
readJointWithBall
|
train
|
function readJointWithBall(conn, unit, handleJoint) {
readJoint(conn, unit, {
ifNotFound: function(){
throw Error("joint not found, unit "+unit);
},
ifFound: function(objJoint){
if (objJoint.ball)
return handleJoint(objJoint);
conn.query("SELECT ball FROM balls WHERE unit=?", [unit], function(rows){
if (rows.length === 1)
objJoint.ball = rows[0].ball;
handleJoint(objJoint);
});
}
});
}
|
javascript
|
{
"resource": ""
}
|
q44756
|
determineBestParent
|
train
|
function determineBestParent(conn, objUnit, arrWitnesses, handleBestParent){
// choose best parent among compatible parents only
conn.query(
"SELECT unit \n\
FROM units AS parent_units \n\
WHERE unit IN(?) \n\
AND (witness_list_unit=? OR ( \n\
SELECT COUNT(*) \n\
FROM unit_witnesses AS parent_witnesses \n\
WHERE parent_witnesses.unit IN(parent_units.unit, parent_units.witness_list_unit) AND address IN(?) \n\
)>=?) \n\
ORDER BY witnessed_level DESC, \n\
level-witnessed_level ASC, \n\
unit ASC \n\
LIMIT 1",
[objUnit.parent_units, objUnit.witness_list_unit,
arrWitnesses, constants.COUNT_WITNESSES - constants.MAX_WITNESS_LIST_MUTATIONS],
function(rows){
if (rows.length !== 1)
return handleBestParent(null);
var best_parent_unit = rows[0].unit;
handleBestParent(best_parent_unit);
}
);
}
|
javascript
|
{
"resource": ""
}
|
q44757
|
buildListOfMcUnitsWithPotentiallyDifferentWitnesslists
|
train
|
function buildListOfMcUnitsWithPotentiallyDifferentWitnesslists(conn, objUnit, last_ball_unit, arrWitnesses, handleList){
function addAndGoUp(unit){
readStaticUnitProps(conn, unit, function(props){
// the parent has the same witness list and the parent has already passed the MC compatibility test
if (objUnit.witness_list_unit && objUnit.witness_list_unit === props.witness_list_unit)
return handleList(true, arrMcUnits);
else
arrMcUnits.push(unit);
if (unit === last_ball_unit)
return handleList(true, arrMcUnits);
if (!props.best_parent_unit)
throw Error("no best parent of unit "+unit+"?");
addAndGoUp(props.best_parent_unit);
});
}
var arrMcUnits = [];
determineBestParent(conn, objUnit, arrWitnesses, function(best_parent_unit){
if (!best_parent_unit)
return handleList(false);
addAndGoUp(best_parent_unit);
});
}
|
javascript
|
{
"resource": ""
}
|
q44758
|
savePrivateProfile
|
train
|
function savePrivateProfile(objPrivateProfile, address, attestor_address, onDone){
db.query(
"INSERT "+db.getIgnore()+" INTO private_profiles (unit, payload_hash, attestor_address, address, src_profile) VALUES(?,?,?,?,?)",
[objPrivateProfile.unit, objPrivateProfile.payload_hash, attestor_address, address, JSON.stringify(objPrivateProfile.src_profile)],
function (res) {
var private_profile_id = (res.insertId && res.affectedRows) ? res.insertId : 0;
var insert_fields = function(current_src_profile) {
var arrQueries = [];
var isSrcProfileUpdated = false;
for (var field in objPrivateProfile.src_profile){
var arrValueAndBlinding = objPrivateProfile.src_profile[field];
if (ValidationUtils.isArrayOfLength(arrValueAndBlinding, 2)) {
if (!current_src_profile || !current_src_profile[field] || !ValidationUtils.isArrayOfLength(current_src_profile[field], 2)) {
if (current_src_profile) {
isSrcProfileUpdated = true;
current_src_profile[field] = arrValueAndBlinding;
}
db.addQuery(arrQueries, "INSERT INTO private_profile_fields (private_profile_id, field, value, blinding) VALUES(?,?,?,?)",
[private_profile_id, field, arrValueAndBlinding[0], arrValueAndBlinding[1] ]);
}
}
}
if (isSrcProfileUpdated)
db.addQuery(arrQueries, "UPDATE private_profiles SET src_profile=? WHERE private_profile_id=?", [JSON.stringify(current_src_profile), private_profile_id]);
async.series(arrQueries, onDone);
}
if (!private_profile_id) { // already saved profile but with new fields being revealed
db.query("SELECT private_profile_id, src_profile FROM private_profiles WHERE payload_hash=?", [objPrivateProfile.payload_hash], function(rows) {
if (!rows.length)
throw Error("can't insert private profile "+JSON.stringify(objPrivateProfile));
private_profile_id = rows[0].private_profile_id;
var src_profile = JSON.parse(rows[0].src_profile);
insert_fields(src_profile);
});
}
else
insert_fields();
}
);
}
|
javascript
|
{
"resource": ""
}
|
q44759
|
updateWitnessedLevelByWitnesslist
|
train
|
function updateWitnessedLevelByWitnesslist(arrWitnesses, cb){
var arrCollectedWitnesses = [];
function setWitnessedLevel(witnessed_level){
profiler.start();
if (witnessed_level !== objValidationState.witnessed_level)
throwError("different witnessed levels, validation: "+objValidationState.witnessed_level+", writer: "+witnessed_level);
objNewUnitProps.witnessed_level = witnessed_level;
conn.query("UPDATE units SET witnessed_level=? WHERE unit=?", [witnessed_level, objUnit.unit], function(){
profiler.stop('write-wl-update');
cb();
});
}
function addWitnessesAndGoUp(start_unit){
profiler.start();
storage.readStaticUnitProps(conn, start_unit, function(props){
profiler.stop('write-wl-select-bp');
var best_parent_unit = props.best_parent_unit;
var level = props.level;
if (level === null)
throw Error("null level in updateWitnessedLevel");
if (level === 0) // genesis
return setWitnessedLevel(0);
profiler.start();
storage.readUnitAuthors(conn, start_unit, function(arrAuthors){
profiler.stop('write-wl-select-authors');
profiler.start();
for (var i=0; i<arrAuthors.length; i++){
var address = arrAuthors[i];
if (arrWitnesses.indexOf(address) !== -1 && arrCollectedWitnesses.indexOf(address) === -1)
arrCollectedWitnesses.push(address);
}
profiler.stop('write-wl-search');
(arrCollectedWitnesses.length < constants.MAJORITY_OF_WITNESSES)
? addWitnessesAndGoUp(best_parent_unit) : setWitnessedLevel(level);
});
});
}
profiler.stop('write-update');
addWitnessesAndGoUp(my_best_parent_unit);
}
|
javascript
|
{
"resource": ""
}
|
q44760
|
sendToPeerAllSharedAddressesHavingUnspentOutputs
|
train
|
function sendToPeerAllSharedAddressesHavingUnspentOutputs(device_address, asset, callbacks){
var asset_filter = !asset || asset == "base" ? " AND outputs.asset IS NULL " : " AND outputs.asset='"+asset+"'";
db.query(
"SELECT DISTINCT shared_address FROM shared_address_signing_paths CROSS JOIN outputs ON shared_address_signing_paths.shared_address=outputs.address\n\
WHERE device_address=? AND outputs.is_spent=0" + asset_filter, [device_address], function(rows){
if (rows.length === 0)
return callbacks.ifNoFundedSharedAddress();
rows.forEach(function(row){
sendSharedAddressToPeer(device_address, row.shared_address, function(err){
if (err)
return console.log(err)
console.log("Definition for " + row.shared_address + " will be sent to " + device_address);
});
});
return callbacks.ifFundedSharedAddress(rows.length);
});
}
|
javascript
|
{
"resource": ""
}
|
q44761
|
sendSharedAddressToPeer
|
train
|
function sendSharedAddressToPeer(device_address, shared_address, handle){
var arrDefinition;
var assocSignersByPath={};
async.series([
function(cb){
db.query("SELECT definition FROM shared_addresses WHERE shared_address=?", [shared_address], function(rows){
if (!rows[0])
return cb("Definition not found for " + shared_address);
arrDefinition = JSON.parse(rows[0].definition);
return cb(null);
});
},
function(cb){
db.query("SELECT signing_path,address,member_signing_path,device_address FROM shared_address_signing_paths WHERE shared_address=?", [shared_address], function(rows){
if (rows.length<2)
return cb("Less than 2 signing paths found for " + shared_address);
rows.forEach(function(row){
assocSignersByPath[row.signing_path] = {address: row.address, member_signing_path: row.member_signing_path, device_address: row.device_address};
});
return cb(null);
});
}
],
function(err){
if (err)
return handle(err);
sendNewSharedAddress(device_address, shared_address, arrDefinition, assocSignersByPath);
return handle(null);
});
}
|
javascript
|
{
"resource": ""
}
|
q44762
|
addNewSharedAddress
|
train
|
function addNewSharedAddress(address, arrDefinition, assocSignersByPath, bForwarded, onDone){
// network.addWatchedAddress(address);
db.query(
"INSERT "+db.getIgnore()+" INTO shared_addresses (shared_address, definition) VALUES (?,?)",
[address, JSON.stringify(arrDefinition)],
function(){
var arrQueries = [];
for (var signing_path in assocSignersByPath){
var signerInfo = assocSignersByPath[signing_path];
db.addQuery(arrQueries,
"INSERT "+db.getIgnore()+" INTO shared_address_signing_paths \n\
(shared_address, address, signing_path, member_signing_path, device_address) VALUES (?,?,?,?,?)",
[address, signerInfo.address, signing_path, signerInfo.member_signing_path, signerInfo.device_address]);
}
async.series(arrQueries, function(){
console.log('added new shared address '+address);
eventBus.emit("new_address-"+address);
if (conf.bLight)
network.addLightWatchedAddress(address);
if (!bForwarded)
forwardNewSharedAddressToCosignersOfMyMemberAddresses(address, arrDefinition, assocSignersByPath);
if (onDone)
onDone();
});
}
);
}
|
javascript
|
{
"resource": ""
}
|
q44763
|
readSharedAddressCosigners
|
train
|
function readSharedAddressCosigners(shared_address, handleCosigners){
db.query(
"SELECT DISTINCT shared_address_signing_paths.device_address, name, "+db.getUnixTimestamp("shared_addresses.creation_date")+" AS creation_ts \n\
FROM shared_address_signing_paths \n\
JOIN shared_addresses USING(shared_address) \n\
LEFT JOIN correspondent_devices USING(device_address) \n\
WHERE shared_address=? AND device_address!=?",
[shared_address, device.getMyDeviceAddress()],
function(rows){
if (rows.length === 0)
throw Error("no cosigners found for shared address "+shared_address);
handleCosigners(rows);
}
);
}
|
javascript
|
{
"resource": ""
}
|
q44764
|
readSharedAddressPeerAddresses
|
train
|
function readSharedAddressPeerAddresses(shared_address, handlePeerAddresses){
readSharedAddressPeers(shared_address, function(assocNamesByAddress){
handlePeerAddresses(Object.keys(assocNamesByAddress));
});
}
|
javascript
|
{
"resource": ""
}
|
q44765
|
readMessageInChunksFromOutbox
|
train
|
function readMessageInChunksFromOutbox(message_hash, len, handleMessage){
var CHUNK_LEN = 1000000;
var start = 1;
var message = '';
function readChunk(){
db.query("SELECT SUBSTR(message, ?, ?) AS chunk FROM outbox WHERE message_hash=?", [start, CHUNK_LEN, message_hash], function(rows){
if (rows.length === 0)
return handleMessage();
if (rows.length > 1)
throw Error(rows.length+' msgs by hash in outbox, start='+start+', length='+len);
message += rows[0].chunk;
start += CHUNK_LEN;
(start > len) ? handleMessage(message) : readChunk();
});
}
readChunk();
}
|
javascript
|
{
"resource": ""
}
|
q44766
|
sendPreparedMessageToConnectedHub
|
train
|
function sendPreparedMessageToConnectedHub(ws, recipient_device_pubkey, message_hash, json, callbacks){
network.sendRequest(ws, 'hub/get_temp_pubkey', recipient_device_pubkey, false, function(ws, request, response){
function handleError(error){
callbacks.ifError(error);
db.query("UPDATE outbox SET last_error=? WHERE message_hash=?", [error, message_hash], function(){});
}
if (response.error)
return handleError(response.error);
var objTempPubkey = response;
if (!objTempPubkey.temp_pubkey || !objTempPubkey.pubkey || !objTempPubkey.signature)
return handleError("missing fields in hub response");
if (objTempPubkey.pubkey !== recipient_device_pubkey)
return handleError("temp pubkey signed by wrong permanent pubkey");
if (!ecdsaSig.verify(objectHash.getDeviceMessageHashToSign(objTempPubkey), objTempPubkey.signature, objTempPubkey.pubkey))
return handleError("wrong sig under temp pubkey");
var objEncryptedPackage = createEncryptedPackage(json, objTempPubkey.temp_pubkey);
var recipient_device_address = objectHash.getDeviceAddress(recipient_device_pubkey);
var objDeviceMessage = {
encrypted_package: objEncryptedPackage,
to: recipient_device_address,
pubkey: objMyPermanentDeviceKey.pub_b64 // who signs. Essentially, the from again.
};
objDeviceMessage.signature = ecdsaSig.sign(objectHash.getDeviceMessageHashToSign(objDeviceMessage), objMyPermanentDeviceKey.priv);
network.sendRequest(ws, 'hub/deliver', objDeviceMessage, false, function(ws, request, response){
if (response === "accepted"){
db.query("DELETE FROM outbox WHERE message_hash=?", [message_hash], function(){
callbacks.ifOk();
});
}
else
handleError( response.error || ("unrecognized response: "+JSON.stringify(response)) );
});
});
}
|
javascript
|
{
"resource": ""
}
|
q44767
|
sendMessageToHub
|
train
|
function sendMessageToHub(ws, recipient_device_pubkey, subject, body, callbacks, conn){
// this content is hidden from the hub by encryption
var json = {
from: my_device_address, // presence of this field guarantees that you cannot strip off the signature and add your own signature instead
device_hub: my_device_hub,
subject: subject,
body: body
};
conn = conn || db;
if (ws)
return reliablySendPreparedMessageToHub(ws, recipient_device_pubkey, json, callbacks, conn);
var recipient_device_address = objectHash.getDeviceAddress(recipient_device_pubkey);
conn.query("SELECT hub FROM correspondent_devices WHERE device_address=?", [recipient_device_address], function(rows){
if (rows.length !== 1)
throw Error("no hub in correspondents");
reliablySendPreparedMessageToHub(rows[0].hub, recipient_device_pubkey, json, callbacks, conn);
});
}
|
javascript
|
{
"resource": ""
}
|
q44768
|
validateUnit
|
train
|
function validateUnit(objUnit, bRequireDefinitionOrChange, cb2){
var bFound = false;
async.eachSeries(
objUnit.authors,
function(author, cb3){
var address = author.address;
// if (arrWitnesses.indexOf(address) === -1) // not a witness - skip it
// return cb3();
var definition_chash = assocDefinitionChashes[address];
if (!definition_chash && arrWitnesses.indexOf(address) === -1) // not a witness - skip it
return cb3();
if (!definition_chash)
throw Error("definition chash not known for address "+address+", unit "+objUnit.unit);
if (author.definition){
try{
if (objectHash.getChash160(author.definition) !== definition_chash)
return cb3("definition doesn't hash to the expected value");
}
catch(e){
return cb3("failed to calc definition chash: " +e);
}
assocDefinitions[definition_chash] = author.definition;
bFound = true;
}
function handleAuthor(){
// FIX
validation.validateAuthorSignaturesWithoutReferences(author, objUnit, assocDefinitions[definition_chash], function(err){
if (err)
return cb3(err);
for (var i=0; i<objUnit.messages.length; i++){
var message = objUnit.messages[i];
if (message.app === 'address_definition_change'
&& (message.payload.address === address || objUnit.authors.length === 1 && objUnit.authors[0].address === address)){
assocDefinitionChashes[address] = message.payload.definition_chash;
bFound = true;
}
}
cb3();
});
}
if (assocDefinitions[definition_chash])
return handleAuthor();
storage.readDefinition(db, definition_chash, {
ifFound: function(arrDefinition){
assocDefinitions[definition_chash] = arrDefinition;
handleAuthor();
},
ifDefinitionNotFound: function(d){
throw Error("definition "+definition_chash+" not found, address "+address+", my witnesses "+arrWitnesses.join(', ')+", unit "+objUnit.unit);
}
});
},
function(err){
if (err)
return cb2(err);
if (bRequireDefinitionOrChange && !bFound)
return cb2("neither definition nor change");
cb2();
}
); // each authors
}
|
javascript
|
{
"resource": ""
}
|
q44769
|
readDependentJointsThatAreReady
|
train
|
function readDependentJointsThatAreReady(unit, handleDependentJoint){
//console.log("readDependentJointsThatAreReady "+unit);
var t=Date.now();
var from = unit ? "FROM dependencies AS src_deps JOIN dependencies USING(unit)" : "FROM dependencies";
var where = unit ? "WHERE src_deps.depends_on_unit="+db.escape(unit) : "";
var lock = unit ? mutex.lock : mutex.lockOrSkip;
lock(["dependencies"], function(unlock){
db.query(
"SELECT dependencies.unit, unhandled_joints.unit AS unit_for_json, \n\
SUM(CASE WHEN units.unit IS NULL THEN 1 ELSE 0 END) AS count_missing_parents \n\
"+from+" \n\
JOIN unhandled_joints ON dependencies.unit=unhandled_joints.unit \n\
LEFT JOIN units ON dependencies.depends_on_unit=units.unit \n\
"+where+" \n\
GROUP BY dependencies.unit \n\
HAVING count_missing_parents=0 \n\
ORDER BY NULL",
function(rows){
//console.log(rows.length+" joints are ready");
//console.log("deps: "+(Date.now()-t));
rows.forEach(function(row) {
db.query("SELECT json, peer, "+db.getUnixTimestamp("creation_date")+" AS creation_ts FROM unhandled_joints WHERE unit=?", [row.unit_for_json], function(internal_rows){
internal_rows.forEach(function(internal_row) {
handleDependentJoint(JSON.parse(internal_row.json), parseInt(internal_row.creation_ts), internal_row.peer);
});
});
});
unlock();
}
);
});
}
|
javascript
|
{
"resource": ""
}
|
q44770
|
readJointsSinceMci
|
train
|
function readJointsSinceMci(mci, handleJoint, onDone){
db.query(
"SELECT units.unit FROM units LEFT JOIN archived_joints USING(unit) \n\
WHERE (is_stable=0 AND main_chain_index>=? OR main_chain_index IS NULL OR is_free=1) AND archived_joints.unit IS NULL \n\
ORDER BY +level",
[mci],
function(rows){
async.eachSeries(
rows,
function(row, cb){
storage.readJoint(db, row.unit, {
ifNotFound: function(){
// throw Error("unit "+row.unit+" not found");
breadcrumbs.add("unit "+row.unit+" not found");
cb();
},
ifFound: function(objJoint){
handleJoint(objJoint);
cb();
}
});
},
onDone
);
}
);
}
|
javascript
|
{
"resource": ""
}
|
q44771
|
hasFieldsExcept
|
train
|
function hasFieldsExcept(obj, arrFields){
for (var field in obj)
if (arrFields.indexOf(field) === -1)
return true;
return false;
}
|
javascript
|
{
"resource": ""
}
|
q44772
|
addInput
|
train
|
function addInput(input){
total_amount += input.amount;
var objInputWithProof = {input: input};
if (objAsset && objAsset.is_private){ // for type=payment only
var spend_proof = objectHash.getBase64Hash({
asset: asset,
amount: input.amount,
address: input.address,
unit: input.unit,
message_index: input.message_index,
output_index: input.output_index,
blinding: input.blinding
});
var objSpendProof = {spend_proof: spend_proof};
if (bMultiAuthored)
objSpendProof.address = input.address;
objInputWithProof.spend_proof = objSpendProof;
}
if (!bMultiAuthored || !input.type)
delete input.address;
delete input.amount;
delete input.blinding;
arrInputsWithProofs.push(objInputWithProof);
}
|
javascript
|
{
"resource": ""
}
|
q44773
|
pickOneCoinJustBiggerAndContinue
|
train
|
function pickOneCoinJustBiggerAndContinue(){
if (amount === Infinity)
return pickMultipleCoinsAndContinue();
var more = is_base ? '>' : '>=';
conn.query(
"SELECT unit, message_index, output_index, amount, blinding, address \n\
FROM outputs \n\
CROSS JOIN units USING(unit) \n\
WHERE address IN(?) AND asset"+(asset ? "="+conn.escape(asset) : " IS NULL")+" AND is_spent=0 AND amount "+more+" ? \n\
AND sequence='good' "+confirmation_condition+" \n\
ORDER BY is_stable DESC, amount LIMIT 1",
[arrSpendableAddresses, amount+is_base*TRANSFER_INPUT_SIZE],
function(rows){
if (rows.length === 1){
var input = rows[0];
// default type is "transfer"
addInput(input);
onDone(arrInputsWithProofs, total_amount);
}
else
pickMultipleCoinsAndContinue();
}
);
}
|
javascript
|
{
"resource": ""
}
|
q44774
|
pickMultipleCoinsAndContinue
|
train
|
function pickMultipleCoinsAndContinue(){
conn.query(
"SELECT unit, message_index, output_index, amount, address, blinding \n\
FROM outputs \n\
CROSS JOIN units USING(unit) \n\
WHERE address IN(?) AND asset"+(asset ? "="+conn.escape(asset) : " IS NULL")+" AND is_spent=0 \n\
AND sequence='good' "+confirmation_condition+" \n\
ORDER BY amount DESC LIMIT ?",
[arrSpendableAddresses, constants.MAX_INPUTS_PER_PAYMENT_MESSAGE-2],
function(rows){
async.eachSeries(
rows,
function(row, cb){
var input = row;
objectHash.cleanNulls(input);
required_amount += is_base*TRANSFER_INPUT_SIZE;
addInput(input);
// if we allow equality, we might get 0 amount for change which is invalid
var bFound = is_base ? (total_amount > required_amount) : (total_amount >= required_amount);
bFound ? cb('found') : cb();
},
function(err){
if (err === 'found')
onDone(arrInputsWithProofs, total_amount);
else if (asset)
issueAsset();
else
addHeadersCommissionInputs();
}
);
}
);
}
|
javascript
|
{
"resource": ""
}
|
q44775
|
addIssueInput
|
train
|
function addIssueInput(serial_number){
total_amount += issue_amount;
var input = {
type: "issue",
amount: issue_amount,
serial_number: serial_number
};
if (bMultiAuthored)
input.address = issuer_address;
var objInputWithProof = {input: input};
if (objAsset && objAsset.is_private){
var spend_proof = objectHash.getBase64Hash({
asset: asset,
amount: issue_amount,
denomination: 1,
address: issuer_address,
serial_number: serial_number
});
var objSpendProof = {spend_proof: spend_proof};
if (bMultiAuthored)
objSpendProof.address = input.address;
objInputWithProof.spend_proof = objSpendProof;
}
arrInputsWithProofs.push(objInputWithProof);
var bFound = is_base ? (total_amount > required_amount) : (total_amount >= required_amount);
bFound ? onDone(arrInputsWithProofs, total_amount) : finish();
}
|
javascript
|
{
"resource": ""
}
|
q44776
|
goDown
|
train
|
function goDown(arrStartUnits){
conn.query(
"SELECT unit, level, latest_included_mc_index, main_chain_index, is_on_main_chain \n\
FROM parenthoods JOIN units ON child_unit=unit \n\
WHERE parent_unit IN(?) AND latest_included_mc_index<? AND level<=?",
[arrStartUnits, objEarlierUnitProps.main_chain_index, max_later_level],
function(rows){
var arrNewStartUnits = [];
for (var i=0; i<rows.length; i++){
var objUnitProps = rows[i];
//if (objUnitProps.latest_included_mc_index >= objEarlierUnitProps.main_chain_index)
// continue;
//if (objUnitProps.level > max_later_level)
// continue;
arrNewStartUnits.push(objUnitProps.unit);
if (objUnitProps.main_chain_index !== null && objUnitProps.main_chain_index <= max_later_limci) // exclude free balls!
arrLandedUnits.push(objUnitProps.unit);
else
arrUnlandedUnits.push(objUnitProps.unit);
}
(arrNewStartUnits.length > 0) ? goDown(arrNewStartUnits) : handleUnits(arrLandedUnits, arrUnlandedUnits);
}
);
}
|
javascript
|
{
"resource": ""
}
|
q44777
|
readAscendantUnitsAfterTakingOffMc
|
train
|
function readAscendantUnitsAfterTakingOffMc(conn, objEarlierUnitProps, arrLaterUnitProps, handleUnits){
var arrLaterUnits = arrLaterUnitProps.map(function(objLaterUnitProps){ return objLaterUnitProps.unit; });
var max_later_limci = Math.max.apply(null, arrLaterUnitProps.map(function(objLaterUnitProps){ return objLaterUnitProps.latest_included_mc_index; }));
var arrLandedUnits = []; // units that took off MC after earlier unit's MCI, they already include the earlier unit
var arrUnlandedUnits = []; // direct shoots from earlier units, without touching the MC
arrLaterUnitProps.forEach(function(objUnitProps){
if (objUnitProps.latest_included_mc_index >= objEarlierUnitProps.main_chain_index)
arrLandedUnits.push(objUnitProps.unit);
else
arrUnlandedUnits.push(objUnitProps.unit);
});
function goUp(arrStartUnits){
conn.query(
"SELECT unit, level, latest_included_mc_index, main_chain_index, is_on_main_chain \n\
FROM parenthoods JOIN units ON parent_unit=unit \n\
WHERE child_unit IN(?) AND (main_chain_index>? OR main_chain_index IS NULL) AND level>=?",
[arrStartUnits, max_later_limci, objEarlierUnitProps.level],
function(rows){
var arrNewStartUnits = [];
for (var i=0; i<rows.length; i++){
var objUnitProps = rows[i];
//if (objUnitProps.main_chain_index <= max_later_limci)
// continue;
//if (objUnitProps.level < objEarlierUnitProps.level)
// continue;
arrNewStartUnits.push(objUnitProps.unit);
if (objUnitProps.latest_included_mc_index >= objEarlierUnitProps.main_chain_index)
arrLandedUnits.push(objUnitProps.unit);
else
arrUnlandedUnits.push(objUnitProps.unit);
}
(arrNewStartUnits.length > 0) ? goUp(arrNewStartUnits) : handleUnits(arrLandedUnits, arrUnlandedUnits);
}
);
}
goUp(arrLaterUnits);
}
|
javascript
|
{
"resource": ""
}
|
q44778
|
validateSkiplist
|
train
|
function validateSkiplist(conn, arrSkiplistUnits, callback){
var prev = "";
async.eachSeries(
arrSkiplistUnits,
function(skiplist_unit, cb){
//if (skiplist_unit.charAt(0) !== "0")
// return cb("skiplist unit doesn't start with 0");
if (skiplist_unit <= prev)
return cb(createJointError("skiplist units not ordered"));
conn.query("SELECT unit, is_stable, is_on_main_chain, main_chain_index FROM units WHERE unit=?", [skiplist_unit], function(rows){
if (rows.length === 0)
return cb("skiplist unit "+skiplist_unit+" not found");
var objSkiplistUnitProps = rows[0];
// if not stable, can't check that it is on MC as MC is not stable in its area yet
if (objSkiplistUnitProps.is_stable === 1){
if (objSkiplistUnitProps.is_on_main_chain !== 1)
return cb("skiplist unit "+skiplist_unit+" is not on MC");
if (objSkiplistUnitProps.main_chain_index % 10 !== 0)
return cb("skiplist unit "+skiplist_unit+" MCI is not divisible by 10");
}
// we can't verify the choice of skiplist unit.
// If we try to find a skiplist unit now, we might find something matching on unstable part of MC.
// Again, we have another check when we reach stability
cb();
});
},
callback
);
}
|
javascript
|
{
"resource": ""
}
|
q44779
|
checkNoSameAddressInDifferentParents
|
train
|
function checkNoSameAddressInDifferentParents(){
if (objUnit.parent_units.length === 1)
return callback();
var assocAuthors = {};
var found_address;
async.eachSeries(
objUnit.parent_units,
function(parent_unit, cb){
storage.readUnitAuthors(conn, parent_unit, function(arrAuthors){
arrAuthors.forEach(function(address){
if (assocAuthors[address])
found_address = address;
assocAuthors[address] = true;
});
cb(found_address);
});
},
function(){
if (found_address)
return callback("some addresses found more than once in parents, e.g. "+found_address);
return callback();
}
);
}
|
javascript
|
{
"resource": ""
}
|
q44780
|
checkNoPendingDefinition
|
train
|
function checkNoPendingDefinition(){
//var next = checkNoPendingOrRetrievableNonserialIncluded;
var next = validateDefinition;
//var filter = bNonserial ? "AND sequence='good'" : "";
// var cross = (objValidationState.max_known_mci - objValidationState.last_ball_mci < 1000) ? 'CROSS' : '';
conn.query( // _left_ join forces use of indexes in units
// "SELECT unit FROM units "+cross+" JOIN unit_authors USING(unit) \n\
// WHERE address=? AND definition_chash IS NOT NULL AND ( /* is_stable=0 OR */ main_chain_index>? OR main_chain_index IS NULL)",
// [objAuthor.address, objValidationState.last_ball_mci],
"SELECT unit FROM unit_authors WHERE address=? AND definition_chash IS NOT NULL AND _mci>? \n\
UNION \n\
SELECT unit FROM unit_authors WHERE address=? AND definition_chash IS NOT NULL AND _mci IS NULL",
[objAuthor.address, objValidationState.last_ball_mci, objAuthor.address],
function(rows){
if (rows.length === 0)
return next();
if (!bNonserial || objValidationState.arrAddressesWithForkedPath.indexOf(objAuthor.address) === -1)
return callback("you can't send anything before your last definition is stable and before last ball");
// from this point, our unit is nonserial
async.eachSeries(
rows,
function(row, cb){
graph.determineIfIncludedOrEqual(conn, row.unit, objUnit.parent_units, function(bIncluded){
if (bIncluded)
console.log("checkNoPendingDefinition: unit "+row.unit+" is included");
bIncluded ? cb("found") : cb();
});
},
function(err){
(err === "found")
? callback("you can't send anything before your last included definition is stable and before last ball (self is nonserial)")
: next();
}
);
}
);
}
|
javascript
|
{
"resource": ""
}
|
q44781
|
validateIndivisibleIssue
|
train
|
function validateIndivisibleIssue(input, cb){
// if (objAsset)
// profiler2.start();
conn.query(
"SELECT count_coins FROM asset_denominations WHERE asset=? AND denomination=?",
[payload.asset, denomination],
function(rows){
if (rows.length === 0)
return cb("invalid denomination: "+denomination);
if (rows.length > 1)
throw Error("more than one record per denomination?");
var denomInfo = rows[0];
if (denomInfo.count_coins === null){ // uncapped
if (input.amount % denomination !== 0)
return cb("issue amount must be multiple of denomination");
}
else{
if (input.amount !== denomination * denomInfo.count_coins)
return cb("wrong size of issue of denomination "+denomination);
}
// if (objAsset)
// profiler2.stop('validateIndivisibleIssue');
cb();
}
);
}
|
javascript
|
{
"resource": ""
}
|
q44782
|
validateSignedMessageSync
|
train
|
function validateSignedMessageSync(objSignedMessage){
var err;
var bCalledBack = false;
validateSignedMessage(objSignedMessage, function(_err){
err = _err;
bCalledBack = true;
});
if (!bCalledBack)
throw Error("validateSignedMessage is not sync");
return err;
}
|
javascript
|
{
"resource": ""
}
|
q44783
|
createListOfBestChildren
|
train
|
function createListOfBestChildren(arrParentUnits, handleBestChildrenList){
if (arrParentUnits.length === 0)
return handleBestChildrenList([]);
var arrBestChildren = arrParentUnits.slice();
function goDownAndCollectBestChildren(arrStartUnits, cb){
conn.query("SELECT unit, is_free FROM units WHERE best_parent_unit IN(?)", [arrStartUnits], function(rows){
if (rows.length === 0)
return cb();
//console.log("unit", arrStartUnits, "best children:", rows.map(function(row){ return row.unit; }), "free units:", rows.reduce(function(sum, row){ return sum+row.is_free; }, 0));
async.eachSeries(
rows,
function(row, cb2){
arrBestChildren.push(row.unit);
if (row.is_free === 1)
cb2();
else
goDownAndCollectBestChildren([row.unit], cb2);
},
cb
);
});
}
goDownAndCollectBestChildren(arrParentUnits, function(){
handleBestChildrenList(arrBestChildren);
});
}
|
javascript
|
{
"resource": ""
}
|
q44784
|
filterAltBranchRootUnits
|
train
|
function filterAltBranchRootUnits(cb){
//console.log('===== before filtering:', arrAltBranchRootUnits);
var arrFilteredAltBranchRootUnits = [];
conn.query("SELECT unit, is_free, main_chain_index FROM units WHERE unit IN(?)", [arrAltBranchRootUnits], function(rows){
if (rows.length === 0)
throw Error("no alt branch root units?");
async.eachSeries(
rows,
function(row, cb2){
function addUnit(){
arrBestChildren.push(row.unit);
// if (row.is_free === 0) // seems no reason to exclude
arrFilteredAltBranchRootUnits.push(row.unit);
cb2();
}
if (row.main_chain_index !== null && row.main_chain_index <= max_later_limci)
addUnit();
else
graph.determineIfIncludedOrEqual(conn, row.unit, arrLaterUnits, function(bIncluded){
bIncluded ? addUnit() : cb2();
});
},
function(){
//console.log('filtered:', arrFilteredAltBranchRootUnits);
if (arrFilteredAltBranchRootUnits.length === 0)
return handleBestChildrenList([]);
var arrInitialBestChildren = _.clone(arrBestChildren);
var start_time = Date.now();
if (conf.bFaster)
return collectBestChildren(arrFilteredAltBranchRootUnits, function(){
console.log("collectBestChildren took "+(Date.now()-start_time)+"ms");
cb();
});
goDownAndCollectBestChildrenOld(arrFilteredAltBranchRootUnits, function(){
console.log("goDownAndCollectBestChildrenOld took "+(Date.now()-start_time)+"ms");
var arrBestChildren1 = _.clone(arrBestChildren.sort());
arrBestChildren = arrInitialBestChildren;
start_time = Date.now();
collectBestChildren(arrFilteredAltBranchRootUnits, function(){
console.log("collectBestChildren took "+(Date.now()-start_time)+"ms");
arrBestChildren.sort();
if (!_.isEqual(arrBestChildren, arrBestChildren1)){
throwError("different best children, old "+arrBestChildren1.join(', ')+'; new '+arrBestChildren.join(', ')+', later '+arrLaterUnits.join(', ')+', earlier '+earlier_unit+", global db? = "+(conn === db));
arrBestChildren = arrBestChildren1;
}
cb();
});
});
}
);
});
}
|
javascript
|
{
"resource": ""
}
|
q44785
|
determineIfStableInLaterUnitsAndUpdateStableMcFlag
|
train
|
function determineIfStableInLaterUnitsAndUpdateStableMcFlag(conn, earlier_unit, arrLaterUnits, bStableInDb, handleResult){
determineIfStableInLaterUnits(conn, earlier_unit, arrLaterUnits, function(bStable){
console.log("determineIfStableInLaterUnits", earlier_unit, arrLaterUnits, bStable);
if (!bStable)
return handleResult(bStable);
if (bStable && bStableInDb)
return handleResult(bStable);
breadcrumbs.add('stable in parents, will wait for write lock');
mutex.lock(["write"], function(unlock){
breadcrumbs.add('stable in parents, got write lock');
storage.readLastStableMcIndex(conn, function(last_stable_mci){
storage.readUnitProps(conn, earlier_unit, function(objEarlierUnitProps){
var new_last_stable_mci = objEarlierUnitProps.main_chain_index;
if (new_last_stable_mci <= last_stable_mci) // fix: it could've been changed by parallel tasks - No, our SQL transaction doesn't see the changes
throw Error("new last stable mci expected to be higher than existing");
var mci = last_stable_mci;
advanceLastStableMcUnitAndStepForward();
function advanceLastStableMcUnitAndStepForward(){
mci++;
if (mci <= new_last_stable_mci)
markMcIndexStable(conn, mci, advanceLastStableMcUnitAndStepForward);
else{
unlock();
handleResult(bStable, true);
}
}
});
});
});
});
}
|
javascript
|
{
"resource": ""
}
|
q44786
|
propagateFinalBad
|
train
|
function propagateFinalBad(arrFinalBadUnits, onPropagated){
if (arrFinalBadUnits.length === 0)
return onPropagated();
conn.query("SELECT DISTINCT unit FROM inputs WHERE src_unit IN(?)", [arrFinalBadUnits], function(rows){
if (rows.length === 0)
return onPropagated();
var arrSpendingUnits = rows.map(function(row){ return row.unit; });
conn.query("UPDATE units SET sequence='final-bad' WHERE unit IN(?)", [arrSpendingUnits], function(){
arrSpendingUnits.forEach(function(unit){
storage.assocUnstableUnits[unit].sequence = 'final-bad';
});
propagateFinalBad(arrSpendingUnits, onPropagated);
});
});
}
|
javascript
|
{
"resource": ""
}
|
q44787
|
getSimilarMcis
|
train
|
function getSimilarMcis(mci){
var arrSimilarMcis = [];
var divisor = 10;
while (true){
if (mci % divisor === 0){
arrSimilarMcis.push(mci - divisor);
divisor *= 10;
}
else
return arrSimilarMcis;
}
}
|
javascript
|
{
"resource": ""
}
|
q44788
|
parsePrivatePaymentChain
|
train
|
function parsePrivatePaymentChain(conn, arrPrivateElements, callbacks){
var bAllStable = true;
var issuePrivateElement = arrPrivateElements[arrPrivateElements.length-1];
if (!issuePrivateElement.payload || !issuePrivateElement.payload.inputs || !issuePrivateElement.payload.inputs[0])
return callbacks.ifError("invalid issue private element");
var asset = issuePrivateElement.payload.asset;
if (!asset)
return callbacks.ifError("no asset in issue private element");
var denomination = issuePrivateElement.payload.denomination;
if (!denomination)
return callbacks.ifError("no denomination in issue private element");
async.forEachOfSeries(
arrPrivateElements,
function(objPrivateElement, i, cb){
if (!objPrivateElement.payload || !objPrivateElement.payload.inputs || !objPrivateElement.payload.inputs[0])
return cb("invalid payload");
if (!objPrivateElement.output)
return cb("no output in private element");
if (objPrivateElement.payload.asset !== asset)
return cb("private element has a different asset");
if (objPrivateElement.payload.denomination !== denomination)
return cb("private element has a different denomination");
var prevElement = null;
if (i+1 < arrPrivateElements.length){ // excluding issue transaction
var prevElement = arrPrivateElements[i+1];
if (prevElement.unit !== objPrivateElement.payload.inputs[0].unit)
return cb("not referencing previous element unit");
if (prevElement.message_index !== objPrivateElement.payload.inputs[0].message_index)
return cb("not referencing previous element message index");
if (prevElement.output_index !== objPrivateElement.payload.inputs[0].output_index)
return cb("not referencing previous element output index");
}
validatePrivatePayment(conn, objPrivateElement, prevElement, {
ifError: cb,
ifOk: function(bStable, input_address){
objPrivateElement.bStable = bStable;
objPrivateElement.input_address = input_address;
if (!bStable)
bAllStable = false;
cb();
}
});
},
function(err){
if (err)
return callbacks.ifError(err);
callbacks.ifOk(bAllStable);
}
);
}
|
javascript
|
{
"resource": ""
}
|
q44789
|
updateIndivisibleOutputsThatWereReceivedUnstable
|
train
|
function updateIndivisibleOutputsThatWereReceivedUnstable(conn, onDone){
function updateOutputProps(unit, is_serial, onUpdated){
// may update several outputs
conn.query(
"UPDATE outputs SET is_serial=? WHERE unit=?",
[is_serial, unit],
function(){
is_serial ? updateInputUniqueness(unit, onUpdated) : onUpdated();
}
);
}
function updateInputUniqueness(unit, onUpdated){
// may update several inputs
conn.query("UPDATE inputs SET is_unique=1 WHERE unit=?", [unit], function(){
onUpdated();
});
}
console.log("updatePrivateIndivisibleOutputsThatWereReceivedUnstable starting");
conn.query(
"SELECT unit, message_index, sequence FROM outputs "+(conf.storage === 'sqlite' ? "INDEXED BY outputsIsSerial" : "")+" \n\
JOIN units USING(unit) \n\
WHERE outputs.is_serial IS NULL AND units.is_stable=1 AND is_spent=0", // is_spent=0 selects the final output in the chain
function(rows){
if (rows.length === 0)
return onDone();
async.eachSeries(
rows,
function(row, cb){
function updateFinalOutputProps(is_serial){
updateOutputProps(row.unit, is_serial, cb);
}
function goUp(unit, message_index){
// we must have exactly 1 input per message
conn.query(
"SELECT src_unit, src_message_index, src_output_index \n\
FROM inputs \n\
WHERE unit=? AND message_index=?",
[unit, message_index],
function(src_rows){
if (src_rows.length === 0)
throw Error("updating unstable: blackbyte input not found");
if (src_rows.length > 1)
throw Error("updating unstable: more than one input found");
var src_row = src_rows[0];
if (src_row.src_unit === null) // reached root of the chain (issue)
return cb();
conn.query(
"SELECT sequence, is_stable, is_serial FROM outputs JOIN units USING(unit) \n\
WHERE unit=? AND message_index=? AND output_index=?",
[src_row.src_unit, src_row.src_message_index, src_row.src_output_index],
function(prev_rows){
if (prev_rows.length === 0)
throw Error("src unit not found");
var prev_output = prev_rows[0];
if (prev_output.is_serial === 0)
throw Error("prev is already nonserial");
if (prev_output.is_stable === 0)
throw Error("prev is not stable");
if (prev_output.is_serial === 1 && prev_output.sequence !== 'good')
throw Error("prev is_serial=1 but seq!=good");
if (prev_output.is_serial === 1) // already was stable when initially received
return cb();
var is_serial = (prev_output.sequence === 'good') ? 1 : 0;
updateOutputProps(src_row.src_unit, is_serial, function(){
if (!is_serial) // overwrite the tip of the chain
return updateFinalOutputProps(0);
goUp(src_row.src_unit, src_row.src_message_index);
});
}
);
}
);
}
var is_serial = (row.sequence === 'good') ? 1 : 0;
updateOutputProps(row.unit, is_serial, function(){
goUp(row.unit, row.message_index);
});
},
onDone
);
}
);
}
|
javascript
|
{
"resource": ""
}
|
q44790
|
buildPrivateElementsChain
|
train
|
function buildPrivateElementsChain(conn, unit, message_index, output_index, payload, handlePrivateElements){
var asset = payload.asset;
var denomination = payload.denomination;
var output = payload.outputs[output_index];
var hidden_payload = _.cloneDeep(payload);
hidden_payload.outputs.forEach(function(o){
delete o.address;
delete o.blinding;
// output_hash was already added
});
var arrPrivateElements = [{
unit: unit,
message_index: message_index,
payload: hidden_payload,
output_index: output_index,
output: {
address: output.address,
blinding: output.blinding
}
}];
function readPayloadAndGoUp(_unit, _message_index, _output_index){
conn.query(
"SELECT src_unit, src_message_index, src_output_index, serial_number, denomination, amount, address, asset, \n\
(SELECT COUNT(*) FROM unit_authors WHERE unit=?) AS count_authors \n\
FROM inputs WHERE unit=? AND message_index=?",
[_unit, _unit, _message_index],
function(in_rows){
if (in_rows.length === 0)
throw Error("building chain: blackbyte input not found");
if (in_rows.length > 1)
throw Error("building chain: more than 1 input found");
var in_row = in_rows[0];
if (!in_row.address)
throw Error("readPayloadAndGoUp: input address is NULL");
if (in_row.asset !== asset)
throw Error("building chain: asset mismatch");
if (in_row.denomination !== denomination)
throw Error("building chain: denomination mismatch");
var input = {};
if (in_row.src_unit){ // transfer
input.unit = in_row.src_unit;
input.message_index = in_row.src_message_index;
input.output_index = in_row.src_output_index;
}
else{
input.type = 'issue';
input.serial_number = in_row.serial_number;
input.amount = in_row.amount;
if (in_row.count_authors > 1)
input.address = in_row.address;
}
conn.query(
"SELECT address, blinding, output_hash, amount, output_index, asset, denomination FROM outputs \n\
WHERE unit=? AND message_index=? ORDER BY output_index",
[_unit, _message_index],
function(out_rows){
if (out_rows.length === 0)
throw Error("blackbyte output not found");
var output = {};
var outputs = out_rows.map(function(o){
if (o.asset !== asset)
throw Error("outputs asset mismatch");
if (o.denomination !== denomination)
throw Error("outputs denomination mismatch");
if (o.output_index === _output_index){
output.address = o.address;
output.blinding = o.blinding;
}
return {
amount: o.amount,
output_hash: o.output_hash
};
});
if (!output.address)
throw Error("output not filled");
var objPrivateElement = {
unit: _unit,
message_index: _message_index,
payload: {
asset: asset,
denomination: denomination,
inputs: [input],
outputs: outputs
},
output_index: _output_index,
output: output
};
arrPrivateElements.push(objPrivateElement);
(input.type === 'issue')
? handlePrivateElements(arrPrivateElements)
: readPayloadAndGoUp(input.unit, input.message_index, input.output_index);
}
);
}
);
}
var input = payload.inputs[0];
(input.type === 'issue')
? handlePrivateElements(arrPrivateElements)
: readPayloadAndGoUp(input.unit, input.message_index, input.output_index);
}
|
javascript
|
{
"resource": ""
}
|
q44791
|
query
|
train
|
function query(){
//console.log(arguments[0]);
var self = this;
var args = arguments;
var last_arg = args[args.length - 1];
var bHasCallback = (typeof last_arg === 'function');
if (!bHasCallback) // no callback
last_arg = function(){};
var count_arguments_without_callback = bHasCallback ? (args.length-1) : args.length;
var new_args = [];
for (var i=0; i<count_arguments_without_callback; i++) // except callback
new_args.push(args[i]);
if (!bHasCallback && !bCordova)
return new Promise(function(resolve){
new_args.push(resolve);
self.query.apply(self, new_args);
});
takeConnectionFromPool(function(connection){
// add callback that releases the connection before calling the supplied callback
new_args.push(function(rows){
connection.release();
last_arg(rows);
});
connection.query.apply(connection, new_args);
});
}
|
javascript
|
{
"resource": ""
}
|
q44792
|
sendJoint
|
train
|
function sendJoint(ws, objJoint, tag) {
console.log('sending joint identified by unit ' + objJoint.unit.unit + ' to', ws.peer);
tag ? sendResponse(ws, tag, {joint: objJoint}) : sendJustsaying(ws, 'joint', objJoint);
}
|
javascript
|
{
"resource": ""
}
|
q44793
|
postJointToLightVendor
|
train
|
function postJointToLightVendor(objJoint, handleResponse) {
console.log('posting joint identified by unit ' + objJoint.unit.unit + ' to light vendor');
requestFromLightVendor('post_joint', objJoint, function(ws, request, response){
handleResponse(response);
});
}
|
javascript
|
{
"resource": ""
}
|
q44794
|
train
|
function(purged_unit, peer){
var ws = getPeerWebSocket(peer);
if (ws)
sendErrorResult(ws, purged_unit, "error on (indirect) parent unit "+objJoint.unit.unit+": "+error);
}
|
javascript
|
{
"resource": ""
}
|
|
q44795
|
handlePostedJoint
|
train
|
function handlePostedJoint(ws, objJoint, onDone){
if (!objJoint || !objJoint.unit || !objJoint.unit.unit)
return onDone('no unit');
var unit = objJoint.unit.unit;
delete objJoint.unit.main_chain_index;
handleJoint(ws, objJoint, false, {
ifUnitInWork: function(){
onDone("already handling this unit");
},
ifUnitError: function(error){
onDone(error);
},
ifJointError: function(error){
onDone(error);
},
ifNeedHashTree: function(){
onDone("need hash tree");
},
ifNeedParentUnits: function(arrMissingUnits){
onDone("unknown parents");
},
ifOk: function(){
onDone();
// forward to other peers
if (!bCatchingUp && !conf.bLight)
forwardJoint(ws, objJoint);
delete assocUnitsInWork[unit];
},
ifOkUnsigned: function(){
delete assocUnitsInWork[unit];
onDone("you can't send unsigned units");
},
ifKnown: function(){
if (objJoint.unsigned)
return onDone("you can't send unsigned units");
onDone("known");
writeEvent('known_good', ws.host);
},
ifKnownBad: function(){
onDone("known bad");
writeEvent('known_bad', ws.host);
},
ifKnownUnverified: function(){ // impossible unless the peer also sends this joint by 'joint' justsaying
onDone("known unverified");
delete assocUnitsInWork[unit];
}
});
}
|
javascript
|
{
"resource": ""
}
|
q44796
|
handleOnlinePrivatePayment
|
train
|
function handleOnlinePrivatePayment(ws, arrPrivateElements, bViaHub, callbacks){
if (!ValidationUtils.isNonemptyArray(arrPrivateElements))
return callbacks.ifError("private_payment content must be non-empty array");
var unit = arrPrivateElements[0].unit;
var message_index = arrPrivateElements[0].message_index;
var output_index = arrPrivateElements[0].payload.denomination ? arrPrivateElements[0].output_index : -1;
var savePrivatePayment = function(cb){
// we may receive the same unit and message index but different output indexes if recipient and cosigner are on the same device.
// in this case, we also receive the same (unit, message_index, output_index) twice - as cosigner and as recipient. That's why IGNORE.
db.query(
"INSERT "+db.getIgnore()+" INTO unhandled_private_payments (unit, message_index, output_index, json, peer) VALUES (?,?,?,?,?)",
[unit, message_index, output_index, JSON.stringify(arrPrivateElements), bViaHub ? '' : ws.peer], // forget peer if received via hub
function(){
callbacks.ifQueued();
if (cb)
cb();
}
);
};
if (conf.bLight && arrPrivateElements.length > 1){
savePrivatePayment(function(){
updateLinkProofsOfPrivateChain(arrPrivateElements, unit, message_index, output_index);
rerequestLostJointsOfPrivatePayments(); // will request the head element
});
return;
}
joint_storage.checkIfNewUnit(unit, {
ifKnown: function(){
//assocUnitsInWork[unit] = true;
privatePayment.validateAndSavePrivatePaymentChain(arrPrivateElements, {
ifOk: function(){
//delete assocUnitsInWork[unit];
callbacks.ifAccepted(unit);
eventBus.emit("new_my_transactions", [unit]);
},
ifError: function(error){
//delete assocUnitsInWork[unit];
callbacks.ifValidationError(unit, error);
},
ifWaitingForChain: function(){
savePrivatePayment();
}
});
},
ifNew: function(){
savePrivatePayment();
// if received via hub, I'm requesting from the same hub, thus telling the hub that this unit contains a private payment for me.
// It would be better to request missing joints from somebody else
requestNewMissingJoints(ws, [unit]);
},
ifKnownUnverified: savePrivatePayment,
ifKnownBad: function(){
callbacks.ifValidationError(unit, "known bad");
}
});
}
|
javascript
|
{
"resource": ""
}
|
q44797
|
checkThatEachChainElementIncludesThePrevious
|
train
|
function checkThatEachChainElementIncludesThePrevious(arrPrivateElements, handleResult){
if (arrPrivateElements.length === 1) // an issue
return handleResult(true);
var arrUnits = arrPrivateElements.map(function(objPrivateElement){ return objPrivateElement.unit; });
requestFromLightVendor('light/get_link_proofs', arrUnits, function(ws, request, response){
if (response.error)
return handleResult(null); // undefined result
var arrChain = response;
if (!ValidationUtils.isNonemptyArray(arrChain))
return handleResult(null); // undefined result
light.processLinkProofs(arrUnits, arrChain, {
ifError: function(err){
console.log("linkproof validation failed: "+err);
throw Error(err);
handleResult(false);
},
ifOk: function(){
console.log("linkproof validated ok");
handleResult(true);
}
});
});
}
|
javascript
|
{
"resource": ""
}
|
q44798
|
checkAndFinalizeWallet
|
train
|
function checkAndFinalizeWallet(wallet, onDone){
db.query("SELECT member_ready_date FROM wallets LEFT JOIN extended_pubkeys USING(wallet) WHERE wallets.wallet=?", [wallet], function(rows){
if (rows.length === 0){ // wallet not created yet or already deleted
// throw Error("no wallet in checkAndFinalizeWallet");
console.log("no wallet in checkAndFinalizeWallet");
return onDone ? onDone() : null;
}
if (rows.some(function(row){ return !row.member_ready_date; }))
return onDone ? onDone() : null;
db.query("UPDATE wallets SET ready_date="+db.getNow()+" WHERE wallet=? AND ready_date IS NULL", [wallet], function(){
if (onDone)
onDone();
eventBus.emit('wallet_completed', wallet);
});
});
}
|
javascript
|
{
"resource": ""
}
|
q44799
|
createWallet
|
train
|
function createWallet(xPubKey, account, arrWalletDefinitionTemplate, walletName, isSingleAddress, handleWallet){
var wallet = crypto.createHash("sha256").update(xPubKey, "utf8").digest("base64");
console.log('will create wallet '+wallet);
var arrDeviceAddresses = getDeviceAddresses(arrWalletDefinitionTemplate);
addWallet(wallet, xPubKey, account, arrWalletDefinitionTemplate, function(){
handleWallet(wallet);
if (arrDeviceAddresses.length === 1) // single sig
return;
console.log("will send offers");
// this continues in parallel while the callback handleWallet was already called
// We need arrOtherCosigners to make sure all cosigners know the pubkeys of all other cosigners, even when they were not paired.
// For example, there are 3 cosigners: A (me), B, and C. A is paired with B, A is paired with C, but B is not paired with C.
device.readCorrespondentsByDeviceAddresses(arrDeviceAddresses, function(arrOtherCosigners){
if (arrOtherCosigners.length !== arrDeviceAddresses.length - 1)
throw Error("incorrect length of other cosigners");
arrDeviceAddresses.forEach(function(device_address){
if (device_address === device.getMyDeviceAddress())
return;
console.log("sending offer to "+device_address);
sendOfferToCreateNewWallet(device_address, wallet, arrWalletDefinitionTemplate, walletName, arrOtherCosigners, isSingleAddress, null);
sendMyXPubKey(device_address, wallet, xPubKey);
});
});
});
}
|
javascript
|
{
"resource": ""
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.