Add full write support to some features

Some old devices do not support partial writes. Therefor the complete dataset needs to be sent.

The features `loadControl`, `deviceConfiguration` support this now, as these also support merges.

Author: DerAndereAndi

features/client/deviceconfiguration.go

@@ -59,13 +59,32 @@ func (d *DeviceConfiguration) WriteKeyValues(data []model.DeviceConfigurationKey
 		return nil, api.ErrMissingData
 	}
 
+	filters := []model.FilterType{*model.NewFilterTypePartial()}
+
+	// does the remote server feature not support partials?
+	operation := d.featureRemote.Operations()[model.FunctionTypeDeviceConfigurationKeyValueListData]
+	if operation == nil || !operation.WritePartial() {
+		filters = nil
+		// we need to send all data
+		updateData := &model.DeviceConfigurationKeyValueListDataType{
+			DeviceConfigurationKeyValueData: data,
+		}
+
+		if mergedData, err := d.featureRemote.UpdateData(false, model.FunctionTypeDeviceConfigurationKeyValueListData, updateData, nil, nil); err == nil {
+			data = mergedData.([]model.DeviceConfigurationKeyValueDataType)
+		}
+	}
+
 	cmd := model.CmdType{
-		Function: util.Ptr(model.FunctionTypeDeviceConfigurationKeyValueListData),
-		Filter:   []model.FilterType{*model.NewFilterTypePartial()},
 		DeviceConfigurationKeyValueListData: &model.DeviceConfigurationKeyValueListDataType{
 			DeviceConfigurationKeyValueData: data,
 		},
 	}
 
+	if filters != nil {
+		cmd.Filter = filters
+		cmd.Function = util.Ptr(model.FunctionTypeDeviceConfigurationKeyValueListData)
+	}
+
 	return d.remoteDevice.Sender().Write(d.featureLocal.Address(), d.featureRemote.Address(), cmd)
 }

features/client/deviceconfiguration_test.go

@@ -20,11 +20,16 @@ func TestDeviceConfigurationSuite(t *testing.T) {
 type DeviceConfigurationSuite struct {
 	suite.Suite
 
-	localEntity      spineapi.EntityLocalInterface
-	remoteEntity     spineapi.EntityRemoteInterface
+	localEntity        spineapi.EntityLocalInterface
+	localEntityPartial spineapi.EntityLocalInterface
+
+	remoteEntity        spineapi.EntityRemoteInterface
+	remoteEntityPartial spineapi.EntityRemoteInterface
+
 	mockRemoteEntity *mocks.EntityRemoteInterface
 
-	deviceConfiguration *DeviceConfiguration
+	deviceConfiguration        *DeviceConfiguration
+	deviceConfigurationPartial *DeviceConfiguration
 }
 
 const remoteSki string = "testremoteski"
@@ -47,6 +52,21 @@ func (s *DeviceConfigurationSuite) BeforeTest(suiteName, testName string) {
 		},
 	)
 
+	s.localEntityPartial, s.remoteEntityPartial = setupFeatures(
+		s.T(),
+		mockWriter,
+		[]featureFunctions{
+			{
+				featureType: model.FeatureTypeTypeDeviceConfiguration,
+				functions: []model.FunctionType{
+					model.FunctionTypeDeviceConfigurationKeyValueDescriptionListData,
+					model.FunctionTypeDeviceConfigurationKeyValueListData,
+				},
+				partial: true,
+			},
+		},
+	)
+
 	mockRemoteDevice := mocks.NewDeviceRemoteInterface(s.T())
 	s.mockRemoteEntity = mocks.NewEntityRemoteInterface(s.T())
 	mockRemoteFeature := mocks.NewFeatureRemoteInterface(s.T())
