bambou

type Error ¶

type Error struct {
	Title       string `json:"title"`
	Description string `json:"description"`
}

func NewBambouError(title, description string) *Error

func NewError(code int, description string) *Error

func (be *Error) Error() string

type Event ¶

type Event struct {
	DataMap         []map[string]interface{} `json:"entities"`
	Data            []byte                   `json:"-"`
	EntityType      string                   `json:"entityType"`
	Type            string                   `json:"type"`
	UpdateMechanism string                   `json:"updateMechanism"`
}

Event represents one item of a Notification. It will contain data from the server regarding the object that has been created, deleted, or modified.

type EventHandler ¶

type EventHandler func(*Event)

EventHandler is prototype of a Push Center Handler.

type EventsList ¶

type EventsList []*Event

EventsList represents a list of *Event.

type FetchingInfo ¶

type FetchingInfo struct {
	Filter     string
	FilterType string
	GroupBy    []string
	OrderBy    string
	Page       int
	PageSize   int
	TotalCount int
}

FetchingInfo is a structure that contains differents values about the fetching of children, either for the user to set, of for the server to fill. This structure will be used to pass and get back information during the fetching of some children.

func NewFetchingInfo() *FetchingInfo

func (f *FetchingInfo) String() string

type Identifiable ¶

type Identifiable interface {

	// Identity returns the Identity of the of the receiver.
	Identity() Identity

	// Identifier returns the unique identifier of the of the receiver.
	Identifier() string

	// SetIdentifier sets the unique identifier of the of the receiver.
	SetIdentifier(string)
}

Identifiable is the interface that object which have Identity must implement.

type IdentifiablesList ¶

type IdentifiablesList []Identifiable

IdentifiablesList is a list of objects implementing the Identifiable interface.

type Identity ¶

type Identity struct {
	Name     string
	Category string
}

Identity is a structure that contains the necessary information about an Identifiable. The Name is usually the singular form of the Category. For instance, "enterprise" and "enterprises".

func (i Identity) String() string

type Notification ¶

type Notification struct {
	Events EventsList `json:"events"`
	UUID   string     `json:"uuid"`
}

Notification represents a collection of Event structures. It also contains a identifier for the Notification.

func NewNotification() *Notification

type NotificationsChannel ¶

type NotificationsChannel chan *Notification

NotificationsChannel is used to received notification from the session

type PushCenter ¶

type PushCenter struct {
	Channel NotificationsChannel
	// contains filtered or unexported fields
}

PushCenter is a structure that allows the user to deal with notifications. You can register multiple handlers for several Identity. When a notification is sent by the server and the Identity of its content matches one of the registered handler, this handler will be called.

func NewPushCenter(session *Session) *PushCenter

func (p *PushCenter) HasHandlerForIdentity(identity Identity) bool

func (p *PushCenter) RegisterHandlerForIdentity(handler EventHandler, identity Identity)

func (p *PushCenter) Start() error

func (p *PushCenter) Stop() error

func (p *PushCenter) UnregisterHandlerForIdentity(identity Identity)

type Rootable ¶

type Rootable interface {
	Identifiable

	// APIKey returns the token that will be used to authentify the communication
	// between a Storer and the backend.
	APIKey() string

	// SetAPIKey sets the token used by the Storer.
	SetAPIKey(string)
}

Rootable is the interface that must be implemented by the root object of the API. A Rootable also implements the Identifiable interface.

type Session ¶

type Session struct {
	Certificate  *tls.Certificate
	Username     string
	Password     string
	Organization string
	URL          string
	// contains filtered or unexported fields
}

Session represents a user session. It provides the entire communication layer with the backend. It must implement the Operationable interface. A session can be authenticated via 1) TLS certificates or 2) user + password (different API endpoints)

func NewSession(username, password, organization, url string, root Rootable) *Session

func NewX509Session(cert *tls.Certificate, url string, root Rootable) *Session

func (s *Session) AssignChildren(parent Identifiable, children []Identifiable, identity Identity) *Error

func (s *Session) CreateChild(parent Identifiable, child Identifiable) *Error

func (s *Session) DeleteEntity(object Identifiable) *Error

func (s *Session) FetchChildren(parent Identifiable, identity Identity, dest interface{}, info *FetchingInfo) *Error

func (s *Session) FetchEntity(object Identifiable) *Error

func (s *Session) NextEvent(channel NotificationsChannel, lastEventID string) *Error

func (s *Session) Reset()

func (s *Session) Root() Rootable

func (s *Session) SaveEntity(object Identifiable) *Error

func (s *Session) SetInsecureSkipVerify(skip bool) *Error

func (s *Session) Start() *Error

type Storer ¶

type Storer interface {
	Start() *Error
	Reset()
	Root() Rootable

	FetchEntity(Identifiable) *Error
	SaveEntity(Identifiable) *Error
	DeleteEntity(Identifiable) *Error
	FetchChildren(Identifiable, Identity, interface{}, *FetchingInfo) *Error
	CreateChild(Identifiable, Identifiable) *Error
	AssignChildren(Identifiable, []Identifiable, Identity) *Error
	NextEvent(NotificationsChannel, string) *Error
}

Storer is the interface that must be implemented by object that can perform CRUD operations on RemoteObjects.

func CurrentSession() Storer

type VsdError ¶

type VsdError struct {
	Property     string  `json:"property"`
	Descriptions []Error `json:"descriptions"` // XXX -- note
}

type VsdErrorList ¶

type VsdErrorList struct {
	VsdErrors    []VsdError `json:"errors"`
	VsdErrorCode int        `json:"internalErrorCode"`
}