Renamed queryBulder to queryProcessor.

plugins/datasource-zabbix/queryProcessor.js

@@ -0,0 +1,211 @@
+define([
+  'angular',
+  'lodash',
+  './utils'
+],
+function (angular, _, utils) {
+  'use strict';
+
+  var module = angular.module('grafana.services');
+
+  module.factory('QueryProcessor', function() {
+
+    function QueryProcessor(zabbixCacheInstance) {
+      var self = this;
+
+      this.cache = zabbixCacheInstance;
+
+      /**
+       * Build query - convert target filters to array of Zabbix items
+       */
+      this.build = function (groupFilter, hostFilter, appFilter, itemFilter) {
+
+        // Find items by item names and perform queries
+        var groups = [];
+        var hosts = [];
+        var apps = [];
+        var items = [];
+
+        if (utils.isRegex(hostFilter)) {
+
+          // Filter groups
+          if (utils.isRegex(groupFilter)) {
+            var groupPattern = utils.buildRegex(groupFilter);
+            groups = _.filter(this.cache.getGroups(), function (groupObj) {
+              return groupPattern.test(groupObj.name);
+            });
+          } else {
+            var findedGroup = _.find(this.cache.getGroups(), {'name': groupFilter});
+            if (findedGroup) {
+              groups.push(findedGroup);
+            } else {
+              groups = undefined;
+            }
+          }
+          if (groups) {
+            var groupids = _.map(groups, 'groupid');
+            hosts = _.filter(this.cache.getHosts(), function (hostObj) {
+              return _.intersection(groupids, hostObj.groups).length;
+            });
+          } else {
+            // No groups finded
+            return [];
+          }
+
+          // Filter hosts
+          var hostPattern = utils.buildRegex(hostFilter);
+          hosts = _.filter(hosts, function (hostObj) {
+            return hostPattern.test(hostObj.name);
+          });
+        } else {
+          var findedHost = _.find(this.cache.getHosts(), {'name': hostFilter});
+          if (findedHost) {
+            hosts.push(findedHost);
+          } else {
+            // No hosts finded
+            return [];
+          }
+        }
+
+        // Find items belongs to selected hosts
+        items = _.filter(this.cache.getItems(), function (itemObj) {
+          return _.contains(_.map(hosts, 'hostid'), itemObj.hostid);
+        });
+
+        if (utils.isRegex(itemFilter)) {
+
+          // Filter applications
+          if (utils.isRegex(appFilter)) {
+            var appPattern = utils.buildRegex(appFilter);
+            apps = _.filter(this.cache.getApplications(), function (appObj) {
+              return appPattern.test(appObj.name);
+            });
+          }
+          // Don't use application filter if it empty
+          else if (appFilter === "") {
+            apps = undefined;
+          }
+          else {
+            var findedApp = _.find(this.cache.getApplications(), {'name': appFilter});
+            if (findedApp) {
+              apps.push(findedApp);
+            } else {
+              // No applications finded
+              return [];
+            }
+          }
+
+          // Find items belongs to selected applications
+          if (apps) {
+            var appids = _.flatten(_.map(apps, 'applicationids'));
+            items = _.filter(items, function (itemObj) {
+              return _.intersection(appids, itemObj.applications).length;
+            });
+          }
+
+          if (items) {
+            var itemPattern = utils.buildRegex(itemFilter);
+            items = _.filter(items, function (itemObj) {
+              return itemPattern.test(itemObj.name);
+            });
+          } else {
+            // No items finded
+            return [];
+          }
+        } else {
+          items = _.filter(items, {'name': hostFilter});
+          if (!items.length) {
+            // No items finded
+            return [];
+          }
+        }
+
+        // Set host as host name for each item
+        items = _.each(items, function (itemObj) {
+          itemObj.host = _.find(hosts, {'hostid': itemObj.hostid}).name;
+        });
+
+        return items;
+      };
+
+      /**
+       * Convert Zabbix API history.get response to Grafana format
+       *
+       * @return {Array}            Array of timeseries in Grafana format
+       *                            {
+       *                               target: "Metric name",
+       *                               datapoints: [[<value>, <unixtime>], ...]
+       *                            }
+       */
+      this.convertHistory = function(history, addHostName, convertPointCallback) {
+        /**
+         * Response should be in the format:
+         * data: [
+         *          {
+         *             target: "Metric name",
+         *             datapoints: [[<value>, <unixtime>], ...]
+         *          }, ...
+         *       ]
+         */
+
+        // Group history by itemid
+        var grouped_history = _.groupBy(history, 'itemid');
+
+        return _.map(grouped_history, function(hist, itemid) {
+          var item = self.cache.getItem(itemid);
+          var alias = item.name;
+          if (addHostName) {
+            var host = self.cache.getHost(item.hostid);
+            alias = host.name + ": " + alias;
+          }
+          return {
+            target: alias,
+            datapoints: _.map(hist, convertPointCallback)
+          };
+        });
+      };
+
+      this.handleHistory = function(history, addHostName) {
+        return this.convertHistory(history, addHostName, convertHistoryPoint);
+      };
+
+      this.handleTrends = function(history, addHostName, valueType) {
+        var convertPointCallback = _.partial(convertTrendPoint, valueType);
+        return this.convertHistory(history, addHostName, convertPointCallback);
+      };
+
+      function convertHistoryPoint(point) {
+        // Value must be a number for properly work
+        return [
+          Number(point.value),
+          point.clock * 1000
+        ];
+      }
+
+      function convertTrendPoint(valueType, point) {
+        var value;
+        switch (valueType) {
+          case "min":
+            value = point.value_min;
+            break;
+          case "max":
+            value = point.value_max;
+            break;
+          case "avg":
+            value = point.value_avg;
+            break;
+          default:
+            value = point.value_avg;
+        }
+
+        return [
+          Number(value),
+          point.clock * 1000
+        ];
+      }
+    }
+
+    return QueryProcessor;
+  });
+
+});