@@ -66,6 +86,10 @@ func (s *DeviceConfigurationSuite) BeforeTest(suiteName, testName string) {
 	s.deviceConfiguration, err = NewDeviceConfiguration(s.localEntity, s.remoteEntity)
 	assert.Nil(s.T(), err)
 	assert.NotNil(s.T(), s.deviceConfiguration)
+
+	s.deviceConfigurationPartial, err = NewDeviceConfiguration(s.localEntityPartial, s.remoteEntityPartial)
+	assert.Nil(s.T(), err)
+	assert.NotNil(s.T(), s.deviceConfiguration)
 }
 
 func (s *DeviceConfigurationSuite) Test_RequestKeyValueDescriptions() {
@@ -104,6 +128,34 @@ func (s *DeviceConfigurationSuite) Test_WriteValues() {
 	assert.NotNil(s.T(), err)
 	assert.Nil(s.T(), counter)
 
+	rF := s.remoteEntity.FeatureOfTypeAndRole(model.FeatureTypeTypeDeviceConfiguration, model.RoleTypeServer)
+	data1 := rF.DataCopy(model.FunctionTypeDeviceConfigurationKeyValueListData).(*model.DeviceConfigurationKeyValueListDataType)
+	assert.Nil(s.T(), data1)
+
+	defaultData := &model.DeviceConfigurationKeyValueListDataType{
+		DeviceConfigurationKeyValueData: []model.DeviceConfigurationKeyValueDataType{
+			{
+				KeyId:             util.Ptr(model.DeviceConfigurationKeyIdType(0)),
+				IsValueChangeable: util.Ptr(true),
+				Value: &model.DeviceConfigurationKeyValueValueType{
+					ScaledNumber: model.NewScaledNumberType(16),
+				},
+			},
+			{
+				KeyId:             util.Ptr(model.DeviceConfigurationKeyIdType(1)),
+				IsValueChangeable: util.Ptr(true),
+				Value: &model.DeviceConfigurationKeyValueValueType{
+					ScaledNumber: model.NewScaledNumberType(32),
+				},
+			},
+		},
+	}
+	_, err1 := rF.UpdateData(true, model.FunctionTypeDeviceConfigurationKeyValueListData, defaultData, nil, nil)
+	assert.Nil(s.T(), err1)
+	data1 = rF.DataCopy(model.FunctionTypeDeviceConfigurationKeyValueListData).(*model.DeviceConfigurationKeyValueListDataType)
+	assert.NotNil(s.T(), data1)
+	assert.Equal(s.T(), 2, len(data1.DeviceConfigurationKeyValueData))
+
 	data = []model.DeviceConfigurationKeyValueDataType{
 		{
 			KeyId: util.Ptr(model.DeviceConfigurationKeyIdType(0)),
@@ -116,3 +168,55 @@ func (s *DeviceConfigurationSuite) Test_WriteValues() {
 	assert.Nil(s.T(), err)
 	assert.NotNil(s.T(), counter)
 }
+
+// test with partial support
+func (s *DeviceConfigurationSuite) Test_WriteValues_Partial() {
+	counter, err := s.deviceConfigurationPartial.WriteKeyValues(nil)
+	assert.NotNil(s.T(), err)
+	assert.Nil(s.T(), counter)
+
+	data := []model.DeviceConfigurationKeyValueDataType{}
+	counter, err = s.deviceConfigurationPartial.WriteKeyValues(data)
+	assert.NotNil(s.T(), err)
+	assert.Nil(s.T(), counter)
+
+	rF := s.remoteEntity.FeatureOfTypeAndRole(model.FeatureTypeTypeDeviceConfiguration, model.RoleTypeServer)
+	data1 := rF.DataCopy(model.FunctionTypeDeviceConfigurationKeyValueListData).(*model.DeviceConfigurationKeyValueListDataType)
+	assert.Nil(s.T(), data1)
+
+	defaultData := &model.DeviceConfigurationKeyValueListDataType{
+		DeviceConfigurationKeyValueData: []model.DeviceConfigurationKeyValueDataType{
+			{
+				KeyId:             util.Ptr(model.DeviceConfigurationKeyIdType(0)),
+				IsValueChangeable: util.Ptr(true),
+				Value: &model.DeviceConfigurationKeyValueValueType{
+					ScaledNumber: model.NewScaledNumberType(16),
+				},
+			},
+			{
+				KeyId:             util.Ptr(model.DeviceConfigurationKeyIdType(1)),
+				IsValueChangeable: util.Ptr(true),
+				Value: &model.DeviceConfigurationKeyValueValueType{
+					ScaledNumber: model.NewScaledNumberType(32),
+				},
+			},
+		},
+	}
+	_, err1 := rF.UpdateData(true, model.FunctionTypeDeviceConfigurationKeyValueListData, defaultData, nil, nil)
+	assert.Nil(s.T(), err1)
+	data1 = rF.DataCopy(model.FunctionTypeDeviceConfigurationKeyValueListData).(*model.DeviceConfigurationKeyValueListDataType)
+	assert.NotNil(s.T(), data1)
+	assert.Equal(s.T(), 2, len(data1.DeviceConfigurationKeyValueData))
+
+	data = []model.DeviceConfigurationKeyValueDataType{
+		{
+			KeyId: util.Ptr(model.DeviceConfigurationKeyIdType(0)),
+			Value: &model.DeviceConfigurationKeyValueValueType{
+				ScaledNumber: model.NewScaledNumberType(10),
+			},
+		},
+	}
+	counter, err = s.deviceConfigurationPartial.WriteKeyValues(data)
+	assert.Nil(s.T(), err)
+	assert.NotNil(s.T(), counter)
+}

features/client/feature.go

@@ -141,7 +141,8 @@ func (f *Feature) requestData(function model.FunctionType, selectors any, elemen
 	}
 
 	// remove the selectors if the remote does not allow partial reads
-	if selectors != nil && !op.ReadPartial() {
+	// or partial writes, because in that case we need to have all data
+	if selectors != nil && (!op.ReadPartial() || !op.WritePartial()) {
 		selectors = nil
 		elements = nil
 	}

features/client/loadcontrol.go

@@ -72,25 +72,44 @@ func (l *LoadControl) WriteLimitData(
 	}
 
 	var filters []model.FilterType
+	var delFilter *model.FilterType
+	partialFilter := model.NewFilterTypePartial()
 	if deleteElements != nil && deleteSelectors != nil {
-		delFilter := model.FilterType{
+		delFilter = &model.FilterType{
 			CmdControl: &model.CmdControlType{
 				Delete: &model.ElementTagType{},
 			},
 			LoadControlLimitListDataSelectors: deleteSelectors,
 			LoadControlLimitDataElements:      deleteElements,
 		}
-		filters = append(filters, delFilter)
+		filters = append(filters, *delFilter)
+	}
+	filters = append(filters, *partialFilter)
+
+	// does the remote server feature not support partials?
+	operation := l.featureRemote.Operations()[model.FunctionTypeLoadControlLimitListData]
+	if operation == nil || !operation.WritePartial() {
+		filters = nil
+		// we need to send all data
+		updateData := &model.LoadControlLimitListDataType{
+			LoadControlLimitData: data,
+		}
+
+		if mergedData, err := l.featureRemote.UpdateData(false, model.FunctionTypeLoadControlLimitListData, updateData, partialFilter, delFilter); err == nil {
+			data = mergedData.([]model.LoadControlLimitDataType)
+		}
 	}
-	filters = append(filters, *model.NewFilterTypePartial())
 
 	cmd := model.CmdType{
-		Function: util.Ptr(model.FunctionTypeLoadControlLimitListData),
-		Filter:   filters,
 		LoadControlLimitListData: &model.LoadControlLimitListDataType{
 			LoadControlLimitData: data,
 		},
 	}
 
+	if filters != nil {
+		cmd.Filter = filters
+		cmd.Function = util.Ptr(model.FunctionTypeLoadControlLimitListData)
+	}
+
 	return l.remoteDevice.Sender().Write(l.featureLocal.Address(), l.featureRemote.Address(), cmd)
 }