/// <summary>
/// Generates the rule from its XML representation.
/// </summary>
protected virtual void OnReadXml(XmlReader reader)
{
switch (reader.Name)
{
case "ErrorStyle":
this.errorStyle = (Dt.Cells.Data.ErrorStyle)Serializer.DeserializeObj(typeof(Dt.Cells.Data.ErrorStyle), reader);
return;
case "IgnoreBlank":
this.ignoreBlank = (bool)((bool)Serializer.DeserializeObj(typeof(bool), reader));
return;
case "InCellDropdown":
this.inCellDropdown = (bool)((bool)Serializer.DeserializeObj(typeof(bool), reader));
return;
case "ShowInputMessage":
this.showInputMessage = (bool)((bool)Serializer.DeserializeObj(typeof(bool), reader));
return;
case "ShowErrorMessage":
this.showErrorMessage = (bool)((bool)Serializer.DeserializeObj(typeof(bool), reader));
return;
case "InputTitle":
this.inputTitle = (string)(Serializer.DeserializeObj(typeof(string), reader) as string);
return;
case "ErrorTitle":
this.errorTitle = (string)(Serializer.DeserializeObj(typeof(string), reader) as string);
return;
case "InputMessage":
this.inputMessage = (string)(Serializer.DeserializeObj(typeof(string), reader) as string);
return;
case "ErrorMessage":
this.errorMessage = (string)(Serializer.DeserializeObj(typeof(string), reader) as string);
return;
case "Operator":
this.comparisonOperator = (Dt.Cells.Data.ComparisonOperator)Serializer.DeserializeObj(typeof(Dt.Cells.Data.ComparisonOperator), reader);
return;
case "Condition":
this.condition = Serializer.DeserializeObj(null, reader) as ConditionBase;
return;
case "Type":
this.type = (CriteriaType)Serializer.DeserializeObj(typeof(CriteriaType), reader);
return;
}
}
void Init()
{
this.errorStyle = Dt.Cells.Data.ErrorStyle.Stop;
this.ignoreBlank = true;
this.inCellDropdown = true;
this.showInputMessage = true;
this.showErrorMessage = true;
this.inputTitle = string.Empty;
this.errorTitle = string.Empty;
this.inputMessage = string.Empty;
this.errorMessage = string.Empty;
this.comparisonOperator = Dt.Cells.Data.ComparisonOperator.Between;
}
/// <summary>
/// Creates a validator based on text length.
/// </summary>
/// <param name="typeOperator">
/// The type of <see cref="P:Dt.Cells.Data.DataValidator.ComparisonOperator" /> compare operator.
/// </param>
/// <param name="v1">The first object.</param>
/// <param name="v2">The second object.</param>
/// <returns>Returns a new validator.</returns>
public static DataValidator CreateTextLengthValidator(Dt.Cells.Data.ComparisonOperator typeOperator, object v1, object v2)
{
string formula = IsFormula(v1) ? (v1 as string).TrimStart(new char[] { '=' }) : null;
object expected = IsFormula(v1) ? null : v1;
string str2 = IsFormula(v2) ? (v2 as string).TrimStart(new char[] { '=' }) : null;
object obj3 = IsFormula(v2) ? null : v2;
ConditionBase condition = null;
switch (typeOperator)
{
case Dt.Cells.Data.ComparisonOperator.Between:
condition = new RelationCondition(RelationCompareType.And, new TextLengthCondition(GeneralCompareType.GreaterThanOrEqualsTo, expected, formula), new TextLengthCondition(GeneralCompareType.LessThanOrEqualsTo, obj3, str2));
break;
case Dt.Cells.Data.ComparisonOperator.NotBetween:
condition = new RelationCondition(RelationCompareType.Or, new TextLengthCondition(GeneralCompareType.LessThan, expected, formula), new TextLengthCondition(GeneralCompareType.GreaterThan, obj3, str2));
break;
case Dt.Cells.Data.ComparisonOperator.EqualTo:
condition = new TextLengthCondition(GeneralCompareType.EqualsTo, expected, formula);
break;
case Dt.Cells.Data.ComparisonOperator.NotEqualTo:
condition = new TextLengthCondition(GeneralCompareType.NotEqualsTo, expected, formula);
break;
case Dt.Cells.Data.ComparisonOperator.GreaterThan:
condition = new TextLengthCondition(GeneralCompareType.GreaterThan, expected, formula);
break;
case Dt.Cells.Data.ComparisonOperator.LessThan:
condition = new TextLengthCondition(GeneralCompareType.LessThan, expected, formula);
break;
case Dt.Cells.Data.ComparisonOperator.GreaterThanOrEqualTo:
condition = new TextLengthCondition(GeneralCompareType.GreaterThanOrEqualsTo, expected, formula);
break;
case Dt.Cells.Data.ComparisonOperator.LessThanOrEqualTo:
condition = new TextLengthCondition(GeneralCompareType.LessThanOrEqualsTo, expected, formula);
break;
}
return(new DataValidator(condition)
{
type = CriteriaType.TextLength, ComparisonOperator = typeOperator
});
}
/// <summary>
/// Creates a validator based on numbers.
/// </summary>
/// <param name="typeOperator">
/// The type of <see cref="P:Dt.Cells.Data.DataValidator.ComparisonOperator" /> compare operator.
/// </param>
/// <param name="v1">The first object.</param>
/// <param name="v2">The second object.</param>
/// <param name="isIntegerValue">
/// <c>true</c> if the validator is set to a number; otherwise, <c>false</c>.
/// </param>
/// <returns>Returns a new validator.</returns>
public static DataValidator CreateNumberValidator(Dt.Cells.Data.ComparisonOperator typeOperator, object v1, object v2, bool isIntegerValue)
{
string formula = IsFormula(v1) ? (v1 as string).TrimStart(new char[] { '=' }) : null;
object expected = IsFormula(v1) ? null : v1;
string str2 = IsFormula(v2) ? (v2 as string).TrimStart(new char[] { '=' }) : null;
object obj3 = IsFormula(v2) ? null : v2;
ConditionBase base2 = null;
switch (typeOperator)
{
case Dt.Cells.Data.ComparisonOperator.Between:
{
NumberCondition condition = new NumberCondition(GeneralCompareType.GreaterThanOrEqualsTo, expected, formula)
{
IntegerValue = isIntegerValue
};
NumberCondition condition2 = new NumberCondition(GeneralCompareType.LessThanOrEqualsTo, obj3, str2)
{
IntegerValue = isIntegerValue
};
base2 = new RelationCondition(RelationCompareType.And, condition, condition2);
break;
}
case Dt.Cells.Data.ComparisonOperator.NotBetween:
{
NumberCondition condition3 = new NumberCondition(GeneralCompareType.LessThan, expected, formula)
{
IntegerValue = isIntegerValue
};
NumberCondition condition4 = new NumberCondition(GeneralCompareType.GreaterThan, obj3, str2)
{
IntegerValue = isIntegerValue
};
base2 = new RelationCondition(RelationCompareType.Or, condition3, condition4);
break;
}
case Dt.Cells.Data.ComparisonOperator.EqualTo:
{
NumberCondition condition5 = new NumberCondition(GeneralCompareType.EqualsTo, expected, formula)
{
IntegerValue = isIntegerValue
};
base2 = condition5;
break;
}
case Dt.Cells.Data.ComparisonOperator.NotEqualTo:
{
NumberCondition condition6 = new NumberCondition(GeneralCompareType.NotEqualsTo, expected, formula)
{
IntegerValue = isIntegerValue
};
base2 = condition6;
break;
}
case Dt.Cells.Data.ComparisonOperator.GreaterThan:
{
NumberCondition condition7 = new NumberCondition(GeneralCompareType.GreaterThan, expected, formula)
{
IntegerValue = isIntegerValue
};
base2 = condition7;
break;
}
case Dt.Cells.Data.ComparisonOperator.LessThan:
{
NumberCondition condition9 = new NumberCondition(GeneralCompareType.LessThan, expected, formula)
{
IntegerValue = isIntegerValue
};
base2 = condition9;
break;
}
case Dt.Cells.Data.ComparisonOperator.GreaterThanOrEqualTo:
{
NumberCondition condition8 = new NumberCondition(GeneralCompareType.GreaterThanOrEqualsTo, expected, formula)
{
IntegerValue = isIntegerValue
};
base2 = condition8;
break;
}
case Dt.Cells.Data.ComparisonOperator.LessThanOrEqualTo:
{
NumberCondition condition10 = new NumberCondition(GeneralCompareType.LessThanOrEqualsTo, expected, formula)
{
IntegerValue = isIntegerValue
};
base2 = condition10;
break;
}
}
return(new DataValidator(base2)
{
type = isIntegerValue ? CriteriaType.WholeNumber : CriteriaType.DecimalValues, ComparisonOperator = typeOperator
});
}
/// <summary>
/// Creates a validator based on the data.
/// </summary>
/// <param name="typeOperator">
/// The type of <see cref="P:Dt.Cells.Data.DataValidator.ComparisonOperator" /> compare operator.
/// </param>
/// <param name="v1">The first object.</param>
/// <param name="v2">The second object.</param>
/// <param name="isTime">
/// <c>true</c> if the validator is set to time; otherwise, <c>false</c>.
/// </param>
/// <returns>Returns a new validator.</returns>
public static DataValidator CreateDateValidator(Dt.Cells.Data.ComparisonOperator typeOperator, object v1, object v2, bool isTime)
{
string formula = IsFormula(v1) ? (v1 as string).TrimStart(new char[] { '=' }) : null;
object expected = IsFormula(v1) ? null : v1;
string str2 = IsFormula(v2) ? (v2 as string).TrimStart(new char[] { '=' }) : null;
object obj3 = IsFormula(v2) ? null : v2;
ConditionBase condition = null;
if (isTime)
{
switch (typeOperator)
{
case Dt.Cells.Data.ComparisonOperator.Between:
condition = new RelationCondition(RelationCompareType.And, new TimeCondition(DateCompareType.AfterEqualsTo, expected, formula), new TimeCondition(DateCompareType.BeforeEqualsTo, obj3, str2));
break;
case Dt.Cells.Data.ComparisonOperator.NotBetween:
condition = new RelationCondition(RelationCompareType.Or, new TimeCondition(DateCompareType.Before, expected, formula), new TimeCondition(DateCompareType.After, obj3, str2));
break;
case Dt.Cells.Data.ComparisonOperator.EqualTo:
condition = new TimeCondition(DateCompareType.EqualsTo, expected, formula);
break;
case Dt.Cells.Data.ComparisonOperator.NotEqualTo:
condition = new TimeCondition(DateCompareType.NotEqualsTo, expected, formula);
break;
case Dt.Cells.Data.ComparisonOperator.GreaterThan:
condition = new TimeCondition(DateCompareType.After, expected, formula);
break;
case Dt.Cells.Data.ComparisonOperator.LessThan:
condition = new TimeCondition(DateCompareType.Before, expected, formula);
break;
case Dt.Cells.Data.ComparisonOperator.GreaterThanOrEqualTo:
condition = new TimeCondition(DateCompareType.AfterEqualsTo, expected, formula);
break;
case Dt.Cells.Data.ComparisonOperator.LessThanOrEqualTo:
condition = new TimeCondition(DateCompareType.BeforeEqualsTo, expected, formula);
break;
}
}
else
{
switch (typeOperator)
{
case Dt.Cells.Data.ComparisonOperator.Between:
condition = new RelationCondition(RelationCompareType.And, new DateCondition(DateCompareType.AfterEqualsTo, expected, formula), new DateCondition(DateCompareType.BeforeEqualsTo, obj3, str2));
break;
case Dt.Cells.Data.ComparisonOperator.NotBetween:
condition = new RelationCondition(RelationCompareType.Or, new DateCondition(DateCompareType.Before, expected, formula), new DateCondition(DateCompareType.After, obj3, str2));
break;
case Dt.Cells.Data.ComparisonOperator.EqualTo:
condition = new DateCondition(DateCompareType.EqualsTo, expected, formula);
break;
case Dt.Cells.Data.ComparisonOperator.NotEqualTo:
condition = new DateCondition(DateCompareType.NotEqualsTo, expected, formula);
break;
case Dt.Cells.Data.ComparisonOperator.GreaterThan:
condition = new DateCondition(DateCompareType.After, expected, formula);
break;
case Dt.Cells.Data.ComparisonOperator.LessThan:
condition = new DateCondition(DateCompareType.Before, expected, formula);
break;
case Dt.Cells.Data.ComparisonOperator.GreaterThanOrEqualTo:
condition = new DateCondition(DateCompareType.AfterEqualsTo, expected, formula);
break;
case Dt.Cells.Data.ComparisonOperator.LessThanOrEqualTo:
condition = new DateCondition(DateCompareType.BeforeEqualsTo, expected, formula);
break;
}
}
return(new DataValidator(condition)
{
type = isTime ? CriteriaType.Time : CriteriaType.Date, ComparisonOperator = typeOperator
});
}
