/// <summary>
/// Create ValueValidationManager of a Variable
/// </summary>
/// <remarks></remarks>
/// <param name="varName"></param>
/// <param name="dataType"></param>
/// <param name="optional"></param>
/// <param name="variable"></param>
/// <returns></returns>
private ValueValidationManager createValueValidationManager(string varName, string dataType, bool optional, DataAttribute variable)
{
string pattern = "";
if (variable != null && variable.DataType != null && variable.DataType.Extra != null)
{
DataTypeDisplayPattern displayPattern = DataTypeDisplayPattern.Materialize(variable.DataType.Extra);
if (displayPattern != null)
{
pattern = displayPattern.StringPattern;
}
}
ValueValidationManager vvm = new ValueValidationManager(varName, dataType, optional, Info.Decimal, pattern);
return(vvm);
}
/// <summary>
/// Create ValueValidationManager of a Variable
/// </summary>
/// <remarks></remarks>
/// <param name="varName"></param>
/// <param name="dataType"></param>
/// <param name="optional"></param>
/// <param name="variable"></param>
/// <returns></returns>
private ValueValidationManager createValueValidationManager(string varName, string dataType, bool optional, Variable variable)
{
string pattern = "";
DataAttribute dataAttribute = variable.DataAttribute;
if (string.IsNullOrEmpty(varName))
{
varName = variable.Label;
}
if (dataAttribute != null && dataAttribute.DataType != null && dataAttribute.DataType.Extra != null)
{
DataTypeDisplayPattern displayPattern = DataTypeDisplayPattern.Materialize(dataAttribute.DataType.Extra);
if (displayPattern != null)
{
pattern = displayPattern.StringPattern;
}
}
ValueValidationManager vvm = new ValueValidationManager(varName, dataType, optional, Info.Decimal, pattern, variable.MissingValues, CultureInfo.CurrentCulture, variable.DataAttribute.Constraints);
return(vvm);
}
/// <summary>
/// Validate a row
/// </summary>
/// <seealso cref=""/>
/// <param name="row">List of strings</param>
/// <param name="indexOfRow">Index of row</param>
/// <returns>List of errors or null</returns>
public List <Error> ValidateRow(List <string> row, int indexOfRow)
{
List <Error> errors = new List <Error>();
// number of variables in datastructure
int numOfVariables = this.StructuredDataStructure.Variables.Count();
// number of current row values
int rowCount = row.Count();
// number of is equal
if (numOfVariables.Equals(rowCount))
{
int valuePosition = 0;
foreach (string v in row)
{
try
{
VariableIdentifier hv = SubmitedVariableIdentifiers.ElementAt(row.IndexOf(v));
Variable sdvu = getVariableUsage(hv);
ValueValidationManager validationManager = ValueValidationManagerDic[sdvu.Id];
List <Error> temp = new List <Error>();
// returns the checked value and update the error list if error appears
object value = validationManager.CheckValue(v, indexOfRow, ref temp);
if (temp.Count == 0)
{
temp = validationManager.ValidateValue(v, indexOfRow);
// check Constraints
foreach (Constraint constraint in sdvu.DataAttribute.Constraints)
{
//new Error(ErrorType.Value, "Not in Range", new object[] { name, value, row, dataType });
if (!constraint.IsSatisfied(value))
{
temp.Add(new Error(ErrorType.Value, constraint.ErrorMessage, new object[] { sdvu.Label, value, indexOfRow, sdvu.DataAttribute.DataType.Name }));
}
}
}
if (temp != null)
{
errors = errors.Union(temp).ToList();
}
valuePosition++;
}
catch
{
//test
if (true)
{
}
}
}
}
// different value lenght
else
{
Error e = new Error(ErrorType.Other, "Number of Values different as number of variables");
errors.Add(e);
}
NumberOfRows++;
return(errors);
}
/// <summary>
/// Validate a row
/// </summary>
/// <seealso cref=""/>
/// <param name="row">List of strings</param>
/// <param name="indexOfRow">Index of row</param>
/// <returns>List of errors or null</returns>
public List <Error> ValidateRow(List <string> row, int indexOfRow)
{
errors = new List <Error>();
// number of variables in datastructure
int numOfVariables = this.StructuredDataStructure.Variables.Count();
// number of current row values
int rowCount = row.Count();
// number of is equal
if (numOfVariables.Equals(rowCount))
{
int valuePosition = 0;
for (int i = 0; i < row.Count; i++)
{
v = row[i];
try
{
hv = SubmitedVariableIdentifiers.ElementAt(i);
var = getVariableUsage(hv);
validationManager = ValueValidationManagerDic[var.Id];
//check if the value is a missing value
if (!validationManager.ValueIsMissingValue(v, indexOfRow))
{
// returns the checked value and update the error list if error appears
value = validationManager.CheckValue(v, indexOfRow, ref temp);
if (temp.Count == 0)
{
temp = validationManager.ValidateValue(v, indexOfRow);
temp2 = validationManager.ValidateConstraints(v, indexOfRow);
temp = temp.Union(temp2).ToList();
}
if (temp.Any())
{
errors = errors.Union(temp).ToList();
}
}
valuePosition++;
}
catch (Exception ex)
{
Error e = new Error(ErrorType.Other, "Error : " + ex.Message);
errors.Add(e);
}
}
}
// different value lenght
else
{
Error e = new Error(ErrorType.Other, "Number of Values different as number of variables");
errors.Add(e);
}
NumberOfRows++;
return(errors);
}
/// <summary>
/// Read Row and convert each value into a variableValue
/// and each row to a Datatuple
/// </summary>
/// <param name="row">List of values in one row</param>
/// <param name="indexOfRow">Currently row index</param>
/// <returns>DataTuple</returns>
public DataTuple ReadRow(List <string> row, int indexOfRow)
{
if (row == null)
{
return(null);
}
if (row.Count == 1 && string.IsNullOrEmpty(row.ElementAt(0)))
{
return(null);
}
if (row.Count > this.StructuredDataStructure.Variables.Count || row.Count < this.StructuredDataStructure.Variables.Count)
{
throw new Exception("Number of values different then the number of values.");
}
DataTuple dt = new DataTuple();
string value = "";
// convert row to List<VariableValue>
for (int i = 0; i < row.Count(); i++)
{
VariableIdentifier variableIdentifier = this.SubmitedVariableIdentifiers.ElementAt(i);
long variableId = 0;
if (variableIdentifier.id > 0)
{
variableId = this.SubmitedVariableIdentifiers.ElementAt(i).id;
}
else
{
variableId = getVariableUsage(variableIdentifier).Id;
}
//if the value is a missing value get the placeholder
ValueValidationManager validationManager = ValueValidationManagerDic[variableId];
if (!validationManager.ValueIsMissingValueGetPlaceHolder(row[i], i, out value)) // jump over this code if its a missing value
{
// if variable from systemtype datatime
// maybee needs to convert into the default datetime culture format
if (this.StructuredDataStructure.Variables.Where(p => p.Id.Equals(variableId)).FirstOrDefault().DataAttribute.DataType.SystemType.Equals("DateTime"))
{
Dlm.Entities.DataStructure.DataType dataType = this.StructuredDataStructure.Variables.Where(p => p.Id.Equals(variableId)).FirstOrDefault().DataAttribute.DataType;
if (dataType != null && dataType.Extra != null)
{
DataTypeDisplayPattern dp = DataTypeDisplayPattern.Materialize(dataType.Extra);
if (dp != null && !string.IsNullOrEmpty(dp.StringPattern))
{
value = IOUtility.ConvertToDateUS(row[i], dp.StringPattern);
}
else
{
value = IOUtility.ConvertDateToCulture(row[i]);
}
}
else
{
value = IOUtility.ConvertDateToCulture(row[i]);
}
}
else
{
if (this.StructuredDataStructure.Variables.Where(p => p.Id.Equals(variableId)).FirstOrDefault().DataAttribute.DataType.SystemType.Equals("Double") ||
this.StructuredDataStructure.Variables.Where(p => p.Id.Equals(variableId)).FirstOrDefault().DataAttribute.DataType.SystemType.Equals("Decimal") ||
this.StructuredDataStructure.Variables.Where(p => p.Id.Equals(variableId)).FirstOrDefault().DataAttribute.DataType.SystemType.Equals("Float"))
{
var datatype = this.StructuredDataStructure.Variables.Where(p => p.Id.Equals(variableId)).FirstOrDefault().DataAttribute.DataType.SystemType;
value = row[i];
if (Info.Decimal.Equals(DecimalCharacter.comma))
{
if (value.Contains("."))
{
value = value.Replace(".", "");
}
if (value.Contains(","))
{
value = value.Replace(',', '.');
}
}
if (Info.Decimal.Equals(DecimalCharacter.point))
{
if (value.Contains(","))
{
value = value.Remove(',');
}
}
switch (datatype)
{
case "Double": {
double tmp = 0;
if (double.TryParse(value, NumberStyles.Any, new CultureInfo("en-US"), out tmp))
{
value = tmp.ToString("G16", new CultureInfo("en-US"));
}
break;
}
case "Decimal":
{
decimal tmp = 0;
if (decimal.TryParse(value, NumberStyles.Any, new CultureInfo("en-US"), out tmp))
{
value = "" + tmp.ToString("G29", new CultureInfo("en-US"));
}
break;
}
case "Float":
{
float tmp = 0;
if (float.TryParse(value, NumberStyles.Any, new CultureInfo("en-US"), out tmp))
{
value = "" + tmp.ToString("G7", new CultureInfo("en-US"));
}
break;
}
}
}
else
{
value = row[i].Trim();
}
}
}
dt.VariableValues.Add(DatasetManager.CreateVariableValue(value, "", DateTime.Now, DateTime.Now, new ObtainingMethod(), variableId, new List <ParameterValue>()));
}
return(dt);
}
/// <summary>
/// Create ValueValidationManager of a Variable
/// </summary>
/// <remarks></remarks>
/// <param name="varName"></param>
/// <param name="dataType"></param>
/// <param name="optional"></param>
/// <param name="variable"></param>
/// <returns></returns>
private ValueValidationManager createValueValidationManager(string varName, string dataType, bool optional, DataAttribute variable)
{
ValueValidationManager vvm = new ValueValidationManager(varName, dataType, optional, Info.Decimal);
return(vvm);
}