func (c *Client) NewRequest(method, urlStr string, body interface{}) (*http.Request, error) {
	rel, err := url.Parse(urlStr)
	if err != nil {
		return nil, err
	}
	u := c.BaseURL.ResolveReference(rel)
	var buf io.ReadWriter
	if body != nil {
		buf = new(bytes.Buffer)
		err := json.NewEncoder(buf).Encode(body)
		if err != nil {
			return nil, err
		}
	}
	req, err := http.NewRequest(method, u.String(), buf)
	if err != nil {
		return nil, err
	}
	if c.UserAgent != "" {
		req.Header.Add("User-Agent", c.UserAgent)
	}
	return req, nil
}
NewRequest creates an API request. A relative URL can be provided in urlStr,
in which case it is resolved relative to the BaseURL of the Client.
Relative URLs should always be specified without a preceding slash.  If
specified, the value pointed to by body is JSON encoded and included as the
request body.
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
}
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
}