Merge branch 'master' into remove-deprecate-notice

Author: inkel

api_key.go

@@ -0,0 +1,67 @@
+package gapi
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"net/url"
+	"strconv"
+	"time"
+)
+
+type CreateAPIKeyRequest struct {
+	Name          string `json:"name"`
+	Role          string `json:"role"`
+	SecondsToLive int64  `json:"secondsToLive,omitempty"`
+}
+
+type CreateAPIKeyResponse struct {
+	// ID field only returned after Grafana v7.
+	ID   int64  `json:"id,omitempty"`
+	Name string `json:"name"`
+	Key  string `json:"key"`
+}
+
+type GetAPIKeysResponse struct {
+	ID         int64     `json:"id"`
+	Name       string    `json:"name"`
+	Role       string    `json:"role"`
+	Expiration time.Time `json:"expiration,omitempty"`
+}
+
+type DeleteAPIKeyResponse struct {
+	Message string `json:"message"`
+}
+
+// CreateAPIKey creates a new Grafana API key.
+func (c *Client) CreateAPIKey(request CreateAPIKeyRequest) (CreateAPIKeyResponse, error) {
+	response := CreateAPIKeyResponse{}
+
+	data, err := json.Marshal(request)
+	if err != nil {
+		return response, err
+	}
+
+	err = c.request("POST", "/api/auth/keys", nil, bytes.NewBuffer(data), &response)
+	return response, err
+}
+
+// GetAPIKeys retrieves a list of all API keys.
+func (c *Client) GetAPIKeys(includeExpired bool) ([]*GetAPIKeysResponse, error) {
+	response := make([]*GetAPIKeysResponse, 0)
+
+	query := url.Values{}
+	query.Add("includeExpired", strconv.FormatBool(includeExpired))
+
+	err := c.request("GET", "/api/auth/keys", query, nil, &response)
+	return response, err
+}
+
+// DeleteAPIKey deletes the Grafana API key with the specified ID.
+func (c *Client) DeleteAPIKey(id int64) (DeleteAPIKeyResponse, error) {
+	response := DeleteAPIKeyResponse{}
+
+	path := fmt.Sprintf("/api/auth/keys/%d", id)
+	err := c.request("DELETE", path, nil, nil, &response)
+	return response, err
+}

api_key_test.go

@@ -0,0 +1,68 @@
+package gapi
+
+import (
+	"testing"
+
+	"github.com/gobs/pretty"
+)
+
+const (
+	createAPIKeyJSON = `{"name":"key-name", "key":"mock-api-key"}`
+	deleteAPIKeyJSON = `{"message":"API key deleted"}`
+
+	getAPIKeysJSON = `[
+		{
+			"id": 1,
+			"name": "key-name-2",
+			"role": "Viewer"
+		},
+		{
+			"id": 2,
+			"name": "key-name-2",
+			"role": "Admin",
+			"expiration": "2021-10-30T10:52:03+03:00"
+		}
+	]`
+)
+
+func TestCreateAPIKey(t *testing.T) {
+	server, client := gapiTestTools(t, 200, createAPIKeyJSON)
+	defer server.Close()
+
+	req := CreateAPIKeyRequest{
+		Name:          "key-name",
+		Role:          "Viewer",
+		SecondsToLive: 0,
+	}
+
+	res, err := client.CreateAPIKey(req)
+	if err != nil {
+		t.Error(err)
+	}
+
+	t.Log(pretty.PrettyFormat(res))
+}
+
+func TestDeleteAPIKey(t *testing.T) {
+	server, client := gapiTestTools(t, 200, deleteAPIKeyJSON)
+	defer server.Close()
+
+	res, err := client.DeleteAPIKey(int64(1))
+	if err != nil {
+		t.Error(err)
+	}
+
+	t.Log(pretty.PrettyFormat(res))
+}
+
+func TestGetAPIKeys(t *testing.T) {
+	server, client := gapiTestTools(t, 200, getAPIKeysJSON)
+	defer server.Close()
+
+	res, err := client.GetAPIKeys(true)
+	if err != nil {
+		t.Error(err)
+	}
+
+	t.Log(pretty.PrettyFormat(res))
+}

datasource_permissions.go

