-
Notifications
You must be signed in to change notification settings - Fork 3
/
blockscore.go
134 lines (110 loc) · 3.41 KB
/
blockscore.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
// Package blockscore is a Go client library for the Blockscore API.
//
// NOTE : This library works with only V4 or newer.
package blockscore
import (
"encoding/json"
"errors"
"fmt"
"io"
"io/ioutil"
"net/http"
"net/url"
"os"
"strconv"
"strings"
)
// The BlockScore API key used to authenticate API requests.
var apiKey string
// The base URL for all BlockScore API requests.
const apiURL string = "https://api.blockscore.com"
// The most recent BlockScore API version.
var apiVersion = 4
// SetKeyEnv Sets the BlockScore API key to use for authenticating API requests.
func SetKeyEnv() (err error) {
apiKey = os.Getenv("BLOCKSCORE_API_KEY")
if apiKey == "" {
err = errors.New("BLOCKSCORE_API_KEY not found in environment")
}
return
}
// SetVersion Sets the version of the BlockScore API to use.
func SetVersion(version int) {
apiVersion = version
}
var (
// People is used to perform domestic identity verification
People = new(PersonClient)
//Companies allow you to verify the authenticity of private and public company information
Companies = new(CompanyClient)
// Candidates are individuals who are queued up to either execute one-off watchlist scans or so that they can be continuously verified using our re-scan system
Candidates = new(CandidateClient)
// QuestionSets help you authenticate customers to see if they are who they say they are
QuestionSets = new(QuestionSetClient)
// Watchlists allow you to take a candidate token and perform a global watchlist search
Watchlists = new(WatchlistClient)
)
// Error encapsulates an error returned by the BlockScore REST API.
type Error struct {
Code int
Detail struct {
Code string `json:"code"`
Message string `json:"message"`
Param string `json:"param"`
Type string `json:"type"`
} `json:"error"`
}
func (e *Error) Error() string {
return e.Detail.Message
}
func query(method, path string, values url.Values, v interface{}) error {
// Parse the API URL.
endpoint, err := url.Parse(apiURL)
if err != nil {
return err
}
// Set the endpoint for the specific API.
endpoint.Path = path
endpoint.User = url.User(apiKey)
// If this is a GET request, add the url.Values to the endpoint.
if method == "GET" {
endpoint.RawQuery = values.Encode()
}
// Else if this is not a GET, encode the url.Values in the body
var reqBody io.Reader
if method != "GET" && values != nil {
reqBody = strings.NewReader(values.Encode())
}
// Create the request.
req, err := http.NewRequest(method, endpoint.String(), reqBody)
if err != nil {
return err
}
// set Accept header with correct BlockScore API version.
blockscoreHeader := fmt.Sprintf("application/vnd.blockscore+json;version=%d", apiVersion)
// Set the request headers.
req.Header.Set("Accept", blockscoreHeader)
req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
req.Header.Set("Content-Length", strconv.Itoa(len(values.Encode())))
req.SetBasicAuth(apiKey, "")
// Submit the http request.
r, err := http.DefaultClient.Do(req)
if err != nil {
return err
}
// Read the body of the http message into a byte array.
body, err := ioutil.ReadAll(r.Body)
defer r.Body.Close()
if err != nil {
return err
}
// Is this an error?
if r.StatusCode != 200 && r.StatusCode != 201 {
fmt.Printf("StatusCode: %d\n", r.StatusCode)
error := Error{}
json.Unmarshal(body, &error)
return &error
}
// Parse the JSON response into the response object.
return json.Unmarshal(body, v)
}