products.go

package apigee

import (
	"errors"
	"path"
)

const productsPath = "apiproducts"

// ProductsService is an interface for interfacing with the Apigee Edge Admin API
// dealing with apiproducts.
type ProductsService interface {
	Create(ApiProduct) (*ApiProduct, *Response, error)
	Delete(string) (*ApiProduct, *Response, error)
	Get(string) (*ApiProduct, *Response, error)
	List() ([]string, *Response, error)
	Update(ApiProduct) (*ApiProduct, *Response, error)
}

type ProductsServiceOp struct {
	client *ApigeeClient
}

var _ ProductsService = &ProductsServiceOp{}

// ApiProduct contains information about an API Product within an Edge organization.
type ApiProduct struct {
	ApiResources   []string    `json:"apiResources,omitempty"`
	ApprovalType   string      `json:"approvalType,omitempty"`
	Attributes     []Attribute `json:"attributes,omitempty"`
	CreatedAt      Timestamp   `json:"createdAt,omitempty"`
	CreatedBy      string      `json:"createdBy,omitempty"`
	Description    string      `json:"description,omitempty"`
	DisplayName    string      `json:"displayName,omitempty"`
	Environments   []string    `json:"environments,omitempty"`
	LastModifiedAt Timestamp   `json:"lastModifiedAt,omitempty"`
	LastModifiedBy string      `json:"lastModifiedBy,omitempty"`
	Name           string      `json:"name,omitempty"`
	Proxies        []string    `json:"proxies,omitempty"`
	Quota          string      `json:"quota,omitempty"`
	QuotaInterval  string      `json:"quotaInterval,omitempty"`
	QuotaTimeUnit  string      `json:"quotaTimeUnit,omitempty"`
	Scopes         []string    `json:"scopes,omitempty"`
}

func reallyUpdateProduct(s ProductsServiceOp, product ApiProduct) (*ApiProduct, *Response, error) {
	path := path.Join(productsPath, product.Name)
	req, e := s.client.NewRequest("POST", path, product)
	if e != nil {
		return nil, nil, e
	}
	returnedProduct := ApiProduct{}
	resp, e := s.client.Do(req, &returnedProduct)
	if e != nil {
		return nil, resp, e
	}
	return &returnedProduct, resp, e
}

func (s *ProductsServiceOp) Update(product ApiProduct) (*ApiProduct, *Response, error) {
	if product.Name == "" {
		return nil, nil, errors.New("must specify Name of ApiProduct to update")
	}

	if product.ApprovalType == "" || product.DisplayName == "" || product.Environments == nil {
		// The request is lacking some required information.
		// Must get the apiproduct first, to fill in these "required" parameters.
		retrievedProduct, resp, e := s.Get(product.Name)
		if e != nil {
			return nil, resp, e
		}
		if product.ApprovalType == "" {
			product.ApprovalType = retrievedProduct.ApprovalType
		}
		if product.DisplayName == "" {
			product.DisplayName = retrievedProduct.DisplayName
		}
		if product.Environments == nil {
			product.Environments = retrievedProduct.Environments
		}
	}

	// We have all required information...
	// If the caller has omitted the list of api proxies from the product,
	// this call will update the product to have no proxies!  Likewise
	// attributes.
	return reallyUpdateProduct(*s, product)
}

func (s *ProductsServiceOp) Create(product ApiProduct) (*ApiProduct, *Response, error) {
	req, e := s.client.NewRequest("POST", productsPath, product)
	if e != nil {
		return nil, nil, e
	}
	returnedProduct := ApiProduct{}
	resp, e := s.client.Do(req, &returnedProduct)
	if e != nil {
		return nil, resp, e
	}
	return &returnedProduct, resp, e
}

func (s *ProductsServiceOp) Delete(productName string) (*ApiProduct, *Response, error) {
	path := path.Join(productsPath, productName)
	req, e := s.client.NewRequest("DELETE", path, nil)
	if e != nil {
		return nil, nil, e
	}
	deletedProduct := ApiProduct{}
	resp, e := s.client.Do(req, &deletedProduct)
	if e != nil {
		return nil, resp, e
	}
	return &deletedProduct, resp, e
}

// List retrieves the list of apiproduct names for the organization referred by the ApigeeClient.
func (s *ProductsServiceOp) List() ([]string, *Response, error) {
	req, e := s.client.NewRequest("GET", productsPath, nil)
	if e != nil {
		return nil, nil, e
	}
	namelist := make([]string, 0)
	resp, e := s.client.Do(req, &namelist)
	if e != nil {
		return nil, resp, e
	}
	return namelist, resp, e
}

// Get retrieves the information about an API Product in an organization, information including
// the list of API Proxies, the scopes, the quota, and other attributes.
func (s *ProductsServiceOp) Get(productName string) (*ApiProduct, *Response, error) {
	path := path.Join(productsPath, productName)
	req, e := s.client.NewRequest("GET", path, nil)
	if e != nil {
		return nil, nil, e
	}
	returnedProduct := ApiProduct{}
	resp, e := s.client.Do(req, &returnedProduct)
	if e != nil {
		return nil, resp, e
	}
	return &returnedProduct, resp, e
}