/**
* Returns all file IDs from a populated release.
*
* @see [[ReleaseDocument.getFileIds]]
* @param {ReleaseDocument} release Release
* @returns {string[]} File IDs
*/
public static getFileIds(release: ReleaseDocument): string[] {
const files = flatten(map(release.versions, 'files'));
const tableFileIds = map(files, '_file').map(file => file ? file._id.toString() : null);
const playfieldImageId = compact(map(files, '_playfield_image')).map(file => file._id.toString());
const playfieldVideoId = compact(map(files, '_playfield_video')).map(file => file._id.toString());
return compact(flatten([...tableFileIds, playfieldImageId, playfieldVideoId]));
}
).then((vendors) => {
const nonNullVendors = _.compact(vendors);
if (nonNullVendors.length) {
const mergedVendor = mergeVendors(_.compact(vendors));
service.vendors[mergedVendor.hash] = mergedVendor;
} else {
delete service.vendors[vendorDef.hash];
}
});
(
state: SearchStateType,
regionCode: string,
lookup: ConversationLookupType,
selectedConversation?: string,
selectedMessage?: string
) => {
return {
contacts: compact(
state.contacts.map(id => {
const value = lookup[id];
if (value && id === selectedConversation) {
return {
...value,
isSelected: true,
};
}
return value;
})
),
conversations: compact(
state.conversations.map(id => {
const value = lookup[id];
if (value && id === selectedConversation) {
return {
...value,
isSelected: true,
};
}
return value;
})
),
hideMessagesHeader: false,
messages: state.messages.map(message => {
if (message.id === selectedMessage) {
return {
...message,
isSelected: true,
};
}
return message;
}),
regionCode: regionCode,
searchTerm: state.query,
showStartNewConversation: Boolean(
state.normalizedPhoneNumber && !lookup[state.normalizedPhoneNumber]
),
};
}
it(name, () => {
let modules = parseCode(fs.readFileSync(sourceFile).toString(), name);
let typings = format(modules, { colors: false, warnings: false });
let expected = fs.readFileSync(definitionFile).toString();
typings = _.compact(typings.split(/\r\n|\r|\n/).map(line => line.replace(/\s*([,!?:.\{\}\(\)\=])\s*/g, '$1').trim())).join('\n');
expected = _.compact(expected.split(/\r\n|\r|\n/).map(line => line.replace(/\s*([,!?:.\{\}\(\)\=])\s*/g, '$1').trim())).join('\n');
expect(typings).to.eq(expected);
})
R.values(filteredAssociations).map(async field => {
const selectable = R.pathOr([], ['options', 'selectable'])(field);
logger.debug(TAG, { field, selectable });
if (selectable) {
const primaryKey = _.first(AppContext.adapters.models.getPrimaryKeys(selectable));
const fieldsOfAssociations = AppContext.adapters.models.getFieldsOfAssociations();
const foreignOpts = [
{
modelName: selectable,
association: fieldsOfAssociations[selectable],
onSearch: _.debounce(async (value, callback) => {
logger.log(TAG, 'onSearch', { value });
AppContext.adapters.models
.loadAssociation(selectable, { keywords: value })
.then(response => {
const items = extractItemsBy(primaryKey)([response]);
callback(items);
})
.catch(reason => {
logger.error(TAG, reason);
});
}, 500),
},
];
logger.debug(TAG, { fieldsOfAssociations, foreignOpts });
try {
const results = await bluebird.props({
itemsResponse: AppContext.adapters.models.loadAssociation(selectable),
existItemsResponse: AppContext.adapters.models.loadAssociationByIds(
selectable,
field.value,
),
});
// 当前方法只处理了单个外键的情况，没有考虑如联合主键的处理
const foreignKeysResponse = {
[selectable]: {
items: _.compact(extractItemsBy(primaryKey)([results.itemsResponse])),
existItems: _.compact(extractItemsBy(primaryKey)([results.existItemsResponse])),
},
};
logger.debug(TAG, { foreignOpts, foreignKeysResponse });
return { ...field, foreignOpts, associations: foreignKeysResponse };
} catch (e) {
logger.error(TAG, e);
}
}
logger.warn(TAG, 'no foreignKeys with association', { field });
return { ...field, type: DynamicFormTypes.Input };
}),
this.storage.fetchPreferences(notification.walletId, null, (
err,
preferences
) => {
if (err) log.error(err);
if (_.isEmpty(preferences)) preferences = [];
const recipientPreferences = _.compact(
_.map(preferences, (p) => {
if (!_.includes(this.availableLanguages, p.language)) {
if (p.language)
log.warn(
'Language for notifications "' +
p.language +
'" not available.'
);
p.language = this.defaultLanguage;
}
return {
copayerId: p.copayerId,
language: p.language,
unit: unit || p.unit || this.defaultUnit
};
})
);
const copayers = _.keyBy(recipientPreferences, 'copayerId');
const recipientsList = _.compact(
_.map(wallet.copayers, (copayer) => {
if (
(copayer.id == notification.creatorId &&
notificationType.notifyCreatorOnly) ||
(copayer.id != notification.creatorId &&
!notificationType.notifyCreatorOnly)
) {
const p = copayers[copayer.id] || {
language: this.defaultLanguage,
unit: this.defaultUnit
};
return {
copayerId: copayer.id,
language: p.language || this.defaultLanguage,
unit: unit || p.unit || this.defaultUnit
};
}
})
);
return cb(null, recipientsList);
});
/**
* Iterates through raw symbols and choose appropriate handler for each one
* @param {Array} rawSymbols
* @param {String[]} text - text editor content splitted by lines
* @return {SymbolInformation[]}
*/
function processRawSymbols(rawSymbols: StylusNode[], text: string[]): SymbolInformation[] {
return _.compact(
rawSymbols.map(symNode => {
if (isVariableNode(symNode)) {
return _variableSymbol(symNode, text);
}
if (isFunctionNode(symNode)) {
return _functionSymbol(symNode, text);
}
if (isSelectorNode(symNode)) {
return _selectorSymbol(symNode, text);
}
if (isSelectorCallNode(symNode)) {
return _selectorCallSymbol(symNode, text);
}
if (isAtRuleNode(symNode)) {
return _atRuleSymbol(symNode, text);
}
})
);
}
annotationQuery(options) {
const start = this.convertToTSDBTime(options.rangeRaw.from, false);
const end = this.convertToTSDBTime(options.rangeRaw.to, true);
const qs = [];
const eventList = [];
qs.push({ aggregator: 'sum', metric: options.annotation.target });
const queries = _.compact(qs);
return this.performTimeSeriesQuery(queries, start, end).then(results => {
if (results.data[0]) {
let annotationObject = results.data[0].annotations;
if (options.annotation.isGlobal) {
annotationObject = results.data[0].globalAnnotations;
}
if (annotationObject) {
_.each(annotationObject, annotation => {
const event = {
text: annotation.description,
time: Math.floor(annotation.startTime) * 1000,
annotation: options.annotation,
};
eventList.push(event);
});
}
}
return eventList;
});
}
before(async () => {
await principalToken.setBalance.sendTransactionAsync(PAYER, Units.ether(1.1), {
from: CONTRACT_OWNER,
});
await principalToken.approve.sendTransactionAsync(
tokenTransferProxy.address,
Units.ether(1.1),
{ from: PAYER },
);
payerBalanceBefore = await principalToken.balanceOf.callAsync(PAYER);
beneficiaryBalanceBefore = await principalToken.balanceOf.callAsync(
BENEFICIARY_1,
);
const txHash = await router.repay.sendTransactionAsync(
agreementId,
Units.ether(1.1),
principalToken.address,
{ from: PAYER },
);
receipt = await web3.eth.getTransactionReceipt(txHash);
[repaymentLog] = _.compact(ABIDecoder.decodeLogs(receipt.logs));
});
]).spread(function(cryptoCertificates: Array<any>, uiDescriptor) {
(cryptoCertificates as any)._objectType = objectType;
context.object = _.compact(cryptoCertificates);
context.userInterfaceDescriptor = uiDescriptor;
return self.updateStackWithContext(stack, context);
});
