INTG-1733 allow jp chassis number decoding (#282)

* change table structure, add unit test

* decoding japan chasis numbers with existing vin in db working

* lint

* refactor and improve code around decoding with existing db vin match

Author: JamesReate

cmd/device-definitions-api/add_vin.go

@@ -90,11 +90,11 @@ func (p *addVINCmd) Execute(ctx context.Context, _ *flag.FlagSet, _ ...interface
 	}
 	vinNumber := models.VinNumber{
 		Vin:              vin,
-		Wmi:              processedVIN.Wmi(),
-		VDS:              processedVIN.VDS(),
-		CheckDigit:       processedVIN.CheckDigit(),
+		Wmi:              null.StringFrom(processedVIN.Wmi()),
+		VDS:              null.StringFrom(processedVIN.VDS()),
 		SerialNumber:     processedVIN.SerialNumber(),
-		Vis:              processedVIN.VIS(),
+		CheckDigit:       null.StringFrom(processedVIN.CheckDigit()),
+		Vis:              null.StringFrom(processedVIN.VIS()),
 		ManufacturerName: wmi.R.DeviceMake.Name,
 		DecodeProvider:   null.StringFrom("manual"),
 		Year:             processedVIN.Year(),

internal/core/queries/decode_vin.go

@@ -73,7 +73,7 @@ func NewDecodeVINQueryHandler(dbs func() *db.ReaderWriter, vinDecodingService se
 
 func (dc DecodeVINQueryHandler) Handle(ctx context.Context, query mediator.Message) (interface{}, error) {
 	qry := query.(*DecodeVINQuery)
-	if len(qry.VIN) != 17 {
+	if !(len(qry.VIN) >= 13 && len(qry.VIN) <= 17) {
 		return nil, &exceptions.ValidationError{Err: fmt.Errorf("invalid vin %s", qry.VIN)}
 	}
 	resp := &p_grpc.DecodeVinResponse{}
@@ -111,30 +111,10 @@ func (dc DecodeVINQueryHandler) Handle(ctx context.Context, query mediator.Messa
 		metrics.InternalError.With(prometheus.Labels{"method": VinErrors}).Inc()
 		return nil, errors.Wrap(err, "error when querying for existing VIN number")
 	}
-	// todo refactor: func hydrateResponseFromVinNumber(...)
-	if vinDecodeNumber != nil {
-		// get from tableland, probably don't need this here anymore
-		//tblDef, errTbl := dc.deviceDefinitionOnChainService.GetDefinitionByID(ctx, vinDecodeNumber.DefinitionID, dc.dbs().Reader)
-		// should mark this deprecated
-		//resp.DeviceMakeId = vinDecodeNumber.DeviceMakeID
-		resp.Manufacturer = vinDecodeNumber.ManufacturerName
-		resp.Year = int32(vinDecodeNumber.Year)
-		resp.DeviceStyleId = vinDecodeNumber.StyleID.String
-		resp.Source = vinDecodeNumber.DecodeProvider.String
-		resp.DefinitionId = vinDecodeNumber.DefinitionID
-		split := strings.Split(vinDecodeNumber.DefinitionID, "_")
-		if len(split) != 3 {
-			return nil, errors.New("invalid definition ID encountered: " + vinDecodeNumber.DefinitionID)
-		}
-		pt, err := dc.powerTrainTypeService.ResolvePowerTrainType(split[0], split[1], vinDecodeNumber.DrivlyData, vinDecodeNumber.VincarioData)
-		if err != nil {
-			pt = coremodels.ICE.String()
-		}
-		resp.Powertrain = pt
-
+	// if database vin_number match found, just return it here
+	if r := dc.hydrateResponseFromVinNumber(vinDecodeNumber); r != nil {
 		metrics.Success.With(prometheus.Labels{"method": VinExists}).Inc()
-
-		return resp, nil
+		return r, nil
 	}
 
 	// todo: this should be a separate specific gRPC endpoint for setting or updating vin number to DD mapping
@@ -161,10 +141,10 @@ func (dc DecodeVINQueryHandler) Handle(ctx context.Context, query mediator.Messa
 		vinDecodeNumber = &models.VinNumber{
 			Vin:              vin.String(),
 			ManufacturerName: dm.Name,
-			Wmi:              dbWMI.Wmi,
-			VDS:              vin.VDS(),
-			Vis:              vin.VIS(),
-			CheckDigit:       vin.CheckDigit(),
+			Wmi:              null.StringFrom(dbWMI.Wmi),
+			VDS:              null.StringFrom(vin.VDS()),
+			Vis:              null.StringFrom(vin.VIS()),
+			CheckDigit:       null.StringFrom(vin.CheckDigit()),
 			SerialNumber:     vin.SerialNumber(),
 			DecodeProvider:   null.StringFrom("manual"),
 			Year:             tblDef.Year,
@@ -373,6 +353,38 @@ func resolveMetadataFromInfo(powertrain string, _ *coremodels.VINDecodingInfoDat
 	return &md
 }
 
+// hydrateResponseFromVinNumber pass in a vin_number database object and converts to vin decode response
+func (dc DecodeVINQueryHandler) hydrateResponseFromVinNumber(vn *models.VinNumber) *p_grpc.DecodeVinResponse {
+	if vn == nil {
+		return nil
+	}
+	// call on-chain svc to get the DD and pull out the powertrain
+	pt := ""
+	tblDef, manufID, err := dc.deviceDefinitionOnChainService.GetDefinitionByID(context.Background(), vn.DefinitionID, dc.dbs().Reader)
+	if err == nil && tblDef != nil {
+		for _, attribute := range tblDef.Metadata.DeviceAttributes {
+			if attribute.Name == common.PowerTrainType {
+				pt = attribute.Value
+			}
+		}
+		if pt == "" {
+			makeName, _ := dc.deviceDefinitionOnChainService.GetManufacturerNameByID(context.Background(), manufID)
+			pt, _ = dc.powerTrainTypeService.ResolvePowerTrainType(shared.SlugString(makeName), shared.SlugString(tblDef.Model), null.JSON{}, null.JSON{})
+		}
+	}
+
+	resp := &p_grpc.DecodeVinResponse{
+		Manufacturer:  vn.ManufacturerName,
+		Year:          int32(vn.Year),
+		DeviceStyleId: vn.StyleID.String,
+		Source:        vn.DecodeProvider.String,
+		DefinitionId:  vn.DefinitionID,
+		Powertrain:    pt,
+	}
+
+	return resp
+}
+
 // processDeviceStyle saves new styles if needed to db and returns the style database ID
 func (dc DecodeVINQueryHandler) processDeviceStyle(ctx context.Context, vinInfo *coremodels.VINDecodingInfoData, definitionID, powertrain string) (string, error) {
 	externalStyleID := shared.SlugString(vinInfo.StyleName)
@@ -425,10 +437,10 @@ func (dc DecodeVINQueryHandler) saveVinDecodeNumber(ctx context.Context, vin sha
 	vinDecodeNumber := &models.VinNumber{
 		Vin:              vin.String(),
 		ManufacturerName: resp.Manufacturer,
-		Wmi:              vin.Wmi(),
-		VDS:              vin.VDS(),
-		Vis:              vin.VIS(),
-		CheckDigit:       vin.CheckDigit(),
+		Wmi:              null.StringFrom(vin.Wmi()),
+		VDS:              null.StringFrom(vin.VDS()),
+		Vis:              null.StringFrom(vin.VIS()),
+		CheckDigit:       null.StringFrom(vin.CheckDigit()),
 		SerialNumber:     vin.SerialNumber(),
 		DecodeProvider:   null.StringFrom(string(vinInfo.Source)),
 		Year:             int(resp.Year),

internal/core/queries/decode_vin_test.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
+	"math/big"
 	"strconv"
 	"strings"
 	"testing"
@@ -190,8 +191,48 @@ func (s *DecodeVINQueryHandlerSuite) TestHandle_Success_WithExistingDD_UpdatesAt
 
 }
 
-// using existing WMI
+// todo two new test: WMI oem conflict, same WMI for different Make name
+
+// Japan
+func (s *DecodeVINQueryHandlerSuite) TestHandle_Success_JapanChassisNumber_existingVIN() {
+	const vin = "ZWR90-8000186" // toyota something or other
+
+	dm := dbtesthelper.SetupCreateMake(s.T(), "Toyota", s.pdb)
+	dd := dbtesthelper.SetupCreateDeviceDefinitionWithVehicleInfo(s.T(), dm, "Yaris", 2024, s.pdb)
+
+	vinNumb := models.VinNumber{
+		Vin:              vin,
+		SerialNumber:     "8000186",
+		ManufacturerName: dm.Name,
+		DefinitionID:     dd.ID,
+		Year:             2024,
+		DecodeProvider:   null.StringFrom("manual"),
+	}
+	err := vinNumb.Insert(s.ctx, s.pdb.DBS().Writer, boil.Infer())
+	s.Require().NoError(err)
+	// mock setup for powertrain lookup, which is in the vin decode response
+	s.mockDeviceDefinitionOnChainService.EXPECT().GetDefinitionByID(gomock.Any(), dd.ID, gomock.Any()).Return(
+		&coremodels.DeviceDefinitionTablelandModel{
+			ID:         dd.ID,
+			Model:      dd.Model,
+			Year:       dd.Year,
+			DeviceType: common.DefaultDeviceType,
+			Metadata: &coremodels.DeviceDefinitionMetadata{DeviceAttributes: []coremodels.DeviceTypeAttribute{
+				{Name: "powertrain_type", Value: "ICE"},
+			}},
+		}, big.NewInt(1), nil)
 
+	qryResult, err := s.queryHandler.Handle(s.ctx, &DecodeVINQuery{VIN: vin, Country: country})
+	s.NoError(err)
+	result := qryResult.(*p_grpc.DecodeVinResponse)
+
+	s.NotNil(result, "expected result not nil")
+	s.Assert().Equal(int32(2024), result.Year)
+	s.Assert().Equal(dd.ID, result.DefinitionId)
+	s.Assert().Equal(dm.Name, result.Manufacturer)
+}
+
+// using existing WMI
 func (s *DecodeVINQueryHandlerSuite) TestHandle_Success_CreatesDD() {
 	ctx := context.Background()
 	const vin = "1FMCU0G61MUA52727" // ford escape 2021
@@ -300,7 +341,7 @@ func (s *DecodeVINQueryHandlerSuite) TestHandle_Success_CreatesDD() {
 	s.Assert().True(vn.DrivlyData.Valid)
 	s.Assert().Equal(2021, vn.Year)
 	s.Assert().Equal(definitionID, vn.DefinitionID)
-	s.Assert().Equal(wmi, vn.Wmi)
+	s.Assert().Equal(wmi, vn.Wmi.String)
 	s.Assert().Equal("drivly", vn.DecodeProvider.String)
 	s.Assert().Equal(vin, vn.Vin)
 	s.Assert().Equal(vinInfoResp.Model, gjson.GetBytes(vn.DrivlyData.JSON, "model").String())
@@ -585,20 +626,29 @@ func (s *DecodeVINQueryHandlerSuite) TestHandle_Success_WithExistingVINNumber()
 	v := shared.VIN(vin)
 	vinNumb := models.VinNumber{
 		Vin:              vin,
-		Wmi:              v.Wmi(),
-		VDS:              v.VDS(),
-		CheckDigit:       v.CheckDigit(),
+		Wmi:              null.StringFrom(v.Wmi()),
+		VDS:              null.StringFrom(v.VDS()),
+		CheckDigit:       null.StringFrom(v.CheckDigit()),
 		SerialNumber:     v.SerialNumber(),
-		Vis:              v.VIS(),
+		Vis:              null.StringFrom(v.VIS()),
 		ManufacturerName: dm.Name,
 		DefinitionID:     dd.ID,
 		Year:             2021,
 		DecodeProvider:   null.StringFrom("drivly"),
 	}
 	err = vinNumb.Insert(s.ctx, s.pdb.DBS().Writer, boil.Infer())
 	s.Require().NoError(err)
-	// when we get the vin already found, we lookup the powertrain using powertrain service
-	s.mockPowerTrainTypeService.EXPECT().ResolvePowerTrainType("ford", "escape", vinNumb.DrivlyData, vinNumb.VincarioData)
+	// mock needed for powertrain lookup
+	s.mockDeviceDefinitionOnChainService.EXPECT().GetDefinitionByID(gomock.Any(), dd.ID, gomock.Any()).Return(
+		&coremodels.DeviceDefinitionTablelandModel{
+			ID:         dd.ID,
+			Model:      dd.Model,
+			Year:       dd.Year,
+			DeviceType: common.DefaultDeviceType,
+			Metadata: &coremodels.DeviceDefinitionMetadata{DeviceAttributes: []coremodels.DeviceTypeAttribute{
+				{Name: "powertrain_type", Value: "ICE"},
+			}},
+		}, big.NewInt(1), nil)
 
 	qryResult, err := s.queryHandler.Handle(s.ctx, &DecodeVINQuery{VIN: vin, Country: country})
 	s.NoError(err)

internal/infrastructure/db/migrations/20250502120939_rename_me.sql

@@ -0,0 +1,45 @@
+-- +goose Up
+-- +goose StatementBegin
+SELECT 'up SQL query';
+alter table vin_numbers
+    alter column vin type varchar(17) using vin::varchar(17);
+
+alter table vin_numbers
+    alter column wmi drop not null;
+
+alter table vin_numbers
+    alter column vds drop not null;
+
+alter table vin_numbers
+    alter column check_digit drop not null;
+
+alter table vin_numbers
+    alter column serial_number type varchar(10) using serial_number::varchar(10);
+
+alter table vin_numbers
+    alter column vis drop not null;
+
+alter table vin_numbers
+    add vin17_data jsonb;
+
+-- +goose StatementEnd
+
+-- +goose Down
+-- +goose StatementBegin
+SELECT 'down SQL query';
+
+alter table vin_numbers
+    drop vin17_data;
+
+alter table vin_numbers
+    alter column wmi set not null;
+
+alter table vin_numbers
+    alter column vds set not null;
+
+alter table vin_numbers
+    alter column check_digit set not null;
+
+alter table vin_numbers
+    alter column vis set not null;
+-- +goose StatementEnd