query

Documentation

Index

• type AreaQuery
• type CropQuery
• type DeviceAreaQueryResult
• type DeviceCropQueryResult
• type DeviceEventQuery
• type DeviceMaterialQueryResult
• type DeviceQuery
• type DeviceReadQuery
• type DeviceReservoirQueryResult
• type EventWrapper
• type MaterialQuery
• type ReservoirQuery
• type Result

Types

type AreaQuery

type AreaQuery interface {
	FindByID(areaUID uuid.UUID) <-chan Result
}

AreaQuery is used ...

type CropQuery

type CropQuery interface {
	FindCropByID(cropUID uuid.UUID) <-chan Result
}

CropQuery is used ...

type DeviceAreaQueryResult

type DeviceAreaQueryResult struct {
	UID  uuid.UUID `json:"uid"`
	Name string    `json:"name"`
}

DeviceAreaQueryResult is used

type DeviceCropQueryResult

type DeviceCropQueryResult struct {
	UID     uuid.UUID `json:"uid"`
	BatchID string    `json:"batch_id"`
}

DeviceCropQueryResult is used

type DeviceEventQuery

type DeviceEventQuery interface {
	FindAllByDeviceID(uid uuid.UUID) <-chan Result
}

DeviceEventQuery is used ...

type DeviceMaterialQueryResult

type DeviceMaterialQueryResult struct {
	UID              uuid.UUID `json:"uid"`
	TypeCode         string    `json:"type"`
	DetailedTypeCode string    `json:"detailed_type"`
	Name             string    `json:"name"`
}

DeviceMaterialQueryResult is used

type DeviceQuery

type DeviceQuery interface {
	FindDeviceByID(deviceUID uuid.UUID) <-chan Result
}

DeviceQuery is used ...

type DeviceReadQuery

type DeviceReadQuery interface {
	FindAll(page, limit int) <-chan Result
	FindByID(taskUID uuid.UUID) <-chan Result
	//FindDevicesWithFilter(params map[string]string, page, limit int) <-chan Result
	CountAll() <-chan Result
	CountDevicesWithFilter(params map[string]string) <-chan Result
}

DeviceReadQuery is used ...

type DeviceReservoirQueryResult

type DeviceReservoirQueryResult struct {
	UID  uuid.UUID `json:"uid"`
	Name string    `json:"name"`
}

DeviceReservoirQueryResult is used

type EventWrapper

type EventWrapper struct {
	EventName string
	EventData interface{}
}

EventWrapper is used to wrap the event interface with its struct name, so it will be easier to unmarshal later

type MaterialQuery

type MaterialQuery interface {
	FindMaterialByID(materialID uuid.UUID) <-chan Result
}

MaterialQuery is used ...

type ReservoirQuery

type ReservoirQuery interface {
	FindReservoirByID(reservoirUID uuid.UUID) <-chan Result
}

ReservoirQuery is used ...

type Result

type Result struct {
	Result interface{}
	Error  error
}

Result is used...