let funcs = _.filter(analyzeStack, (as) => {
return (_.has(as, 'args'));
});
var dimensionKey = _.findKey(target.dimensions, v => {
return templateSrv.variableExists(v) && !_.has(scopedVars, templateSrv.getVariableName(v));
});
return player => _.has(player, 'nickname') && re.test(player.nickname);
static isEvent(proto: any): proto is Event {
return _.has(proto, "context") && _.has(proto, "data");
}
(uiData) => uiData && _.has(uiData, VERSION_DISMISSED_KEY),
.reduce((acc: IInstanceCounts, instance: any) => {
if (has(instance, 'health.state')) {
acc[camelCase(instance.health.state)]++;
}
return acc;
}, {up: 0, down: 0, outOfService: 0, succeeded: 0, failed: 0, starting: 0, unknown: 0}).value();
_.each(tavoitteet, function(tavoite) {
if (!tavoite.pakollinen && tavoite._esitieto && _.has(groups.grouped, tavoite._esitieto)) {
groups.grouped[tavoite._esitieto].push(tavoite);
processed.push(tavoite);
}
});
export default function createPlayer(manifestEntry: ManifestEntry, sourceEntry: SourceEntry): Player {
let {
faction, extraData
} = manifestEntry;
let {
oid,
name,
nickname,
level,
errors,
extraData: sourceExtraData
} = sourceEntry;
const player: Player = {
oid,
faction,
level,
nickname,
name,
anomaly: [],
community: [],
event: [],
sources: [],
errors,
};
if (_.has(sourceExtraData, 'faction')) {
player.faction = parseFaction(sourceExtraData['faction']);
sourceExtraData = _.omit<ExtraData, ExtraData>(sourceExtraData, 'faction');
}
let extra = _.merge({} as ExtraData, extraData, sourceExtraData);
const community = extractCommunityOrEvent('community', extra);
if (community != null) {
player.community.push(community);
}
const event = extractCommunityOrEvent('event', extra);
if (event != null) {
player.event.push(event);
}
if (_.has(extra, 'anomaly')) {
if (isValidAnomaly(extra['anomaly'])) {
player.anomaly.push(parseAnomaly(extra['anomaly']));
} else {
player.errors.push(`Unknown anomaly: "${extra['anomaly']}"`);
}
delete extra['anomaly'];
}
if (!_.isEmpty(extra)) {
player.extra = mapExtra(extra);
}
return player;
}
export function isLeaf<T>(t: TreeNode<T>): boolean {
return !_.has(t, "children");
}
selectionSet.selections.forEach((selection) => {
if (selection.kind !== 'Field') {
throw new Error('Only fields supported so far, not fragments.');
}
const field = selection as Field;
const storeFieldKey = storeKeyNameFromField(field, variables);
const resultFieldKey = resultKeyNameFromField(field);
if (! has(storeObj, storeFieldKey)) {
if (throwOnMissingField) {
throw new Error(`Can't find field ${storeFieldKey} on object ${storeObj}.`);
}
missingSelections.push(field);
return;
}
const storeValue = storeObj[storeFieldKey];
if (! field.selectionSet) {
result[resultFieldKey] = storeValue;
return;
}
if (isNull(storeValue)) {
// Basically any field in a GraphQL response can be null
result[resultFieldKey] = null;
return;
}
if (isArray(storeValue)) {
result[resultFieldKey] = storeValue.map((id) => {
const itemDiffResult = diffSelectionSetAgainstStore({
store,
throwOnMissingField,
rootId: id,
selectionSet: field.selectionSet,
variables,
});
itemDiffResult.missingSelectionSets.forEach(
itemSelectionSet => missingSelectionSets.push(itemSelectionSet));
return itemDiffResult.result;
});
return;
}
if (isString(storeValue)) {
const subObjDiffResult = diffSelectionSetAgainstStore({
store,
throwOnMissingField,
rootId: storeValue,
selectionSet: field.selectionSet,
variables,
});
// This is a nested query
subObjDiffResult.missingSelectionSets.forEach(
subObjSelectionSet => missingSelectionSets.push(subObjSelectionSet));
result[resultFieldKey] = subObjDiffResult.result;
return;
}
throw new Error('Unexpected number value in the store where the query had a subselection.');
});
