Ejemplo n.º 1
0
        public object Clone()
        {
            ClientDefinition clientDefinition = new ClientDefinition();

            if (this.country != null)
            {
                clientDefinition.country = string.Copy(this.country);
            }
            clientDefinition.countryId  = this.countryId;
            clientDefinition.clientDate = this.clientDate;
            clientDefinition.accessSiFa = this.accessSiFa;
            if (this.brandAuthorization != null)
            {
                clientDefinition.brandAuthorization = string.Copy(this.brandAuthorization);
            }
            if (this.brandIds != null)
            {
                clientDefinition.brandIds = (long[])this.brandIds.Clone();
            }
            if (this.productType != null)
            {
                clientDefinition.productType = string.Copy(this.productType);
            }
            return(clientDefinition);
        }
Ejemplo n.º 2
0
 public override EEvaluationResult EvaluateVariantRule(ClientDefinition client, CharacteristicSet baseConfiguration, EcuConfiguration ecus)
 {
     if (ecus.IStufe != this.value && ecus.IStufe != 0L)
     {
         return(EEvaluationResult.INVALID);
     }
     return(EEvaluationResult.VALID);
 }
Ejemplo n.º 3
0
 public override EEvaluationResult EvaluateVariantRule(ClientDefinition client, CharacteristicSet baseConfiguration, EcuConfiguration ecus)
 {
     if (client.ClientDate >= DateTime.FromBinary(this.value))
     {
         return(EEvaluationResult.VALID);
     }
     return(EEvaluationResult.INVALID);
 }
Ejemplo n.º 4
0
 public override EEvaluationResult EvaluateVariantRule(ClientDefinition client, CharacteristicSet baseConfiguration, EcuConfiguration ecus)
 {
     if (ecus.SaLaPas.Count != 0 && ecus.SaLaPas.ToList <long>().BinarySearch(this.value) < 0)
     {
         return(EEvaluationResult.INVALID);
     }
     return(EEvaluationResult.VALID);
 }
Ejemplo n.º 5
0
 public override EEvaluationResult EvaluateVariantRule(ClientDefinition client, CharacteristicSet baseConfiguration, EcuConfiguration ecus)
 {
     if (ecus.EcuVariants.ToList <long>().BinarySearch(this.value) >= 0)
     {
         return(EEvaluationResult.VALID);
     }
     if (ecus.UnknownEcuVariants.ToList <long>().BinarySearch(this.value) >= 0)
     {
         return(EEvaluationResult.MISSING_VARIANT);
     }
     return(EEvaluationResult.INVALID);
 }
Ejemplo n.º 6
0
        public override EEvaluationResult EvaluateVariantRule(ClientDefinition client, CharacteristicSet baseConfiguration, EcuConfiguration ecus)
        {
            long num;

            if (!baseConfiguration.Characteristics.TryGetValue(this.dataclassId, out num))
            {
                return(EEvaluationResult.MISSING_CHARACTERISTIC);
            }
            if (num == this.datavalueId)
            {
                return(EEvaluationResult.VALID);
            }
            return(EEvaluationResult.INVALID);
        }
Ejemplo n.º 7
0
        public override EEvaluationResult EvaluateVariantRule(ClientDefinition client, CharacteristicSet baseConfiguration, EcuConfiguration ecus)
        {
            EEvaluationResult eevaluationResult = this.operand.EvaluateVariantRule(client, baseConfiguration, ecus);

            if (eevaluationResult == EEvaluationResult.VALID)
            {
                return(EEvaluationResult.INVALID);
            }
            if (eevaluationResult == EEvaluationResult.INVALID)
            {
                return(EEvaluationResult.VALID);
            }
            return(eevaluationResult);
        }
