[dev] draft for request make

nanmu42 · nanmu42 · commit f552dcf34584 · 2018-07-30T23:08:42.000+08:00
diff --git a/client.go b/client.go
@@ -7,20 +7,94 @@
 
 package etherscan
 
-import "net/http"
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+)
 
 // Client etherscan API client
 // Clients are safe for concurrent use by multiple goroutines.
 type Client struct {
-	network Network
 	coon    *http.Client
+	network Network
+	key     string
+	baseURL string
+
+	// Verbose when true, talks a lot
+	Verbose bool
+
+	// BeforeRequest runs before every client request, in the same goroutine.
+	// May be used in rate limit.
+	// Request will be aborted, if BeforeRequest returns non-nil err.
+	BeforeRequest func(module, action string, param map[string]interface{}) error
+
+	// AfterRequest runs after every client request, even when there is an error.
+	AfterRequest func(module, action string, param map[string]interface{}, outcome interface{}, requestErr error)
 }
 
 // New initialize a new etherscan API client
 // please use pre-defined network value
-func New(network Network) *Client {
+func New(network Network, APIKey string) *Client {
 	return &Client{
-		network: network,
 		coon:    &http.Client{},
+		network: network,
+		key:     APIKey,
+		baseURL: fmt.Sprintf(`https://%s.etherscan.io/api?`, network.SubDomain()),
+	}
+}
+
+// call does almost all the dirty work.
+func (c *Client) call(module, action string, param map[string]interface{}, outcome interface{}) (err error) {
+	// todo: fire hooks
+	// todo: verbose mode
+
+	req, err := http.NewRequest(http.MethodGet, c.craftURL(param), http.NoBody)
+	if err != nil {
+		err = wrapErr(err, "http.NewRequest")
+		return
+	}
+
+	res, err := c.coon.Do(req)
+	if err != nil {
+		err = wrapErr(err, "sending request")
+		return
 	}
+	defer res.Body.Close()
+
+	var content bytes.Buffer
+	if _, err = io.Copy(&content, res.Body); err != nil {
+		err = wrapErr(err, "reading response")
+		return
+	}
+
+	if res.StatusCode != http.StatusOK {
+		err = fmt.Errorf("response status %v %s, response body: %s", res.StatusCode, res.Status, content.String())
+		return
+	}
+
+	err = json.Unmarshal(content.Bytes(), outcome)
+	if err != nil {
+		err = wrapErr(err, "json unmarshal")
+		return
+	}
+
+	return
+}
+
+// craftURL returns desired URL via param provided
+func (c *Client) craftURL(param map[string]interface{}) (URL string) {
+	q := url.Values{
+		"apikey": []string{c.key},
+	}
+
+	for k, v := range param {
+		q[k] = extractValue(v)
+	}
+
+	URL = c.baseURL + q.Encode()
+	return
 }
diff --git a/reflect.go b/reflect.go
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2018 LI Zhennan
+ *
+ * Use of this work is governed by a MIT License.
+ * You may find a license copy in project root.
+ */
+
+package etherscan
+
+import (
+	"fmt"
+	"reflect"
+	"strconv"
+)
+
+// extractValue obtains string-formed slice representation via
+// input. It only handles string, int, and their slice form, and
+// panics otherwise.
+func extractValue(input interface{}) (output []string) {
+	v := reflect.ValueOf(input)
+
+	if v.Kind() == reflect.Slice {
+		length := v.Len()
+		output = make([]string, length)
+
+		for i := 0; i < length; i++ {
+			output[i] = valueToStr(v.Index(i))
+		}
+	} else {
+		output = append(output, valueToStr(v))
+	}
+
+	return
+}
+
+// valueToStr convert v into proper string representation
+// Only handles int and string, panic otherwise.
+func valueToStr(v reflect.Value) (str string) {
+	switch v.Kind() {
+	case reflect.String:
+		str = v.String()
+	case reflect.Int:
+		str = strconv.FormatInt(v.Int(), 10)
+	default:
+		panic(fmt.Sprintf("valueToStr: %v is of unexpected kind %q", v.Interface(), v.Kind()))
+	}
+	return
+}
