api

package
v0.0.41 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jan 6, 2025 License: Apache-2.0 Imports: 17 Imported by: 0

Documentation

Index

Constants

View Source 
const DisplayNameAttributeKey = "shared/nickname"
View Source 
const DisplayNameAttributeOrigin = "shared"
View Source 
const UpdateOnlySameOriginAttributesKey = "update-only-same-origin-attributes"
View Source 
const WaitQueryParamName = "wait"

Variables

This section is empty.

Functions

func GetRouter added in v0.0.24 

func GetRouter(config config.Config, control Controller) http.Handler

GetRouter doc @title Device-Manager API @version 0.1 @license.name Apache 2.0 @license.url http://www.apache.org/licenses/LICENSE-2.0.html @BasePath / @securityDefinitions.apikey Bearer @in header @name Authorization @description Type "Bearer" followed by a space and JWT token.

func GetRouterWithoutMiddleware added in v0.0.24 

func GetRouterWithoutMiddleware(config config.Config, command Controller) http.Handler

func Start 

func Start(config config.Config, control Controller) (srv *http.Server, err error)

Types

type AspectEndpoints added in v0.0.24 

type AspectEndpoints struct{}

func (*AspectEndpoints) Create added in v0.0.24 

func (this *AspectEndpoints) Create(config config.Config, router *http.ServeMux, control Controller)

Create godoc @Summary create aspect @Description create aspect with generated id @Tags create, aspects @Produce json @Security Bearer @Param wait query bool false "wait for done message in kafka before responding" @Param message body models.Aspect true "element" @Success 200 {object} models.Aspect @Failure 400 @Failure 401 @Failure 403 @Failure 404 @Failure 500 @Router /aspects [POST]

func (*AspectEndpoints) Delete added in v0.0.24 

func (this *AspectEndpoints) Delete(config config.Config, router *http.ServeMux, control Controller)

Delete godoc @Summary delete aspect @Description delete aspect @Tags delete, aspects @Produce json @Security Bearer @Param id path string true "Aspect Id" @Param wait query bool false "wait for done message in kafka before responding" @Success 200 @Failure 400 @Failure 401 @Failure 403 @Failure 404 @Failure 500 @Router /aspects/{id} [DELETE]

func (*AspectEndpoints) Get added in v0.0.24 

func (this *AspectEndpoints) Get(config config.Config, router *http.ServeMux, control Controller)

Get godoc @Summary get aspect @Description get aspect @Tags get, aspects @Produce json @Security Bearer @Param id path string true "Aspect Id" @Success 200 {object} models.Aspect @Failure 400 @Failure 401 @Failure 403 @Failure 404 @Failure 500 @Router /aspects/{id} [GET]

func (*AspectEndpoints) Set added in v0.0.24 

func (this *AspectEndpoints) Set(config config.Config, router *http.ServeMux, control Controller)

Set godoc @Summary set aspect @Description set aspect @Tags set, aspects @Produce json @Security Bearer @Param id path string true "Aspect Id" @Param wait query bool false "wait for done message in kafka before responding" @Param message body models.Aspect true "element" @Success 200 {object} models.Aspect @Failure 400 @Failure 401 @Failure 403 @Failure 404 @Failure 500 @Router /aspects/{id} [PUT]

type CharacteristicsEndpoints 

type CharacteristicsEndpoints struct{}

func (*CharacteristicsEndpoints) Create added in v0.0.24 

func (this *CharacteristicsEndpoints) Create(config config.Config, router *http.ServeMux, control Controller)

Create godoc @Summary create characteristic @Description create characteristic @Tags create, characteristics @Produce json @Security Bearer @Param wait query bool false "wait for done message in kafka before responding" @Param message body models.Characteristic true "element" @Success 200 {object} models.Characteristic @Failure 400 @Failure 401 @Failure 403 @Failure 404 @Failure 500 @Router /characteristics [POST]

func (*CharacteristicsEndpoints) Delete added in v0.0.24 

func (this *CharacteristicsEndpoints) Delete(config config.Config, router *http.ServeMux, control Controller)

Delete godoc @Summary delete characteristic @Description delete characteristic @Tags delete, characteristics @Produce json @Security Bearer @Param id path string true "Characteristic Id" @Param wait query bool false "wait for done message in kafka before responding" @Success 200 @Failure 400 @Failure 401 @Failure 403 @Failure 404 @Failure 500 @Router /characteristics/{id} [DELETE]

func (*CharacteristicsEndpoints) Get added in v0.0.24 

func (this *CharacteristicsEndpoints) Get(config config.Config, router *http.ServeMux, control Controller)

Get godoc @Summary get characteristic @Description get characteristic @Tags get, characteristics @Produce json @Security Bearer @Param id path string true "Characteristics Id" @Success 200 {object} models.Characteristic @Failure 400 @Failure 401 @Failure 403 @Failure 404 @Failure 500 @Router /characteristics/{id} [GET]

func (*CharacteristicsEndpoints) Set added in v0.0.24 

