private void ExportCleanData(object parameter, string folderPath)
{
if (parameter is DataGrid dataGrid)
{
using (var streamWriter = new StreamWriter($"{folderPath}"))
{
foreach (var row in dataGrid.Items)
{
if (row is CleanDataEntity cleanRowData)
{
if ((IsShowDuplicatesChecked && cleanRowData.IsDuplicate) ||
IsCorruptValuesChecked && cleanRowData.ContainsSpecialCharacter)
{
continue;
}
for (var a = 0; a < cleanRowData.Data.Count; a++)
{
if (a == (cleanRowData.Data.Count - 1))
{
streamWriter.Write(cleanRowData.Data.ElementAt(a).Value);
}
else
{
streamWriter.Write(cleanRowData.Data.ElementAt(a).Value);
streamWriter.Write(",");
}
}
streamWriter.Write("\n");
}
}
foreach (var duplicate in CleanDataItems.Where(x => x.IsDuplicate).Distinct())
{
var count = 0;
var colCount = duplicate.Data.Count;
foreach (var column in duplicate.Data)
{
if (count == (colCount - 1))
{
streamWriter.Write(column.Value);
}
else
{
streamWriter.Write(column.Value);
streamWriter.Write(",");
}
count++;
}
streamWriter.Write("\n");
}
}
}
IsModalVisible = false;
}
private void OnShowPredictions(object parameter)
{
lock (_lockPredictionValuesObject)
{
if (parameter is DataGrid dataGrid && SelectedPredictionColumnIndex >= 0 && ColumnsDictionary.Any())
{
PredictionValues = new List <Dictionary <int, string> >();
var selectedPredictionColumnKey = ColumnsDictionary.ElementAt(SelectedPredictionColumnIndex).Key;
var distinctPredicitonValues = CleanDataItems.SelectMany(x => x.Data.Where(z => z.Key == selectedPredictionColumnKey))
.Select(c => c.Value).Distinct();
foreach (var prediction in distinctPredicitonValues)
{
var columns = new Dictionary <int, string>();
for (var colIndex = 0; colIndex < ColumnsDictionary.Count; colIndex++)
{
var keyValuePairs = CleanDataItems.Select(x => x.Data).Where(c => c.Values.Contains(prediction));
var allPredictionsForColumn = keyValuePairs.SelectMany(x => x).Where(c => c.Key == ColumnsDictionary.ElementAt(colIndex).Key)
.GroupBy(z => z.Value)
.OrderByDescending(v => v.Count()).FirstOrDefault();
if (allPredictionsForColumn != null)
{
foreach (var c in allPredictionsForColumn)
{
columns.Add(ColumnsDictionary.ElementAt(colIndex).Key, c.Value);
break;
}
}
}
PredictionValues.Add(columns);
}
Application.Current.Dispatcher.Invoke(() => dataGrid.ItemsSource = PredictionValues);
Application.Current.Dispatcher.Invoke(() => dataGrid.Columns.Clear());
var colCount = 0;
foreach (var prediction in ColumnsDictionary)
{
Application.Current.Dispatcher.Invoke(() => dataGrid.Columns.Add(new DataGridTextColumn()
{
Header = prediction.Value,
Binding = new Binding($".[{prediction.Key}]"),
DisplayIndex = colCount
}));
colCount++;
}
}
}
}
private void CheckAndSetDuplicates()
{
if (IsShowDuplicatesChecked)
{
DuplicateCount = 0;
var duplicateValues = CleanDataItems.Select(x => x).GroupBy(c => c.GetHashCode()).Where(x => x.Count() > 1);
foreach (var duplicate in duplicateValues.SelectMany(x => x))
{
duplicate.IsDuplicate = true;
DuplicateCount++;
}
}
}
private void ExecuteFunction(object parameter)
{
try
{
if (!string.IsNullOrEmpty(DynamicFunction) &&
parameter is DataGrid dataGrid)
{
var replaceColumnIndex = 0;
var replaceColumnValue = string.Empty;
foreach (var column in ColumnsDictionary)
{
if (DynamicFunction.Contains(column.Value))
{
replaceColumnValue = column.Value;
replaceColumnIndex = column.Key;
}
}
var ingnoreFirstRow = false;
foreach (var row in CleanDataItems)
{
if (ingnoreFirstRow)
{
var newFunction = DynamicFunction.Replace(replaceColumnValue, row.Data[replaceColumnIndex]);
var returnValue = _dynamicFunctions.InvokeDynamicFunction(newFunction);
if (returnValue is Exception exception)
{
throw exception;
}
else
{
row.Data[replaceColumnIndex] = returnValue.ToString();
}
}
ingnoreFirstRow = true;
}
CreateColumnsAndBindings(dataGrid, CleanDataItems.FirstOrDefault().Data.Count);
}
}
catch (Exception ex)
{
_exceptionLogDataAccess.LogException(ex.ToString());
}
}
private void ReadExcelData(DataGrid dataGrid)
{
try
{
using (var package = new ExcelPackage(new FileInfo(FileName)))
{
Application.Current.Dispatcher.Invoke(() => CleanDataItems.Clear());
CorruptValueCount = 0;
var workbook = package.Workbook;
foreach (var worksheet in workbook.Worksheets)
{
for (var row = 1; row <= worksheet.Dimension.Rows; row++)
{
var columnsList = new CleanDataEntity();
for (var column = 1; column <= worksheet.Dimension.Columns; column++)
{
var columnText = worksheet.Cells[row, column].Text;
columnsList.Data.Add(column, columnText);
if (IsCorruptValuesChecked && Regex.Match(columnText, $"{RegularExpression}").Success)
{
columnsList.ContainsSpecialCharacter = true;
CorruptValueCount++;
}
}
columnsList.Id = row;
Application.Current.Dispatcher.Invoke(() => CleanDataItems.Add(columnsList));
if (IsLimitRowsChecked && RowReadLimit > 0 && row >= RowReadLimit)
{
break;
}
}
CheckAndSetDuplicates();
CreateColumnsAndBindings(dataGrid, worksheet.Dimension.Columns);
}
}
}
catch (Exception ex)
{
_exceptionLogDataAccess.LogException(ex.ToString());
}
}
private void ReadCSVFile(DataGrid dataGrid)
{
using (var streamReader = new StreamReader(FileName))
{
Application.Current.Dispatcher.Invoke(() => CleanDataItems.Clear());
var columnsDictionary = new Dictionary <int, string>();
CorruptValueCount = 0;
var columnCount = 0;
var rowCount = 0;
while (!streamReader.EndOfStream)
{
var line = streamReader.ReadLine();
var columns = line.Split(',');
if (!string.IsNullOrEmpty(line) && line.Contains(","))
{
var columnsList = new CleanDataEntity();
var colCount = 0;
foreach (var column in columns)
{
columnsList.Data.Add(colCount, column);
if (IsCorruptValuesChecked && Regex.Match(column, $"{RegularExpression}").Success)
{
columnsList.ContainsSpecialCharacter = true;
CorruptValueCount++;
}
colCount++;
}
columnsList.Id = rowCount;
Application.Current.Dispatcher.Invoke(() => CleanDataItems.Add(columnsList));
columnCount = colCount;
}
rowCount++;
if (IsLimitRowsChecked && RowReadLimit > 0 && rowCount >= RowReadLimit)
{
break;
}
}
CheckAndSetDuplicates();
CreateColumnsAndBindings(dataGrid, columnCount);
}
}
private void OnVisualiseColumnn()
{
if (SelectedVisualisationColumnIndex >= 0 && ColumnsDictionary.Any())
{
try
{
SelectedColumnItemsCount = new ObservableCollection <KeyValuePair <string, int> >();
var selectedColumnKey = ColumnsDictionary.ElementAt(SelectedVisualisationColumnIndex).Key;
var visualiseColumnData = CleanDataItems.SelectMany(x => x.Data).Where(c => c.Key == selectedColumnKey);
foreach (var visualColumnData in visualiseColumnData.Select(x => x.Value).Distinct())
{
Application.Current.Dispatcher.Invoke(() => SelectedColumnItemsCount.Add(new KeyValuePair <string, int>(visualColumnData,
visualiseColumnData.Select(x => x).Where(c => string.Equals(c.Value, visualColumnData, StringComparison.OrdinalIgnoreCase)).Count())));
}
}
catch (Exception ex)
{
_exceptionLogDataAccess.LogException(ex.ToString());
}
}
}
