base

type AccessOptions struct {
	Token security.SecurityToken
	Roles security.Attributes
}

type AccessVoter struct {
}

type DatabaseNodeHandler interface {
	PreUpdate(node *Node, m NodeManager) error
	PostUpdate(node *Node, m NodeManager) error
	PreInsert(node *Node, m NodeManager) error
	PostInsert(node *Node, m NodeManager) error
}

type DownloadData struct {
	ContentType  string
	Filename     string
	CacheControl string
	Pragma       string
	Expires      string
	Stream       func(node *Node, w io.Writer)
}

type DownloadNodeHandler interface {
	GetDownloadData(node *Node) *DownloadData
}

type Errors map[string][]string

type Handler interface {
	GetStruct() (NodeData, NodeMeta) // Data, Meta
}

type HandlerCollection map[string]Handler

type HandlerMetadata struct {
	Name        string   `json:"name"`
	Description string   `json:"description"`
	Icon        string   `json:"icon"`
	Code        string   `json:"code"`
	Require     []string `json:"require"`
	Authors     []string `json:"authors"`
}

type HandlerViewMetadata struct {
	Name        string   `json:"name"`
	Description string   `json:"description"`
	Icon        string   `json:"icon"`
	Code        string   `json:"code"`
	Require     []string `json:"require"`
	Authors     []string `json:"authors"`
}

type Handlers interface {
	NewNode(t string) *Node
	Get(node *Node) Handler
	GetByType(code string) Handler
	GetTypes() []string
	HasType(code string) bool
}

type HttpClient interface {
	Do(req *http.Request) (resp *http.Response, err error)
	Get(url string) (resp *http.Response, err error)
	Head(url string) (resp *http.Response, err error)
	Post(url string, bodyType string, body io.Reader) (resp *http.Response, err error)
	PostForm(url string, data url.Values) (resp *http.Response, err error)
}

type Listener interface {
	Handle(notification *pq.Notification, manager NodeManager) (int, error)
}

type LoadNodeHandler interface {
	Load(data []byte, meta []byte, node *Node) error
}

type MetadataHandler interface {
	GetMetadata() *HandlerMetadata
}

type MockedManager struct {
	mock.Mock
}

type ModelEvent struct {
	Subject     string    `json:"subject"`
	Action      string    `json:"action"`
	Type        string    `json:"type"`
	Revision    int       `json:"revision"`
	Date        time.Time `json:"date"`
	Extra       string    `json:"extra"`
	Name        string    `json:"name"`
	NewRevision bool      `json:"new_revision"`
}

type Modules map[string]interface{}

type Node struct {
	Id         int         `json:"-"`
	Uuid       Reference   `json:"uuid"`
	Type       string      `json:"type"`
	Name       string      `json:"name"`
	Slug       string      `json:"slug"`
	Path       string      `json:"path"`
	Data       interface{} `json:"data"`
	Meta       interface{} `json:"meta"`
	Status     int         `json:"status"`
	Weight     int         `json:"weight"`
	Revision   int         `json:"revision"`
	Version    int         `json:"version"`
	CreatedAt  time.Time   `json:"created_at"`
	UpdatedAt  time.Time   `json:"updated_at"`
	Enabled    bool        `json:"enabled"`
	Deleted    bool        `json:"deleted"`
	Parents    []Reference `json:"parents"`
	UpdatedBy  Reference   `json:"updated_by"`
	CreatedBy  Reference   `json:"created_by"`
	ParentUuid Reference   `json:"parent_uuid"`
	SetUuid    Reference   `json:"set_uuid"`
	Source     Reference   `json:"source"`
	Modules    Modules     `json:"modules"`
	Access     []string    `json:"access"` // key => roles required to access the nodes
}

type NodeData interface{}

type NodeDeserializer func(r io.Reader, node *Node) error

type NodeManager interface {
	SelectBuilder(option *SelectOptions) sq.SelectBuilder
	FindBy(query sq.SelectBuilder, offset uint64, limit uint64) *list.List
	FindOneBy(query sq.SelectBuilder) *Node
	Find(uuid Reference) *Node
	Remove(query sq.SelectBuilder) error
	RemoveOne(node *Node) (*Node, error)
	Save(node *Node, revision bool) (*Node, error)
	Notify(channel string, payload string)
	NewNode(t string) *Node
	Validate(node *Node) (bool, Errors)
	Move(uuid, parent Reference) (int64, error)
}

type NodeMeta interface{}

type NodeSerializer func(w io.Writer, node *Node) error

type PgNodeManager struct {
	Logger   *log.Logger
	Handlers Handlers
	Db       *sql.DB
	ReadOnly bool
	Prefix   string
}

type Reference struct {
	uuid.UUID
}

type SelectOptions struct {
	TableSuffix  string
	SelectClause string
}

type Serializer struct {
	Handlers Handlers
	// contains filtered or unexported fields
}

type StoreStreamNodeHandler interface {
	StoreStream(node *Node, r io.Reader) (int64, error)
}

type Subscriber struct {
	// contains filtered or unexported fields
}

type SubscriberHander func(notification *pq.Notification) (int, error)

type ValidateNodeHandler interface {
	Validate(node *Node, m NodeManager, e Errors)
}

type ViewHandler interface {
	Support(node *Node, request *ViewRequest, response *ViewResponse) bool
	Execute(node *Node, request *ViewRequest, response *ViewResponse) error
}

type ViewHandlerCollection map[string]ViewHandler

type ViewMetadataHandler interface {
	GetViewMetadata() *HandlerViewMetadata
}

type ViewRequest struct {
	Format      string
	HttpRequest *http.Request
	Context     web.C
}

type ViewResponse struct {
	StatusCode   int
	Template     string
	Context      template.Context
	HttpResponse http.ResponseWriter
	ContentType  string
}