func (c *Client) Do(req *http.Request, v interface{}) (*Response, error) {
	resp, err := c.client.Do(req)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()
	response := newResponse(resp)
		err = CheckResponse(resp)
		if err != nil {
			return response, err
		}
	content, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		fmt.Printf("%s", err)
		os.Exit(1)
	}
	response.RawContent = content
	return response, err
}
Do sends an API request and returns the API response.  The API response is
JSON decoded and stored in the value pointed to by v, or returned as an
error if an API error has occurred.  If v implements the io.Writer
interface, the raw response body will be written to v, without attempting to
first decode it.
package otxapi
import (
	"bytes"
	"encoding/json"
	"fmt"
	"github.com/google/go-querystring/query"
	"io"
	"io/ioutil"
	"net/http"
	"net/url"
	"os"
	"reflect"
)
const (
	get                  = "GET"
	libraryVersion       = "0.1"
	userAgent            = "go-otx-api/" + libraryVersion
	defaultBaseURL       = "https://otx.alienvault.com/"
	subscriptionsURLPath = "api/v1/pulses/subscribed"
	pulseDetailURLPath   = "api/v1/pulses/"
	userURLPath          = "api/v1/user/"
	apiVersion           = "v1"
)
type Client struct {
	client *http.Client
	BaseURL *url.URL
	UserAgent string
	UserDetail  *OTXUserDetailService
	PulseDetail *OTXPulseDetailService
	ThreatIntel *OTXThreatIntelFeedService
}
type Response struct {
	*http.Response
	RawContent []uint8
	Content map[string]interface{} `json:"results,omitempty"`
}
type ListOptions struct {
	Page int `url:"page,omitempty"`
	PerPage int `url:"limit,omitempty"`
}
func addOptions(s string, opt interface{}) (string, error) {
	v := reflect.ValueOf(opt)
	if v.Kind() == reflect.Ptr && v.IsNil() {
		return s, nil
	}
	u, err := url.Parse(s)
	if err != nil {
		return s, err
	}
	qs, err := query.Values(opt)
	if err != nil {
		return s, err
	}
	u.RawQuery = qs.Encode()
	return u.String(), nil
}
func (c *OTXPulseDetailService) Get(id_string string) (PulseDetail, Response, error) {
	client := &http.Client{}
	req, _ := http.NewRequest(get, fmt.Sprintf("%s/%s/%s/", defaultBaseURL, pulseDetailURLPath, id_string), nil)
	req.Header.Set("X-OTX-API-KEY", fmt.Sprintf("%s", os.Getenv("X_OTX_API_KEY")))
	response, _ := client.Do(req)
	resp := Response{Response: response}
	contents, err := ioutil.ReadAll(response.Body)
	if err != nil {
		fmt.Printf("%s", err)
		os.Exit(1)
	}
	pulse_detail := new(PulseDetail)
	json.Unmarshal(contents, &(pulse_detail))
	json.Unmarshal(contents, &(resp.Content))
	return *pulse_detail, resp, err
}
func (c *OTXThreatIntelFeedService) List(opt *ListOptions) (ThreatIntelFeed, Response, error) {
	client := &http.Client{}
	requestpath, err := addOptions(defaultBaseURL + subscriptionsURLPath, opt)
	if err != nil {
		return ThreatIntelFeed{}, Response{}, err
	}
	req, _ := http.NewRequest(get, requestpath, nil)
	req.Header.Set("X-OTX-API-KEY", fmt.Sprintf("%s", os.Getenv("X_OTX_API_KEY")))
	response, _ := client.Do(req)
	resp := Response{Response: response}
	contents, err := ioutil.ReadAll(response.Body)
	if err != nil {
		fmt.Printf("%s", err)
		os.Exit(1)
	}
	pulse_list := new(ThreatIntelFeed)
	err = json.Unmarshal(contents, &(pulse_list))
	json.Unmarshal(contents, &(resp.Content))
	if err != nil {
		fmt.Println("error not nil on json unmarshall")
		fmt.Println(err)
	}
	return *pulse_list, resp, err
}
func (c *OTXUserDetailService) Get() (UserDetail, *Response, error) {
	req, err := c.client.NewRequest(get, userURLPath, nil)
	if err != nil {
		return UserDetail{}, nil, err
	}
	req.Header.Set("X-OTX-API-KEY", fmt.Sprintf("%s", os.Getenv("X_OTX_API_KEY")))
	userdetail := &UserDetail{}
	resp, err := c.client.Do(req, userdetail)
	if err != nil {
		return UserDetail{}, resp, err
	}
	err = json.Unmarshal(resp.RawContent, &(userdetail))
	json.Unmarshal(resp.RawContent, &(resp.Content))
	return *userdetail, resp, err
}
func NewClient(httpClient *http.Client) *Client {
	if httpClient == nil {
		httpClient = http.DefaultClient
	}
	baseURL, _ := url.Parse(defaultBaseURL)
	c := &Client{client: httpClient, BaseURL: baseURL, UserAgent: userAgent}
	c.UserDetail = &OTXUserDetailService{client: c}
	return c
}