github.com/muxinc/mux-go@v1.1.1/client.go

// Mux Go - Copyright 2019 Mux Inc.
// NOTE: This file is auto generated. Do not edit this file manually.

package muxgo

import (
	"bytes"
	"context"
	"encoding/json"
	"encoding/xml"
	"errors"
	"fmt"
	"io"
	"mime/multipart"
	"net/http"
	"net/url"
	"os"
	"path/filepath"
	"reflect"
	"regexp"
	"strconv"
	"strings"
	"time"
	"unicode/utf8"
)

var (
	jsonCheck = regexp.MustCompile("(?i:[application|text]/json)")
	xmlCheck  = regexp.MustCompile("(?i:[application|text]/xml)")
)

// APIClient manages communication with the Mux API API vv1
// In most cases there should be only one, shared, APIClient.
type APIClient struct {
	cfg    *Configuration
	httpc  *http.Client
	common service // Reuse a single struct instead of allocating one for each service on the heap.

	// API Services
	AssetsApi         *AssetsApiService
	DeliveryUsageApi  *DeliveryUsageApiService
	DimensionsApi     *DimensionsApiService
	DirectUploadsApi  *DirectUploadsApiService
	ErrorsApi         *ErrorsApiService
	ExportsApi        *ExportsApiService
	FiltersApi        *FiltersApiService
	IncidentsApi      *IncidentsApiService
	LiveStreamsApi    *LiveStreamsApiService
	MetricsApi        *MetricsApiService
	PlaybackIDApi     *PlaybackIDApiService
	RealTimeApi       *RealTimeApiService
	URLSigningKeysApi *URLSigningKeysApiService
	VideoViewsApi     *VideoViewsApiService
}

type service struct {
	client *APIClient
}

// NewAPIClient creates a new API client.
func NewAPIClient(cfg *Configuration) *APIClient {
	c := &APIClient{}
	c.cfg = cfg
	c.httpc = &http.Client{
		Timeout: cfg.timeout,
	}
	c.common.client = c

	// API Services
	c.AssetsApi = (*AssetsApiService)(&c.common)
	c.DeliveryUsageApi = (*DeliveryUsageApiService)(&c.common)
	c.DimensionsApi = (*DimensionsApiService)(&c.common)
	c.DirectUploadsApi = (*DirectUploadsApiService)(&c.common)
	c.ErrorsApi = (*ErrorsApiService)(&c.common)
	c.ExportsApi = (*ExportsApiService)(&c.common)
	c.FiltersApi = (*FiltersApiService)(&c.common)
	c.IncidentsApi = (*IncidentsApiService)(&c.common)
	c.LiveStreamsApi = (*LiveStreamsApiService)(&c.common)
	c.MetricsApi = (*MetricsApiService)(&c.common)
	c.PlaybackIDApi = (*PlaybackIDApiService)(&c.common)
	c.RealTimeApi = (*RealTimeApiService)(&c.common)
	c.URLSigningKeysApi = (*URLSigningKeysApiService)(&c.common)
	c.VideoViewsApi = (*VideoViewsApiService)(&c.common)

	return c
}

func atoi(in string) (int, error) {
	return strconv.Atoi(in)
}

// selectHeaderContentType select a content type from the available list.
func selectHeaderContentType(contentTypes []string) string {
	if len(contentTypes) == 0 {
		return ""
	}
	if contains(contentTypes, "application/json") {
		return "application/json"
	}
	return contentTypes[0] // use the first content type specified in 'consumes'
}

// selectHeaderAccept join all accept types and return
func selectHeaderAccept(accepts []string) string {
	if len(accepts) == 0 {
		return ""
	}

	if contains(accepts, "application/json") {
		return "application/json"
	}

	return strings.Join(accepts, ",")
}

// contains is a case insenstive match, finding needle in a haystack
func contains(haystack []string, needle string) bool {
	for _, a := range haystack {
		if strings.ToLower(a) == strings.ToLower(needle) {
			return true
		}
	}
	return false
}

// Verify optional parameters are of the correct type.
func typeCheckParameter(obj interface{}, expected string, name string) error {
	// Make sure there is an object.
	if obj == nil {
		return nil
	}

	// Check the type is as expected.
	if reflect.TypeOf(obj).String() != expected {
		return fmt.Errorf("Expected %s to be of type %s but received %s.", name, expected, reflect.TypeOf(obj).String())
	}
	return nil
}

// parameterToString convert interface{} parameters to string, using a delimiter if format is provided.
func parameterToString(obj interface{}, collectionFormat string) string {
	var delimiter string

	switch collectionFormat {
	case "pipes":
		delimiter = "|"
	case "ssv":
		delimiter = " "
	case "tsv":
		delimiter = "\t"
	case "csv":
		delimiter = ","
	}

	if reflect.TypeOf(obj).Kind() == reflect.Slice {
		return strings.Trim(strings.Replace(fmt.Sprint(obj), " ", delimiter, -1), "[]")
	} else if t, ok := obj.(time.Time); ok {
		return t.Format(time.RFC3339)
	}

	return fmt.Sprintf("%v", obj)
}