func (this *CharacteristicsEndpoints) Set(config config.Config, router *http.ServeMux, control Controller)

Set godoc @Summary set characteristic @Description set characteristic @Tags set, characteristics @Produce json @Security Bearer @Param id path string true "Characteristic Id" @Param wait query bool false "wait for done message in kafka before responding" @Param message body models.Characteristic true "element" @Success 200 {object} models.Characteristic @Failure 400 @Failure 401 @Failure 403 @Failure 404 @Failure 500 @Router /characteristics/{id} [PUT]

type ConceptsEndpoints 

type ConceptsEndpoints struct{}

func (*ConceptsEndpoints) Create added in v0.0.24 

func (this *ConceptsEndpoints) Create(config config.Config, router *http.ServeMux, control Controller)

Create godoc @Summary create concept @Description create concept @Tags create, concepts @Produce json @Security Bearer @Param wait query bool false "wait for done message in kafka before responding" @Param message body models.Concept true "element" @Success 200 {object} models.Concept @Failure 400 @Failure 401 @Failure 403 @Failure 404 @Failure 500 @Router /concepts [POST]

func (*ConceptsEndpoints) Delete added in v0.0.24 

func (this *ConceptsEndpoints) Delete(config config.Config, router *http.ServeMux, control Controller)

Delete godoc @Summary delete concept @Description delete concept @Tags delete, concepts @Produce json @Security Bearer @Param id path string true "Concept Id" @Param wait query bool false "wait for done message in kafka before responding" @Success 200 @Failure 400 @Failure 401 @Failure 403 @Failure 404 @Failure 500 @Router /concepts/{id} [DELETE]

func (*ConceptsEndpoints) Get added in v0.0.24 

func (this *ConceptsEndpoints) Get(config config.Config, router *http.ServeMux, control Controller)

Get godoc @Summary get concept @Description get concept @Tags get, concepts @Produce json @Security Bearer @Param id path string true "Concept Id" @Success 200 {object} models.Concept @Failure 400 @Failure 401 @Failure 403 @Failure 404 @Failure 500 @Router /concepts/{id} [GET]

func (*ConceptsEndpoints) Set added in v0.0.24 

func (this *ConceptsEndpoints) Set(config config.Config, router *http.ServeMux, control Controller)

Set godoc @Summary set concept @Description set concept @Tags set, concepts @Produce json @Security Bearer @Param id path string true "Concept Id" @Param wait query bool false "wait for done message in kafka before responding" @Param message body models.Concept true "element" @Success 200 {object} models.Concept @Failure 400 @Failure 401 @Failure 403 @Failure 404 @Failure 500 @Router /concepts/{id} [PUT]

type Controller 

