cloud-services/pkg/usecase_helpers/get_cds.go

package usecase_helpers

import (
	"encoding/hex"
	"encoding/json"
	"fmt"
	"strings"

	"github.com/fiskerinc/cloud-services/pkg/common"
	"github.com/fiskerinc/cloud-services/pkg/db/queries"
	"github.com/fiskerinc/cloud-services/pkg/logger"
	"github.com/fiskerinc/cloud-services/pkg/utils/envtool"
	"github.com/fiskerinc/cloud-services/pkg/utils/vod"
	vconfig "github.com/fiskerinc/cloud-services/pkg/vehicleconfig"
	"github.com/go-pg/pg/v10"
	"github.com/pkg/errors"
)

var noCDSResult = map[string]string{}

func GetCDS(config vconfig.ConfigServiceInterface, ccd queries.CarConfigDataInterface, vin string) (map[string]string, error) {
	// if SAP is not available, get the stored feature codes instead
	conf, err := getStoredFeatureCodes(vin, ccd)
	if err != nil {
		logger.At(logger.Error(), common.TRex.Key(vin), "update").
			Err(err).Send()

		return nil, err
	}

	if len(conf.Features) == 0 {
		return noCDSResult, nil
	}

	featureCodes := make([]string, 0, len(conf.Features))
	for _, f := range conf.Features {
		featureCodes = append(featureCodes, f.FeatureCode)
	}

	sYear := fmt.Sprint(conf.ModelYear)
	if len(sYear) > 2 {
		sYear = sYear[2:]
	}

	pdxVersion := getPDXVersion(vin)
	vodcdsReq := common.NewVODCDSRequest()
	vodcdsReq.ModelYear = sYear
	vodcdsReq.VersionDModelYear = conf.VersionDuringModelYear
	vodcdsReq.FeatureCodes = featureCodes
	vodcdsReq.PDXIndexVersion = pdxVersion
	vodcdsReq.VehicleVIN = vin

	cdsMap, err := config.GetCDS(vodcdsReq)
	if err != nil {
		logger.At(logger.Error(), common.TRex.Key(vin), "update").
			Str("request", fmt.Sprintf("%v", vodcdsReq)).
			Err(err).Send()
		return nil, err
	}

	// Lazy way to fix some tests instead of fixing the tests
	bcm, ok := cdsMap["BCM"]
	if ok {
		bcm = overwriteBCMBeep(bcm)
		bcm = overwriteBCMSequentialLighting(bcm)
		cdsMap["BCM"] = bcm
	}
	icc, ok := cdsMap["ICC"]
	if ok {
		icc = overwriteICCHotSpot(icc)
		cdsMap["ICC"] = icc
	}

	cdsMap = cdsNameTransform(cdsMap)
	cdsMap = cdsRemoval(cdsMap)
	return cdsMap, nil
}

func overwriteBCMBeep(bcm string) string {
	// COD_Sirene_Master_beep_type adding rule 161300 -> no beep.
	bcmR := []rune(bcm)
	bcmR[39] = '0'
	bcm = string(bcmR)

	return overwriteCalc(bcm)
}

func overwriteBCMSequentialLighting(bcm string) string {
	bcmR := []rune(bcm)
	bcmR[25] = '1'
	bcm = string(bcmR)

	return overwriteCalc(bcm)
}

func overwriteICCHotSpot(icc string) string {
	// COD_Car_as_Hotspot removal of rule 130100 -> without. !130100 is with hotspot
	iccR := []rune(icc)
	iccR[127] = '1'
	icc = string(iccR)

	return overwriteCalc(icc)
}

// Given the modified coding string, we will calculate the hex values and such
func overwriteCalc(ecu string) string {
	vodHelper := vod.NewVODHelper(false, false, false)

	hexECU, err := hex.DecodeString(ecu)
	if err != nil {
		panic(err)
	}
	// chop off CRC
	hexECU = hexECU[:len(hexECU)-1]
	// CRC does not include short vin value
	steinway := hexECU[9:]
	crc := vodHelper.GenerateCRC(steinway)
	//crc := crc8.Checksum(hexBCMData, v.table)

	hexECU = append(hexECU, crc)

	ecu = hex.EncodeToString(hexECU)
	ecu = strings.ToUpper(ecu)
	return ecu
}

func getStoredFeatureCodes(vin string, db queries.CarConfigDataInterface) (common.SAPResponse, error) {
	config, err := db.SelectByVIN(vin)
	if err != nil {
		if errors.Is(err, pg.ErrNoRows) {
			// Default config if none is available in db
			config = common.CarConfigData{
				ConfigData: `{"modelYear":0,"versionDuringModelYear":"","modelType":"","features":[]}`,
			}
			err = nil
		} else {
			return common.SAPResponse{}, err
		}
	}

	var parsedConfig common.SAPResponse

	err = json.Unmarshal([]byte(config.ConfigData), &parsedConfig)

	return parsedConfig, err
}

func getPDXVersion(vin string) (pdxVersion string) {
	return envtool.GetEnv("PDX_FILE_VERSION", "V3.20.0")
}

// Need to replace certain names to match up with new ones, and remove ECU's that arn't being coded
func cdsNameTransform(cdsMap map[string]string) map[string]string {
	for ecuName, ecuReplacement := range common.ECUReplacement() {
		cdsString, ok := cdsMap[ecuName]
		if !ok {
			continue
		}
		delete(cdsMap, ecuName)
		cdsMap[ecuReplacement] = cdsString
	}
	return cdsMap
}

// Run this after the name transform. If the ecu is not in the list to send, don't send it
func cdsRemoval(cdsMap map[string]string) map[string]string {
	for ecuName := range cdsMap {
		_, ok := common.FilterECUConfigurationMap[ecuName]
		if ok {
			delete(cdsMap, ecuName)
		}
	}
	return cdsMap
}