/// <summary>
/// Appends the key values according to the rules for formatting a key expression in an OData uri
/// </summary>
/// <param name="converter">The literal converter for formatting key values</param>
/// <param name="builder">The string builder to append to</param>
/// <param name="keyValues">The key values to append</param>
public static void AppendKeyExpression(this IODataLiteralConverter converter, StringBuilder builder, IEnumerable <NamedValue> keyValues)
{
ExceptionUtilities.CheckArgumentNotNull(converter, "converter");
ExceptionUtilities.CheckArgumentNotNull(builder, "builder");
ExceptionUtilities.CheckArgumentNotNull(keyValues, "keyValues");
var keyValuesList = keyValues.ToList();
builder.Append('(');
if (keyValuesList.Count == 1)
{
builder.Append(Uri.EscapeDataString(converter.SerializePrimitive(keyValues.Single().Value)));
}
else
{
bool first = true;
foreach (var keyValue in keyValuesList)
{
if (!first)
{
builder.Append(',');
}
else
{
first = false;
}
builder.Append(Uri.EscapeDataString(keyValue.Name));
builder.Append('=');
builder.Append(Uri.EscapeDataString(converter.SerializePrimitive(keyValue.Value)));
}
}
builder.Append(')');
}
/// <summary>
/// Constructs a weak etag using property values from the given instance
/// </summary>
/// <param name="converter">The converter to extend</param>
/// <param name="instance">The instance to get property values from</param>
/// <returns>A weak etag</returns>
public static string ConstructWeakETag(this IODataLiteralConverter converter, QueryStructuralValue instance)
{
// the other method will check that the instance is non null
string strongETag = converter.ConstructStrongETag(instance);
if (strongETag == null)
{
return(null);
}
return("W/" + strongETag);
}
/// <summary>
/// Constructs a strong etag using property values from the given instance
/// </summary>
/// <param name="converter">The converter to extend</param>
/// <param name="instance">The instance to get property values from</param>
/// <returns>A strong etag</returns>
public static string ConstructStrongETag(this IODataLiteralConverter converter, QueryStructuralValue instance)
{
ExceptionUtilities.CheckArgumentNotNull(instance, "instance");
var entityType = instance.Type as QueryEntityType;
ExceptionUtilities.CheckObjectNotNull(entityType, "Given structural instance was not an entity. Type was: {0}", instance.Type);
var properties = entityType.EntityType.AllProperties.Where(p => p.Annotations.OfType <ConcurrencyTokenAnnotation>().Any()).ToList();
if (!properties.Any())
{
return(null);
}
var values = properties.Select(p => instance.GetScalarValue(p.Name));
// TODO: pad any fixed-length fields
var pieces = values.Select(v => Uri.EscapeDataString(converter.SerializePrimitive(v.Value)));
var etag = string.Format(CultureInfo.InvariantCulture, "\"{0}\"", string.Join(",", pieces.ToArray()));
return(etag);
}
/// <summary>
/// Initializes a new instance of the UriExpressionVisitor class
/// </summary>
/// <param name="literalConverter">The literal converter to use</param>
public UriExpressionVisitor(IODataLiteralConverter literalConverter)
{
ExceptionUtilities.CheckArgumentNotNull(literalConverter, "literalConverter");
this.literalConverter = literalConverter;
}
/// <summary>
/// Converts the given value to a string according to the OData literal formatting rules
/// </summary>
/// <param name="converter">The converter.</param>
/// <param name="value">The value to serialize</param>
/// <returns>
/// The serialized value
/// </returns>
public static string SerializePrimitive(this IODataLiteralConverter converter, object value)
{
ExceptionUtilities.CheckArgumentNotNull(converter, "converter");
return(converter.SerializePrimitive(value, false));
}
/// <summary>
/// Initializes a new instance of the UriExpressionVisitor class
/// </summary>
/// <param name="literalConverter">The literal converter to use</param>
public UriExpressionVisitor(IODataLiteralConverter literalConverter)
{
ExceptionUtilities.CheckArgumentNotNull(literalConverter, "literalConverter");
this.literalConverter = literalConverter;
}
