public TableTreeViewItemViewModel(BrowserViewModel browser, DiffDataTable diffTable)
: base(browser)
{
this.diffTable = diffTable;
this.diffTable.PropertyChanged += DiffType_PropertyChanged;
this.diffTable.SourceItem1.PropertyChanged += SourceItem1_PropertyChanged;
this.diffTable.SourceItem2.PropertyChanged += SourceItem2_PropertyChanged;
this.header1 = diffTable.Header1;
this.header2 = diffTable.Header2;
this.viewCommand = new DelegateCommand(this.View);
this.isActivated = diffTable.DiffState != DiffState.Unchanged;
this.Target = diffTable;
foreach (var item in diffTable.Childs)
{
var viewModel = new TableTreeViewItemViewModel(browser, item);
viewModel.PropertyChanged += ChildViewModel_PropertyChanged;
this.Items.Add(viewModel);
if (this.isActivated == false && viewModel.DiffState != DiffState.Unchanged)
{
this.isActivated = true;
}
}
this.Dispatcher.InvokeAsync(() =>
{
if (this.DiffState != DiffState.Unchanged && this.Parent != null)
{
this.Parent.IsExpanded = true;
}
});
}
internal DiffDataRow(DiffDataTable diffTable, int index)
{
this.diffTable = diffTable;
this.index = index;
this.item1 = index < diffTable.SourceItem1.Rows.Count ? diffTable.SourceItem1.Rows[index] : null;
this.item2 = index < diffTable.SourceItem2.Rows.Count ? diffTable.SourceItem2.Rows[index] : null;
}
private static void UpdateValidation(InternalDataRow dataRow1, InternalDataRow dataRow2)
{
if (dataRow2 != null && (bool)dataRow1[DiffUtility.DiffEnabledKey] == true)
{
foreach (var item in dataRow1.Table.Columns)
{
if (item is InternalDataColumn dataColumn)
{
var field1 = dataRow1[dataColumn.ColumnName];
var dataColumn2 = GetColumn(dataRow2, dataColumn.Index);
var field2 = dataRow2[dataColumn2];
DiffDataTable.Validate((CremaDataRow)dataRow1, (CremaDataColumn)dataColumn);
}
}
if (dataRow1.GetColumnsInError().Any())
{
dataRow1.RowError = rowError;
}
else
{
dataRow1.RowError = string.Empty;
}
}
}
public ItemViewModel(DiffDataTable diffTable, DependencyObject parent)
{
this.diffTable = diffTable;
this.parent = parent;
this.diffState = DiffUtility.GetDiffState(this.diffTable.SourceItem1) == DiffState.Imaginary ? DiffState.Inserted : DiffUtility.GetDiffState(this.diffTable.SourceItem1);
BindingOperations.SetBinding(this, ReadOnlyProperty, new Binding("ReadOnly")
{
Source = parent,
});
}
public TableTreeViewItemViewModel(DiffDataTable diffTable)
{
this.diffTable = diffTable;
this.diffTable.PropertyChanged += DiffType_PropertyChanged;
this.diffTable.SourceItem1.PropertyChanged += DataTable1_PropertyChanged;
this.diffTable.SourceItem2.PropertyChanged += DataTable2_PropertyChanged;
this.viewCommand = new DelegateCommand(this.View);
this.Target = diffTable;
foreach (var item in diffTable.Childs)
{
this.Items.Add(new TableTreeViewItemViewModel(item));
}
}
public DiffDataTableItemViewModel(DiffDataTableViewModel viewModel, DiffDataTable source)
{
this.viewModel = viewModel;
this.Source = source;
}
public DiffDataTableViewModel(DiffDataTable diffTable)
{
this.Source = diffTable;
}
private void InitializeTables(IProgress progress)
{
var tables1 = this.dataSet1.Tables.Where(item => item.Parent == null && item.TemplatedParent == null)
.OrderBy(item => item.Name)
.ToList();
var tables2 = this.dataSet2.Tables.Where(item => item.Parent == null && item.TemplatedParent == null)
.OrderBy(item => item.Name)
.ToList();
var tableList = new List <DiffDataTable>();
foreach (var item in tables1.ToArray())
{
var count = tables2.Count(i => i.TableID == item.TableID);
if (count == 1)
{
var dataTable1 = item;
var dataTable2 = tables2.Single(i => i.TableID == item.TableID);
var tableName1 = dataTable1.TableName != dataTable2.TableName ? DiffUtility.DiffDummyKey + dataTable1.TableName : dataTable2.TableName;
var tableName2 = dataTable2.TableName;
var diffTable1 = DiffDataTable.Create(this.diffSet1, tableName1);
var diffTable2 = DiffDataTable.Create(this.diffSet2, tableName2);
DiffInternalUtility.SyncColumns(diffTable1, diffTable2, dataTable1, dataTable2);
var diffTable = new DiffDataTable(diffTable1, diffTable2, dataTable1, dataTable2, this);
var diffTemplate = new DiffTemplate(diffTable1, diffTable2, dataTable1, dataTable2)
{
DiffTable = diffTable
};
diffTable.Template = diffTemplate;
diffTable.InitializeChilds();
tableList.Add(diffTable);
tables1.Remove(dataTable1);
tables2.Remove(dataTable2);
}
}
foreach (var item in tables1)
{
var dataTable1 = item;
if (this.dataSet2.Tables.Contains(dataTable1.TableName) == true)
{
var dataTable2 = this.dataSet2.Tables[dataTable1.TableName];
var diffTable1 = DiffDataTable.Create(this.diffSet1, dataTable1.TableName);
var diffTable2 = DiffDataTable.Create(this.diffSet2, dataTable2.TableName);
DiffInternalUtility.SyncColumns(diffTable1, diffTable2, dataTable1, dataTable2);
var diffTable = new DiffDataTable(diffTable1, diffTable2, dataTable1, dataTable2, this);
var diffTemplate = new DiffTemplate(diffTable1, diffTable2, dataTable1, dataTable2)
{
DiffTable = diffTable
};
diffTable.Template = diffTemplate;
diffTable.InitializeChilds();
tableList.Add(diffTable);
tables2.Remove(dataTable2);
}
else
{
var diffTable1 = DiffDataTable.Create(new CremaDataSet(), dataTable1.TableName);
var diffTable2 = DiffDataTable.Create(new CremaDataSet(), dataTable1.TableName);
DiffInternalUtility.SyncColumns(diffTable1, diffTable2, dataTable1, null);
var diffTable = new DiffDataTable(diffTable1, diffTable2, dataTable1, null, this);
var diffTemplate = new DiffTemplate(diffTable1, diffTable2, dataTable1, null)
{
DiffTable = diffTable
};
diffTable.Template = diffTemplate;
diffTable.InitializeChilds();
tableList.Add(diffTable);
}
}
foreach (var item in tables2)
{
var dataTable2 = item;
var diffTable1 = DiffDataTable.Create(this.diffSet1, dataTable2.TableName);
var diffTable2 = DiffDataTable.Create(this.diffSet2, dataTable2.TableName);
DiffInternalUtility.SyncColumns(diffTable1, diffTable2, null, dataTable2);
var diffTable = new DiffDataTable(diffTable1, diffTable2, null, dataTable2, this);
var diffTemplate = new DiffTemplate(diffTable1, diffTable2, null, dataTable2)
{
DiffTable = diffTable
};
diffTable.Template = diffTemplate;
diffTable.InitializeChilds();
tableList.Add(diffTable);
}
foreach (var item in tableList.ToArray())
{
item.InitializeDerivedTables();
}
foreach (var item in tableList.ToArray())
{
tableList.AddRange(item.DerivedTables);
}
tableList.AsParallel().ForAll(item => item.DiffTemplate());
tableList.AsParallel().ForAll(item => item.Diff());
this.tables = tableList.OrderBy(item => item.SourceItem1.TableName).ToArray();
}
private static void Update(InternalDataRow dataRow1, InternalDataRow dataRow2, DiffState defaultState, string[] filters)
{
if (dataRow2 == null || (bool)dataRow1[DiffUtility.DiffEnabledKey] == false)
{
DiffUtility.SetDiffFields(dataRow1, null);
DiffUtility.SetDiffState(dataRow1, DiffState.Imaginary);
}
else
{
var fieldsList = new List <string>(dataRow1.Table.Columns.Count);
var diffState = defaultState;
foreach (var item in dataRow1.Table.Columns)
{
if (item is InternalDataColumn dataColumn)
{
if (filters.Contains(dataColumn.ColumnName) == true)
{
continue;
}
var field1 = dataRow1[dataColumn.ColumnName];
var dataColumn2 = GetColumn(dataRow2, dataColumn.Index);
var field2 = dataRow2[dataColumn2];
if (object.Equals(field1, field2) == false)
{
fieldsList.Add(dataColumn.ColumnName);
}
DiffDataTable.Validate((CremaDataRow)dataRow1, (CremaDataColumn)dataColumn);
}
else if (item is InternalAttribute attribute)
{
if (attribute.ColumnMapping == MappingType.Hidden || filters.Contains(attribute.AttributeName) == true)
{
continue;
}
var field1 = dataRow1[attribute.AttributeName];
var field2 = dataRow2[attribute.AttributeName];
if (object.Equals(field1, field2) == false)
{
fieldsList.Add(attribute.AttributeName);
}
}
}
if (dataRow1.GetColumnsInError().Any())
{
dataRow1.RowError = rowError;
}
else
{
dataRow1.RowError = string.Empty;
}
if ((bool)dataRow2[DiffUtility.DiffEnabledKey] == true)
{
if (fieldsList.Any() == true || object.Equals(dataRow1[CremaSchema.Index], dataRow2[CremaSchema.Index]) == false)
{
diffState = DiffState.Modified;
}
else
{
diffState = DiffState.Unchanged;
}
DiffUtility.SetDiffFields(dataRow1, fieldsList);
DiffUtility.SetDiffState(dataRow1, diffState);
}
else
{
DiffUtility.SetDiffFields(dataRow1, null);
DiffUtility.SetDiffState(dataRow1, diffState);
}
}
}