type Controller interface {
	ReadDeviceGroup(token auth.Token, id string) (device models.DeviceGroup, err error, code int)
	PublishDeviceGroupCreate(token auth.Token, dg models.DeviceGroup, options model.DeviceGroupUpdateOptions) (result models.DeviceGroup, err error, code int)
	PublishDeviceGroupUpdate(token auth.Token, id string, device models.DeviceGroup, options model.DeviceGroupUpdateOptions) (result models.DeviceGroup, err error, code int)
	PublishDeviceGroupDelete(token auth.Token, id string, options model.DeviceGroupDeleteOptions) (err error, code int)

	ReadDeviceType(token auth.Token, id string) (device models.DeviceType, err error, code int)
	PublishDeviceTypeCreate(token auth.Token, dt models.DeviceType, options model.DeviceTypeUpdateOptions) (result models.DeviceType, err error, code int)
	PublishDeviceTypeUpdate(token auth.Token, id string, dt models.DeviceType, options model.DeviceTypeUpdateOptions) (result models.DeviceType, err error, code int)
	PublishDeviceTypeDelete(token auth.Token, id string, options model.DeviceTypeDeleteOptions) (err error, code int)

	ListDevicesByQuery(token auth.Token, query url.Values) (devices []models.Device, err error, code int)
	ReadDevice(token auth.Token, id string) (device models.Device, err error, code int)
	ReadDeviceByLocalId(token auth.Token, ownerId string, localId string) (device models.Device, err error, errCode int)
	PublishDeviceCreate(token auth.Token, device models.Device, options model.DeviceCreateOptions) (result models.Device, err error, code int)
	PublishDeviceUpdate(token auth.Token, id string, device models.Device, options model.DeviceUpdateOptions) (result models.Device, err error, code int)
	PublishDeviceDelete(token auth.Token, id string, options model.DeviceDeleteOptions) (err error, code int)

	ReadHub(token auth.Token, id string) (hub models.Hub, err error, code int)
	PublishHubCreate(token auth.Token, hub models.Hub, options model.HubUpdateOptions) (result models.Hub, err error, code int)
	PublishHubUpdate(token auth.Token, id string, hub models.Hub, options model.HubUpdateOptions) (result models.Hub, err error, code int)
	PublishHubDelete(token auth.Token, id string, options model.HubDeleteOptions) (err error, code int)

	ReadProtocol(token auth.Token, id string) (device models.Protocol, err error, code int)
	PublishProtocolCreate(token auth.Token, protocol models.Protocol, options model.ProtocolUpdateOptions) (result models.Protocol, err error, code int)
	PublishProtocolUpdate(token auth.Token, id string, device models.Protocol, options model.ProtocolUpdateOptions) (result models.Protocol, err error, code int)
	PublishProtocolDelete(token auth.Token, id string, options model.ProtocolDeleteOptions) (err error, code int)

	ReadConcept(token auth.Token, id string) (device models.Concept, err error, code int)
	PublishConceptCreate(token auth.Token, concept models.Concept, options model.ConceptUpdateOptions) (result models.Concept, err error, code int)
	PublishConceptUpdate(token auth.Token, id string, concept models.Concept, options model.ConceptUpdateOptions) (result models.Concept, err error, code int)
	PublishConceptDelete(token auth.Token, id string, options model.ConceptDeleteOptions) (err error, code int)

	PublishCharacteristicCreate(token auth.Token, characteristic models.Characteristic, options model.CharacteristicUpdateOptions) (result models.Characteristic, err error, code int)
	PublishCharacteristicUpdate(token auth.Token, characteristicId string, characteristic models.Characteristic, options model.CharacteristicUpdateOptions) (result models.Characteristic, err error, code int)
	PublishCharacteristicDelete(token auth.Token, id string, options model.CharacteristicDeleteOptions) (err error, code int)
	ReadCharacteristic(token auth.Token, id string) (result models.Characteristic, err error, code int)

	DeviceLocalIdToId(token auth.Token, ownerId string, localId string) (id string, err error, errCode int)

	ReadAspect(token auth.Token, id string) (device models.Aspect, err error, code int)
	PublishAspectCreate(token auth.Token, aspect models.Aspect, options model.AspectUpdateOptions) (result models.Aspect, err error, code int)
	PublishAspectUpdate(token auth.Token, id string, aspect models.Aspect, options model.AspectUpdateOptions) (result models.Aspect, err error, code int)
	PublishAspectDelete(token auth.Token, id string, options model.AspectDeleteOptions) (err error, code int)

	ReadFunction(token auth.Token, id string) (device models.Function, err error, code int)
	PublishFunctionCreate(token auth.Token, f models.Function, options model.FunctionUpdateOptions) (result models.Function, err error, code int)
	PublishFunctionUpdate(token auth.Token, id string, device models.Function, options model.FunctionUpdateOptions) (result models.Function, err error, code int)
	PublishFunctionDelete(token auth.Token, id string, options model.FunctionDeleteOptions) (err error, code int)

	ReadDeviceClass(token auth.Token, id string) (device models.DeviceClass, err error, code int)
	PublishDeviceClassCreate(token auth.Token, dc models.DeviceClass, options model.DeviceClassUpdateOptions) (result models.DeviceClass, err error, code int)
	PublishDeviceClassUpdate(token auth.Token, id string, device models.DeviceClass, options model.DeviceClassUpdateOptions) (result models.DeviceClass, err error, code int)
	PublishDeviceClassDelete(token auth.Token, id string, options model.DeviceClassDeleteOptions) (err error, code int)

	ReadLocation(token auth.Token, id string) (device models.Location, err error, code int)
	PublishLocationCreate(token auth.Token, location models.Location, options model.LocationUpdateOptions) (result models.Location, err error, code int)
	PublishLocationUpdate(token auth.Token, id string, device models.Location, options model.LocationUpdateOptions) (result models.Location, err error, code int)
	PublishLocationDelete(token auth.Token, id string, options model.LocationDeleteOptions) (err error, code int)

	ValidateDistinctDeviceTypeAttributes(token auth.Token, devicetype models.DeviceType, attributeKeys []string) error
}

type DeviceClassesEndpoints 

type DeviceClassesEndpoints struct{}

func (*DeviceClassesEndpoints) Create added in v0.0.24 

func (this *DeviceClassesEndpoints) Create(config config.Config, router *http.ServeMux, control Controller)

Create godoc @Summary create device-class @Description create device-class @Tags create, device-classes @Produce json @Security Bearer @Param wait query bool false "wait for done message in kafka before responding" @Param message body models.DeviceClass true "element" @Success 200 {object} models.DeviceClass @Failure 400 @Failure 401 @Failure 403 @Failure 404 @Failure 500 @Router /device-classes [POST]

func (*DeviceClassesEndpoints) Delete added in v0.0.24 

func (this *DeviceClassesEndpoints) Delete(config config.Config, router *http.ServeMux, control Controller)

Delete godoc @Summary delete device-class @Description delete device-class @Tags delete, device-classes @Produce json @Security Bearer @Param id path string true "DeviceClass Id" @Param wait query bool false "wait for done message in kafka before responding" @Success 200 @Failure 400 @Failure 401 @Failure 403 @Failure 404 @Failure 500 @Router /device-classes/{id} [DELETE]

func (*DeviceClassesEndpoints) Get added in v0.0.24 

