Add write approval API to UCLPCServer

Author: DerAndereAndi

uclpcserver/api.go

@@ -4,6 +4,7 @@ import (
 	"time"
 
 	"github.com/enbility/cemd/api"
+	"github.com/enbility/spine-go/model"
 )
 
 //go:generate mockery
@@ -27,6 +28,17 @@ type UCLPCServerInterface interface {
 	// set the current loadcontrol limit data
 	SetConsumptionLimit(limit api.LoadLimit) (resultErr error)
 
+	// return the currently pending incoming consumption write limits
+	PendingConsumptionLimits() map[model.MsgCounterType]api.LoadLimit
+
+	// accept or deny an incoming consumption write limit
+	//
+	// parameters:
+	//  - msg: the incoming write message
+	//  - approve: if the write limit for msg should be approved or not
+	//  - reason: the reason why the approval is denied, otherwise an empty string
+	ApproveOrDenyConsumptionLimit(msgCounter model.MsgCounterType, approve bool, reason string)
+
 	// Scenario 2
 
 	// return Failsafe limit for the consumed active (real) power of the

uclpcserver/public.go

@@ -103,6 +103,77 @@ func (e *UCLPCServer) SetConsumptionLimit(limit api.LoadLimit) (resultErr error)
 	return nil
 }
 
+// return the currently pending incoming consumption write limits
+func (e *UCLPCServer) PendingConsumptionLimits() map[model.MsgCounterType]api.LoadLimit {
+	e.pendingMux.Lock()
+	defer e.pendingMux.Unlock()
+
+	result := make(map[model.MsgCounterType]api.LoadLimit)
+
+	descriptions := util.GetLocalLimitDescriptionsForTypeCategoryDirectionScope(
+		e.service,
+		model.LoadControlLimitTypeTypeSignDependentAbsValueLimit,
+		model.LoadControlCategoryTypeObligation,
+		model.EnergyDirectionTypeConsume,
+		model.ScopeTypeTypeActivePowerLimit,
+	)
+	if len(descriptions) != 1 || descriptions[0].LimitId == nil {
+		return result
+	}
+	description := descriptions[0]
+
+	for key, msg := range e.pendingLimits {
+		data := msg.Cmd.LoadControlLimitListData
+
+		if data == nil || data.LoadControlLimitData == nil || len(data.LoadControlLimitData) == 0 {
+			continue
+		}
+
+		// we assume there is always only one limit
+		element := data.LoadControlLimitData[0]
+
+		if description.LimitId == nil || element.LimitId == nil || *description.LimitId != *element.LimitId {
+			continue
+		}
+
+		limit := api.LoadLimit{}
+
+		if element.TimePeriod != nil {
+			if duration, err := element.TimePeriod.GetDuration(); err == nil {
+				limit.Duration = duration
+			}
+		}
+
+		if element.IsLimitActive != nil {
+			limit.IsActive = *element.IsLimitActive
+		}
+
+		if element.Value != nil {
+			limit.Value = element.Value.GetValue()
+		}
+
+		result[key] = limit
+	}
+
+	return result
+}
+
+// accept or deny an incoming consumption write limit
+func (e *UCLPCServer) ApproveOrDenyConsumptionLimit(msgCounter model.MsgCounterType, approve bool, reason string) {
+	e.pendingMux.Lock()
+	defer e.pendingMux.Unlock()
+
+	msg, ok := e.pendingLimits[msgCounter]
+	if !ok {
+		return
+	}
+
+	localEntity := e.service.LocalDevice().EntityForType(model.EntityTypeTypeCEM)
+
+	f := localEntity.FeatureOfTypeAndRole(model.FeatureTypeTypeLoadControl, model.RoleTypeServer)
+	f.ApproveOrDenyWrite(msg, approve, reason)
+}
+
 // Scenario 2
 
 // return Failsafe limit for the consumed active (real) power of the

uclpcserver/public_test.go

@@ -4,6 +4,9 @@ import (
 	"time"
 
 	"github.com/enbility/cemd/api"
+	eebusutil "github.com/enbility/eebus-go/util"
+	spineapi "github.com/enbility/spine-go/api"
+	"github.com/enbility/spine-go/model"
 	"github.com/stretchr/testify/assert"
 )
 
@@ -26,6 +29,73 @@ func (s *UCLPCServerSuite) Test_ConsumptionLimit() {
 	assert.Nil(s.T(), err)
 }
 
