plivoclient.go

package plivo

import (
	"fmt"
	"net/http"
	"net/url"
	"os"
	"runtime"
	"time"
)

const baseUrlString = "https://api.plivo.com/"

var HttpsScheme = "https"
var voiceBaseUrlString = "api.plivo.com"
var voiceBaseUrlStringFallback1 = "api.plivo.com"
var voiceBaseUrlStringFallback2 = "api.plivo.com"

const baseRequestString = "/v1/Account/%s/"

type Client struct {
	BaseClient
	Messages                *MessageService
	Accounts                *AccountService
	Subaccounts             *SubaccountService
	Applications            *ApplicationService
	Endpoints               *EndpointService
	Numbers                 *NumberService
	PhoneNumbers            *PhoneNumberService
	Pricing                 *PricingService // TODO Rename?
	Recordings              *RecordingService
	Calls                   *CallService
	Token                   *TokenService
	LiveCalls               *LiveCallService
	QueuedCalls             *QueuedCallService
	Conferences             *ConferenceService
	CallFeedback            *CallFeedbackService
	Powerpack               *PowerpackService
	Media                   *MediaService
	Lookup                  *LookupService
	EndUsers                *EndUserService
	ComplianceDocuments     *ComplianceDocumentService
	ComplianceDocumentTypes *ComplianceDocumentTypeService
	ComplianceRequirements  *ComplianceRequirementService
	ComplianceApplications  *ComplianceApplicationService
	MultiPartyCall          *MultiPartyCallService
	Brand                   *BrandService
	Profile                 *ProfileService
	Campaign                *CampaignService
}

/*
To set a proxy for all requests, configure the Transport for the HttpClient passed in:

	&http.Client{
 		Transport: &http.Transport{
 			Proxy: http.ProxyURL("http//your.proxy.here"),
 		},
 	}

Similarly, to configure the timeout, set it on the HttpClient passed in:

	&http.Client{
 		Timeout: time.Minute,
 	}
*/
func NewClient(authId, authToken string, options *ClientOptions) (client *Client, err error) {

	client = &Client{}

	if len(authId) == 0 {
		authId = os.Getenv("PLIVO_AUTH_ID")
	}
	if len(authToken) == 0 {
		authToken = os.Getenv("PLIVO_AUTH_TOKEN")
	}
	client.AuthId = authId
	client.AuthToken = authToken
	client.userAgent = fmt.Sprintf("%s/%s (Go: %s)", "plivo-go", sdkVersion, runtime.Version())

	baseUrl, err := url.Parse(baseUrlString) // Todo: handle error case?

	client.BaseUrl = baseUrl
	client.httpClient = &http.Client{
		Timeout: time.Second * 10,
	}

	if options.HttpClient != nil {
		client.httpClient = options.HttpClient
	}

	client.Messages = &MessageService{client: client}
	client.Accounts = &AccountService{client: client}
	client.Subaccounts = &SubaccountService{client: client}
	client.Applications = &ApplicationService{client: client}
	client.Endpoints = &EndpointService{client: client}
	client.Numbers = &NumberService{client: client}
	client.PhoneNumbers = &PhoneNumberService{client: client}
	client.Pricing = &PricingService{client: client}
	client.Recordings = &RecordingService{client: client}
	client.Calls = &CallService{client: client}
	client.Token = &TokenService{client: client}
	client.LiveCalls = &LiveCallService{client: client}
	client.QueuedCalls = &QueuedCallService{client: client}
	client.Conferences = &ConferenceService{client: client}
	client.CallFeedback = &CallFeedbackService{client: client}
	client.Powerpack = &PowerpackService{client: client}
	client.Media = &MediaService{client: client}
	client.EndUsers = &EndUserService{client: client}
	client.ComplianceDocuments = &ComplianceDocumentService{client: client}
	client.ComplianceDocumentTypes = &ComplianceDocumentTypeService{client: client}
	client.ComplianceRequirements = &ComplianceRequirementService{client: client}
	client.ComplianceApplications = &ComplianceApplicationService{client: client}
	client.Lookup = &LookupService{client: client}
	client.MultiPartyCall = &MultiPartyCallService{client: client}
	client.Brand = &BrandService{client: client}
	client.Campaign = &CampaignService{client: client}
	client.Profile = &ProfileService{client: client}
	return
}

func (client *Client) NewRequest(method string, params interface{}, formatString string,
	formatParams ...interface{}) (*http.Request, error) {
	formatParams = append([]interface{}{client.AuthId}, formatParams...)
	formatString = fmt.Sprintf("%s/%s", "%s", formatString)
	return client.BaseClient.NewRequest(method, params, baseRequestString, formatString, formatParams...)
}