func (this *DeviceClassesEndpoints) Get(config config.Config, router *http.ServeMux, control Controller)

Get godoc @Summary get device-class @Description get device-class @Tags get, device-classes @Produce json @Security Bearer @Param id path string true "DeviceClass Id" @Success 200 {object} models.DeviceClass @Failure 400 @Failure 401 @Failure 403 @Failure 404 @Failure 500 @Router /device-classes/{id} [GET]

func (*DeviceClassesEndpoints) Set added in v0.0.24 

func (this *DeviceClassesEndpoints) Set(config config.Config, router *http.ServeMux, control Controller)

Set godoc @Summary set device-class @Description set device-class @Tags set, device-classes @Produce json @Security Bearer @Param id path string true "DeviceClass Id" @Param wait query bool false "wait for done message in kafka before responding" @Param message body models.DeviceClass true "element" @Success 200 {object} models.DeviceClass @Failure 400 @Failure 401 @Failure 403 @Failure 404 @Failure 500 @Router /device-classes/{id} [PUT]

type DeviceGroupsEndpoints 

type DeviceGroupsEndpoints struct{}

func (*DeviceGroupsEndpoints) Create added in v0.0.24 

func (this *DeviceGroupsEndpoints) Create(config config.Config, router *http.ServeMux, control Controller)

Create godoc @Summary create device-group @Description create device-group @Tags create, device-groups @Produce json @Security Bearer @Param wait query bool false "wait for done message in kafka before responding" @Param message body models.DeviceGroup true "element" @Success 200 {object} models.DeviceGroup @Failure 400 @Failure 401 @Failure 403 @Failure 404 @Failure 500 @Router /device-groups [POST]

func (*DeviceGroupsEndpoints) Delete added in v0.0.24 

func (this *DeviceGroupsEndpoints) Delete(config config.Config, router *http.ServeMux, control Controller)

Delete godoc @Summary delete device-group @Description delete device-group @Tags delete, device-groups @Produce json @Security Bearer @Param id path string true "DeviceGroup Id" @Param wait query bool false "wait for done message in kafka before responding" @Success 200 @Failure 400 @Failure 401 @Failure 403 @Failure 404 @Failure 500 @Router /device-groups/{id} [DELETE]

func (*DeviceGroupsEndpoints) Get added in v0.0.24 

func (this *DeviceGroupsEndpoints) Get(config config.Config, router *http.ServeMux, control Controller)

Get godoc @Summary get device-group @Description get device-group @Tags get, device-groups @Produce json @Security Bearer @Param id path string true "DeviceGroup Id" @Success 200 {object} models.DeviceGroup @Failure 400 @Failure 401 @Failure 403 @Failure 404 @Failure 500 @Router /device-groups/{id} [GET]

func (*DeviceGroupsEndpoints) Set added in v0.0.24 

func (this *DeviceGroupsEndpoints) Set(config config.Config, router *http.ServeMux, control Controller)

Set godoc @Summary set device-group @Description set device-group @Tags set, device-groups @Produce json @Security Bearer @Param id path string true "DeviceGroup Id" @Param wait query bool false "wait for done message in kafka before responding" @Param message body models.DeviceGroup true "element" @Success 200 {object} models.DeviceGroup @Failure 400 @Failure 401 @Failure 403 @Failure 404 @Failure 500 @Router /device-groups/{id} [PUT]

type DeviceTypesEndpoints 

type DeviceTypesEndpoints struct{}

func (*DeviceTypesEndpoints) Create added in v0.0.24 

func (this *DeviceTypesEndpoints) Create(config config.Config, router *http.ServeMux, control Controller)

Create godoc @Summary create device-type @Description create device-type @Tags create, device-types @Produce json @Security Bearer @Param wait query bool false "wait for done message in kafka before responding" @Param distinct_attributes query string false "comma separated list of attribute keys; no other device-type with the same attribute key/value may exist" @Param message body models.DeviceType true "element" @Success 200 {object} models.DeviceType @Failure 400 @Failure 401 @Failure 403 @Failure 404 @Failure 500 @Router /device-types [POST]

func (*DeviceTypesEndpoints) Delete added in v0.0.24 

func (this *DeviceTypesEndpoints) Delete(config config.Config, router *http.ServeMux, control Controller)

Delete godoc @Summary delete device-type @Description delete device-type @Tags delete, device-types @Produce json @Security Bearer @Param id path string true "DeviceType Id" @Param wait query bool false "wait for done message in kafka before responding" @Success 200 @Failure 400 @Failure 401 @Failure 403 @Failure 404 @Failure 500 @Router /device-types/{id} [DELETE]

func (*DeviceTypesEndpoints) Get added in v0.0.24 

func (this *DeviceTypesEndpoints) Get(config config.Config, router *http.ServeMux, control Controller)

Get godoc @Summary get device-type @Description get device-type @Tags get, device-types @Produce json @Security Bearer @Param id path string true "DeviceType Id" @Success 200 {object} models.DeviceType @Failure 400 @Failure 401 @Failure 403 @Failure 404 @Failure 500 @Router /device-types/{id} [GET]

