oef/client/client.go

package client

import (
	"bytes"
	"encoding/json"
	"errors"
	"fmt"
	"io/ioutil"
	"net/http"
	"net/url"
	"reflect"
	"strconv"
	"strings"

	"git.andreafazzi.eu/andrea/oef/i18n"
	"git.andreafazzi.eu/andrea/oef/orm"
	"git.andreafazzi.eu/andrea/oef/renderer"
	"github.com/jinzhu/inflection"
)

// A client represents a client connection to the Headmaster test
// server.
type Client struct {
	Url      *url.URL
	Username string
	Password string
	User     string

	token string
}

// Dial connects to a test server instance at the specified address
// using the given credentials.
func Dial(host, username, password string) (*Client, error) {
	url, err := url.Parse(host)
	if err != nil {
		return nil, err
	}

	client := &Client{
		Url:      url,
		Username: username,
		Password: password,
	}

	response, err := client.SendRequest("GET", "get_token", nil)
	if err != nil {
		panic(err)
	}

	var data struct {
		Token string
		User  string
	}
	if err := json.Unmarshal(response, &data); err != nil {
		panic(err)
	}
	client.token = data.Token
	client.User = data.User

	return client, nil
}

func (c *Client) SendRequest(method string, path string, data []byte) ([]byte, error) {
	// Create the https request

	folderUrl, err := url.Parse(path)
	if err != nil {
		return nil, err
	}

	client := &http.Client{}
	req, err := http.NewRequest(method, c.Url.ResolveReference(folderUrl).String(), bytes.NewReader(data))
	if err != nil {
		return nil, err
	}

	req.Header.Set("Content-Type", "application/json")
	req.SetBasicAuth(c.Username, c.Password)

	if c.token != "" {
		req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", c.token))
	}

	resp, err := client.Do(req)
	if err != nil {
		return nil, err
	}

	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		return nil, err
	}

	return body, nil
}

func (c *Client) ReadAll(model interface{}) error {
	var response renderer.JsonResponse

	data, err := c.SendRequest("GET", fmt.Sprintf("/api/%s?format=json", pluralizedModelName(model)), nil)
	if err != nil {
		return err
	}

	if err := json.Unmarshal(data, &response); err != nil {
		return err
	}

	if string(response.Error) != "" {
		return errors.New(string(response.Error))
	}

	if err := json.Unmarshal(response.Result, &model); err != nil {
		return err
	}
	return nil
}

func (c *Client) Create(model interface{}) (uint, error) {
	var response renderer.JsonResponse
	data, err := json.Marshal(model)
	if err != nil {
		return 0, err
	}

	resp, err := c.SendRequest("POST", fmt.Sprintf("/api/%s/create/?format=json", pluralizedModelName(model)), data)
	if err != nil {
		return 0, err
	}

	if err := json.Unmarshal(resp, &response); err != nil {
		return 0, err
	}

	if string(response.Error) != "" {
		return 0, errors.New(string(response.Error))
	}

	id, err := strconv.Atoi(string(response.Result))
	if err != nil {
		return 0, err
	}

	return uint(id), nil
}

func (c *Client) Delete(model orm.IDer) (uint, error) {
	var response renderer.JsonResponse
	data, err := json.Marshal(model)
	if err != nil {
		return 0, err
	}

	resp, err := c.SendRequest("DELETE", fmt.Sprintf("/api/%s/%d/delete?format=json", pluralizedModelName(model), model.GetID()), data)
	if err != nil {
		return 0, err
	}

	if err := json.Unmarshal(resp, &response); err != nil {
		return 0, err
	}

	if string(response.Error) != "" {
		return 0, errors.New(string(response.Error))
	}

	id, err := strconv.Atoi(string(response.Result))
	if err != nil {
		return 0, err
	}

	return uint(id), nil
}

func (c *Client) DeleteAllByName(model interface{}, name string) error {
	err := c.ReadAll(model)
	if err != nil {
		return err
	}
	switch reflect.TypeOf(model).Kind() {
	case reflect.Ptr:
		s := reflect.ValueOf(model).Elem()

		// FIXME: Check whatever s is a slice before cycling through it!

		for i := 0; i < s.Len(); i++ {
			if callString(s.Index(i).Interface()) == name {
				_, err := c.Delete(s.Index(i).Interface().(orm.IDer))
				if err != nil {
					return err
				}
			}

		}
	}
	return nil
}

// FIXME: refactor this (it's duplicated across the code)
func pluralizedModelName(value interface{}) string {
	return inflection.Plural(strings.ToLower(orm.ModelName(value)))
}

// FIXME: refactor this (it's duplicated across the code)
func callString(value interface{}) string {
	if value != nil {
		switch reflect.ValueOf(value).Kind() {
		case reflect.String:
			return value.(string)
		case reflect.Bool:
			if value.(bool) {
				return i18n.Text["answerCorrect"]["it"]
			}
			return "false"
		default:
			return reflect.ValueOf(value).MethodByName("String").Interface().(func() string)()
		}
	} else {
		return ""
	}
}