events.js

'use strict';

angular.module('openshiftConsole')
  .directive('events', function($routeParams, $filter, DataService, ProjectsService, Logger) {
    return {
      restrict: 'E',
      scope: {
        resourceKind: "@?",
        resourceName: "@?",
        projectContext: "="
      },
      templateUrl: 'views/directives/events.html',
      controller: function($scope){
        $scope.filter = {
          text: ''
        };

        var filterForResource = function(events) {
          if (!$scope.resourceKind || !$scope.resourceName) {
            return events;
          }

          return _.filter(events, function(event) {
            return event.involvedObject.kind === $scope.resourceKind &&
                   event.involvedObject.name === $scope.resourceName;
          });
        };

        var sortedEvents = [];
        var sortEvents = function() {
          // TODO: currentField is renamed in angular-patternfly 3.0
          var sortID = _.get($scope, 'sortConfig.currentField.id', 'lastTimestamp'),
              order = $scope.sortConfig.isAscending ? 'asc' : 'desc';
          sortedEvents = _.sortByOrder($scope.events, [sortID], [order]);
        };

        var filterExpressions = [];
        var updateKeywords = function() {
          if (!$scope.filter.text) {
            filterExpressions = [];
            return;
          }

          var keywords = _.uniq($scope.filter.text.split(/\s+/));
          // Sort the longest keyword first.
          keywords.sort(function(a, b){
            return b.length - a.length;
          });

          // Convert the keyword to a case-insensitive regular expression for the filter.
          filterExpressions = _.map(keywords, function(keyword) {
            return new RegExp(_.escapeRegExp(keyword), "i");
          });
        };

        // Only filter by keyword on certain fields.
        var filterFields = [
          'reason',
          'message',
          'type'
        ];
        if (!$scope.resourceKind || !$scope.resourceName) {
          filterFields.splice(0, 0, 'involvedObject.name', 'involvedObject.kind');
        }

        var filterForKeyword = function() {
          $scope.filteredEvents = sortedEvents;
          if (!filterExpressions.length) {
            return;
          }

          // Find events that match all keywords.
          angular.forEach(filterExpressions, function(regex) {
            var matchesKeyword = function(event) {
              var i;
              for (i = 0; i < filterFields.length; i++) {
                var value = _.get(event, filterFields[i]);
                if (value && regex.test(value)) {
                  return true;
                }
              }

              return false;
            };

            $scope.filteredEvents = _.filter($scope.filteredEvents, matchesKeyword);
          });
        };

        $scope.$watch('filter.text', _.debounce(function() {
          updateKeywords();
          $scope.$apply(filterForKeyword);
        }, 50, { maxWait: 250 }));

        var update = function() {
          // Sort first so we can update the filter as the user types without resorting.
          sortEvents();
          filterForKeyword();
        };

        // Invoke update when first called, debouncing subsequent calls.
        var debounceUpdate = _.debounce(function() {
          $scope.$evalAsync(update);
        }, 250, {
          leading: true,
          trailing: false,
          maxWait: 1000
        });

        // Set up the sort configuration for `pf-sort`.
        $scope.sortConfig = {
          fields: [{
            id: 'lastTimestamp',
            title: 'Time',
            sortType: 'alpha'
          }, {
            id: 'type',
            title: 'Severity',
            sortType: 'alpha'
          }, {
            id: 'reason',
            title: 'Reason',
            sortType: 'alpha'
          }, {
            id: 'message',
            title: 'Message',
            sortType: 'alpha'
          }, {
            id: 'count',
            title: 'Count',
            sortType: 'numeric'
          }],
          isAscending: false,
          onSortChange: update
        };

        // Conditionally add kind and name to sort fields if not passed to the directive.
        if (!$scope.resourceKind || !$scope.resourceName) {
          $scope.sortConfig.fields.splice(1, 0, {
            id: 'involvedObject.name',
            title: 'Name',
            sortType: 'alpha'
          }, {
            id: 'involvedObject.kind',
            title: 'Kind',
            sortType: 'alpha'
          });
        }

        var watches = [];
        watches.push(DataService.watch("events", $scope.projectContext, function(events) {
          $scope.events = filterForResource(events.by('metadata.name'));
          debounceUpdate();
          Logger.log("events (subscribe)", $scope.filteredEvents);
        }));

        $scope.$on('$destroy', function(){
          DataService.unwatchAll(watches);
        });

      },
    };
  });