func (*DeviceTypesEndpoints) Set added in v0.0.24 

func (this *DeviceTypesEndpoints) Set(config config.Config, router *http.ServeMux, control Controller)

Set godoc @Summary set device-type @Description set device-type @Tags set, device-types @Produce json @Security Bearer @Param id path string true "DeviceType Id" @Param wait query bool false "wait for done message in kafka before responding" @Param distinct_attributes query string false "comma separated list of attribute keys; no other device-type with the same attribute key/value may exist" @Param message body models.DeviceType true "element" @Success 200 {object} models.DeviceType @Failure 400 @Failure 401 @Failure 403 @Failure 404 @Failure 500 @Router /device-types/{id} [PUT]

type DevicesEndpoints 

type DevicesEndpoints struct{}

func (*DevicesEndpoints) Create added in v0.0.24 

func (this *DevicesEndpoints) Create(config config.Config, router *http.ServeMux, control Controller)

Create godoc @Summary create device @Description create device @Tags create, devices @Produce json @Security Bearer @Param wait query bool false "wait for done message in kafka before responding" @Param message body models.Device true "element" @Success 200 {object} models.Device @Failure 400 @Failure 401 @Failure 403 @Failure 404 @Failure 500 @Router /devices [POST]

func (*DevicesEndpoints) Delete added in v0.0.24 

func (this *DevicesEndpoints) Delete(config config.Config, router *http.ServeMux, control Controller)

Delete godoc @Summary delete device @Description delete device @Tags delete, devices @Produce json @Security Bearer @Param id path string true "Device Id" @Param wait query bool false "wait for done message in kafka before responding" @Success 200 @Failure 400 @Failure 401 @Failure 403 @Failure 404 @Failure 500 @Router /devices/{id} [DELETE]

func (*DevicesEndpoints) DeleteMany added in v0.0.24 

func (this *DevicesEndpoints) DeleteMany(config config.Config, router *http.ServeMux, control Controller)

DeleteMany godoc @Summary delete multiple devices @Description delete multiple devices @Tags delete, devices @Produce json @Security Bearer @Param wait query bool false "wait for done message in kafka before responding" @Param message body []string true "ids to be deleted" @Success 200 @Failure 400 @Failure 401 @Failure 403 @Failure 404 @Failure 500 @Router /devices [DELETE]

func (*DevicesEndpoints) Get added in v0.0.24 

func (this *DevicesEndpoints) Get(config config.Config, router *http.ServeMux, control Controller)

Get godoc @Summary get device @Description get device @Tags get, devices @Produce json @Security Bearer @Param id path string true "Device Id" @Success 200 {object} models.Device @Failure 400 @Failure 401 @Failure 403 @Failure 404 @Failure 500 @Router /devices/{id} [GET]

func (*DevicesEndpoints) List added in v0.0.24 

func (this *DevicesEndpoints) List(config config.Config, router *http.ServeMux, control Controller)

List godoc @Summary list devices @Description list devices @Tags list, devices @Produce json @Security Bearer @Param limit query integer false "default 100, will be ignored if 'ids' is set" @Param offset query integer false "default 0, will be ignored if 'ids' is set" @Param search query string false "filter" @Param sort query string false "default name.asc" @Param ids query string false "filter; ignores limit/offset; comma-seperated list" @Param device-type-ids query string false "filter; comma-seperated list" @Param attr-keys query string false "filter; comma-seperated list; lists elements only if they have an attribute key that is in the given list" @Param attr-values query string false "filter; comma-seperated list; lists elements only if they have an attribute value that is in the given list" @Param connection-state query integer false "filter; valid values are 'online', 'offline' and an empty string for unknown states" @Success 200 {array} models.Device @Failure 400 @Failure 401 @Failure 403 @Failure 404 @Failure 500 @Router /devices [GET]

func (*DevicesEndpoints) Set added in v0.0.24 

func (this *DevicesEndpoints) Set(config config.Config, router *http.ServeMux, control Controller)

Set godoc @Summary set device @Description set device; admins may create new devices but only without using the UpdateOnlySameOriginAttributesKey query parameter @Tags set, devices @Produce json @Security Bearer @Param id path string true "Device Id" @Param wait query bool false "wait for done message in kafka before responding" @Param update-only-same-origin-attributes query string false "comma separated list; ensure that no attribute from another origin is overwritten" @Param message body models.Device true "element" @Success 200 {object} models.Device @Failure 400 @Failure 401 @Failure 403 @Failure 404 @Failure 500 @Router /devices/{id} [PUT]

func (*DevicesEndpoints) SetAttributes added in v0.0.24 

func (this *DevicesEndpoints) SetAttributes(config config.Config, router *http.ServeMux, control Controller)

SetAttributes godoc @Summary set device attributes @Description set device attributes @Tags set, devices @Produce json @Security Bearer @Param id path string true "Device Id" @Param wait query bool false "wait for done message in kafka before responding" @Param update-only-same-origin-attributes query string false "comma separated list; ensure that no attribute from another origin is overwritten" @Param message body []models.Attribute true "attributes" @Success 200 {object} models.Device @Failure 400 @Failure 401 @Failure 403 @Failure 404 @Failure 500 @Router /devices/{id}/attributes [PUT]

