//Validate missVal. It must be a comma delimited list of values convertable to FieldDataType.
//An item in the list might possibly be in format "x thru y" where x and y must be convertable
//with x <= y.
private void CheckMissVal(string valueToCheck, FieldDataType fdt)
{
//Check MissVal by attempting to create a RangeList object.
RangeList throwaway = new RangeList(valueToCheck, fdt);
////create a string array containing the comma delimited items
//string[] listItems = valueToCheck.Split(new char[] { ',' });
////validate each item
//foreach (string sItem in listItems)
//{
// //create a string array by splitting each item on the string "thru"
// string[] splitItem = sItem.ToLower().Split(new string[] { "thru" }, StringSplitOptions.None);
// //throw an exception if splitting results in more that 2 elements
// if (splitItem.Length > 2)
// {
// throw new ArgumentException("missVal not valid.");
// }
// foreach (string s in splitItem)
// {
// CheckType(s, fdt);
// }
// //verify that x <= y
// if (splitItem.Length == 2)
// {
// switch (fdt)
// {
// case FieldDataType.DATE:
// if (!(DateTime.Parse(splitItem[0]) <= DateTime.Parse(splitItem[1])))
// {
// throw new ArgumentException("missVal not valid.");
// }
// break;
// case FieldDataType.FLOAT:
// if (!(float.Parse(splitItem[0]) <= float.Parse(splitItem[1])))
// {
// throw new ArgumentException("missVal not valid.");
// }
// break;
// case FieldDataType.INT:
// if (!(int.Parse(splitItem[0]) <= int.Parse(splitItem[1])))
// {
// throw new ArgumentException("missVal not valid.");
// }
// break;
// case FieldDataType.TEXT:
// // nothing to check
// break;
// default:
// throw new Exception("FieldDataType invalid.");
// }
// }
//}
}
/*
* Returns a List<string> containing any errors. If no errors the List.count ==0.
*
* Checks:
*
* ID is required.
* fldname is Required.
*
* FieldDataType is required.
*
* At least one of IsInsertField, IsEntryField, IsReadOnly must be true.
*
* If IsReadOnly == true then
* IsEntryField == false
* IsInsertField == false
* IsDoubleEntryField == false
*
* If IsEntryField == false then
* IsDoubleEntryField == false
*
* Validates any supplied value for FormatString, MinVal, MaxVal, ValidList, RegEx
*
* Attempts to create RangeList objects for any supplied ValidList or MissVal.
* See RangeList Class for details.
*/
public List <string> ValidateAndInitializeProperties()
{
List <string> errors = new List <string>();
#region fldname, ID, FieldDataType
if (string.IsNullOrEmpty(this.FldName))
{
errors.Add("A value for the fldname property is required.");
}
if (string.IsNullOrEmpty(this.ID))
{
errors.Add("A value for the ID property is a required.");
}
if (this.FieldDataType == FieldDataType.UNKNOWN)
{
errors.Add("FieldDataType is required. A value must be set on the field tag if metadata is missing.");
}
#endregion
#region FormatString, Min/MaxVal, ValidList
//validation of FormatString, Min/MaxVal, ValidList depends on existence of FieldDataType
//so return if it might be missing
if (errors.Count != 0)
{
return(errors);
}
// If supplied, make sure FormatString is valid by attempting
// to apply it
if (string.IsNullOrEmpty(FormatString) == false)
{
string fstr = FormatString;
try
{
//calls to string.Format() will fail if fstr invalid
string formatted = string.Empty;
switch (FieldDataType)
{
case FieldDataType.DATE:
formatted = string.Format(fstr, DateTime.Parse("5/5/2004"));
break;
case FieldDataType.FLOAT:
formatted = string.Format(fstr, float.Parse("4.235"));
break;
case FieldDataType.INT:
formatted = string.Format(fstr, int.Parse("5"));
break;
case FieldDataType.TEXT:
// throw an exception because formatstring isn't
// allowed for text types
throw new Exception("FormatString isn't allowed for text data type.");
default:
throw new Exception("Value of FieldDataType can't be UNKNOWN if setting FormatString");
}
}
catch (Exception e)
{
errors.Add("Invalid format string: " + e.Message);
}
}
// If supplied, make sure MinVal value is appropriate for
// data type
if (string.IsNullOrEmpty(MinVal) == false)
{
try
{
switch (FieldDataType)
{
case FieldDataType.DATE:
DateTime.Parse(MinVal);
break;
case FieldDataType.FLOAT:
float.Parse(MinVal);
break;
case FieldDataType.INT:
int.Parse(MinVal);
break;
case FieldDataType.TEXT:
// nothing to check
break;
default:
throw new Exception("Invalid FieldDataType");
}
}
catch
{
errors.Add(string.Format("MinVal invalid because it cannot be converted to {0}.", FieldDataType));
}
}
// If supplied make sure MaxVal value is appropriate for
// data type
if (string.IsNullOrEmpty(MaxVal) == false)
{
try
{
switch (FieldDataType)
{
case FieldDataType.DATE:
DateTime.Parse(MaxVal);
break;
case FieldDataType.FLOAT:
float.Parse(MaxVal);
break;
case FieldDataType.INT:
int.Parse(MaxVal);
break;
case FieldDataType.TEXT:
// nothing to check
break;
default:
throw new Exception("Invalid FieldDataType");
}
}
catch
{
errors.Add(string.Format("MaxVal invalid because it cannot be converted to {0}.", FieldDataType));
}
}
//Initialize ValidList RangeList
if (string.IsNullOrEmpty(ValidList) == false)
{
try
{
_validListRangeList = new RangeList(ValidList, FieldDataType);
}
catch (Exception e)
{
errors.Add(string.Format("ValidList {0} invalid. " + e.Message, ValidList));
}
}
//Initialize MissVal RangeList
if (string.IsNullOrEmpty(MissVal) == false)
{
try
{
_missValRangeList = new RangeList(MissVal, FieldDataType);
}
catch (Exception e)
{
errors.Add(string.Format("MissVal {0} invalid. " + e.Message, MissVal));
}
}
#endregion
#region Others
//At least one of IsInsertField, IsEntryField, IsReadOnly must be true.
if ((IsInsertField || IsEntryField || IsReadOnly) == false)
{
errors.Add("At least one of IsInsertField, IsEntryField, IsReadOnly must be true.");
}
// If IsReadOnly == true then
// IsEntryField == false
// IsInsertField == false
// IsDoubleEntryField == false
if (IsReadOnly == true && (IsEntryField || IsInsertField || IsDoubleEntryField))
{
errors.Add("A ReadOnly field can't also have IsEntryField, IsInsertField, or IsDoubleEntry set to true.");
}
// If IsEntryField == false then
// IsDoubleEntryField == false
if (IsEntryField == false && IsDoubleEntryField == true)
{
errors.Add("A setting of IsDoubleEntryField = true requires IsEntryField = true.");
}
// if RegEx supplied test the value
if (string.IsNullOrEmpty(RegEx) == false)
{
try
{
Regex r = new Regex(RegEx);
}
catch (ArgumentException ae)
{
if (ae != null)
{
errors.Add("Invalid regular expression: " + RegEx);
}
}
}
#endregion
//return errors
return(errors);
}
