api

type AppDB interface {
	Put(string, interface{})
	Get(string) interface{}
	Delete(string)
	Purge()
}

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

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

type ChannelConfiguration struct {
	Type      string
	Enabled   bool
	Port      string
	Baud      uint32
	Protocols []string
}

type CommChannelManager interface {
	GetChannelForProtocol(string) CommunicationChannel
	InitChannels([]ChannelConfiguration)
	Register(string, CommunicationChannel)

	ContainerAware
	SetFactory(Factory)
}

type CommunicationChannel interface {
	Start() error
	IsEnabled() bool
	GetName() string
	GetLabel() string
	AddProtocol(ProtocolHandler)
	GetProtocol(string) ProtocolHandler
	GetProtocols() map[string]ProtocolHandler
	Write(WriteRequest)

	SetChannelConfiguration(ChannelConfiguration)
	SetThingManager(ThingManager)
	SetFactory(Factory)
	SetEnvironment(Environment)
	ContainerAware
}

type Condition interface {
	Evaluate(when *RuleWhen, facts *RuleFacts, rule *Rule) bool
}

type Configuration struct {
	Name       string
	NodeID     string
	Db         string
	MaxProcs   uint8
	ServerPort uint16
	Channels   []ChannelConfiguration
	Mail       MailConfig
}

type Consequence interface {
	Execute(config map[string]interface{}, container Container)
}

type Container interface {
	CommChannelManager() CommChannelManager
	RulesManager() RulesManager
	ThingManager() ThingManager
	Env() Environment
	ScheduleService() ScheduleService
	DataSource() DataSource
	Factory() Factory
	ProtocolHandlers() map[string]ProtocolHandler
	ProtocolHandler(string) ProtocolHandler

	Channels() map[string]CommunicationChannel
	Channel(string) CommunicationChannel
}

type ContainerAware interface {
	SetContainer(Container)
	ValidateWiring()
}

type DataSource interface {
	PutThing(*Thing) Thing

	GetThingCount() int
	GetThings() []Thing

	GetEventsCountForThing(*Thing) int
	GetEventsCount() int
	GetEvents(int) []Event

	GetThingEvents(int, string) []Event

	CreateAppDB(*Thing) AppDB

	SaveThing(Thing)
	DeleteThing(Thing)

	PutEvent(*Event)
	SaveState(*Thing, map[string]interface{})
	ContainerAware

	SetEnvironment(Environment)
}

type Environment interface {
	GetUptime() string
	GetConfig() Configuration
	GetHome() string
	IsStartedUp() bool
	ContainerAware
}

type Event struct {
	Uid       string
	Thing     string
	Service   string
	Ts        time.Time
	ShortText string
	LongText  string
	Event     int
	Data      interface{}
}

type Factory interface {
	CreateCondition(string) Condition
	CreateConsequence(string) Consequence
	CreateChannelHandler(ChannelConfiguration) CommunicationChannel
	CreateProtocolHandler(string) ProtocolHandler
	CreateThingAdapter(string) ThingAdapter
	ContainerAware
}

type MailConfig struct {
	User string
	Pass string
	Host string
	Port uint16
}

type ProtocolHandler interface {
	OnStart()
	OnStop()
	GetName() string
	GetLabel() string
	OnRead(data ReadRequest)
	Write(*Thing, WriteRequest)

	GetChannel() CommunicationChannel
	SetChannel(CommunicationChannel)

	SetThingManager(ThingManager)
	SetFactory(Factory)
	SetEnvironment(Environment)
}

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

type Rule struct {
	Id          string
	Path        string
	Name        string
	Description string
	Enabled     bool
	Priority    byte
	Async       bool
	Buffer      int
	LastRun     time.Time
	Targets     []string
	When        []RuleWhen
	Then        []RuleThen
}

type RuleFacts struct {
	Target  string
	Thing   *Thing
	Service *ThingService
}

type RuleThen struct {
	Do     string
	Config map[string]interface{}
}

type RuleWhen struct {
	Target  string
	Service string
	Event   string
}

type RulesManager interface {
	GetRule(string) Rule
	GetRules() map[string]Rule
	Trigger(triggerType uint8, facts *RuleFacts)
	RegisterRule(Rule)

	ContainerAware
	SetThingManager(ThingManager)
	SetFactory(Factory)
}

type ScheduleService interface {
	Start()
	Stop()
	ContainerAware

	SetRulesManager(RulesManager)
	SetThingManager(ThingManager)
}

type State map[string]interface{}

type Thing struct {
	DatabaseId  bson.ObjectId                  `bson:"_id"`
	Id          string                         `bson:"uid"`
	Name        string                         `bson:"lbl"`
	Group       string                         `bson:"grp"`
	Class       string                         `bson:"c"`
	Type        string                         `bson:"tid"`
	Enabled     bool                           `bson:"en"`
	Description string                         `bson:"desc"`
	LogEvents   bool                           `bson:"logEvents"`
	Descriptor  ThingType                      `bson:",omitempty"`
	Attributes  map[string]ThingAttributeValue `bson:"attrs"`
	LastEvents  map[string]time.Time
	LastEvent   time.Time
	LastCycle   time.Time
	Data        map[string]interface{}  `bson:"data"`
	Content     string                  `bson:""`
	Services    map[string]ThingService `bson:"services"`
	State       State                   `bson:"state"`
}

type ThingAdapter interface {
	Cycle(*Thing)
	OnRead(*Thing, *ThingService, ReadRequest, ProtocolHandler) State
	OnWrite(*Thing, string, WriteRequest, AppDB, ProtocolHandler)
	GetEventText(*Thing, *ThingService, State) (shortText string, longText string)
}

type ThingAttribute struct {
	Name     string      `json:"name"`
	Type     string      `json:"type"`
	Config   bool        `json:"config"`
	Required bool        `json:"required"`
	Default  interface{} `json:"default"`
}

type ThingAttributeValue struct {
	Name  string      `bson:"n"`
	Value interface{} `bson:"v"`
}

type ThingData interface {
	GetData() map[string]interface{}
}

type ThingManager interface {
	GetThing(string) (Thing, bool)
	SaveThing(Thing)
	GetThingType(string) (ThingType, error)
	GetThingTypes() map[string]ThingType
	RegisterThingType(ThingType)
	RegisterThing(Thing)
	GetThings() []Thing
	Handle(*Thing, *ThingService, State)
	CreateThing(*Thing)
	RemoveThing(Thing)
	GetProtocolHandlerForThing(*Thing) ProtocolHandler

	LoadThings()

	Cycle()
	Actuate(*Thing, string, map[string]interface{})

	ContainerAware
	SetRulesManager(RulesManager)
	SetFactory(Factory)
	SetDataSource(DataSource)
	SetCommChannelManager(CommChannelManager)
}

type ThingOperation struct {
	Name        string
	Description string
	// contains filtered or unexported fields
}

type ThingOperationConfiguration struct {
}

type ThingService struct {
	Name      string `json:"name"`
	Label     string `json:"lbl"`
	LastEvent time.Time
}

type ThingType struct {
	TypeId            string `json:"tid"`
	LogEvents         bool   `json:"logEvents"`
	Name              string
	Description       string
	Protocol          string
	Vendor            string
	Model             string
	EventUpdateBuffer int
	Path              string
	Group             string
	CycleTime         int
	Operations        []ThingOperation
	Services          []ThingService
	Attributes        []ThingAttribute `json:"attributes"`
}

type Things []Thing

type WebAwareThing interface {
	HandleRequest(w http.ResponseWriter, req *http.Request)
	HandleOperation(w http.ResponseWriter, req *http.Request)
}

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