func (*DevicesEndpoints) SetDisplayName added in v0.0.24 

func (this *DevicesEndpoints) SetDisplayName(config config.Config, router *http.ServeMux, control Controller)

SetDisplayName godoc @Summary set device display name @Description set device display name @Tags set, devices @Produce json @Security Bearer @Param id path string true "Device Id" @Param wait query bool false "wait for done message in kafka before responding" @Param message body string true "display name" @Success 200 {object} models.Device @Failure 400 @Failure 401 @Failure 403 @Failure 404 @Failure 500 @Router /devices/{id}/display_name [PUT]

type EndpointMethod added in v0.0.24 

type EndpointMethod = func(config config.Config, router *http.ServeMux, ctrl Controller)

type FunctionsEndpoints 

type FunctionsEndpoints struct{}

func (*FunctionsEndpoints) Create added in v0.0.24 

func (this *FunctionsEndpoints) Create(config config.Config, router *http.ServeMux, control Controller)

Create godoc @Summary create function @Description create function @Tags create, functions @Produce json @Security Bearer @Param wait query bool false "wait for done message in kafka before responding" @Param message body models.Function true "element" @Success 200 {object} models.Function @Failure 400 @Failure 401 @Failure 403 @Failure 404 @Failure 500 @Router /functions [POST]

func (*FunctionsEndpoints) Delete added in v0.0.24 

func (this *FunctionsEndpoints) Delete(config config.Config, router *http.ServeMux, control Controller)

Delete godoc @Summary delete function @Description delete function @Tags delete, functions @Produce json @Security Bearer @Param id path string true "Function Id" @Param wait query bool false "wait for done message in kafka before responding" @Success 200 @Failure 400 @Failure 401 @Failure 403 @Failure 404 @Failure 500 @Router /functions/{id} [DELETE]

func (*FunctionsEndpoints) Get added in v0.0.24 

func (this *FunctionsEndpoints) Get(config config.Config, router *http.ServeMux, control Controller)

Get godoc @Summary get function @Description get function @Tags get, functions @Produce json @Security Bearer @Param id path string true "Function Id" @Success 200 {object} models.Function @Failure 400 @Failure 401 @Failure 403 @Failure 404 @Failure 500 @Router /functions/{id} [GET]

func (*FunctionsEndpoints) Set added in v0.0.24 

func (this *FunctionsEndpoints) Set(config config.Config, router *http.ServeMux, control Controller)

Set godoc @Summary set function @Description set function @Tags set, functions @Produce json @Security Bearer @Param id path string true "Function Id" @Param wait query bool false "wait for done message in kafka before responding" @Param message body models.Function true "element" @Success 200 {object} models.Function @Failure 400 @Failure 401 @Failure 403 @Failure 404 @Failure 500 @Router /functions/{id} [PUT]

type HelperEndpoints added in v0.0.4 

type HelperEndpoints struct{}

func (*HelperEndpoints) Id added in v0.0.24 

func (this *HelperEndpoints) Id(config config.Config, router *http.ServeMux, control Controller)

Id godoc @Summary transforms short id to long id @Description transforms short id to long id @Tags helper @Produce json @Security Bearer @Param short_id query string true "short id" @Param prefix query string true "prefix added to generated long id" @Success 200 {object} string @Failure 400 @Router /helper/id [GET]

type HubsEndpoints 

type HubsEndpoints struct{}

func (*HubsEndpoints) Create added in v0.0.24 

func (this *HubsEndpoints) Create(config config.Config, router *http.ServeMux, control Controller)

Create godoc @Summary create hub @Description create hub @Tags create, hubs @Produce json @Security Bearer @Param wait query bool false "wait for done message in kafka before responding" @Param message body models.Hub true "element" @Success 200 {object} models.Hub @Failure 400 @Failure 401 @Failure 403 @Failure 404 @Failure 500 @Router /hubs [POST]

func (*HubsEndpoints) Delete added in v0.0.24 

func (this *HubsEndpoints) Delete(config config.Config, router *http.ServeMux, control Controller)

Delete godoc @Summary delete hub @Description delete hub @Tags delete, hubs @Produce json @Security Bearer @Param id path string true "Hub Id" @Param wait query bool false "wait for done message in kafka before responding" @Success 200 @Failure 400 @Failure 401 @Failure 403 @Failure 404 @Failure 500 @Router /hubs/{id} [DELETE]

func (*HubsEndpoints) Get added in v0.0.24 

func (this *HubsEndpoints) Get(config config.Config, router *http.ServeMux, control Controller)

Get godoc @Summary get hub @Description get hub @Tags get, hubs @Produce json @Security Bearer @Param id path string true "Hub Id" @Success 200 {object} models.Hub @Failure 400 @Failure 401 @Failure 403 @Failure 404 @Failure 500 @Router /hubs/{id} [GET]

