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.');
  });