public static void ChangeBackendNcdCalculationValueTo(ProgrammingService programmingService, PsdzBackendNcdCalculationEtoEnum backendNcdCalculation)
        {
#if false
            string configString = ConfigSettings.getConfigString("BMW.Rheingold.Programming.Security.SC.BackendNcdCalculationMode");
            if (!string.IsNullOrEmpty(configString) && Enum.IsDefined(typeof(PsdzBackendNcdCalculationEtoEnum), configString))
            {
                SecureCodingConfigWrapper.GetSecureCodingConfig().BackendNcdCalculationEtoEnum = (PsdzBackendNcdCalculationEtoEnum)Enum.Parse(typeof(PsdzBackendNcdCalculationEtoEnum), configString);
                return;
            }
#endif
            SecureCodingConfigWrapper.GetSecureCodingConfig(programmingService).BackendNcdCalculationEtoEnum = backendNcdCalculation;
        }
        public static void ChangeNcdRecalculationValueTo(ProgrammingService programmingService, PsdzNcdRecalculationEtoEnum psdzNcdRecalculation)
        {
#if false
            string value = ConfigSettings.getConfigString("BMW.Rheingold.Programming.Security.SC.NcdRecalculationEnum").ToUpper();
            if (!string.IsNullOrEmpty(value) && Enum.IsDefined(typeof(PsdzNcdRecalculationEtoEnum), value))
            {
                SecureCodingConfigWrapper.GetSecureCodingConfig().NcdRecalculationEtoEnum = (PsdzNcdRecalculationEtoEnum)Enum.Parse(typeof(PsdzNcdRecalculationEtoEnum), value);
                return;
            }
#endif
            SecureCodingConfigWrapper.GetSecureCodingConfig(programmingService).NcdRecalculationEtoEnum = psdzNcdRecalculation;
        }
 public static PsdzSecureCodingConfigCto GetSecureCodingConfig(ProgrammingService programmingService)
 {
     if (SecureCodingConfigWrapper.instance == null)
     {
         object obj = SecureCodingConfigWrapper.@lock;
         lock (obj)
         {
             if (SecureCodingConfigWrapper.instance == null)
             {
                 SecureCodingConfigWrapper.instance = new SecureCodingConfigWrapper(programmingService).SecureCodingConfigCto;
             }
         }
     }
     return(SecureCodingConfigWrapper.instance);
 }
        private SecureCodingConfigWrapper(ProgrammingService programmingService)
        {
            this.SecureCodingConfigCto = new PsdzSecureCodingConfigCto();
#if false
            if (ConfigSettings.getConfigStringAsBoolean("BMW.Rheingold.Programming.Security.SC.UseOnlineNCD", false))
            {
                string configString = ConfigSettings.getConfigString("BMW.Rheingold.Programming.Security.SC.BackendNcdCalculationMode");
                if (!string.IsNullOrEmpty(configString) && Enum.IsDefined(typeof(PsdzBackendNcdCalculationEtoEnum), configString))
                {
                    this.SecureCodingConfigCto.BackendNcdCalculationEtoEnum = (PsdzBackendNcdCalculationEtoEnum)Enum.Parse(typeof(PsdzBackendNcdCalculationEtoEnum), configString);
                }
                else
                {
                    this.SecureCodingConfigCto.BackendNcdCalculationEtoEnum = PsdzBackendNcdCalculationEtoEnum.MUST_NOT;
                }
                this.SecureCodingConfigCto.BackendSignatureEtoEnum = PsdzBackendSignatureEtoEnum.MUST_NOT;
                string value = ConfigSettings.getConfigString("BMW.Rheingold.Programming.Security.SC.NcdRecalculationEnum").ToUpper();
                if (!string.IsNullOrEmpty(value) && Enum.IsDefined(typeof(PsdzNcdRecalculationEtoEnum), value))
                {
                    this.SecureCodingConfigCto.NcdRecalculationEtoEnum = (PsdzNcdRecalculationEtoEnum)Enum.Parse(typeof(PsdzNcdRecalculationEtoEnum), value);
                }
                else
                {
                    this.SecureCodingConfigCto.NcdRecalculationEtoEnum = PsdzNcdRecalculationEtoEnum.ALLOW;
                }
            }
            else
#endif
            {
                this.SecureCodingConfigCto.BackendNcdCalculationEtoEnum = PsdzBackendNcdCalculationEtoEnum.MUST_NOT;
                this.SecureCodingConfigCto.BackendSignatureEtoEnum      = PsdzBackendSignatureEtoEnum.MUST_NOT;
                this.SecureCodingConfigCto.NcdRecalculationEtoEnum      = PsdzNcdRecalculationEtoEnum.ALLOW;
            }
            this.SecureCodingConfigCto.ConnectionTimeout = 5000;
            this.SecureCodingConfigCto.ScbPollingTimeout = 120;
            this.SecureCodingConfigCto.NcdRootDirectory  = Path.Combine(programmingService.BackupDataPath, NcdRoot);
            this.SecureCodingConfigCto.Retries           = 3;
            this.SecureCodingConfigCto.Crls = null;
            this.SecureCodingConfigCto.SwlSecBackendUrls = null;
            this.SecureCodingConfigCto.ScbUrls           = new List <string>
            {
                string.Empty
                //BackendConnector.GetBackendServiceUrl(BackendServiceType.SecureCoding, ContextError.SecureCoding).ResultObject
            };
            this.SecureCodingConfigCto.PsdzAuthenticationTypeEto = PsdzAuthenticationTypeEto.SSL;
        }
 public static string GetSecureCodingPathWithVin(ProgrammingService programmingService, string vin)
 {
     return(Path.Combine(programmingService.BackupDataPath, NcdRoot, vin));
 }
