.map(data => _.get(data, 'earnings'))

export const getView = (state: AppState, id: string): View => {
  return get(state, `views.views.${id}.view`)
}

 addFunctionParameter(func, value) {
   if (func.params.length >= func.def.params.length && !_.get(_.last(func.def.params), 'multiple', false)) {
     throw { message: 'too many parameters for function ' + func.def.name };
   }
   func.params.push(value);
 }

 return (doc: SavedObjectDoc) =>
   _.set(doc, path, _.isFunction(value) ? value(_.get(doc, path)) : value) as SavedObjectDoc;

		objPaths.forEach(path => {
			const id = get(this, path);
			if (id) {
				ids.push(id._id || id);
			}
		});

 circular.forEach(c => {
   const ref = _.get(json, c.circuralTargetPath)
   _.set(json, c.pathToObj, ref)
 })

const addFilter = (state: LogsState, action: AddFilterAction): LogsState => {
  const {filter} = action.payload

  return {...state, filters: [filter, ..._.get(state, 'filters', [])]}
}

  /**
   * Fetches data used to populate monitor charts
   * @param request Kibana request
   * @param monitorId ID value for the selected monitor
   * @param dateRangeStart timestamp bounds
   * @param dateRangeEnd timestamp bounds
   */
  public async getMonitorChartsData(
    request: any,
    monitorId: string,
    dateRangeStart: string,
    dateRangeEnd: string
  ): Promise<MonitorChart> {
    const params = {
      index: INDEX_NAMES.HEARTBEAT,
      body: {
        query: {
          bool: {
            filter: [
              { range: { '@timestamp': { gte: dateRangeStart, lte: dateRangeEnd } } },
              { term: { 'monitor.id': monitorId } },
            ],
          },
        },
        size: 0,
        aggs: {
          timeseries: {
            auto_date_histogram: {
              field: '@timestamp',
              buckets: 25,
            },
            aggs: {
              status: { terms: { field: 'monitor.status', size: 2, shard_size: 2 } },
              duration: { stats: { field: 'monitor.duration.us' } },
            },
          },
        },
      },
    };

    const result = await this.database.search(request, params);
    const buckets = dropLatestBucket(get(result, 'aggregations.timeseries.buckets', []));

    /**
     * The code below is responsible for formatting the aggregation data we fetched above in a way
     * that the chart components used by the client understands.
     * There are five required values. Two are lists of points that conform to a simple (x,y) structure.
     *
     * The third list is for an area chart expressing a range, and it requires an (x,y,y0) structure,
     * where y0 is the min value for the point and y is the max.
     *
     * Additionally, we supply the maximum value for duration and status, so the corresponding charts know
     * what the domain size should be.
     */
    const monitorChartsData: MonitorChart = {
      durationArea: [],
      durationLine: [],
      status: [],
      durationMaxValue: 0,
      statusMaxCount: 0,
    };

    buckets.forEach(bucket => {
      const x = get(bucket, 'key');
      const docCount = get(bucket, 'doc_count', 0);
      // update the maximum value for each point
      monitorChartsData.statusMaxCount = Math.max(docCount, monitorChartsData.statusMaxCount);
      monitorChartsData.durationMaxValue = Math.max(
        monitorChartsData.durationMaxValue,
        get(bucket, 'duration.max', 0)
      );

      // these points express a range that will be displayed as an area chart
      monitorChartsData.durationArea.push({
        x,
        yMin: get(bucket, 'duration.min', null),
        yMax: get(bucket, 'duration.max', null),
      });
      monitorChartsData.durationLine.push({ x, y: get(bucket, 'duration.avg', null) });
      monitorChartsData.status.push(
        formatStatusBuckets(x, get(bucket, 'status.buckets', []), docCount)
      );
    });
    return monitorChartsData;
  }

  $("[style]").each((idx, elem) => {
    const root = parse(_.get(elem.attribs, "style"));
    const styles = pickDeclToStyleObject(root.nodes as Declaration[]);

    appendStyleProps(elem, styles);
  });

  /**
   * Fetch options for the filter bar.
   * @param request Kibana request object
   * @param dateRangeStart timestamp bounds
   * @param dateRangeEnd timestamp bounds
   */
  public async getFilterBar(
    request: any,
    dateRangeStart: string,
    dateRangeEnd: string
  ): Promise<FilterBar> {
    const params = {
      index: INDEX_NAMES.HEARTBEAT,
      body: {
        _source: ['monitor.id', 'monitor.type', 'url.full', 'url.port', 'monitor.name'],
        size: 1000,
        query: {
          range: {
            '@timestamp': {
              gte: dateRangeStart,
              lte: dateRangeEnd,
            },
          },
        },
        collapse: {
          field: 'monitor.id',
        },
        sort: {
          '@timestamp': 'desc',
        },
      },
    };
    const result = await this.database.search(request, params);
    const ids: MonitorKey[] = [];
    const ports = new Set<number>();
    const types = new Set<string>();
    const names = new Set<string>();

    const hits = get(result, 'hits.hits', []);
    hits.forEach((hit: any) => {
      const key: string = get(hit, '_source.monitor.id');
      const url: string | null = get(hit, '_source.url.full', null);
      const port: number | undefined = get(hit, '_source.url.port', undefined);
      const type: string | undefined = get(hit, '_source.monitor.type', undefined);
      const name: string | null = get(hit, '_source.monitor.name', null);

      if (key) {
        ids.push({ key, url });
      }
      if (port) {
        ports.add(port);
      }
      if (type) {
        types.add(type);
      }
      if (name) {
        names.add(name);
      }
    });

    return {
      ids,
      ports: Array.from(ports),
      schemes: Array.from(types),
      names: Array.from(names),
      statuses: ['up', 'down'],
    };
  }