Functionality for Managing Orgs and Users

admin.go

@@ -6,32 +6,38 @@ import (
 	"errors"
 	"fmt"
 	"io/ioutil"
-
-	"github.com/grafana/grafana/pkg/api/dtos"
 )
 
-func (c *Client) CreateUserForm(settings dtos.AdminCreateUserForm) error {
-	data, err := json.Marshal(settings)
-	req, err := c.newRequest("POST", "/api/admin/users", bytes.NewBuffer(data))
+func (c *Client) CreateUser(user User) (int64, error) {
+	id := int64(0)
+	data, err := json.Marshal(user)
+	req, err := c.newRequest("POST", "/api/admin/users", nil, bytes.NewBuffer(data))
 	if err != nil {
-		return err
+		return id, err
 	}
 	resp, err := c.Do(req)
 	if err != nil {
-		return err
+		return id, err
+	}
+	if resp.StatusCode != 200 {
+		return id, errors.New(resp.Status)
 	}
 	data, err = ioutil.ReadAll(resp.Body)
 	if err != nil {
-		return err
+		return id, err
 	}
-	if resp.StatusCode != 200 {
-		return errors.New(resp.Status)
+	created := struct {
+		Id int64 `json:"id"`
+	}{}
+	err = json.Unmarshal(data, &created)
+	if err != nil {
+		return id, err
 	}
-	return err
+	return created.Id, err
 }
 
 func (c *Client) DeleteUser(id int64) error {
-	req, err := c.newRequest("DELETE", fmt.Sprintf("/api/admin/users/%d", id), nil)
+	req, err := c.newRequest("DELETE", fmt.Sprintf("/api/admin/users/%d", id), nil, nil)
 	if err != nil {
 		return err
 	}

admin_test.go

@@ -0,0 +1,39 @@
+package gapi
+
+import (
+	"testing"
+)
+
+const (
+	createUserJSON = `{"id":1,"message":"User created"}`
+	deleteUserJSON = `{"message":"User deleted"}`
+)
+
+func TestCreateUser(t *testing.T) {
+	server, client := gapiTestTools(200, createUserJSON)
+	defer server.Close()
+	user := User{
+		Email:    "admin@localhost",
+		Login:    "admin",
+		Name:     "Administrator",
+		Password: "password",
+	}
+	resp, err := client.CreateUser(user)
+	if err != nil {
+		t.Error(err)
+	}
+
+	if resp != 1 {
+		t.Error("Not correctly parsing returned user message.")
+	}
+}
+
+func TestDeleteUser(t *testing.T) {
+	server, client := gapiTestTools(200, deleteUserJSON)
+	defer server.Close()
+
+	err := client.DeleteUser(int64(1))
+	if err != nil {
+		t.Error(err)
+	}
+}

alertnotification.go

@@ -9,16 +9,16 @@ import (
 )
 
 type AlertNotification struct {
-	Id          int64       `json:"id,omitempty"`
-	Name        string      `json:"name"`
-	Type        string      `json:"type"`
-	IsDefault   bool        `json:"isDefault"`
-	Settings    interface{} `json:"settings"`
+	Id        int64       `json:"id,omitempty"`
+	Name      string      `json:"name"`
+	Type      string      `json:"type"`
+	IsDefault bool        `json:"isDefault"`
+	Settings  interface{} `json:"settings"`
 }
 
 func (c *Client) AlertNotification(id int64) (*AlertNotification, error) {
 	path := fmt.Sprintf("/api/alert-notifications/%d", id)
-	req, err := c.newRequest("GET", path, nil)
+	req, err := c.newRequest("GET", path, nil, nil)
 	if err != nil {
 		return nil, err
 	}
@@ -46,7 +46,7 @@ func (c *Client) NewAlertNotification(a *AlertNotification) (int64, error) {
 	if err != nil {
 		return 0, err
 	}
-	req, err := c.newRequest("POST", "/api/alert-notifications", bytes.NewBuffer(data))
+	req, err := c.newRequest("POST", "/api/alert-notifications", nil, bytes.NewBuffer(data))
 	if err != nil {
 		return 0, err
 	}
@@ -77,7 +77,7 @@ func (c *Client) UpdateAlertNotification(a *AlertNotification) error {
 	if err != nil {
 		return err
 	}
-	req, err := c.newRequest("PUT", path, bytes.NewBuffer(data))
+	req, err := c.newRequest("PUT", path, nil, bytes.NewBuffer(data))
 	if err != nil {
 		return err
 	}
@@ -95,7 +95,7 @@ func (c *Client) UpdateAlertNotification(a *AlertNotification) error {
 
 func (c *Client) DeleteAlertNotification(id int64) error {
 	path := fmt.Sprintf("/api/alert-notifications/%d", id)
-	req, err := c.newRequest("DELETE", path, nil)
+	req, err := c.newRequest("DELETE", path, nil, nil)
 	if err != nil {
 		return err
 	}

client.go

@@ -39,9 +39,10 @@ func New(auth, baseURL string) (*Client, error) {
 	}, nil
 }
 
-func (c *Client) newRequest(method, requestPath string, body io.Reader) (*http.Request, error) {
+func (c *Client) newRequest(method, requestPath string, query url.Values, body io.Reader) (*http.Request, error) {
 	url := c.baseURL
 	url.Path = path.Join(url.Path, requestPath)
+	url.RawQuery = query.Encode()
 	req, err := http.NewRequest(method, url.String(), body)
 	if err != nil {
 		return req, err

dashboard.go

@@ -33,7 +33,7 @@ func (c *Client) SaveDashboard(model map[string]interface{}, overwrite bool) (*D
 	if err != nil {
 		return nil, err
 	}
-	req, err := c.newRequest("POST", "/api/dashboards/db", bytes.NewBuffer(data))
+	req, err := c.newRequest("POST", "/api/dashboards/db", nil, bytes.NewBuffer(data))
 	if err != nil {
 		return nil, err
 	}
@@ -58,7 +58,7 @@ func (c *Client) SaveDashboard(model map[string]interface{}, overwrite bool) (*D
 
 func (c *Client) Dashboard(slug string) (*Dashboard, error) {
 	path := fmt.Sprintf("/api/dashboards/db/%s", slug)
-	req, err := c.newRequest("GET", path, nil)
+	req, err := c.newRequest("GET", path, nil, nil)
 	if err != nil {
 		return nil, err
 	}
@@ -83,7 +83,7 @@ func (c *Client) Dashboard(slug string) (*Dashboard, error) {
 
 func (c *Client) DeleteDashboard(slug string) error {
 	path := fmt.Sprintf("/api/dashboards/db/%s", slug)
-	req, err := c.newRequest("DELETE", path, nil)
+	req, err := c.newRequest("DELETE", path, nil, nil)
 	if err != nil {
 		return err
 	}

datasource.go

@@ -32,9 +32,10 @@ type DataSource struct {
 
 // JSONData is a representation of the datasource `jsonData` property
 type JSONData struct {
-	AssumeRoleArn string `json:"assumeRoleArn,omitempty"`
-	AuthType      string `json:"authType,omitempty"`
-	DefaultRegion string `json:"defaultRegion,omitempty"`
+	AssumeRoleArn           string `json:"assumeRoleArn,omitempty"`
+	AuthType                string `json:"authType,omitempty"`
+	CustomMetricsNamespaces string `json:"customMetricsNamespaces,omitempty"`
+	DefaultRegion           string `json:"defaultRegion,omitempty"`
 }
 
 // SecureJSONData is a representation of the datasource `secureJsonData` property
@@ -48,7 +49,7 @@ func (c *Client) NewDataSource(s *DataSource) (int64, error) {
 	if err != nil {
 		return 0, err
 	}
-	req, err := c.newRequest("POST", "/api/datasources", bytes.NewBuffer(data))
+	req, err := c.newRequest("POST", "/api/datasources", nil, bytes.NewBuffer(data))
 	if err != nil {
 		return 0, err
 	}
@@ -79,7 +80,7 @@ func (c *Client) UpdateDataSource(s *DataSource) error {
 	if err != nil {
 		return err
 	}
-	req, err := c.newRequest("PUT", path, bytes.NewBuffer(data))
+	req, err := c.newRequest("PUT", path, nil, bytes.NewBuffer(data))
 	if err != nil {
 		return err
 	}
@@ -97,7 +98,7 @@ func (c *Client) UpdateDataSource(s *DataSource) error {
 
 func (c *Client) DataSource(id int64) (*DataSource, error) {
 	path := fmt.Sprintf("/api/datasources/%d", id)
-	req, err := c.newRequest("GET", path, nil)
+	req, err := c.newRequest("GET", path, nil, nil)
 	if err != nil {
 		return nil, err
 	}
@@ -122,7 +123,7 @@ func (c *Client) DataSource(id int64) (*DataSource, error) {
 
 func (c *Client) DeleteDataSource(id int64) error {
 	path := fmt.Sprintf("/api/datasources/%d", id)
-	req, err := c.newRequest("DELETE", path, nil)
+	req, err := c.newRequest("DELETE", path, nil, nil)
 	if err != nil {
 		return err
 	}

datasource_test.go

@@ -10,6 +10,10 @@ import (
 	"github.com/gobs/pretty"
 )
 
+const (
+	createdDataSourceJSON = `{"id":1,"message":"Datasource added", "name": "test_datasource"}`
+)
+
 func gapiTestTools(code int, body string) (*httptest.Server, *Client) {
 	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		w.WriteHeader(code)
@@ -46,9 +50,10 @@ func TestNewDataSource(t *testing.T) {
 		Access:    "access",
 		IsDefault: true,
 		JSONData: JSONData{
-			AssumeRoleArn: "arn:aws:iam::123:role/some-role",
-			AuthType:      "keys",
-			DefaultRegion: "us-east-1",
+			AssumeRoleArn:           "arn:aws:iam::123:role/some-role",
+			AuthType:                "keys",
+			CustomMetricsNamespaces: "SomeNamespace",
+			DefaultRegion:           "us-east-1",
 		},
 		SecureJSONData: SecureJSONData{
 			AccessKey: "123",

org_users.go

@@ -0,0 +1,95 @@
+package gapi
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io/ioutil"
+)
+
+type OrgUser struct {
+	OrgId  int64  `json:"orgId"`
+	UserId int64  `json:"userId"`
+	Email  string `json:"email"`
+	Login  string `json:"login"`
+	Role   string `json:"role"`
+}
+
+func (c *Client) OrgUsers(orgId int64) ([]OrgUser, error) {
+	users := make([]OrgUser, 0)
+	req, err := c.newRequest("GET", fmt.Sprintf("/api/orgs/%d/users", orgId), nil, nil)
+	if err != nil {
+		return users, err
+	}
+	resp, err := c.Do(req)
+	if err != nil {
+		return users, err
+	}
+	if resp.StatusCode != 200 {
+		return users, errors.New(resp.Status)
+	}
+	data, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		return users, err
+	}
+	err = json.Unmarshal(data, &users)
+	if err != nil {
+		return users, err
+	}
+	return users, err
+}
+
+func (c *Client) AddOrgUser(orgId int64, user, role string) error {
+	dataMap := map[string]string{
+		"loginOrEmail": user,
+		"role":         role,
+	}
+	data, err := json.Marshal(dataMap)
+	req, err := c.newRequest("POST", fmt.Sprintf("/api/orgs/%d/users", orgId), nil, bytes.NewBuffer(data))
+	if err != nil {
+		return err
+	}
+	resp, err := c.Do(req)
+	if err != nil {
+		return err
+	}
+	if resp.StatusCode != 200 {
+		return errors.New(resp.Status)
+	}
+	return err
+}
+
+func (c *Client) UpdateOrgUser(orgId, userId int64, role string) error {
+	dataMap := map[string]string{
+		"role": role,
+	}
+	data, err := json.Marshal(dataMap)
+	req, err := c.newRequest("PATCH", fmt.Sprintf("/api/orgs/%d/users/%d", orgId, userId), nil, bytes.NewBuffer(data))
+	if err != nil {
+		return err
+	}
+	resp, err := c.Do(req)
+	if err != nil {
+		return err
+	}
+	if resp.StatusCode != 200 {
+		return errors.New(resp.Status)
+	}
+	return err
+}
+
+func (c *Client) RemoveOrgUser(orgId, userId int64) error {
+	req, err := c.newRequest("DELETE", fmt.Sprintf("/api/orgs/%d/users/%d", orgId, userId), nil, nil)
+	if err != nil {
+		return err
+	}
+	resp, err := c.Do(req)
+	if err != nil {
+		return err
+	}
+	if resp.StatusCode != 200 {
+		return errors.New(resp.Status)
+	}
+	return err
+}