public static List <KeyValuePair <object, string> > GetAllConditions()
{
return(Enum.GetValues(typeof(ConditionType))
.Cast <ConditionType> ()
.Select(c => new KeyValuePair <object, string> (c, PriceRuleCondition.TypeToString(c)))
.ToList());
}
public static List <KeyValuePair <object, string> > GetAllExceptions()
{
return(new []
{
ConditionType.Partner,
ConditionType.PartnerGroup,
ConditionType.Object,
ConditionType.ObjectGroup,
ConditionType.User,
ConditionType.UserGroup,
ConditionType.Good,
ConditionType.GoodGroup,
ConditionType.PaymentTypeUsed,
ConditionType.DatabaseUpdated
}
.Select(c => new KeyValuePair <object, string> (c, PriceRuleCondition.TypeToString(c)))
.ToList());
}
private bool ParseFormula()
{
string [] conditionsAndActions = Formula.Split(new [] { " THEN " }, StringSplitOptions.RemoveEmptyEntries);
if (conditionsAndActions.Length != 2)
{
return(false);
}
string prerequisitesString = conditionsAndActions [0];
int operationsStart = prerequisitesString.IndexOf("(operation", StringComparison.Ordinal);
string conditionsString = prerequisitesString.Substring(0, operationsStart);
string operationsString = prerequisitesString.Substring(operationsStart);
string actionsString = conditionsAndActions [1];
return(PriceRuleCondition.Parse(conditionsString, conditions) &&
ParseOperations(operationsString) &&
PriceRuleAction.Parse(actionsString, actions));
}
public static bool Parse(string conditionsString, List <PriceRuleCondition> conditions)
{
foreach (string condition in conditionsString.Split(new [] { "IF ", PriceRule.AND, "(", ")" }, StringSplitOptions.RemoveEmptyEntries))
{
int indexOfEquals = condition.IndexOf('=');
if (indexOfEquals < 0)
{
return(false);
}
string conditionTypeName = condition.Substring(0, indexOfEquals).Trim(' ', '>', '<');
bool isException = false;
if (conditionTypeName.Contains(NOT))
{
conditionTypeName = conditionTypeName.Substring(NOT.Length);
isException = true;
}
PriceRule.ConditionType cType;
if (!Enum.TryParse(conditionTypeName, true, out cType))
{
return(false);
}
int index = conditions.FindIndex(c => c.Type == cType && c.IsException == isException);
// a duplicate type indicates a 2-sided condition: (a >= x) AND (a <= y)
if (index > -1)
{
string value = conditions [index].Formula + ")" + PriceRule.AND + "(" + condition;
conditions [index] = new PriceRuleCondition(cType, value, conditions [index].IsException);
}
else if (isException)
{
conditions.Add(new PriceRuleCondition(cType, condition.Substring(NOT.Length), true));
}
else
{
conditions.Add(new PriceRuleCondition(cType, condition));
}
}
return(true);
}
public PriceRuleCondition AddCondition(ConditionType conditionType, bool isException, params object [] values)
{
PriceRuleCondition condition = conditions.Find(c => c.Type == conditionType && c.IsException == isException);
try {
if (condition == null)
{
condition = new PriceRuleCondition(conditionType, values, isException);
conditions.Add(condition);
}
else
{
condition.IsActive = true;
condition.SetValues(values);
}
return(condition);
} catch (Exception) {
return(null);
}
}
private void BuildFormula()
{
if (conditions.Count == 0)
{
throw new InvalidOperationException("A price rule must contain at least one condition.");
}
if (actions.Count == 0)
{
throw new InvalidOperationException("A price rule must contain at least one action.");
}
if (operations.Count == 0)
{
throw new InvalidOperationException("A price rule must apply to at least one operation.");
}
Formula = string.Format("IF {0} AND (operation = {1}) THEN {2}",
PriceRuleCondition.GetFormula(conditions),
string.Join(",", operations.Cast <int> ()),
PriceRuleAction.GetFormula(actions));
}