func (*HubsEndpoints) Head added in v0.0.24 

func (this *HubsEndpoints) Head(config config.Config, router *http.ServeMux, control Controller)

Head godoc @Summary head hub @Description head hub @Tags head, hubs @Produce json @Security Bearer @Param id path string true "Hub Id" @Param message body models.Hub true "element" @Success 200 {object} models.Hub @Failure 400 @Failure 401 @Failure 403 @Failure 404 @Failure 500 @Router /hubs/{id} [HEAD]

func (*HubsEndpoints) Set added in v0.0.24 

func (this *HubsEndpoints) Set(config config.Config, router *http.ServeMux, control Controller)

Set godoc @Summary set hub @Description set hub @Tags set, hubs @Produce json @Security Bearer @Param id path string true "Hub Id" @Param user_id query string false "only admins may set user_id; overwrites hub.OwnerId; defaults to existing hub.OwnerId and falls back to user-id of requesting user if hub does not exist" @Param wait query bool false "wait for done message in kafka before responding" @Param message body models.Hub true "element" @Success 200 {object} models.Hub @Failure 400 @Failure 401 @Failure 403 @Failure 404 @Failure 500 @Router /hubs/{id} [PUT]

func (*HubsEndpoints) SetName added in v0.0.24 

func (this *HubsEndpoints) SetName(config config.Config, router *http.ServeMux, control Controller)

SetName godoc @Summary set hub name @Description set hub name @Tags set, hubs @Produce json @Security Bearer @Param id path string true "Hub Id" @Param wait query bool false "wait for done message in kafka before responding" @Param message body string true "name" @Success 200 {object} models.Hub @Failure 400 @Failure 401 @Failure 403 @Failure 404 @Failure 500 @Router /hubs/{id}/name [PUT]

type LocalDevicesEndpoints 

type LocalDevicesEndpoints struct{}

func (*LocalDevicesEndpoints) Create added in v0.0.24 

func (this *LocalDevicesEndpoints) Create(config config.Config, router *http.ServeMux, control Controller)

Create godoc @Summary create device (local-id variant) @Description create device (local-id variant) @Tags create, devices @Produce json @Security Bearer @Param wait query bool false "wait for done message in kafka before responding" @Param message body models.Device true "element" @Success 200 {object} models.Device @Failure 400 @Failure 401 @Failure 403 @Failure 404 @Failure 500 @Router /local-devices/{id} [POST]

func (*LocalDevicesEndpoints) Delete added in v0.0.24 

func (this *LocalDevicesEndpoints) Delete(config config.Config, router *http.ServeMux, control Controller)

Delete godoc @Summary delete device (local-id variant) @Description delete device (local-id variant) @Tags delete, devices @Produce json @Security Bearer @Param id path string true "Device Local Id" @Param owner_id query string false "defaults to requesting user; used in combination with id to find device" @Param wait query bool false "wait for done message in kafka before responding" @Success 200 @Failure 400 @Failure 401 @Failure 403 @Failure 404 @Failure 500 @Router /local-devices/{id} [DELETE]

func (*LocalDevicesEndpoints) Get added in v0.0.24 

func (this *LocalDevicesEndpoints) Get(config config.Config, router *http.ServeMux, control Controller)

Get godoc @Summary get device by local id @Description get device by local id @Tags get, devices @Produce json @Security Bearer @Param id path string true "Device Local Id" @Param owner_id query string false "defaults to requesting user; used in combination with id to find device" @Success 200 {object} models.Device @Failure 400 @Failure 401 @Failure 403 @Failure 404 @Failure 500 @Router /local-devices/{id} [GET]

func (*LocalDevicesEndpoints) List added in v0.0.24 

func (this *LocalDevicesEndpoints) List(config config.Config, router *http.ServeMux, control Controller)

List godoc @Summary list devices (local-id variant) @Description list devices (local-id variant) @Tags list, devices @Produce json @Security Bearer @Param ids query string false "comma separated list of local ids" @Param owner_id query string false "defaults to requesting user; used in combination with local_id to find devices" @Param limit query integer false "default 100, will be ignored if 'ids' is set" @Param offset query integer false "default 0, will be ignored if 'ids' is set" @Param search query string false "filter" @Param sort query string false "default name.asc" @Param device-type-ids query string false "filter; comma-seperated list" @Param attr-keys query string false "filter; comma-seperated list; lists elements only if they have an attribute key that is in the given list" @Param attr-values query string false "filter; comma-seperated list; lists elements only if they have an attribute value that is in the given list" @Param connection-state query integer false "filter; valid values are 'online', 'offline' and an empty string for unknown states" @Success 200 {array} models.Device @Failure 400 @Failure 401 @Failure 403 @Failure 404 @Failure 500 @Router /local-devices/{id} [GET]

func (*LocalDevicesEndpoints) Set added in v0.0.24 

func (this *LocalDevicesEndpoints) Set(config config.Config, router *http.ServeMux, control Controller)

