pkg/database/cosmosdb/zz_generated_subscriptiondocument.go

// Code generated by github.com/bennerv/go-cosmosdb, DO NOT EDIT.

package cosmosdb

import (
	"context"
	"net/http"
	"strconv"
	"strings"

	pkg "github.com/Azure/ARO-RP/pkg/api"
)

type subscriptionDocumentClient struct {
	*databaseClient
	path string
}

// SubscriptionDocumentClient is a subscriptionDocument client
type SubscriptionDocumentClient interface {
	Create(context.Context, string, *pkg.SubscriptionDocument, *Options) (*pkg.SubscriptionDocument, error)
	List(*Options) SubscriptionDocumentIterator
	ListAll(context.Context, *Options) (*pkg.SubscriptionDocuments, error)
	Get(context.Context, string, string, *Options) (*pkg.SubscriptionDocument, error)
	Replace(context.Context, string, *pkg.SubscriptionDocument, *Options) (*pkg.SubscriptionDocument, error)
	Delete(context.Context, string, *pkg.SubscriptionDocument, *Options) error
	Query(string, *Query, *Options) SubscriptionDocumentRawIterator
	QueryAll(context.Context, string, *Query, *Options) (*pkg.SubscriptionDocuments, error)
	ChangeFeed(*Options) SubscriptionDocumentIterator
}

type subscriptionDocumentChangeFeedIterator struct {
	*subscriptionDocumentClient
	continuation string
	options      *Options
}

type subscriptionDocumentListIterator struct {
	*subscriptionDocumentClient
	continuation string
	done         bool
	options      *Options
}

type subscriptionDocumentQueryIterator struct {
	*subscriptionDocumentClient
	partitionkey string
	query        *Query
	continuation string
	done         bool
	options      *Options
}

// SubscriptionDocumentIterator is a subscriptionDocument iterator
type SubscriptionDocumentIterator interface {
	Next(context.Context, int) (*pkg.SubscriptionDocuments, error)
	Continuation() string
}

// SubscriptionDocumentRawIterator is a subscriptionDocument raw iterator
type SubscriptionDocumentRawIterator interface {
	SubscriptionDocumentIterator
	NextRaw(context.Context, int, interface{}) error
}

// NewSubscriptionDocumentClient returns a new subscriptionDocument client
func NewSubscriptionDocumentClient(collc CollectionClient, collid string) SubscriptionDocumentClient {
	return &subscriptionDocumentClient{
		databaseClient: collc.(*collectionClient).databaseClient,
		path:           collc.(*collectionClient).path + "/colls/" + collid,
	}
}

func (c *subscriptionDocumentClient) all(ctx context.Context, i SubscriptionDocumentIterator) (*pkg.SubscriptionDocuments, error) {
	allsubscriptionDocuments := &pkg.SubscriptionDocuments{}

	for {
		subscriptionDocuments, err := i.Next(ctx, -1)
		if err != nil {
			return nil, err
		}
		if subscriptionDocuments == nil {
			break
		}

		allsubscriptionDocuments.Count += subscriptionDocuments.Count
		allsubscriptionDocuments.ResourceID = subscriptionDocuments.ResourceID
		allsubscriptionDocuments.SubscriptionDocuments = append(allsubscriptionDocuments.SubscriptionDocuments, subscriptionDocuments.SubscriptionDocuments...)
	}

	return allsubscriptionDocuments, nil
}

func (c *subscriptionDocumentClient) Create(ctx context.Context, partitionkey string, newsubscriptionDocument *pkg.SubscriptionDocument, options *Options) (subscriptionDocument *pkg.SubscriptionDocument, err error) {
	headers := http.Header{}
	headers.Set("X-Ms-Documentdb-Partitionkey", `["`+partitionkey+`"]`)

	if options == nil {
		options = &Options{}
	}
	options.NoETag = true

	err = c.setOptions(options, newsubscriptionDocument, headers)
	if err != nil {
		return
	}

	err = c.do(ctx, http.MethodPost, c.path+"/docs", "docs", c.path, http.StatusCreated, &newsubscriptionDocument, &subscriptionDocument, headers)
	return
}