Ejemplo n.º 8
0
        public override EEvaluationResult EvaluateVariantRule(ClientDefinition client, CharacteristicSet baseConfiguration, EcuConfiguration ecus)
        {
            bool flag = false;

            this.missingCharacteristics.Clear();
            this.missingVariants.Clear();
            EEvaluationResult result = EEvaluationResult.INVALID;

            foreach (RuleExpression ruleExpression in this.operands)
            {
                EEvaluationResult eevaluationResult = ruleExpression.EvaluateVariantRule(client, baseConfiguration, ecus);
                switch (eevaluationResult)
                {
                case EEvaluationResult.VALID:
                    this.missingCharacteristics.Clear();
                    this.missingVariants.Clear();
                    return(eevaluationResult);

                case EEvaluationResult.INVALID:
                    break;

                case EEvaluationResult.MISSING_CHARACTERISTIC:
                    this.missingCharacteristics.AddRange(ruleExpression.GetUnknownCharacteristics(baseConfiguration));
                    if (!flag)
                    {
                        flag   = true;
                        result = eevaluationResult;
                    }
                    break;

                case EEvaluationResult.MISSING_VARIANT:
                    this.missingVariants.AddRange(ruleExpression.GetUnknownVariantIds(ecus));
                    if (!flag)
                    {
                        flag   = true;
                        result = eevaluationResult;
                    }
                    break;

                default:
                    throw new Exception("Unknown result");
                }
            }
            return(result);
        }
Ejemplo n.º 9
0
 public override EEvaluationResult EvaluateVariantRule(ClientDefinition client, CharacteristicSet baseConfiguration, EcuConfiguration ecus)
 {
     if (client.AccessSiFa)
     {
         if (this.value == 0L)
         {
             return(EEvaluationResult.INVALID);
         }
         return(EEvaluationResult.VALID);
     }
     else
     {
         if (this.value == 0L)
         {
             return(EEvaluationResult.VALID);
         }
         return(EEvaluationResult.INVALID);
     }
 }
Ejemplo n.º 10
0
        public override EEvaluationResult EvaluateVariantRule(ClientDefinition client, CharacteristicSet baseConfiguration, EcuConfiguration ecus)
        {
            if (baseConfiguration.ProdDates.Count == 0)
            {
                return(EEvaluationResult.MISSING_CHARACTERISTIC);
            }
            int num = baseConfiguration.ProdDates.BinarySearch(this.datevalue);

            switch (this.compareOperator)
            {
            case CompareExpression.ECompareOperator.EQUAL:
                if (num < 0)
                {
                    return(EEvaluationResult.INVALID);
                }
                return(EEvaluationResult.VALID);

            case CompareExpression.ECompareOperator.NOT_EQUAL:
                if (num >= 0)
                {
                    return(EEvaluationResult.INVALID);
                }
                return(EEvaluationResult.VALID);

            case CompareExpression.ECompareOperator.GREATER:
                if (num >= 0 && num < baseConfiguration.ProdDates.Count - 1)
                {
                    return(EEvaluationResult.VALID);
                }
                if (baseConfiguration.ProdDates.Count > 0 && baseConfiguration.ProdDates[0] > this.datevalue)
                {
                    return(EEvaluationResult.VALID);
                }
                return(EEvaluationResult.INVALID);

            case CompareExpression.ECompareOperator.GREATER_EQUAL:
                if (num >= 0)
                {
                    return(EEvaluationResult.VALID);
                }
                if (baseConfiguration.ProdDates.Count > 0 && baseConfiguration.ProdDates[0] > this.datevalue)
                {
                    return(EEvaluationResult.VALID);
                }
                return(EEvaluationResult.INVALID);

            case CompareExpression.ECompareOperator.LESS:
                if (num > 0)
                {
                    return(EEvaluationResult.VALID);
                }
                if (baseConfiguration.ProdDates.Count > 0 && baseConfiguration.ProdDates[baseConfiguration.ProdDates.Count - 1] < this.datevalue)
                {
                    return(EEvaluationResult.VALID);
                }
                return(EEvaluationResult.INVALID);

            case CompareExpression.ECompareOperator.LESS_EQUAL:
                if (num >= 0)
                {
                    return(EEvaluationResult.VALID);
                }
                if (baseConfiguration.ProdDates.Count > 0 && baseConfiguration.ProdDates[baseConfiguration.ProdDates.Count - 1] < this.datevalue)
                {
                    return(EEvaluationResult.VALID);
                }
                return(EEvaluationResult.INVALID);

            default:
                throw new Exception("Unknown logical operator");
            }
        }
Ejemplo n.º 11
0
 public override EEvaluationResult EvaluateVariantRule(ClientDefinition client, CharacteristicSet baseConfiguration, EcuConfiguration ecus)
 {
     return(EEvaluationResult.INVALID);
 }