remove unused

pkg/datasource.go

@@ -12,8 +12,6 @@ import (
 	"time"
 
 	"github.com/alexanderzobnin/grafana-zabbix/pkg/gtime"
-	simplejson "github.com/bitly/go-simplejson"
-	"github.com/grafana/grafana_plugin_model/go/datasource"
 	hclog "github.com/hashicorp/go-hclog"
 	plugin "github.com/hashicorp/go-plugin"
 
@@ -34,8 +32,8 @@ type ZabbixDatasource struct {
 	logger          log.Logger
 }
 
-// ZabbixDatasourceInstance stores state about a specific datasource and provides methods to make
+// ZabbixDatasourceInstance stores state about a specific datasource
-// requests to the Zabbix API
+// and provides methods to make requests to the Zabbix API
 type ZabbixDatasourceInstance struct {
 	url        *url.URL
 	authToken  string
@@ -193,34 +191,6 @@ func readZabbixSettings(dsInstanceSettings *backend.DataSourceInstanceSettings)
 	return zabbixSettings, nil
 }
 
-// Query receives requests from the Grafana backend. Requests are filtered by query type and sent to the
-// applicable ZabbixDatasource.
-// func (p *ZabbixPlugin) Query(ctx context.Context, tsdbReq *datasource.DatasourceRequest) (resp *datasource.DatasourceResponse, err error) {
-// 	zabbixDS, err := p.GetDatasource(tsdbReq)
-// 	if err != nil {
-// 		return nil, err
-// 	}
-
-// 	queryType, err := GetQueryType(tsdbReq)
-// 	if err != nil {
-// 		return nil, err
-// 	}
-
-// 	switch queryType {
-// 	case "zabbixAPI":
-// 		resp, err = zabbixDS.ZabbixAPIQuery(ctx, tsdbReq)
-// 	case "query":
-// 		resp, err = zabbixDS.queryNumericItems(ctx, tsdbReq)
-// 	case "connectionTest":
-// 		resp, err = zabbixDS.TestConnection(ctx, tsdbReq)
-// 	default:
-// 		err = errors.New("Query not implemented")
-// 		return BuildErrorResponse(err), nil
-// 	}
-
-// 	return
-// }
-
 // GetDatasource Returns cached datasource or creates new one
 func (ds *ZabbixDatasource) GetDatasource(pluginContext backend.PluginContext) (*ZabbixDatasourceInstance, error) {
 	dsSettings := pluginContext.DataSourceInstanceSettings
@@ -244,79 +214,8 @@ func (ds *ZabbixDatasource) GetDatasource(pluginContext backend.PluginContext) (
 	return dsInstance, nil
 }
 
-// GetQueryType determines the query type from a query or list of queries
-func GetQueryType(tsdbReq *datasource.DatasourceRequest) (string, error) {
-	queryType := "query"
-	if len(tsdbReq.Queries) > 0 {
-		firstQuery := tsdbReq.Queries[0]
-		queryJSON, err := simplejson.NewJson([]byte(firstQuery.ModelJson))
-		if err != nil {
-			return "", err
-		}
-		queryType = queryJSON.Get("queryType").MustString("query")
-	}
-	return queryType, nil
-}
-
-// // BuildDataResponse transforms a Zabbix API response to the QueryDataResponse
-// func BuildDataResponse(responseData interface{}) (*backend.QueryDataResponse, error) {
-// 	jsonBytes, err := json.Marshal(responseData)
-// 	if err != nil {
-// 		return nil, err
-// 	}
-
-// 	return &backend.QueryDataResponse{
-// 		Responses: map[string]backend.DataResponse{
-// 			"zabbixAPI": {
-// 				Frames: ,
-// 			}
-// 		},
-// 	}, nil
-// }
-
 func BuildAPIResponse(responseData *interface{}) (*ZabbixAPIResourceResponse, error) {
 	return &ZabbixAPIResourceResponse{
 		Result: *responseData,
 	}, nil
 }
-
-// BuildResponse transforms a Zabbix API response to a DatasourceResponse
-func BuildResponse(responseData interface{}) (*datasource.DatasourceResponse, error) {
-	jsonBytes, err := json.Marshal(responseData)
-	if err != nil {
-		return nil, err
-	}
-
-	return &datasource.DatasourceResponse{
-		Results: []*datasource.QueryResult{
-			{
-				RefId:    "zabbixAPI",
-				MetaJson: string(jsonBytes),
-			},
-		},
-	}, nil
-}
-
-// BuildErrorResponse creates a QueryResult that forwards an error to the front-end
-func BuildErrorResponse(err error) *datasource.DatasourceResponse {
-	return &datasource.DatasourceResponse{
-		Results: []*datasource.QueryResult{
-			{
-				RefId: "zabbixAPI",
-				Error: err.Error(),
-			},
-		},
-	}
-}
-
-// BuildMetricsResponse builds a response object using a given TimeSeries array
-func BuildMetricsResponse(metrics []*datasource.TimeSeries) (*datasource.DatasourceResponse, error) {
-	return &datasource.DatasourceResponse{
-		Results: []*datasource.QueryResult{
-			{
-				RefId:  "zabbixMetrics",
-				Series: metrics,
-			},
-		},
-	}, nil
-}

pkg/zabbix_api.go

@@ -2,7 +2,6 @@ package main
 
 import (
 	"encoding/json"
-	"errors"
 	"fmt"
 	"regexp"
 	"time"
@@ -11,20 +10,9 @@ import (
 	simplejson "github.com/bitly/go-simplejson"
 	"github.com/grafana/grafana-plugin-sdk-go/backend"
 	"github.com/grafana/grafana-plugin-sdk-go/data"
-	"github.com/grafana/grafana_plugin_model/go/datasource"
 	"golang.org/x/net/context"
 )
 
-type FunctionCategories struct {
-	Transform []map[string]interface{}
-	Aggregate []map[string]interface{}
-	Filter    []map[string]interface{}
-	Trends    []map[string]interface{}
-	Time      []map[string]interface{}
-	Alias     []map[string]interface{}
-	Special   []map[string]interface{}
-}
-
 // ZabbixAPIQuery handles query requests to Zabbix
 func (dsInstance *ZabbixDatasourceInstance) ZabbixAPIQuery(ctx context.Context, apiReq *ZabbixAPIRequest) (*ZabbixAPIResourceResponse, error) {
 	var result interface{}
@@ -45,38 +33,6 @@ func (dsInstance *ZabbixDatasourceInstance) ZabbixAPIQuery(ctx context.Context,
 	return BuildAPIResponse(&result)
 }
 
-func (ds *ZabbixDatasourceInstance) ZabbixAPIQueryOld(ctx context.Context, tsdbReq *datasource.DatasourceRequest) (*datasource.DatasourceResponse, error) {
-	result, queryExistInCache := ds.queryCache.Get(HashString(tsdbReq.String()))
-
-	if !queryExistInCache {
-		queries := []requestModel{}
-		for _, query := range tsdbReq.Queries {
-			req := requestModel{}
-			err := json.Unmarshal([]byte(query.GetModelJson()), &req)
-
-			if err != nil {
-				return nil, err
-			}
-			queries = append(queries, req)
-		}
-
-		if len(queries) == 0 {
-			return nil, errors.New("At least one query should be provided")
-		}
-
-		query := queries[0].Target
-		var err error
-		result, err = ds.ZabbixRequest(ctx, query.Method, query.Params)
-		ds.queryCache.Set(HashString(tsdbReq.String()), result)
-		if err != nil {
-			ds.logger.Debug("ZabbixAPIQuery", "error", err)
-			return nil, errors.New("ZabbixAPIQuery is not implemented yet")
-		}
-	}
-
-	return BuildResponse(result)
-}
-
 // TestConnection checks authentication and version of the Zabbix API and returns that info
 func (ds *ZabbixDatasourceInstance) TestConnection(ctx context.Context) (string, error) {
 	_, err := ds.getAllGroups(ctx)