worker.addEventListener("message", ({data}) => {
     _.forOwn(callbacks, (callback, name) => {
         if (data.type == name) {
             callback(data.content)
         }
     })
 })

export const pricingServiceReducer = (state: PricingOperationsReducerState = {}, action): PricingOperationsReducerState => {

  const { type, payload } = action
  switch (type) {
    case ACTION_TYPES.SPOT_PRICES_UPDATE:

      const updatedPrices = keyBy(action.payload, 'symbol')
      const updatedPricesDataObj = {}

      _.forOwn(updatedPrices, (value, key) => {
        const prevItem = state[key] || {}
        const newItem:SpotPriceTick = { ...value }
        newItem.priceStale = false
        newItem.priceMovementType = getPriceMovementType(prevItem, newItem)
        updatedPricesDataObj[key] = newItem
      })

      return { ...state, ...updatedPricesDataObj }
    case ACTION_TYPES.PRICING_STALE:
      return {
        ...state,
        [payload.symbol]: {
          ...state[payload.symbol],
          priceStale: true,
          notification: buildNotification(null, stalePriceErrorMessage)
        }
      }
    default:
      return state
  }
}

 _.forEach(result, (resource) => {
   _.forOwn(resource["metrics"], (id, name) => {
     if (re.test(name)) {
       metrics[id] = this._compute_label(user_label, resource, name, target.aggregator);
     }
   });
 });

    it('successful password update', co(function *isSuccessfulPasswordUpdate() {
      const oldPassword = 'oldPassword';
      const newPassword = 'newPassword';
      const otherPassword = 'otherPassword';

      nock(bgUrl)
      .post('/api/v1/user/encrypted')
      .reply(200, {
        keychains: {
          xpub1: bitgo.encrypt({ input: 'xprv1', password: oldPassword }),
          xpub2: bitgo.encrypt({ input: 'xprv2', password: otherPassword })
        },
        version: 1
      });

      const result = yield keychains.updatePassword({ oldPassword: oldPassword, newPassword: newPassword });
      _.forOwn(result.keychains, function(encryptedXprv, xpub) {
        xpub.should.startWith('xpub');
        try {
          const decryptedPrv = bitgo.decrypt({ input: encryptedXprv, password: newPassword });
          decryptedPrv.should.startWith('xprv');
        } catch (e) {
          // the decryption didn't work because of the wrong password, this is one of the keychains that didn't match
          // the old password
          e.message.should.startWith('password error');
        }
      });
      result.should.hasOwnProperty('version');
    }));

 transform(iterable: any, args: any[]): any {
     let result = [];
     _.forOwn(iterable, (value, key) => {
          result.push({key: key, value: value, id: cuid() });
     });
     return result;
 }

 _.forEach(groupPaths, (groupPath) => {
     badgesByGroup[groupPath] = [];
     _.forOwn(badges, (badge) => {
         if (_.includes(badge.groups, groupPath)) {
             badgesByGroup[groupPath].push(badge);
         }
     });
 });

    private getQueryStringPrams(settings: RequestSettings): HttpParams {
        let queryParams = new HttpParams();

        _.forOwn(settings.queryString.getParams(), (value: string, key: string) => {
            queryParams = queryParams.set(key, value);
        });
        return queryParams;
    }

function objectToMap(input: object): Map<string, object> {
  const result = new Map<string, object>();

  forOwn(input, (value, key) => {
    result.set(key, value);
  });

  return result;
}

  private buildLookupTable(periodStarts: object): Map<string, TimePeriod> {
    let result = new Map<string, TimePeriod>();

    forOwn(periodStarts, (value, key) => {
      result.set(key, value);
    });

    return result;
  }

    private replaceTemplateTokensWithValues(urlTemplate: string, tokens: {[name: string]:any} ): string {
        
        forOwn(tokens, (value: any, key: string) => {
            urlTemplate = this.replaceRouteTokens(urlTemplate, key, value);
            urlTemplate = this.replaceRouteTokens(urlTemplate, lowerFirst(key), value);
        });

        return this.removeOptionalRouteTokens(urlTemplate);
    }

 return forOwn(groupsByProvider, (groupsByRegion: IRegions, provider: string) => {
   forOwn(groupsByRegion, (groups: IRegionAccount[]) => {
     groups.forEach((group: IRegionAccount) => {
       group.provider = provider;
       group.account = account;
     });
   });
   securityGroups.push({account, provider, securityGroups: groupsByProvider[provider]});
 });

 return forOwn(groupsByProvider, (groupsByRegion, provider) => {
   forOwn(groupsByRegion, (groups: ISecurityGroup[]) => {
     groups.forEach((group) => {
       group.provider = provider;
       group.account = account;
     });
   });
   securityGroups.push({account, provider, securityGroups: groupsByProvider[provider]});
 });

    return function(items, checkModel) {
        const keyArr = [];
        _.forOwn(checkModel, (value, key) => {
            if (value) {
                keyArr.push(key);
            }
        });

        return _.filter(items, (item: any) => _.some(keyArr, key => key === item.OrderStatus));
    };

export function getOperatonFunctionName(term: ParsedTerm): string {
    if (term.type !== 'function') {
        return null;
    }
    let result = null;
    _.forOwn(operationFunctions, (value, key) => {
        if (value === term.name) {
            result = key;
            return false;
        }
    });
    _.forOwn(singleArgOperationFunctions, (value, key) => {
        if (value === term.name) {
            result = key;
            return false;
        }
    });
    return result;
}

    private getLinks(resource: IHalResource): Link[] {
        let links: Link[] = [];

        _.forOwn(resource._links, (link: Link, rel: string) => {
            link.rel = rel;
            links.push(link);
        });

        return links;
    }

    programmesConfiguration.forEach((programme, name) => {
      const values: Map<string, any> = new Map<string, any>();

      forOwn(programme["values"], (value, key) => {
        values.set(key, value);
      });

      const newProgramme = new Programme(name, programme["displayName"], values, lights);

      programmes.push(newProgramme);
    });

  private toNestedMap(input): Map<string, Transitions> {
    let result = new Map<string, Transitions>();

    forOwn(input, (transitionsInput, event) => {
      let transitions: Transitions = new Map(toPairs(transitionsInput));

      result.set(event, transitions);
    });

    return result;
  }

export function install(packages: StringMap, timeoutDuration = 0) {
    const args = ['install'];

    _.forOwn(packages, (version, pkgname) => {
        args.push(`${pkgname}@${version}`);
    });

    return helpers.getOutput('npm', args, {
        timeoutDuration, stdout: StdioPolicy.copy, stderr: StdioPolicy.inherit
    });
}

 forOwn(groupedByCategory, (categoryServerGroups, category) => {
   const groupedByCluster = groupBy(categoryServerGroups, 'cluster');
   forOwn(groupedByCluster, (clusterServerGroups, clusterName) => {
     const cluster: ICluster = {
       account: account,
       category: category,
       name: clusterName,
       serverGroups: clusterServerGroups,
       cloudProvider: clusterServerGroups[0].cloudProvider
     };
     this.addHealthCountsToCluster(cluster);
     clusters.push(cluster);
   });
 });

 data.map((row) => {
   let step = row.step;
   // iterate over each event in values
   _.forOwn(row.values, (value: number, key: string) => {
     // if new type of event, create new obj for key
     if (!_.has(chartData, key)){
       chartData[key] = [key];
       chartData[key + '_x'] = [key + '_x'];
       xs[key] = key + '_x';
     }
     chartData[key].push(value);
     chartData[key + '_x'].push(step);
   });
 });