/// <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);
}
