public override Task <IDataToSent> TransformData(IDataToSent receiveData)
{
if (receiveData == null)
{
receiveData = new DataToSentTable();
}
var dt = new DataTable(tableName);
dt.Columns.Add(colName, typeof(string));
dt.Rows.Add(text);
FastAddTable(receiveData, dt);
return(Task.FromResult(receiveData));
}
public override async Task <IDataToSent> TransformData(IDataToSent receiveData)
{
var data = new DataToSentTable();
if (receiveData == null)
{
return(null);
}
var tablesMetadata = receiveData.Metadata.Tables.Select(it => it.Name).ToList();
if (tablesMetadata.Count != receiveData.DataToBeSentFurther.Count)
{
throw new NotSupportedException($"Metadata has {tablesMetadata.Count} tables, data has {receiveData.DataToBeSentFurther.Count} tables");
}
var tablesData = receiveData.DataToBeSentFurther.Select(it => it.Value.TableName).ToArray();
var except = tablesMetadata.Except(tablesData).ToArray();
if (except.Length > 0)
{
throw new NotSupportedException($"metadata tables has {except[0]} that is not a table in DataToBeSentFurther ");
}
except = tablesData.Except(tablesMetadata).ToArray();
if (except.Length > 0)
{
throw new NotSupportedException($"table {except[0]} has no metadata");
}
foreach (var item in receiveData.DataToBeSentFurther)
{
//verify name exists
if (!tablesMetadata.Contains(item.Value.TableName))
{
throw new NotSupportedException($"{item.Value.TableName} is not found in metadata tables");
}
//verify tables
var tablesFound = receiveData.Metadata.Tables.Where(t => t.Id == item.Key).ToArray();
if (tablesFound.Length != 1)
{
throw new NotSupportedException($"{item.Value.TableName} with id {item.Key} is retrieved {tablesFound.Length} times ( should be 1)");
}
//verify columns
var colsMetadata = receiveData.Metadata
.Columns
.Where(it => it.IDTable == item.Key)
.Select(it => it.Name)
.ToList();
var colsTable = new List <string>();
foreach (DataColumn dc in item.Value.Columns)
{
colsTable.Add(dc.ColumnName);
}
if (colsTable.Count != colsMetadata.Count)
{
throw new NotSupportedException($"length not the same for cols {colsTable.Count} and metadata cols {colsMetadata.Count} from {item.Value.TableName} ");
}
except = colsMetadata.Except(colsTable).ToArray();
if (except.Length > 0)
{
throw new NotSupportedException($"metadata has {except[0]} that is not a column in {item.Value.TableName} ");
}
except = colsTable.Except(colsMetadata).ToArray();
if (except.Length > 0)
{
throw new NotSupportedException($"cols for {item.Value.TableName} has {except[0]} that is not a metadata column ");
}
}
return(await Task.FromResult(receiveData));
}
public override async Task <IDataToSent> TransformData(IDataToSent receiveData)
{
string colName = ColumnNameWithData;
string receiver = ReceiverProperty;
//TODO : remove from release builds
var v = new Verifier();
if (ColumnNameWithData.Contains(separator))
{
var arr = ColumnNameWithData.Split(new [] { separator }, StringSplitOptions.RemoveEmptyEntries);
colName = arr[0];
base.dataNeeded[nameof(ColumnNameWithData)] = string.Join(separator, arr.Skip(1).ToArray());
}
if (ReceiverProperty.Contains(separator))
{
var arr = ReceiverProperty.Split(new[] { separator }, StringSplitOptions.RemoveEmptyEntries);
receiver = arr[0];
base.dataNeeded[nameof(ReceiverProperty)] = string.Join(separator, arr.Skip(1).ToArray());
}
var column = receiveData.Metadata.Columns.FirstOrDefault(it => it.Name == colName);
if (column == null)
{
column = receiveData.Metadata.Columns.FirstOrDefault(it => it.Name.Equals(colName, StringComparison.InvariantCultureIgnoreCase));
}
if (column == null)
{
throw new ArgumentException($"no column {colName} in metadata");
}
var table = receiveData.DataToBeSentFurther[column.IDTable];
DataToSentTable modelData = null;
ITable[] tableModel = null;
//TODO: verify null
foreach (DataRow item in table.Rows)
{
object data = null;
try
{
data = item[column.Name];
var d = new CtorDictionary(dataNeeded)
{
{ receiver, data }
};
var r = Activator.CreateInstance(typeof(T), d) as BaseObject;
r.Name = data.ToString();
//create model to be sent
if (this.TableWithModel?.Length > 0)
{
tableModel = receiveData.Metadata.Tables.Where(it => TableWithModel.Contains(it.Name)).ToArray();
modelData = new DataToSentTable();
foreach (var iTable in tableModel)
{
var model = receiveData.DataToBeSentFurther[iTable.Id];
var idExistingTable = modelData.AddNewTable(model);
modelData.Metadata.AddTable(model, idExistingTable);
}
await v.TransformData(modelData);
}
await v.TransformData(modelData);
var dataToBeSent = await r.TransformData(modelData);
//TODO : remove from release builds
await v.TransformData(dataToBeSent);
if (modelData != null)
{
foreach (var tbl in tableModel)
{
var iTable = dataToBeSent.Metadata.Tables.First(it => it.Id == tbl.Id);
dataToBeSent.Metadata.RemoveTable(iTable);
dataToBeSent.DataToBeSentFurther.Remove(tbl.Id);
}
//var iTable = dataToBeSent.Metadata.Tables.First(it => it.Id == idExistingTable.Value);
//dataToBeSent.Metadata.RemoveTable(iTable);
//dataToBeSent.DataToBeSentFurther.Remove(idExistingTable.Value);
}
await v.TransformData(dataToBeSent);
foreach (var dataTable in dataToBeSent.DataToBeSentFurther)
{
dataTable.Value.TableName += data.ToString();
var dc = new DataColumn(column.Name + "_origin", data.GetType())
{
DefaultValue = data
};
dataTable.Value.Columns.Add(dc);
var idTable = receiveData.AddNewTable(dataTable.Value);
var meta = dataToBeSent.Metadata.Tables.FirstOrDefault(it => it.Id == dataTable.Key);
//TODO: make a metadata table constructor
var newMeta = new Table();
newMeta.Name = dataTable.Value.TableName;
newMeta.Id = idTable;
receiveData.Metadata.Tables.Add(newMeta);
var cols = dataToBeSent.Metadata.Columns.Where(it => it.IDTable == dataTable.Key);
foreach (var c in cols)
{
//TODO: copy constructor for column
var newC = new Column();
newC.IDTable = idTable;
newC.Name = c.Name;
receiveData.Metadata.Columns.Add(newC);
}
//foreach (var c in dataToBeSent.Metadata.Columns)
//{
// c.IDTable = idTable;
// receiveData.Metadata.Columns.Add(c);
//}
receiveData.Metadata.Columns.Add(new Column()
{
Name = column.Name + "_origin",
Id = receiveData.Metadata.Columns.Count,
IDTable = idTable
});
//TODO: add relation
}
//TODO : remove from release builds
await v.TransformData(receiveData);
}
catch (Exception ex)
{
//TODO: log or put into error table
Console.WriteLine("error at " + column.Name + "-" + data?.ToString() + "-" + ex.Message);
throw;
}
}
return(await Task.FromResult(receiveData));
}
