/// <summary>
/// Builds and returns a <see cref="INameExpression" /> instance which can be used to generate name from the provided expression
/// </summary>
/// <param name="sportEvent">A <see cref="ISportEvent" /> instance representing associated sport @event</param>
/// <param name="specifiers">A <see cref="IReadOnlyDictionary{String, String}" /> representing specifiers of the associated market</param>
/// <param name="operator">A <see cref="string" /> specifying the operator for which to build the expression</param>
/// <param name="operand">An operand for the built expression</param>
/// <returns>The constructed <see cref="INameExpression" /> instance</returns>
public INameExpression BuildExpression(ISportEvent sportEvent, IReadOnlyDictionary <string, string> specifiers, string @operator, string operand)
{
if (sportEvent == null)
{
throw new ArgumentNullException(nameof(sportEvent));
}
if (string.IsNullOrEmpty(operand))
{
throw new ArgumentNullException(nameof(operand));
}
if (@operator == null)
{
EnsureSpecifiersNotNullOrEmpty(specifiers);
Contract.Assume(specifiers != null && specifiers.Any());
return(new CardinalNameExpression(_operandFactory.BuildOperand(specifiers, operand)));
}
switch (Array.IndexOf(NameExpressionHelper.DefinedOperators, @operator))
{
case 0: //+
{
EnsureSpecifiersNotNullOrEmpty(specifiers);
Contract.Assume(specifiers != null && specifiers.Any());
return(new PlusNameExpression(_operandFactory.BuildOperand(specifiers, operand)));
}
case 1: //-
{
EnsureSpecifiersNotNullOrEmpty(specifiers);
Contract.Assume(specifiers != null && specifiers.Any());
return(new MinusNameExpression(_operandFactory.BuildOperand(specifiers, operand)));
}
case 2: //$
{
return(BuildEntityNameExpression(operand, sportEvent));
}
case 3: //!
{
EnsureSpecifiersNotNullOrEmpty(specifiers);
Contract.Assume(specifiers != null && specifiers.Any());
return(new OrdinalNameExpression(_operandFactory.BuildOperand(specifiers, operand)));
}
case 4: //%
{
EnsureSpecifiersNotNullOrEmpty(specifiers);
Contract.Assert(specifiers != null && specifiers.Any());
return(new PlayerProfileExpression(_profileCache, _operandFactory.BuildOperand(specifiers, operand)));
}
default:
{
throw new ArgumentException($"Operator {@operator} is not supported. Supported operators are: {string.Join(",", NameExpressionHelper.DefinedOperators)}", nameof(@operator));
}
}
}
public void OrdinalNameExpressionTest()
{
var specifiers = new Dictionary <string, string> {
{ "reply_nr", "1" }
};
var expression = new OrdinalNameExpression(_operandFactory.BuildOperand(new ReadOnlyDictionary <string, string>(specifiers), "reply_nr"));
var result = expression.BuildNameAsync(new CultureInfo("en")).Result;
Assert.AreEqual("1st", result, "The result is not correct");
}
public void player_profile_expression_returns_correct_value()
{
var specifiers = new Dictionary <string, string> {
{ "player", "sr:player:1" }
};
var expression = new PlayerProfileExpression(_profileCache, _operandFactory.BuildOperand(new ReadOnlyDictionary <string, string>(specifiers), "player"));
var result = expression.BuildNameAsync(TestData.Culture).Result;
Assert.AreEqual(
_profileCache.GetPlayerProfileAsync(URN.Parse("sr:player:1"), new [] { TestData.Culture }).Result.GetName(TestData.Culture),
result, "The result is not correct");
}
public void ZeroIsHandledCorrectly()
{
var specifiers = new ReadOnlyDictionary <string, string>(new Dictionary <string, string> {
{ Specifier, "0" }
});
var expression = new PlusNameExpression(_operandFactory.BuildOperand(specifiers, Specifier));
var name = expression.BuildNameAsync(CultureInfo.InvariantCulture).Result;
Assert.AreEqual("0", name, "Value of name is not correct");
}
public void missing_left_parenthesis_throws()
{
_factory.BuildOperand(
BuildSpecifiers(Specifier, "1"),
"total+1)");
}
