/// <summary>
/// Method transfers data format from <seealso cref="DataSet"/> with <seealso cref="DataTable"/> items
/// and <seealso cref="DataRow"/> items into the current schema of options
/// and option values for data read from XML persistence into the in-memory model.
/// Converts external XML format into internal format.
/// </summary>
/// <param name="engine"></param>
/// <param name="dataSet"></param>
private void ConvertFromDataSetToModel(IEngine engine, DataSet dataSet)
{
AlternativeDataTypeHandler handle = new AlternativeDataTypeHandler();
foreach (DataTable table in dataSet.Tables)
{
string optionName;
// Locate options group for this table
IOptionGroup optionsGroup = FindOptionsGroup(engine, table.TableName, out optionName);
// Found a table that refers to a list of values stored in an optiongroup/option
if (string.IsNullOrEmpty(optionName) == false)
{
// Empty list is allowed but requires no processing
// -> remove defaults if actual data is available
if (table.Rows.Count > 0)
{
optionsGroup.List_Clear(optionName);
for (int i = 0; i < table.Rows.Count; i++)
{
// assumption: Address first column in each row since list
// table contains only 1 data column
optionsGroup.SetValue(optionName, table.Rows[i].ItemArray[0]);
}
}
}
else
{
// This code requires at least a header row and 1 data row in order to work!
if (table.Rows.Count >= 2)
{
for (int i = 0; i < table.Columns.Count; i++)
{
IOptionsSchema schema = null;
schema = optionsGroup.GetOptionDefinition(table.Columns[i].ColumnName);
var handler = handle.FindHandler(schema.TypeOfValue);
if (handler != null)
{
object s = handler.ConvertBack(table.Rows[1].ItemArray[i] as string);
optionsGroup.SetValue(table.Columns[i].ColumnName, s);
}
else
{
optionsGroup.SetValue(table.Columns[i].ColumnName, table.Rows[1].ItemArray[i]);
}
}
}
}
}
dataSet = null;
}
/// <summary>
/// Creates a <seealso cref="DataTable"/> object with 1 column and n rows
/// that represnts the values of a list of values.
/// </summary>
/// <param name="tableName"></param>
/// <param name="columnSchema"></param>
/// <param name="handler"></param>
/// <param name="masterRow"></param>
/// <returns></returns>
private static DataTable CreateListTable(string tableName,
IOptionsSchema columnSchema,
IAlternativeDataTypeHandler handler,
DataRow masterRow)
{
DataTable dataTable = new DataTable(tableName);
DataColumn col = new DataColumn(columnSchema.OptionName,
(columnSchema.TypeOfValue == typeof(SecureString) ? typeof(string) :
columnSchema.TypeOfValue));
col.AllowDBNull = columnSchema.IsOptional;
dataTable.Columns.Add(col);
////var list = columnSchema.Value as IEnumerable<object>;
bool IsFirstRow = true;
foreach (var item in columnSchema.List_GetListOfValues())
{
if (IsFirstRow == true)
{
IsFirstRow = false;
// Initialize row for caller this must be non-null to make it storeable
if (handler != null)
{
masterRow[columnSchema.OptionName] = handler.Convert(item as SecureString);
}
else
{
masterRow[columnSchema.OptionName] = item;
}
}
var row = dataTable.NewRow();
if (handler != null)
{
row[columnSchema.OptionName] = handler.Convert(item as SecureString);
}
else
{
row[columnSchema.OptionName] = item;
}
dataTable.Rows.Add(row);
}
return(dataTable);
}
/// <summary>
/// Creates a unique id-able name for list items that are indirectly attached to OptionsGroups
/// but are physically stored in their own table (to enable storage of multiple values in XML).
/// </summary>
/// <param name="optionsGroup"></param>
/// <param name="optionSchema"></param>
/// <returns></returns>
private string CreateListItemTableName(IOptionGroup optionsGroup, IOptionsSchema optionSchema)
{
return("${" + optionsGroup.Name + "}${" + optionSchema.OptionName + "}");
}