+func (s *UCLPCServerSuite) Test_PendingConsumptionLimits() {
+	data := s.sut.PendingConsumptionLimits()
+	assert.Equal(s.T(), 0, len(data))
+
+	msgCounter := model.MsgCounterType(500)
+
+	msg := &spineapi.Message{
+		RequestHeader: &model.HeaderType{
+			MsgCounter: eebusutil.Ptr(msgCounter),
+		},
+		Cmd: model.CmdType{
+			LoadControlLimitListData: &model.LoadControlLimitListDataType{},
+		},
+	}
+
+	s.sut.loadControlWriteCB(msg)
+
+	data = s.sut.PendingConsumptionLimits()
+	assert.Equal(s.T(), 0, len(data))
+
+	msg.Cmd = model.CmdType{
+		LoadControlLimitListData: &model.LoadControlLimitListDataType{
+			LoadControlLimitData: []model.LoadControlLimitDataType{},
+		},
+	}
+
+	s.sut.loadControlWriteCB(msg)
+
+	data = s.sut.PendingConsumptionLimits()
+	assert.Equal(s.T(), 0, len(data))
+
+	msg.Cmd = model.CmdType{
+		LoadControlLimitListData: &model.LoadControlLimitListDataType{
+			LoadControlLimitData: []model.LoadControlLimitDataType{
+				{},
+			},
+		},
+	}
+
+	s.sut.loadControlWriteCB(msg)
+
+	data = s.sut.PendingConsumptionLimits()
+	assert.Equal(s.T(), 0, len(data))
+
+	msg.Cmd = model.CmdType{
+		LoadControlLimitListData: &model.LoadControlLimitListDataType{
+			LoadControlLimitData: []model.LoadControlLimitDataType{
+				{
+					LimitId:       eebusutil.Ptr(model.LoadControlLimitIdType(0)),
+					IsLimitActive: eebusutil.Ptr(true),
+					Value:         model.NewScaledNumberType(1000),
+					TimePeriod:    model.NewTimePeriodTypeWithRelativeEndTime(time.Minute * 2),
+				},
+			},
+		},
+	}
+
+	s.sut.loadControlWriteCB(msg)
+
+	data = s.sut.PendingConsumptionLimits()
+	assert.Equal(s.T(), 1, len(data))
+
+	s.sut.ApproveOrDenyConsumptionLimit(model.MsgCounterType(499), true, "")
+
+	s.sut.ApproveOrDenyConsumptionLimit(msgCounter, true, "")
+}
+
 func (s *UCLPCServerSuite) Test_Failsafe() {
 	limit, changeable, err := s.sut.FailsafeConsumptionActivePowerLimit()
 	assert.Equal(s.T(), 0.0, limit)

uclpcserver/types.go

@@ -12,6 +12,11 @@ const (
 	// Use Case LPC, Scenario 1
 	DataUpdateLimit api.EventType = "DataUpdateLimit"
 
+	// An incoming load control obligation limit needs to be approved or denied
+	//
+	// Use Case LPC, Scenario 1
+	WriteApprovalRequired api.EventType = "WriteApprovalRequired"
+
 	// Failsafe limit for the consumed active (real) power of the
 	// Controllable System data update received
 	//

uclpcserver/uclpc.go

@@ -1,6 +1,8 @@
 package uclpcserver
 
 import (
+	"sync"
+
 	"github.com/enbility/cemd/api"
 	"github.com/enbility/cemd/util"
 	eebusapi "github.com/enbility/eebus-go/api"
@@ -17,15 +19,19 @@ type UCLPCServer struct {
 
 	validEntityTypes []model.EntityTypeType
 
+	pendingMux    sync.Mutex
+	pendingLimits map[model.MsgCounterType]*spineapi.Message
+
 	heartbeatKeoWorkaround bool // required because KEO Stack uses multiple identical entities for the same functionality, and it is not clear which to use
 }
 
 var _ UCLPCServerInterface = (*UCLPCServer)(nil)
 
 func NewUCLPC(service eebusapi.ServiceInterface, eventCB api.EntityEventCallback) *UCLPCServer {
 	uc := &UCLPCServer{
-		service: service,
-		eventCB: eventCB,
+		service:       service,
+		eventCB:       eventCB,
+		pendingLimits: make(map[model.MsgCounterType]*spineapi.Message),
 	}
 
 	uc.validEntityTypes = []model.EntityTypeType{
@@ -42,6 +48,19 @@ func (c *UCLPCServer) UseCaseName() model.UseCaseNameType {
 	return model.UseCaseNameTypeLimitationOfPowerConsumption
 }
 
+func (e *UCLPCServer) loadControlWriteCB(msg *spineapi.Message) {
+	e.pendingMux.Lock()
+	defer e.pendingMux.Unlock()
+
+	if msg.RequestHeader == nil || msg.RequestHeader.MsgCounter == nil {
+		return
+	}
+
+	if _, ok := e.pendingLimits[*msg.RequestHeader.MsgCounter]; !ok {
+		e.pendingLimits[*msg.RequestHeader.MsgCounter] = msg
+	}
+}
+
 func (e *UCLPCServer) AddFeatures() {
 	localEntity := e.service.LocalDevice().EntityForType(model.EntityTypeTypeCEM)
 
@@ -52,6 +71,7 @@ func (e *UCLPCServer) AddFeatures() {
 	f := localEntity.GetOrAddFeature(model.FeatureTypeTypeLoadControl, model.RoleTypeServer)
 	f.AddFunctionType(model.FunctionTypeLoadControlLimitDescriptionListData, true, false)
 	f.AddFunctionType(model.FunctionTypeLoadControlLimitListData, true, true)
+	_ = f.AddWriteApprovalCallback(e.loadControlWriteCB)
 
 	var limitId model.LoadControlLimitIdType = 0
 	// get the highest limitId

uclpcserver/uclpc_test.go

@@ -2,10 +2,25 @@ package uclpcserver
 
 import (
 	eebusutil "github.com/enbility/eebus-go/util"
+	spineapi "github.com/enbility/spine-go/api"
 	"github.com/enbility/spine-go/model"
 	"github.com/stretchr/testify/assert"
 )
 
+func (s *UCLPCServerSuite) Test_loadControlWriteCB() {
+	msg := &spineapi.Message{}
+
+	s.sut.loadControlWriteCB(msg)
+
+	msg = &spineapi.Message{
+		RequestHeader: &model.HeaderType{
+			MsgCounter: eebusutil.Ptr(model.MsgCounterType(500)),
+		},
+	}
+
+	s.sut.loadControlWriteCB(msg)
+}
+
 func (s *UCLPCServerSuite) Test_UpdateUseCaseAvailability() {
 	s.sut.UpdateUseCaseAvailability(true)
 }