// callAPI do the request.
func (c *APIClient) callAPI(request *http.Request) (*http.Response, error) {
	return c.httpc.Do(request)
}

// prepareRequest build the request
func (c *APIClient) prepareRequest(
	opts *APIOptions,
	path string, method string,
	postBody interface{},
	headerParams map[string]string,
	queryParams url.Values,
	formParams url.Values,
	formFileName string,
	fileName string,
	fileBytes []byte) (localVarRequest *http.Request, err error) {

	var body *bytes.Buffer

	// Detect postBody type and post.
	if postBody != nil {
		contentType := headerParams["Content-Type"]
		if contentType == "" {
			contentType = detectContentType(postBody)
			headerParams["Content-Type"] = contentType
		}

		body, err = setBody(postBody, contentType)
		if err != nil {
			return nil, err
		}
	}

	// add form parameters and file if available.
	if strings.HasPrefix(headerParams["Content-Type"], "multipart/form-data") && len(formParams) > 0 || (len(fileBytes) > 0 && fileName != "") {
		if body != nil {
			return nil, errors.New("Cannot specify postBody and multipart form at the same time.")
		}
		body = &bytes.Buffer{}
		w := multipart.NewWriter(body)

		for k, v := range formParams {
			for _, iv := range v {
				if strings.HasPrefix(k, "@") { // file
					err = addFile(w, k[1:], iv)
					if err != nil {
						return nil, err
					}
				} else { // form value
					w.WriteField(k, iv)
				}
			}
		}
		if len(fileBytes) > 0 && fileName != "" {
			w.Boundary()
			//_, fileNm := filepath.Split(fileName)
			part, err := w.CreateFormFile(formFileName, filepath.Base(fileName))
			if err != nil {
				return nil, err
			}
			_, err = part.Write(fileBytes)
			if err != nil {
				return nil, err
			}
			// Set the Boundary in the Content-Type
			headerParams["Content-Type"] = w.FormDataContentType()
		}

		// Set Content-Length
		headerParams["Content-Length"] = fmt.Sprintf("%d", body.Len())
		w.Close()
	}

	if strings.HasPrefix(headerParams["Content-Type"], "application/x-www-form-urlencoded") && len(formParams) > 0 {
		if body != nil {
			return nil, errors.New("Cannot specify postBody and x-www-form-urlencoded form at the same time.")
		}
		body = &bytes.Buffer{}
		body.WriteString(formParams.Encode())
		// Set Content-Length
		headerParams["Content-Length"] = fmt.Sprintf("%d", body.Len())
	}

	// Setup path and query parameters
	url, err := url.Parse(path)
	if err != nil {
		return nil, err
	}

	// Adding Query Param
	query := url.Query()
	for k, v := range queryParams {
		for _, iv := range v {
			query.Add(k, iv)
		}
	}

	// Encode the parameters.
	url.RawQuery = query.Encode()

	// Generate a new request
	if body != nil {
		localVarRequest, err = http.NewRequest(method, url.String(), body)
	} else {
		localVarRequest, err = http.NewRequest(method, url.String(), nil)
	}
	if err != nil {
		return nil, err
	}

	// add header parameters, if any
	if len(headerParams) > 0 {
		headers := http.Header{}
		for h, v := range headerParams {
			headers.Set(h, v)
		}
		localVarRequest.Header = headers
	}

	// Override request host, if applicable
	if c.cfg.host != "" {
		localVarRequest.Host = c.cfg.host
	}

	// Add the user agent to the request.
	localVarRequest.Header.Add("User-Agent", c.cfg.userAgent)

	if opts.ctx != nil {
		// add context to the request
		localVarRequest = localVarRequest.WithContext(opts.ctx)
	}

	// Basic HTTP Authentication
	if c.cfg.username == "" || c.cfg.password == "" {
		return nil, errors.New("unauthorized APIClient")
	}
	localVarRequest.SetBasicAuth(c.cfg.username, c.cfg.password)

	return localVarRequest, nil
}

func (c *APIClient) decode(v interface{}, b []byte, contentType string) (err error) {
	if strings.Contains(contentType, "application/xml") {
		if err = xml.Unmarshal(b, v); err != nil {
			return err
		}
		return nil
	} else if strings.Contains(contentType, "application/json") {
		if err = json.Unmarshal(b, v); err != nil {
			return err
		}
		return nil
	}
	return errors.New("undefined response type")
}

// Add a file to the multipart request
func addFile(w *multipart.Writer, fieldName, path string) error {
	file, err := os.Open(path)
	if err != nil {
		return err
	}
	defer file.Close()

	part, err := w.CreateFormFile(fieldName, filepath.Base(path))
	if err != nil {
		return err
	}
	_, err = io.Copy(part, file)

	return err
}

// Prevent trying to import "fmt"
func reportError(format string, a ...interface{}) error {
	return fmt.Errorf(format, a...)
}

