/// <summary> /// Constructs the condition with the details /// </summary> /// <param name="signature">The conditions signature</param> /// <param name="valueType">The value type</param> /// <param name="value">The parsed value</param> public BooleanConditionValue ( string signature, NettleValueType valueType, object value ) { Validate.IsNotEmpty(signature); this.Signature = signature; this.ValueType = valueType; this.Value = value; }
/// <summary> /// Parses the value signature into the value type specified /// </summary> /// <param name="type">The value type</param> /// <param name="signature">The value signature</param> /// <returns>The parsed value</returns> public static object ParseValue ( this NettleValueType type, string signature ) { if (String.IsNullOrEmpty(signature)) { return(null); } var convertedValue = default(object); switch (type) { case NettleValueType.String: { if (signature.Equals("\"\"")) { convertedValue = String.Empty; } else if (signature.StartsWith("\"") && signature.EndsWith("\"")) { convertedValue = signature.Crop ( 1, signature.Length - 2 ); } else { convertedValue = signature; } break; } case NettleValueType.Number: { convertedValue = Double.Parse(signature); break; } case NettleValueType.Boolean: { convertedValue = Boolean.Parse(signature); break; } case NettleValueType.ModelBinding: { var bindingPath = signature; if (bindingPath.StartsWith(@"{{") && bindingPath.EndsWith(@"}}")) { bindingPath = bindingPath.Crop ( 2, bindingPath.Length - 3 ); } if (bindingPath.StartsWith(@"$") && bindingPath.Length > 1) { // Ensure a property reference isn't being made on the model if (false == bindingPath.StartsWith(@"$.")) { bindingPath = bindingPath.Crop(1); } } convertedValue = bindingPath; break; } case NettleValueType.Variable: { // NOTE: this isn't resolvable until runtime convertedValue = signature; break; } case NettleValueType.Function: { var functionParser = new FunctionParser(); var templateContent = String.Copy(signature); var positionOffset = default(int); convertedValue = functionParser.Parse ( ref templateContent, ref positionOffset, signature ); break; } case NettleValueType.BooleanExpression: { var expressionParser = new BooleanExpressionParser(); var expression = signature; if (expression.StartsWith(@"(") && expression.EndsWith(@")")) { expression = expression.Crop ( 1, expression.Length - 2 ); } convertedValue = expressionParser.Parse ( expression ); break; } case NettleValueType.KeyValuePair: { var pairParser = new KeyValuePairParser(); convertedValue = pairParser.Parse ( signature ); break; } case NettleValueType.AnonymousType: { var typeParser = new AnonymousTypeParser(); convertedValue = typeParser.Parse ( signature ); break; } } return(convertedValue); }
/// <summary> /// Resolves a value by converting it to the Nettle value type specified /// </summary> /// <param name="context">The template context</param> /// <param name="rawValue">The raw value</param> /// <param name="type">The value type</param> /// <returns>The resolved value</returns> protected object ResolveValue ( ref TemplateContext context, object rawValue, NettleValueType type ) { if (rawValue == null) { return(null); } var resolvedValue = default(object); switch (type) { case NettleValueType.ModelBinding: { var bindingName = rawValue.ToString(); resolvedValue = ResolveBindingValue ( ref context, bindingName ); break; } case NettleValueType.Function: { if (rawValue != null && rawValue is FunctionCall) { var parsedFunction = (FunctionCall)rawValue; var result = ExecuteFunction ( ref context, parsedFunction ); resolvedValue = result.Output; break; } else { throw new NettleRenderException ( "The function call is invalid." ); } } case NettleValueType.Variable: { resolvedValue = context.ResolveVariableValue ( rawValue.ToString() ); break; } case NettleValueType.KeyValuePair: { var unresolvedPair = (UnresolvedKeyValuePair)rawValue; var key = ResolveValue ( ref context, unresolvedPair.ParsedKey, unresolvedPair.KeyType ); var value = ResolveValue ( ref context, unresolvedPair.ParsedValue, unresolvedPair.ValueType ); resolvedValue = new KeyValuePair <object, object> ( key, value ); break; } case NettleValueType.AnonymousType: { var unresolvedType = (UnresolvedAnonymousType)rawValue; var resolvedProperties = new Dictionary <string, object>(); foreach (var unresolvedProperty in unresolvedType.Properties) { var propertyValue = ResolveValue ( ref context, unresolvedProperty.RawValue, unresolvedProperty.ValueType ); resolvedProperties.Add ( unresolvedProperty.Name, propertyValue ); } // Convert the property dictionary to an expando object dynamic eo = resolvedProperties.Aggregate ( new ExpandoObject() as IDictionary <string, Object>, (a, p) => { a.Add(p.Key, p.Value); return(a); } ); resolvedValue = eo; break; } default: { resolvedValue = rawValue; break; } } return(resolvedValue); }