@@ -0,0 +1,95 @@
+package gapi
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+)
+
+type DatasourcePermissionType int
+
+const (
+	_ DatasourcePermissionType = iota // 0 is not a valid permission
+	DatasourcePermissionQuery
+)
+
+// DatasourcePermission has information such as a datasource, user, team, role and permission.
+type DatasourcePermission struct {
+	ID           int64  `json:"id"`
+	DatasourceID int64  `json:"datasourceId"`
+	UserID       int64  `json:"userId"`
+	UserEmail    string `json:"userEmail"`
+	TeamID       int64  `json:"teamId"`
+
+	// Permission levels are
+	// 1 = Query
+	Permission     DatasourcePermissionType `json:"permission"`
+	PermissionName string                   `json:"permissionName"`
+}
+
+type DatasourcePermissionsResponse struct {
+	DatasourceID int64                   `json:"datasourceId"`
+	Enabled      bool                    `json:"enabled"`
+	Permissions  []*DatasourcePermission `json:"permissions"`
+}
+
+type DatasourcePermissionAddPayload struct {
+	UserID     int64                    `json:"userId"`
+	TeamID     int64                    `json:"teamId"`
+	Permission DatasourcePermissionType `json:"permission"`
+}
+
+// EnableDatasourcePermissions enables the datasource permissions (this is a datasource setting)
+func (c *Client) EnableDatasourcePermissions(id int64) error {
+	path := fmt.Sprintf("/api/datasources/%d/enable-permissions", id)
+	if err := c.request("POST", path, nil, nil, nil); err != nil {
+		return fmt.Errorf("error enabling permissions at %s: %w", path, err)
+	}
+	return nil
+}
+
+// DisableDatasourcePermissions disables the datasource permissions (this is a datasource setting)
+func (c *Client) DisableDatasourcePermissions(id int64) error {
+	path := fmt.Sprintf("/api/datasources/%d/disable-permissions", id)
+	if err := c.request("POST", path, nil, nil, nil); err != nil {
+		return fmt.Errorf("error disabling permissions at %s: %w", path, err)
+	}
+	return nil
+}
+
+// DatasourcePermissions fetches and returns the permissions for the datasource whose ID it's passed.
+func (c *Client) DatasourcePermissions(id int64) (*DatasourcePermissionsResponse, error) {
+	path := fmt.Sprintf("/api/datasources/%d/permissions", id)
+	var out *DatasourcePermissionsResponse
+	err := c.request("GET", path, nil, nil, &out)
+	if err != nil {
+		return out, fmt.Errorf("error getting permissions at %s: %w", path, err)
+	}
+
+	return out, nil
+}
+
+// AddDatasourcePermission adds the given permission item
+func (c *Client) AddDatasourcePermission(id int64, item *DatasourcePermissionAddPayload) error {
+	path := fmt.Sprintf("/api/datasources/%d/permissions", id)
+	data, err := json.Marshal(item)
+	if err != nil {
+		return fmt.Errorf("marshal err: %w", err)
+	}
+
+	if err = c.request("POST", path, nil, bytes.NewBuffer(data), nil); err != nil {
+		return fmt.Errorf("error adding permissions at %s: %w", path, err)
+	}
+
+	return nil
+}
+
+// RemoveDatasourcePermission removes the permission with the given id
+func (c *Client) RemoveDatasourcePermission(id, permissionID int64) error {
+	path := fmt.Sprintf("/api/datasources/%d/permissions/%d", id, permissionID)
+	if err := c.request("DELETE", path, nil, nil, nil); err != nil {
+		return fmt.Errorf("error deleting permissions at %s: %w", path, err)
+	}
+
+	return nil
+}

datasource_permissions_test.go

@@ -0,0 +1,102 @@
+package gapi
+
+import (
+	"testing"
+
+	"github.com/gobs/pretty"
+)
+
+const (
+	getDatasourcePermissionsJSON = `{
+	"datasourceId": 1,
+	"enabled": true,
+	"permissions": [
+		{
+			"datasourceId": 1,
+			"userId": 1,
+			"userLogin": "user",
+			"userEmail": "user@test.com",
+			"userAvatarUrl": "/avatar/46d229b033af06a191ff2267bca9ae56",
+			"permission": 1,
+			"permissionName": "Query",
+			"created": "2017-06-20T02:00:00+02:00",
+			"updated": "2017-06-20T02:00:00+02:00"
+		},
+		{
+			"datasourceId": 2,
+			"teamId": 1,
+			"team": "A Team",
+			"teamAvatarUrl": "/avatar/46d229b033af06a191ff2267bca9ae56",
+			"permission": 1,
+			"permissionName": "Query",
+			"created": "2017-06-20T02:00:00+02:00",
+			"updated": "2017-06-20T02:00:00+02:00"
+		}
+	]
+}`
+	addDatasourcePermissionsJSON = `{
+	"message": "Datasource permission added"
+}`
+)
+
+func TestDatasourcePermissions(t *testing.T) {
+	server, client := gapiTestTools(t, 200, getDatasourcePermissionsJSON)
+	defer server.Close()
+
+	resp, err := client.DatasourcePermissions(1)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	t.Log(pretty.PrettyFormat(resp))
+
+	expects := []*DatasourcePermission{
+		{
+			DatasourceID:   1,
+			UserID:         1,
+			TeamID:         0,
+			Permission:     1,
+			PermissionName: "Query",
+		},
+		{
+			DatasourceID:   2,
+			UserID:         0,
+			TeamID:         1,
+			Permission:     1,
+			PermissionName: "Query",
+		},
+	}
+
+	for i, expect := range expects {
+		t.Run("check data", func(t *testing.T) {
+			if resp.Permissions[i].DatasourceID != expect.DatasourceID ||
+				resp.Permissions[i].UserID != expect.UserID ||
+				resp.Permissions[i].TeamID != expect.TeamID ||
+				resp.Permissions[i].Permission != expect.Permission ||
+				resp.Permissions[i].PermissionName != expect.PermissionName {
+				t.Error("Not correctly parsing returned datasource permission")
+			}
+		})
+	}
+}
+
+func TestAddDatasourcePermissions(t *testing.T) {
+	server, client := gapiTestTools(t, 200, addDatasourcePermissionsJSON)
+	defer server.Close()
+
+	for _, item := range []*DatasourcePermissionAddPayload{
+		{
+			TeamID:     1,
+			Permission: 1,
+		},
+		{
+			UserID:     11,
+			Permission: 1,
+		},
+	} {
+		err := client.AddDatasourcePermission(1, item)
+		if err != nil {
+			t.Error(err)
+		}
+	}
+}