// Set request body from an interface{}
func setBody(body interface{}, contentType string) (bodyBuf *bytes.Buffer, err error) {
	if bodyBuf == nil {
		bodyBuf = &bytes.Buffer{}
	}

	if reader, ok := body.(io.Reader); ok {
		_, err = bodyBuf.ReadFrom(reader)
	} else if b, ok := body.([]byte); ok {
		_, err = bodyBuf.Write(b)
	} else if s, ok := body.(string); ok {
		_, err = bodyBuf.WriteString(s)
	} else if s, ok := body.(*string); ok {
		_, err = bodyBuf.WriteString(*s)
	} else if jsonCheck.MatchString(contentType) {
		err = json.NewEncoder(bodyBuf).Encode(body)
	} else if xmlCheck.MatchString(contentType) {
		xml.NewEncoder(bodyBuf).Encode(body)
	}

	if err != nil {
		return nil, err
	}

	if bodyBuf.Len() == 0 {
		err = fmt.Errorf("Invalid body type %s\n", contentType)
		return nil, err
	}
	return bodyBuf, nil
}

// detectContentType method is used to figure out `Request.Body` content type for request header
func detectContentType(body interface{}) string {
	contentType := "text/plain; charset=utf-8"
	kind := reflect.TypeOf(body).Kind()

	switch kind {
	case reflect.Struct, reflect.Map, reflect.Ptr:
		contentType = "application/json; charset=utf-8"
	case reflect.String:
		contentType = "text/plain; charset=utf-8"
	default:
		if b, ok := body.([]byte); ok {
			contentType = http.DetectContentType(b)
		} else if kind == reflect.Slice {
			contentType = "application/json; charset=utf-8"
		}
	}

	return contentType
}

func strlen(s string) int {
	return utf8.RuneCountInString(s)
}

// APIOption sets options for API calls.
type APIOption func(*APIOptions)

// APIOptions wraps internal API call options.
type APIOptions struct {
	ctx    context.Context
	params interface{}
}

// WithContext returns an APIOption that sets the context for an API call.
func WithContext(ctx context.Context) APIOption {
	return func(o *APIOptions) {
		o.ctx = ctx
	}
}

// WithParams returns an APIOption that sets the params for an API call. The params provided must be the correct type for the call or an error will be thrown by the call.
func WithParams(params interface{}) APIOption {
	return func(o *APIOptions) {
		o.params = params
	}
}

func isSet(val interface{}) bool {
	return !(val == nil || reflect.DeepEqual(val, reflect.Zero(reflect.TypeOf(val)).Interface()))
}

// GenericOpenAPIError Provides access to the body, error and model on returned errors.
type GenericOpenAPIError struct {
	body  []byte
	error string
	model interface{}
}

// Error returns non-empty string if there was an error.
func (e GenericOpenAPIError) Error() string {
	return e.error
}

// Body returns the raw bytes of the response
func (e GenericOpenAPIError) Body() []byte {
	return e.body
}

// Model returns the unpacked model of the error
func (e GenericOpenAPIError) Model() interface{} {
	return e.model
}

// Below are the custom Mux API Error types, so that users of the SDK can identify
// what issue they're running into more easily.

// Generic 400 error
type BadRequestError struct {
	body  []byte
	error string
}

func (e BadRequestError) Error() string {
	return e.error
}

// 401 Error
type UnauthorizedError struct {
	body  []byte
	error string
}

func (e UnauthorizedError) Error() string {
	return e.error
}

func (e UnauthorizedError) Body() []byte {
	return e.body
}

// 403 Error
type ForbiddenError struct {
	body  []byte
	error string
}

func (e ForbiddenError) Error() string {
	return e.error
}

func (e ForbiddenError) Body() []byte {
	return e.body
}

// 404 Error
type NotFoundError struct {
	body  []byte
	error string
}

func (e NotFoundError) Error() string {
	return e.error
}

func (e NotFoundError) Body() []byte {
	return e.body
}

// 429 Error
type TooManyRequestsError struct {
	body  []byte
	error string
}

func (e TooManyRequestsError) Error() string {
	return e.error
}

func (e TooManyRequestsError) Body() []byte {
	return e.body
}

// 5XX Error
type ServiceError struct {
	body   []byte
	status int
	error  string
}

func (e ServiceError) Error() string {
	return e.error
}

func (e ServiceError) Body() []byte {
	return e.body
}

func (e ServiceError) Code() int {
	return e.status
}

// Helper to check for common non-200 errors
func CheckForHttpError(code int, body []byte) error {

	if code >= 200 && code <= 299 {
		return nil
	}

	switch code {
	case 400:
		return BadRequestError{body: body, error: "Bad Request"}
	case 401:
		return UnauthorizedError{body: body, error: "Unauthorized"}
	case 403:
		return ForbiddenError{body: body, error: "Forbidden"}
	case 404:
		return NotFoundError{body: body, error: "Not Found"}
	case 429:
		return TooManyRequestsError{body: body, error: "Too Many Requests"}
	}

	if code >= 500 && code <= 599 {
		return ServiceError{body: body, status: code, error: "Service Error"}
	}

	return GenericOpenAPIError{body: body, error: "Generic Error"}
}