func (c *subscriptionDocumentClient) List(options *Options) SubscriptionDocumentIterator {
	continuation := ""
	if options != nil {
		continuation = options.Continuation
	}

	return &subscriptionDocumentListIterator{subscriptionDocumentClient: c, options: options, continuation: continuation}
}

func (c *subscriptionDocumentClient) ListAll(ctx context.Context, options *Options) (*pkg.SubscriptionDocuments, error) {
	return c.all(ctx, c.List(options))
}

func (c *subscriptionDocumentClient) Get(ctx context.Context, partitionkey, subscriptionDocumentid string, options *Options) (subscriptionDocument *pkg.SubscriptionDocument, err error) {
	headers := http.Header{}
	headers.Set("X-Ms-Documentdb-Partitionkey", `["`+partitionkey+`"]`)

	err = c.setOptions(options, nil, headers)
	if err != nil {
		return
	}

	err = c.do(ctx, http.MethodGet, c.path+"/docs/"+subscriptionDocumentid, "docs", c.path+"/docs/"+subscriptionDocumentid, http.StatusOK, nil, &subscriptionDocument, headers)
	return
}

func (c *subscriptionDocumentClient) Replace(ctx context.Context, partitionkey string, newsubscriptionDocument *pkg.SubscriptionDocument, options *Options) (subscriptionDocument *pkg.SubscriptionDocument, err error) {
	headers := http.Header{}
	headers.Set("X-Ms-Documentdb-Partitionkey", `["`+partitionkey+`"]`)

	err = c.setOptions(options, newsubscriptionDocument, headers)
	if err != nil {
		return
	}

	err = c.do(ctx, http.MethodPut, c.path+"/docs/"+newsubscriptionDocument.ID, "docs", c.path+"/docs/"+newsubscriptionDocument.ID, http.StatusOK, &newsubscriptionDocument, &subscriptionDocument, headers)
	return
}

func (c *subscriptionDocumentClient) Delete(ctx context.Context, partitionkey string, subscriptionDocument *pkg.SubscriptionDocument, options *Options) (err error) {
	headers := http.Header{}
	headers.Set("X-Ms-Documentdb-Partitionkey", `["`+partitionkey+`"]`)

	err = c.setOptions(options, subscriptionDocument, headers)
	if err != nil {
		return
	}

	err = c.do(ctx, http.MethodDelete, c.path+"/docs/"+subscriptionDocument.ID, "docs", c.path+"/docs/"+subscriptionDocument.ID, http.StatusNoContent, nil, nil, headers)
	return
}

func (c *subscriptionDocumentClient) Query(partitionkey string, query *Query, options *Options) SubscriptionDocumentRawIterator {
	continuation := ""
	if options != nil {
		continuation = options.Continuation
	}

	return &subscriptionDocumentQueryIterator{subscriptionDocumentClient: c, partitionkey: partitionkey, query: query, options: options, continuation: continuation}
}

func (c *subscriptionDocumentClient) QueryAll(ctx context.Context, partitionkey string, query *Query, options *Options) (*pkg.SubscriptionDocuments, error) {
	return c.all(ctx, c.Query(partitionkey, query, options))
}

func (c *subscriptionDocumentClient) ChangeFeed(options *Options) SubscriptionDocumentIterator {
	continuation := ""
	if options != nil {
		continuation = options.Continuation
	}

	return &subscriptionDocumentChangeFeedIterator{subscriptionDocumentClient: c, options: options, continuation: continuation}
}

