Allow legacy deduplication

data/blood/glucose/test/glucose.go

@@ -15,15 +15,15 @@ func RandomUnits() string {
 func ExpectRaw(raw *metadata.Metadata, expectedRaw *metadata.Metadata) {
 	if expectedRaw != nil {
 		gomega.Expect(raw).ToNot(gomega.BeNil())
-		if expectedRaw.Get("units") == nil {
+		if units := expectedRaw.Get("units"); units == nil {
 			gomega.Expect(raw.Get("units")).To(gomega.BeNil())
 		} else {
-			gomega.Expect(raw.Get("units")).To(gomega.Equal(expectedRaw.Get("units")))
+			gomega.Expect(raw.Get("units")).To(gomega.Equal(units))
 		}
-		if expectedRaw.Get("value") == nil {
+		if value := expectedRaw.Get("value"); value == nil {
 			gomega.Expect(raw.Get("value")).To(gomega.BeNil())
 		} else {
-			gomega.Expect(raw.Get("value")).To(gomega.Equal(expectedRaw.Get("value")))
+			gomega.Expect(raw.Get("value")).To(gomega.Equal(value))
 		}
 	} else {
 		gomega.Expect(raw).To(gomega.BeNil())

data/data_set.go

@@ -111,7 +111,7 @@ func (d *DataSetClient) Validate(validator structure.Validator) {
 
 type DataSetFilter struct {
 	ClientName *string
-	IsLegacy   *bool
+	LegacyOnly *bool
 	Deleted    *bool
 	DeviceID   *string
 }

data/datum.go

@@ -15,8 +15,7 @@ type Datum interface {
 	Validate(validator structure.Validator)
 	Normalize(normalizer Normalizer)
 
-	IdentityFields() ([]string, error)
-	LegacyIdentityFields() ([]string, error)
+	IdentityFields(version string) ([]string, error)
 
 	GetOrigin() *origin.Origin
 	GetPayload() *metadata.Metadata

data/deduplicator/deduplicator/base.go

@@ -24,8 +24,6 @@ func NewBase(name string, version string) (*Base, error) {
 	}
 	if version == "" {
 		return nil, errors.New("version is missing")
-	} else if !net.IsValidSemanticVersion(version) {
-		return nil, errors.New("version is invalid")
 	}
 
 	return &Base{

data/deduplicator/deduplicator/base_test.go

@@ -25,7 +25,10 @@ var _ = Describe("Base", func() {
 
 	BeforeEach(func() {
 		name = netTest.RandomReverseDomain()
-		version = netTest.RandomSemanticVersion()
+		version = test.RandomStringFromArray([]string{
+			dataDeduplicatorDeduplicator.DeviceDeactivateHashVersionCurrent,
+			dataDeduplicatorDeduplicator.DeviceDeactivateHashVersionLegacy,
+		})
 	})
 
 	Context("NewBase", func() {
@@ -50,13 +53,6 @@ var _ = Describe("Base", func() {
 			Expect(deduplicator).To(BeNil())
 		})
 
-		It("returns an error when version is invalid", func() {
-			version = "invalid"
-			deduplicator, err := dataDeduplicatorDeduplicator.NewBase(name, version)
-			Expect(err).To(MatchError("version is invalid"))
-			Expect(deduplicator).To(BeNil())
-		})
-
 		It("returns successfully", func() {
 			Expect(dataDeduplicatorDeduplicator.NewBase(name, version)).ToNot(BeNil())
 		})

data/deduplicator/deduplicator/device_deactivate_hash.go

@@ -5,18 +5,17 @@ import (
 
 	"github.com/tidepool-org/platform/data"
 	dataStore "github.com/tidepool-org/platform/data/store"
+	"github.com/tidepool-org/platform/data/types"
 	dataTypesUpload "github.com/tidepool-org/platform/data/types/upload"
 	"github.com/tidepool-org/platform/errors"
 	"github.com/tidepool-org/platform/page"
 	"github.com/tidepool-org/platform/pointer"
 )
 
-type DeviceDeactivateHashVersion string
-
 const (
-	DeviceDeactivateHashVersionUnkown  DeviceDeactivateHashVersion = ""
-	DeviceDeactivateHashVersionCurrent DeviceDeactivateHashVersion = "1.1.0"
-	DeviceDeactivateHashVersionLegacy  DeviceDeactivateHashVersion = "0.0.0"
+	DeviceDeactivateHashVersionUnknown = "unknown-hash"
+	DeviceDeactivateHashVersionLegacy  = "legacy-hash"
+	DeviceDeactivateHashVersionCurrent = "current-hash"
 )
 
 const DeviceDeactivateHashName = "org.tidepool.deduplicator.device.deactivate.hash"
@@ -46,7 +45,7 @@ type DeviceDeactivateHash struct {
 }
 
 func NewDeviceDeactivateLegacyHash() (*DeviceDeactivateHash, error) {
-	base, err := NewBase(DeviceDeactivateHashName, string(DeviceDeactivateHashVersionLegacy))
+	base, err := NewBase(DeviceDeactivateHashName, DeviceDeactivateHashVersionLegacy)
 	if err != nil {
 		return nil, err
 	}
@@ -57,7 +56,7 @@ func NewDeviceDeactivateLegacyHash() (*DeviceDeactivateHash, error) {
 }
 
 func NewDeviceDeactivateHash() (*DeviceDeactivateHash, error) {
-	base, err := NewBase(DeviceDeactivateHashName, string(DeviceDeactivateHashVersionCurrent))
+	base, err := NewBase(DeviceDeactivateHashName, DeviceDeactivateHashVersionCurrent)
 	if err != nil {
 		return nil, err
 	}
@@ -67,13 +66,13 @@ func NewDeviceDeactivateHash() (*DeviceDeactivateHash, error) {
 	}, nil
 }
 
-func getDeviceDeactivateHashVersion(dataSet *dataTypesUpload.Upload) DeviceDeactivateHashVersion {
+func getDeduplicatorVersion(dataSet *dataTypesUpload.Upload) string {
 	if dataSet.Deduplicator != nil {
 		if dataSet.Deduplicator.Name != nil && dataSet.Deduplicator.Version != nil {
 			if *dataSet.Deduplicator.Name == DeviceDeactivateHashName {
-				if *dataSet.Deduplicator.Version == string(DeviceDeactivateHashVersionLegacy) {
+				if types.LegacyIdentityFieldsVersion == *dataSet.Deduplicator.Version {
 					return DeviceDeactivateHashVersionLegacy
-				} else if *dataSet.Deduplicator.Version == string(DeviceDeactivateHashVersionCurrent) {
+				} else if types.IdentityFieldsVersion == *dataSet.Deduplicator.Version {
 					return DeviceDeactivateHashVersionCurrent
 				}
 			}
@@ -99,10 +98,10 @@ func getDeviceDeactivateHashVersion(dataSet *dataTypesUpload.Upload) DeviceDeact
 			}
 		}
 	}
-	return DeviceDeactivateHashVersionUnkown
+	return DeviceDeactivateHashVersionUnknown
 }
 
-func (d *DeviceDeactivateHash) New(dataSet *dataTypesUpload.Upload) (bool, error) {
+func (d *DeviceDeactivateHash) New(ctx context.Context, dataSet *dataTypesUpload.Upload) (bool, error) {
 	if dataSet == nil {
 		return false, errors.New("data set is missing")
 	}
@@ -115,20 +114,20 @@ func (d *DeviceDeactivateHash) New(dataSet *dataTypesUpload.Upload) (bool, error
 	if dataSet.HasDeduplicatorName() {
 		return d.Get(ctx, dataSet)
 	}
-	return getDeviceDeactivateHashVersion(dataSet) != DeviceDeactivateHashVersionUnkown, nil
+	return getDeduplicatorVersion(dataSet) != DeviceDeactivateHashVersionUnknown, nil
 }
 
-func (d *DeviceDeactivateHash) Get(dataSet *dataTypesUpload.Upload) (bool, error) {
+func (d *DeviceDeactivateHash) Get(ctx context.Context, dataSet *dataTypesUpload.Upload) (bool, error) {
 	// NOTE: check legacy first then fallback to other matches
 	if dataSet == nil {
 		return false, errors.New("data set is missing")
 	}
 
-	if getDeviceDeactivateHashVersion(dataSet) == DeviceDeactivateHashVersionLegacy {
+	if getDeduplicatorVersion(dataSet) == DeviceDeactivateHashVersionLegacy {
 		return true, nil
 	}
 
-	if found, err := d.Base.Get(dataSet); err != nil || found {
+	if found, err := d.Base.Get(ctx, dataSet); err != nil || found {
 		return found, err
 	}
 	return dataSet.HasDeduplicatorNameMatch("org.tidepool.hash-deactivate-old"), nil // TODO: DEPRECATED
@@ -150,18 +149,19 @@ func (d *DeviceDeactivateHash) AddData(ctx context.Context, repository dataStore
 
 	options := NewDefaultDeviceDeactivateHashOptions()
 
-	if getDeviceDeactivateHashVersion(dataSet) == DeviceDeactivateHashVersionLegacy {
-		filter := &data.DataSetFilter{IsLegacy: pointer.FromBool(true), DeviceID: dataSet.DeviceID}
+	if getDeduplicatorVersion(dataSet) == DeviceDeactivateHashVersionLegacy {
+		filter := &data.DataSetFilter{LegacyOnly: pointer.FromBool(true), DeviceID: dataSet.DeviceID}
 		pagination := &page.Pagination{Page: 1, Size: 1}
 
 		uploads, err := repository.ListUserDataSets(ctx, *dataSet.UserID, filter, pagination)
 		if err != nil {
 			return errors.Wrap(err, "error getting datasets for user")
 		}
 		if len(uploads) != 0 {
-			if uploads[0].LegacyGroupID != nil {
-				options = NewLegacyDeviceDeactivateHashOptions(*uploads[0].LegacyGroupID)
+			if uploads[0].LegacyGroupID == nil {
+				return errors.New("missing required legacy groupId for the device deactive hash legacy version")
 			}
+			options = NewLegacyHashOptions(*uploads[0].LegacyGroupID)
 		}
 	}
 

data/deduplicator/deduplicator/device_deactivate_hash_test.go

@@ -25,6 +25,18 @@ var _ = Describe("DeviceDeactivateHash", func() {
 		Expect(dataDeduplicatorDeduplicator.DeviceDeactivateHashName).To(Equal("org.tidepool.deduplicator.device.deactivate.hash"))
 	})
 
+	It("DeviceDeactivateHashVersionCurrent is current-hash", func() {
+		Expect(dataDeduplicatorDeduplicator.DeviceDeactivateHashVersionCurrent).To(Equal("current-hash"))
+	})
+
+	It("DeviceDeactivateHashVersionLegacy is legacy-hash", func() {
+		Expect(dataDeduplicatorDeduplicator.DeviceDeactivateHashVersionLegacy).To(Equal("legacy-hash"))
+	})
+
+	It("DeviceDeactivateHashVersionUnknown is unkown-hash", func() {
+		Expect(dataDeduplicatorDeduplicator.DeviceDeactivateHashVersionUnknown).To(Equal("unknown-hash"))
+	})
+
 	Context("NewDeviceDeactivateHash", func() {
 		It("returns succesfully", func() {
 			Expect(dataDeduplicatorDeduplicator.NewDeviceDeactivateHash()).ToNot(BeNil())
@@ -66,14 +78,14 @@ var _ = Describe("DeviceDeactivateHash", func() {
 
 			It("returns false when the deduplicator name does not match", func() {
 				dataSet.Deduplicator.Name = pointer.FromString(netTest.RandomReverseDomain())
-				Expect(deduplicator.New(dataSet)).To(BeFalse())
+				Expect(deduplicator.New(context.Background(), dataSet)).To(BeFalse())
 			})
 
 			DescribeTable("returns true when",
 				func(deviceManufacturer string, deviceModel string) {
 					dataSet.DeviceManufacturers = pointer.FromStringArray([]string{deviceManufacturer})
 					dataSet.DeviceModel = pointer.FromString(deviceModel)
-					Expect(deduplicator.New(dataSet)).To(BeTrue())
+					Expect(deduplicator.New(context.Background(), dataSet)).To(BeTrue())
 				},
 				Entry("is Abbott FreeStyle Libre", "Abbott", "FreeStyle Libre"),
 				Entry("is LifeScan OneTouch Ultra 2", "LifeScan", "OneTouch Ultra 2"),
@@ -264,7 +276,7 @@ var _ = Describe("DeviceDeactivateHash", func() {
 				dataSet.Deduplicator.Name = pointer.FromString(dataDeduplicatorDeduplicator.DeviceDeactivateHashName)
 				dataSet.DeviceManufacturers = pointer.FromStringArray([]string{"Tandem"})
 				dataSet.DeviceModel = pointer.FromString("1002717")
-				Expect(deduplicator.Get(dataSet)).To(BeTrue())
+				Expect(deduplicator.Get(context.Background(), dataSet)).To(BeTrue())
 			})
 		})
 
@@ -308,7 +320,7 @@ var _ = Describe("DeviceDeactivateHash", func() {
 						update.Active = pointer.FromBool(false)
 						update.Deduplicator = &data.DeduplicatorDescriptor{
 							Name:    pointer.FromString("org.tidepool.deduplicator.device.deactivate.hash"),
-							Version: pointer.FromString("1.1.0"),
+							Version: pointer.FromString(dataDeduplicatorDeduplicator.DeviceDeactivateHashVersionCurrent),
 						}
 					})
 

data/deduplicator/deduplicator/hash.go

@@ -13,58 +13,63 @@ import (
 	"github.com/tidepool-org/platform/pointer"
 )
 
-type deviceDeactivateHashOptions struct {
-	version       DeviceDeactivateHashVersion
-	legacyGroupID *string
+type HashOptions struct {
+	Version       string
+	LegacyGroupID *string
 }
 
-func NewLegacyDeviceDeactivateHashOptions(legacyGroupID string) deviceDeactivateHashOptions {
-	return deviceDeactivateHashOptions{
-		version:       DeviceDeactivateHashVersionLegacy,
-		legacyGroupID: &legacyGroupID,
+func NewLegacyHashOptions(legacyGroupID string) HashOptions {
+	return HashOptions{
+		Version:       DeviceDeactivateHashVersionLegacy,
+		LegacyGroupID: &legacyGroupID,
 	}
 }
 
-func NewDefaultDeviceDeactivateHashOptions() deviceDeactivateHashOptions {
-	return deviceDeactivateHashOptions{
-		version: DeviceDeactivateHashVersionCurrent,
+func NewDefaultDeviceDeactivateHashOptions() HashOptions {
+	return HashOptions{
+		Version: DeviceDeactivateHashVersionCurrent,
 	}
 }
 
-func (d deviceDeactivateHashOptions) ValidateLegacy() error {
-	if d.version == DeviceDeactivateHashVersionLegacy {
-		if d.legacyGroupID == nil || *d.legacyGroupID == "" {
+func (d HashOptions) Validate() error {
+
+	switch d.Version {
+	case DeviceDeactivateHashVersionLegacy:
+		if d.LegacyGroupID == nil || *d.LegacyGroupID == "" {
 			return errors.New("missing required legacy groupId for the device deactive hash legacy version")
 		}
+	case DeviceDeactivateHashVersionCurrent:
+		if d.LegacyGroupID != nil {
+			return errors.New("groupId is not required for the device deactive hash current version")
+		}
+	default:
+		return errors.Newf("missing valid version %s", d.Version)
 	}
 	return nil
 }
 
-func AssignDataSetDataIdentityHashes(dataSetData data.Data, options deviceDeactivateHashOptions) error {
+func AssignDataSetDataIdentityHashes(dataSetData data.Data, options HashOptions) error {
+	if err := options.Validate(); err != nil {
+		return err
+	}
 	for _, dataSetDatum := range dataSetData {
 		var hash string
-		if options.version == DeviceDeactivateHashVersionLegacy {
-			if err := options.ValidateLegacy(); err != nil {
-				return err
-			}
-			fields, err := dataSetDatum.LegacyIdentityFields()
-			if err != nil {
-				return errors.Wrapf(err, "unable to gather legacy identity fields for datum %T", dataSetDatum)
-			}
 
+		fields, err := dataSetDatum.IdentityFields(options.Version)
+		if err != nil {
+			return errors.Wrap(err, "unable to gather identity fields for datum")
+		}
+
+		if options.Version == DeviceDeactivateHashVersionLegacy {
 			hash, err = GenerateLegacyIdentityHash(fields)
 			if err != nil {
 				return errors.Wrapf(err, "unable to generate legacy identity hash for datum %T", dataSetDatum)
 			}
-			hash, err = GenerateLegacyIdentityHash([]string{hash, *options.legacyGroupID})
+			hash, err = GenerateLegacyIdentityHash([]string{hash, *options.LegacyGroupID})
 			if err != nil {
 				return errors.Wrapf(err, "unable to generate legacy identity hash with legacy groupID for datum %T", dataSetDatum)
 			}
 		} else {
-			fields, err := dataSetDatum.IdentityFields()
-			if err != nil {
-				return errors.Wrap(err, "unable to gather identity fields for datum")
-			}
 			hash, err = GenerateIdentityHash(fields)
 			if err != nil {
 				return errors.Wrap(err, "unable to generate identity hash for datum")