Set godoc @Summary set device (local-id variant) @Description set device (local-id variant) @Tags set, devices @Produce json @Security Bearer @Param id path string true "Device Local Id" @Param update-only-same-origin-attributes query string false "comma separated list; ensure that no attribute from another origin is overwritten" @Param wait query bool false "wait for done message in kafka before responding" @Param message body models.Device true "element" @Success 200 {object} models.Device @Failure 400 @Failure 401 @Failure 403 @Failure 404 @Failure 500 @Router /local-devices/{id} [PUT]

type LocationsEndpoints 

type LocationsEndpoints struct{}

func (*LocationsEndpoints) Create added in v0.0.24 

func (this *LocationsEndpoints) Create(config config.Config, router *http.ServeMux, control Controller)

Create godoc @Summary create location @Description create location @Tags create, locations @Produce json @Security Bearer @Param id path string true "Location Id" @Param wait query bool false "wait for done message in kafka before responding" @Param message body models.Location true "element" @Success 200 {object} models.Location @Failure 400 @Failure 401 @Failure 403 @Failure 404 @Failure 500 @Router /locations [POST]

func (*LocationsEndpoints) Delete added in v0.0.24 

func (this *LocationsEndpoints) Delete(config config.Config, router *http.ServeMux, control Controller)

Delete godoc @Summary delete location @Description delete location @Tags delete, locations @Produce json @Security Bearer @Param id path string true "Location Id" @Param wait query bool false "wait for done message in kafka before responding" @Success 200 @Failure 400 @Failure 401 @Failure 403 @Failure 404 @Failure 500 @Router /locations/{id} [DELETE]

func (*LocationsEndpoints) Get added in v0.0.24 

func (this *LocationsEndpoints) Get(config config.Config, router *http.ServeMux, control Controller)

Get godoc @Summary get location @Description get location @Tags get, locations @Produce json @Security Bearer @Param id path string true "Location Id" @Success 200 {object} models.Location @Failure 400 @Failure 401 @Failure 403 @Failure 404 @Failure 500 @Router /locations/{id} [GET]

func (*LocationsEndpoints) Set added in v0.0.24 

func (this *LocationsEndpoints) Set(config config.Config, router *http.ServeMux, control Controller)

Set godoc @Summary set location @Description set location @Tags set, locations @Produce json @Security Bearer @Param id path string true "Location Id" @Param wait query bool false "wait for done message in kafka before responding" @Param message body models.Location true "element" @Success 200 {object} models.Location @Failure 400 @Failure 401 @Failure 403 @Failure 404 @Failure 500 @Router /locations/{id} [PUT]

type ProtocolsEndpoints 

type ProtocolsEndpoints struct{}

func (*ProtocolsEndpoints) Create added in v0.0.24 

func (this *ProtocolsEndpoints) Create(config config.Config, router *http.ServeMux, control Controller)

Create godoc @Summary create protocol @Description create protocol @Tags create, protocols @Produce json @Security Bearer @Param wait query bool false "wait for done message in kafka before responding" @Param message body models.Protocol true "element" @Success 200 {object} models.Protocol @Failure 400 @Failure 401 @Failure 403 @Failure 404 @Failure 500 @Router /protocols [POST]

func (*ProtocolsEndpoints) Delete added in v0.0.24 

func (this *ProtocolsEndpoints) Delete(config config.Config, router *http.ServeMux, control Controller)

Delete godoc @Summary delete protocol @Description delete protocol @Tags delete, protocols @Produce json @Security Bearer @Param id path string true "Protocol Id" @Param wait query bool false "wait for done message in kafka before responding" @Success 200 @Failure 400 @Failure 401 @Failure 403 @Failure 404 @Failure 500 @Router /protocols/{id} [DELETE]

func (*ProtocolsEndpoints) Get added in v0.0.24 

func (this *ProtocolsEndpoints) Get(config config.Config, router *http.ServeMux, control Controller)

Get godoc @Summary get protocol @Description get protocol @Tags get, protocols @Produce json @Security Bearer @Param id path string true "Protocol Id" @Param wait query bool false "wait for done message in kafka before responding" @Success 200 {object} models.Protocol @Failure 400 @Failure 401 @Failure 403 @Failure 404 @Failure 500 @Router /protocols/{id} [GET]

func (*ProtocolsEndpoints) Set added in v0.0.24 

func (this *ProtocolsEndpoints) Set(config config.Config, router *http.ServeMux, control Controller)

Set godoc @Summary set protocol @Description set protocol @Tags set, protocols @Produce json @Security Bearer @Param id path string true "Protocol Id" @Param wait query bool false "wait for done message in kafka before responding" @Param message body models.Protocol true "element" @Success 200 {object} models.Protocol @Failure 400 @Failure 401 @Failure 403 @Failure 404 @Failure 500 @Router /protocols/{id} [PUT]

type Swagger added in v0.0.24 

type Swagger struct{}

func (*Swagger) Swagger added in v0.0.24 

func (this *Swagger) Swagger(config config.Config, router *http.ServeMux, control Controller)

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.