.forEach((s: SymbolInformation, index: number, arr: SymbolInformation[]) => {
   let container: Container;
   /**
    * For Enum class in Java, the container name and symbol name that LSP gives are special.
    * For more information, see https://github.com/elastic/codesearch/issues/580
    */
   if (s.containerName === SPECIAL_CONTAINER_NAME) {
     container = _.findLast(
       arr.slice(0, index),
       (sy: SymbolInformation) => sy.name === SPECIAL_SYMBOL_NAME
     );
   } else {
     container = findContainer(structureTree, s.containerName);
   }
   if (container) {
     if (!container.path) {
       container.path = container.name;
     }
     if (container.members) {
       container.members.push({ ...s, path: `${container.path}/${s.name}` });
     } else {
       container.members = [{ ...s, path: `${container.path}/${s.name}` }];
     }
   } else {
     structureTree.push({ ...s, path: s.name });
   }
 });

      $scope.syncFromOrcid = function() {
        $scope.busy = 'sync';

        const account = _.findLast($scope.user.externalIds, {type: 'orcid'});

        $http.put(config.apiUrl +
                  '/people/' + $scope.user.id + '/syncFromOrcid').
          success(function(data) {
            $scope.busy = false;
            authService.user = data;
          }).
          error(function(data) {
            $scope.busy = false;
            notificationService.httpError('could not sync data');
          });
      };

    this.$rootScope.$on('timeframeZoom', function (event, zoom) {
      let diff = zoom.to - zoom.from;

      let timeframe = _.findLast(that.timeframes, function (timeframe: Timeframe) {
        return timeframe.range < diff;
      });

      if (!timeframe) {
        timeframe = that.timeframes[0];
      }

      that.update({
        interval: timeframe.interval,
        from: zoom.from,
        to: zoom.to
      });
    });

  update(timeframeParam) {
    let that = this;

    let timeframe = {
      interval: parseInt(timeframeParam.interval),
      from: parseInt(timeframeParam.from),
      to: parseInt(timeframeParam.to)
    };

    // Select the best timeframe
    let diff = timeframe.to - timeframe.from;

    let tf = _.findLast(that.timeframes, function (tframe: Timeframe) {
      return tframe.range <= diff;
    });

    this.timeframe = tf ? tf : that.timeframes[0];

    // timeframeChange event is dynamically initialized, so we have to define a timeout to correctly fired it
    this.$timeout(function () {
      let event = {
        interval: that.timeframe.interval,
        from: timeframe.from,
        to: timeframe.to
      };

      that.onTimeframeChange({timeframe: event});
    }, 200);

    this.current = {
      interval: this.timeframe.interval,
      intervalLabel: moment.duration(this.timeframe.interval).humanize(),
      from: timeframe.from,
      to: timeframe.to
    };

    this.$state.transitionTo(
      this.$state.current, _.merge(this.$state.params, this.current));

    this.pickerStartDate = moment(timeframe.from);
    this.pickerEndDate = moment(timeframe.to);
  }

  updateRangeDate() {
    let from =  this.pickerStartDate.startOf('minute').unix() * 1000;
    let to = this.pickerEndDate.endOf('minute').unix() * 1000;

    let diff = to - from;

    let timeframe = _.findLast(this.timeframes, function (timeframe: Timeframe) {
      return timeframe.range < diff;
    });

    if (!timeframe) {
      timeframe = this.timeframes[0];
    }

    this.update({
      interval: timeframe.interval,
      from: from,
      to: to
    });
  }