func (c *subscriptionDocumentClient) setOptions(options *Options, subscriptionDocument *pkg.SubscriptionDocument, headers http.Header) error {
	if options == nil {
		return nil
	}

	if subscriptionDocument != nil && !options.NoETag {
		if subscriptionDocument.ETag == "" {
			return ErrETagRequired
		}
		headers.Set("If-Match", subscriptionDocument.ETag)
	}
	if len(options.PreTriggers) > 0 {
		headers.Set("X-Ms-Documentdb-Pre-Trigger-Include", strings.Join(options.PreTriggers, ","))
	}
	if len(options.PostTriggers) > 0 {
		headers.Set("X-Ms-Documentdb-Post-Trigger-Include", strings.Join(options.PostTriggers, ","))
	}
	if len(options.PartitionKeyRangeID) > 0 {
		headers.Set("X-Ms-Documentdb-PartitionKeyRangeID", options.PartitionKeyRangeID)
	}

	return nil
}

func (i *subscriptionDocumentChangeFeedIterator) Next(ctx context.Context, maxItemCount int) (subscriptionDocuments *pkg.SubscriptionDocuments, err error) {
	headers := http.Header{}
	headers.Set("A-IM", "Incremental feed")

	headers.Set("X-Ms-Max-Item-Count", strconv.Itoa(maxItemCount))
	if i.continuation != "" {
		headers.Set("If-None-Match", i.continuation)
	}

	err = i.setOptions(i.options, nil, headers)
	if err != nil {
		return
	}

	err = i.do(ctx, http.MethodGet, i.path+"/docs", "docs", i.path, http.StatusOK, nil, &subscriptionDocuments, headers)
	if IsErrorStatusCode(err, http.StatusNotModified) {
		err = nil
	}
	if err != nil {
		return
	}

	i.continuation = headers.Get("Etag")

	return
}

func (i *subscriptionDocumentChangeFeedIterator) Continuation() string {
	return i.continuation
}

func (i *subscriptionDocumentListIterator) Next(ctx context.Context, maxItemCount int) (subscriptionDocuments *pkg.SubscriptionDocuments, err error) {
	if i.done {
		return
	}

	headers := http.Header{}
	headers.Set("X-Ms-Max-Item-Count", strconv.Itoa(maxItemCount))
	if i.continuation != "" {
		headers.Set("X-Ms-Continuation", i.continuation)
	}

	err = i.setOptions(i.options, nil, headers)
	if err != nil {
		return
	}

	err = i.do(ctx, http.MethodGet, i.path+"/docs", "docs", i.path, http.StatusOK, nil, &subscriptionDocuments, headers)
	if err != nil {
		return
	}

	i.continuation = headers.Get("X-Ms-Continuation")
	i.done = i.continuation == ""

	return
}

func (i *subscriptionDocumentListIterator) Continuation() string {
	return i.continuation
}

func (i *subscriptionDocumentQueryIterator) Next(ctx context.Context, maxItemCount int) (subscriptionDocuments *pkg.SubscriptionDocuments, err error) {
	err = i.NextRaw(ctx, maxItemCount, &subscriptionDocuments)
	return
}

func (i *subscriptionDocumentQueryIterator) NextRaw(ctx context.Context, maxItemCount int, raw interface{}) (err error) {
	if i.done {
		return
	}

	headers := http.Header{}
	headers.Set("X-Ms-Max-Item-Count", strconv.Itoa(maxItemCount))
	headers.Set("X-Ms-Documentdb-Isquery", "True")
	headers.Set("Content-Type", "application/query+json")
	if i.partitionkey != "" {
		headers.Set("X-Ms-Documentdb-Partitionkey", `["`+i.partitionkey+`"]`)
	} else {
		headers.Set("X-Ms-Documentdb-Query-Enablecrosspartition", "True")
	}
	if i.continuation != "" {
		headers.Set("X-Ms-Continuation", i.continuation)
	}

	err = i.setOptions(i.options, nil, headers)
	if err != nil {
		return
	}

	err = i.do(ctx, http.MethodPost, i.path+"/docs", "docs", i.path, http.StatusOK, &i.query, &raw, headers)
	if err != nil {
		return
	}

	i.continuation = headers.Get("X-Ms-Continuation")
	i.done = i.continuation == ""

	return
}

func (i *subscriptionDocumentQueryIterator) Continuation() string {
	return i.continuation
}