{this.props.metadata.faqs.map(({question, answer}) =>
<div key={hash(question)} className="accordion-group panel">
<div className="accordion-heading accordionize"> <a className="accordion-toggle active" data-toggle="collapse" data-parent="#accordionArea" href={`#${hash(question)}`}>{question}<i className="fa fa-angle-down" /> </a> </div>
<div id={hash(question)} className="accordion-body in collapse">
<div className="accordion-inner">{answer}</div>
</div>
</div>
preOmitFunc: function(payload) {
console.log('pre');
if (cache[hash(payload)]) {
console.log('cached');
// console.log(cache[hash(payload)]);
return cache[hash(payload)];
}
},
hashValue(value: any): string {
if (!value) return value;
const type = typeof value;
switch (type) {
case 'object':
if (Array.isArray(value)) return value.map(v => hash(v));
return hash(value);
default:
return hash(value);
}
}
export const getCommits = options => {
const key = hash(options);
return new Promise((resolve, reject) => {
redis.get(key, (error, response) => {
if (response) {
return void resolve(JSON.parse(response));
}
github.repos.getCommits(options, (error, response) => {
redis.set(key, JSON.stringify(response));
redis.expire(key, config.cacheExpiration);
if (error) {
const response = JSON.parse(error.message);
const prettyError = new PrettyError();
console.log(prettyError.render(new Error(response.message)));
reject();
return;
}
resolve(response);
});
});
});
};
function getHash(collectionName, paths, vals) {
var queryObject = { collection: collectionName };
_.times(paths.length, function(i) {
queryObject['vals.' + paths[i]] = vals[i];
});
return hash(queryObject);
}
self.ensureTemplateExists = (client, name, template) => {
const toHash = {
name: name,
template: template
};
const templateKey = hash(toHash);
if (templatesFound[templateKey]) {
log.debug(`template '${name}' previously found`);
return Promise.resolve('previously found');
}
return client.indices.existsTemplate({name: name}).then((response) => {
if (!response) {
log.info(`template '${name}' does not exist. creating ..`);
return client.indices.putTemplate({
name: name,
body: template
}).then(() => {
log.info(`template '${name}' successfully created`);
templatesFound[templateKey] = true;
return Promise.resolve('created');
});
}
log.debug(`template '${name}' exists`);
return Promise.resolve('exists');
});
};
_.each(optionList, function (option) {
var optionKey = option
var fieldOptions = {}
// if option is an object, set the key and set the field options
if (_.isObject(option)) {
optionKey = option.key
fieldOptions = option
delete fieldOptions.key
}
// hash the field options and use as value field key
var fieldHash = 'value' + type + '_' + hash(fieldOptions)
// push option key to all options array
allOptions.push({ value: optionKey, label: optionKey })
// add option key to field map, mapping field to value field
fieldMap[optionKey] = fieldHash
// if field doesn't already exist in all fields array, create it, adding custom options
if (!allFields[fieldHash])
allFields[fieldHash] = _.extend({ type: Types[type], label: 'Value', dependsOn: {key: []} }, fieldOptions)
// push the field to the value field dependencies
allFields[fieldHash].dependsOn.key.push(optionKey)
})
hashNode(node) {
const _node = clone(node)
_node.id = undefined
_node.namespace = undefined
_node.parent = undefined
return objectHash(_node)
}
export async function createProductHash(product, collections) {
const variants = await collections.Products.find({ ancestors: product._id, type: "variant" }).toArray();
const productForHashing = {};
productFieldsThatNeedPublishing.forEach((field) => {
productForHashing[field] = product[field];
});
customPublishedProductFields.forEach((field) => {
productForHashing[field] = product[field];
});
// Track changes to all related media, too
productForHashing.media = await getCatalogProductMedia(product._id, collections);
// Track changes to all variants, too
productForHashing.variants = variants.map((variant) => {
const variantForHashing = {};
variantFieldsThatNeedPublishing.forEach((field) => {
variantForHashing[field] = variant[field];
});
customPublishedProductVariantFields.forEach((field) => {
variantForHashing[field] = variant[field];
});
return variantForHashing;
});
return hash(productForHashing);
}
function compareHashObject({
obj,
clone
}) {
// equal
const hash1 = hashObj(JSON.stringify(obj));
const hash2 = hashObj(JSON.stringify(clone));
assert.equal(hash1, hash2);
// not equal
const hash3 = hashObj(JSON.stringify(obj));
const hash4 = hashObj(JSON.stringify(checkObj));
assert.notEqual(hash3, hash4);
return;
}
ReverseProxy.buildRoute = function (route) {
if (!_.isString(route) && !_.isObject(route)) {
return null;
}
if (_.isObject(route) && route.hasOwnProperty('urls') && route.hasOwnProperty('path')) {
// default route type matched.
return route;
}
var cacheKey = _.isString(route) ? route : hash(route);
var entry = routeCache.get(cacheKey);
if (entry) {
return entry;
}
var routeObject = { rr: 0, isResolved: true };
if (_.isString(route)) {
routeObject.urls = [ReverseProxy.buildTarget(route)];
routeObject.path = '/';
} else {
if (!route.hasOwnProperty('url')) {
return null;
}
routeObject.urls = (_.isArray(route.url) ? route.url : [route.url]).map(function (url) {
return ReverseProxy.buildTarget(url, route.opts || {});
});
routeObject.path = route.path || '/';
}
routeCache.set(cacheKey, routeObject);
return routeObject;
};
Queue.prototype.getKeyFromArgs = function Queue$getKeyByArgs (input) {
return hashing(input, {
unorderedArrays: true,
//algorithm: 'md5',
encoding: 'base64'
});
};
self.ensureIndexExists = (client, index) => {
const toHash = {
index: index
};
const aliasKey = hash(toHash);
if (indicesFound[aliasKey]) {
log.debug(`index '${index}' previously found`);
return Promise.resolve('previously found');
}
return client.indices.exists({index: index}).then((response) => {
if (!response) {
log.info(`index '${index}' does not exist. creating ..`);
return client.indices.create({index: index}).then(() => {
log.info(`index '${index}' successfully created`);
indicesFound[aliasKey] = true;
return Promise.resolve('created');
});
}
log.debug(`index '${index}' exists`);
return Promise.resolve('exists');
});
};
var hashNode = function (n) {
var node = clone(n);
node.id = undefined;
node.namespace = undefined;
node.parent = undefined;
return objectHash(node);
};
self.ensureAliasExists = (client, alias, index) => {
const toHash = {
alias: alias,
index: index
};
const aliasKey = hash(toHash);
if (aliasesFound[aliasKey]) {
log.debug(`alias '${alias}' previously found`);
return Promise.resolve('previously found');
}
return client.indices.existsAlias({
name: alias,
index: index
}).then((response) => {
if (!response) {
log.info(`alias '${alias}' does not exist. creating ..`);
return client.indices.putAlias({
name: alias,
index: index
}).then(() => {
log.info(`alias '${alias}' successfully created`);
aliasesFound[aliasKey] = true;
return Promise.resolve('created');
});
}
log.debug(`alias '${alias}' exists`);
return Promise.resolve('exists');
});
};
_buildLib(){
const libsObj = this.libsObj
if(!libsObj){
return;
}
const vals = Object.keys(libsObj).map(function (key) {
return libsObj[key];
});
var result = UglifyJS.minify(vals,this.options.uglify_lib_options)
var libDistPath = this._replaceHolder('[dist_path]/[project_name]/')
mkdirp.sync(libDistPath);
fs.writeFileSync(libDistPath+'lib.js',result.code);
const libHash = objHash(this.libsObj);
const options = this.options;
this.libAssets = {
'lib':{
js:`${options.cdn_path}/${options.project_name}/lib.js?v=${libHash}`
}
}
}
indexDocs = function (i) {
if (i < batch.length) {
//verify document format
if (Object.prototype.toString.call(batch[i]) != '[object Object]') {
searchIndexLogger.error('malformed document: check document formatting at batch index ' + i);
return callback(true);
}
var docID = '';
if (batch[i]['id'])
docID = batch[i]['id'];
else
docID = Date.now() + '-' + Math.random()*10000000000000000 + '-' + hash(batch[i]);
deleter.deleteDoc(docID, indexes, indexesMultiply, function(msgg) {
indexDoc(indexes, docID, batch[i], filters, function(msg) {
searchIndexLogger.info(msg.status);
tf[docID] = msg.tfValues;
indexDocs(++i);
});
});
}
else {
searchIndexLogger.info('starting calibration');
calibrater.incrementallyCalibrate(indexesMultiply, reduceTF(tf), function(msg) {
searchIndexLogger.info(msg);
searchIndexLogger.info('indexed batch: ' + batchName);
callback(false);
});
}
};
export function mangle (node) {
if (node.settings && node.settings.isGeneric) {
return hash(_.merge({}, node.inputPorts, node.outputPorts))
} else {
return ''
}
}
export function typeName (type) {
if (typeof (type) === 'object') {
return 'type_' + hash(type)
} else {
return type
}
}
export function *ensureEntityIndexTask(action) {
const { collectionName, filter } = action.payload;
const indexHash = hash({ collectionName, filter });
const apiContext = yield select(getApiContext);
const ApiService = yield select(getApiService);
const authContext = yield select(getAuthContext);
// const { collectionName, filter } = yield select(getEntityIndexSelector(indexHash));
yield put(attemptFetchEntityIndex(indexHash));
try {
const normalizedFilter = normalizeFilter(filter);
const result = yield call(
ApiService.getEntityIndex,
collectionName,
normalizedFilter,
apiContext,
authContext
);
apiServiceResultTypeInvariant(result, EntityIndexResult);
const entitySchemas = yield select(getEntitySchemas);
const normalized = normalize(result.data, collectionName, entitySchemas);
const nowTime = moment().format();
yield put(receiveEntities(normalized.entities, nowTime));
yield put(receiveEntityIndex(indexHash, normalized.result, result.existingCount, nowTime));
} catch (e) {
apiServiceResultTypeInvariant(e, Error);
yield put(fetchEntityIndexFailure(indexHash, e));
}
}
ListItem.prototype.getHash = function () {
var self = this;
var objectToHash = {};
_.map(this.valuesToHash, function (value) {
objectToHash[value] = self.values[value];
});
return hash(this.values);
}
fn: function(inputs, exits) {
var hashFn = require('object-hash');
var hash = hashFn(inputs.dictionary);
return exits.success(hash);
},
const hash = value =>
objectHash(
value,
{
algorithm: 'md5',
unorderedObjects: true
}
);
saveAction(action) {
const streamId = action.reduxLive.streamId;
const streamIdKey = hash(streamId);
this._actions[streamIdKey][action.reduxLive.sequenceNumber] = action;
this._eventEmitter.emit(NEW_ACTION_EVENT + streamIdKey, action);
this._eventEmitter.emit(NEW_ACTION_EVENT, action);
return Promise.resolve();
}
async getSnapshot(streamId) {
const snapshotKey = hash(streamId);
const snapshots = await this.snapshotCollection.find({_id: snapshotKey}).toArray();
if (snapshots.length === 0) {
throw new Error(util.format('No state for stream ID %j', streamId));
}
return censorDocument(snapshots[0])
}
getSnapshot(streamId) {
const streamIdKey = hash(streamId);
const snapshot = this._snapshots[streamIdKey];
if (!snapshot) {
return Promise.reject(`No state for stream ID ${streamId}`);
}
return Promise.resolve(snapshot);
}
const hash = ctx => {
const {
headers: { 'user-agent': userAgent },
url,
} = ctx.request
// Hash the storage key by the url, and the userAgent
return objectHash({ url, userAgent })
}
getStateHash(state) {
return objectHash(
state,
{
algorithm: 'md5',
unorderedObjects: true
}
);
}
async saveSnapshot(snapshot) {
const {streamId, sequenceNumber} = snapshot.reduxLive;
const snapshotKey = hash(streamId);
var snapshotToSave = {...snapshot, _id: snapshotKey};
await this.snapshotCollection.updateOne(
{_id: snapshotKey, 'reduxLive.sequenceNumber': sequenceNumber - 1},
snapshotToSave);
}
/**
* @private emitResponse
*
* sends data back to the client through socket
*
* @param {object} resource that was requested
* @param {error|null} error
* @param {object} response
* @param {string} body
*/
function emitResponse (resource, error, response, body) {
var timeDiff = Date.now() - resource.startTs;
var responseHash;
if(error) {
log.debug('[ERROR]: (id: ' + resource.id + ', url: ' + resource.url + ')');
log.trace('[ERROR]: (id: ' + resource.id + ', url: ' + resource.url + ') body : (' + error.toString() + ')');
if (this.polledResources[resource.id]) {
responseHash = hash(error || {});
if (this.polledResources[resource.id].response === responseHash.toString()) {
return;
} else {
this.polledResources[resource.id].response = responseHash.toString();
}
}
this.connection.write(JSON.stringify({
resource: resource,
error: error,
warning: error.toString()
}, stripResource));
} else {
log.debug('[SUCCESS]: (id: ' + resource.id + ', url: ' + resource.url + ')');
log.trace('[' + timeDiff + 'ms] Success (' + resource.id + ',' + resource.url + ') body : (' + JSON.stringify(body) + ')');
if (this.polledResources[resource.id]) {
responseHash = hash(body || {});
if (this.polledResources[resource.id].response === responseHash.toString()){
// No need to send this to the client as nothing changed.
return;
} else {
this.polledResources[resource.id].response = responseHash;
}
}
log.debug('[RESPONSE]: (id: ' + resource.id + ', url: ' + resource.url + ')' );
this.connection.write(JSON.stringify({
resource: resource,
statusCode: response.statusCode,
response: body
}, stripResource));
}
}