Exemple #6
0
        public bool UpdateVehicle(ProgrammingService programmingService, IPsdzStandardSvt psdzStandardSvt)
        {
            if (Vehicle == null)
            {
                return(false);
            }

            ProgrammingObjectBuilder programmingObjectBuilder = programmingService.ProgrammingInfos.ProgrammingObjectBuilder;

            Vehicle.VehicleIdentLevel       = IdentificationLevel.VINVehicleReadout;
            Vehicle.VehicleIdentAlreadyDone = true;
            Vehicle.ILevelWerk  = IstufeShipment;
            Vehicle.ILevel      = IstufeCurrent;
            Vehicle.BNType      = GetBnType();
            Vehicle.VIN17       = DetectVehicle.Vin;
            Vehicle.Modelljahr  = DetectVehicle.ConstructYear;
            Vehicle.Modellmonat = DetectVehicle.ConstructMonth;
            Vehicle.SetVINRangeTypeFromVINRanges();

            CharacteristicExpression.EnumBrand brand = CharacteristicExpression.EnumBrand.BMWBMWiMINI;
            if (Vehicle.IsMotorcycle())
            {
                brand = CharacteristicExpression.EnumBrand.BMWMotorrad;
            }

            ClientContext clientContext = ClientContext.GetClientContext(Vehicle);

            if (clientContext != null)
            {
                clientContext.SelectedBrand = brand;
            }

            for (int i = 0; i < 2; i++)
            {
                ObservableCollection <ECU> EcuList = new ObservableCollection <ECU>();
                foreach (PdszDatabase.EcuInfo ecuInfo in DetectVehicle.EcuList)
                {
                    IEcuObj ecuObj = programmingObjectBuilder.Build(ecuInfo.PsdzEcu);
                    ECU     ecu    = programmingObjectBuilder.Build(ecuObj);
                    if (ecu != null)
                    {
                        if (string.IsNullOrEmpty(ecu.ECU_NAME))
                        {
                            ecu.ECU_NAME = ecuInfo.Name;
                        }

                        if (string.IsNullOrEmpty(ecu.ECU_SGBD))
                        {
                            ecu.ECU_SGBD = ecuInfo.Sgbd;
                        }

                        if (string.IsNullOrEmpty(ecu.ECU_GRUPPE))
                        {
                            ecu.ECU_GRUPPE = ecuInfo.Grp;
                        }
                        EcuList.Add(ecu);
                    }
                }

                Vehicle.ECU = EcuList;
            }

            List <PdszDatabase.Characteristics> characteristicsList = programmingService.PdszDatabase.GetVehicleCharacteristics(Vehicle);

            if (characteristicsList == null)
            {
                return(false);
            }
            VehicleCharacteristicIdent vehicleCharacteristicIdent = new VehicleCharacteristicIdent();

            foreach (PdszDatabase.Characteristics characteristics in characteristicsList)
            {
                if (!vehicleCharacteristicIdent.AssignVehicleCharacteristic(characteristics.RootNodeClass, Vehicle, characteristics))
                {
                    return(false);
                }
            }

            return(true);
        }