private void FlashFeature(object param)
{
if (_resultFeature == null)
{
return;
}
if (_resultFeature is HluDataSet.incid_mm_polygonsRow)
{
List <List <SqlFilterCondition> > whereClause =
ViewModelWindowMainHelpers.GisSelectionToWhereClause(new R[] { _resultFeature },
_keyOrdinals, 10, _selectedFeatures);
if (whereClause.Count == 1)
{
_gisApp.FlashSelectedFeature(whereClause[0]);
}
}
else if ((_currChildRows != null) && (_currChildRows.Length > 0))
{
foreach (HluDataSet.incid_mm_polygonsRow r in _currChildRows)
{
List <List <SqlFilterCondition> > whereClause =
ViewModelWindowMainHelpers.GisSelectionToWhereClause(new HluDataSet.incid_mm_polygonsRow[] { r },
_keyOrdinals, 100, _selectedFeatures);
if (whereClause.Count == 1)
{
_gisApp.FlashSelectedFeature(whereClause[0]);
}
}
}
}
private void FlashFeature(object param)
{
if (_resultFeature == null)
{
return;
}
if (_resultFeature is HluDataSet.incid_mm_polygonsRow)
{
List <List <SqlFilterCondition> > whereClause =
ViewModelWindowMainHelpers.GisSelectionToWhereClause(new R[] { _resultFeature },
_keyOrdinals, 10, _selectedFeatures);
// Flash all the features relating to the where clause together.
if (whereClause.Count == 1)
{
_gisApp.FlashSelectedFeature(whereClause[0]);
}
}
else if ((_currChildRows != null) && (_currChildRows.Length > 0))
{
//---------------------------------------------------------------------
// CHANGED: CR23 (Merged features)
// Flash all the features relating to the selected incid at once.
//
//foreach (HluDataSet.incid_mm_polygonsRow r in _currChildRows)
//{
// List<List<SqlFilterCondition>> whereClause =
// ViewModelWindowMainHelpers.GisSelectionToWhereClause(new HluDataSet.incid_mm_polygonsRow[] { r },
// _keyOrdinals, 100, _selectedFeatures);
// if (whereClause.Count == 1)
// _gisApp.FlashSelectedFeature(whereClause[0]);
//}
List <List <SqlFilterCondition> > whereClauses =
ViewModelWindowMainHelpers.GisSelectionToWhereClause(_currChildRows,
_keyOrdinals, 100, _selectedFeatures);
// Flash all the features relating to the where clause together
// or in groups if there are too many features to fit within a single
// item in the where clauses list.
if (whereClauses.Count == 1)
{
_gisApp.FlashSelectedFeature(whereClauses[0]);
}
else
{
_gisApp.FlashSelectedFeatures(whereClauses);
}
//---------------------------------------------------------------------
}
}
/// <summary>
/// Writes history records to DB.
/// </summary>
/// <param name="fixedValues">Dictionary of insert values that will be equal for all new rows.</param>
/// <param name="newHistoryRecords">DataTable containing the new history rows to be inserted.</param>
/// <param name="operation">One of the members of the Operations enum describing the operation
/// that created the new history records.</param>
internal void HistoryWrite(Dictionary <int, string> fixedValues,
DataTable newHistoryRecords, ViewModelWindowMain.Operations operation)
{
if ((newHistoryRecords == null) || (newHistoryRecords.Rows.Count == 0))
{
return;
}
bool startTransaction = _viewModelMain.DataBase.Transaction == null;
if (startTransaction)
{
_viewModelMain.DataBase.BeginTransaction(true, IsolationLevel.ReadCommitted);
}
try
{
// create dictionary of insert values that will be equal for all new rows
Dictionary <int, object> fixedValueDict = new Dictionary <int, object>();
if (fixedValues != null)
{
foreach (KeyValuePair <int, string> kv in fixedValues)
{
fixedValueDict.Add(kv.Key, kv.Value);
}
}
if (!fixedValueDict.ContainsKey(_viewModelMain.HluDataset.history.modified_user_idColumn.Ordinal))
{
fixedValueDict.Add(_viewModelMain.HluDataset.history.modified_user_idColumn.Ordinal, _viewModelMain.UserID);
}
if (!fixedValueDict.ContainsKey(_viewModelMain.HluDataset.history.modified_dateColumn.Ordinal))
{
fixedValueDict.Add(_viewModelMain.HluDataset.history.modified_dateColumn.Ordinal, DateTime.Today);
}
if (!fixedValueDict.ContainsKey(_viewModelMain.HluDataset.history.modified_reasonColumn.Ordinal))
{
fixedValueDict.Add(_viewModelMain.HluDataset.history.modified_reasonColumn.Ordinal, _viewModelMain.Reason);
}
if (!fixedValueDict.ContainsKey(_viewModelMain.HluDataset.history.modified_processColumn.Ordinal))
{
fixedValueDict.Add(_viewModelMain.HluDataset.history.modified_processColumn.Ordinal, _viewModelMain.Process);
}
if (!fixedValueDict.ContainsKey(_viewModelMain.HluDataset.history.modified_operationColumn.Ordinal))
{
string operationCode = ViewModelWindowMainHelpers.GetOperationsCode(_viewModelMain.HluDataset, operation);
if (!String.IsNullOrEmpty(operationCode))
{
fixedValueDict.Add(_viewModelMain.HluDataset.history.modified_operationColumn.Ordinal,
operationCode);
}
else
{
throw new Exception(String.Format("Missing or indeterminate operation code for {0}.",
operation.ToString()));
}
}
// rename the generically named geom1 and geom2 fields according to layer type
HistoryRenameGeometryPropertyColumns(_viewModelMain.HluDataset.history.modified_lengthColumn.ColumnName,
_viewModelMain.HluDataset.history.modified_areaColumn.ColumnName, ref newHistoryRecords);
// get an array of column ordinals in the new history table as they match columns
// in DB history table and are not among the fixed values (fixedValueDic)
// a new history column named "<columnName>" will match both DB history columns named
// "<columnName>" *and* "modified_<columnName>" as long as there is no column named
// "modified_<columnName>" in the new history table
int[] newHistoryColumns = (from t in _viewModelMain.HluDataset.history.Columns.Cast <DataColumn>()
let gisCols = (from g in newHistoryRecords.Columns.Cast <DataColumn>()
select g.ColumnName).ToArray()
let gisColsMod = (from g in newHistoryRecords.Columns.Cast <DataColumn>()
select !gisCols.Contains("modified_" + g.ColumnName) ?
"modified_" + g.ColumnName : String.Empty).ToArray()
select new
{
gisPos = !fixedValueDict.ContainsKey(t.Ordinal) ?
Array.IndexOf(gisCols, t.ColumnName) : -1,
gisModPos = !fixedValueDict.ContainsKey(t.Ordinal) ?
Array.IndexOf(gisColsMod, t.ColumnName) : -1
})
.Select(a => a.gisPos != -1 ? a.gisPos : a.gisModPos).ToArray();
// get the next available history_id
object objHistId = _viewModelMain.DataBase.ExecuteScalar(String.Format("SELECT MAX({0}) + 1 FROM {1}",
_viewModelMain.DataBase.QuoteIdentifier(_viewModelMain.HluDataset.history.history_idColumn.ColumnName),
_viewModelMain.DataBase.QualifyTableName(_viewModelMain.HluDataset.history.TableName)),
_viewModelMain.DataBase.Connection.ConnectionTimeout, CommandType.Text);
int historyId = objHistId != DBNull.Value && objHistId != null ? (int)objHistId : 1;
// append new history rows to a history table
HluDataSet.historyDataTable historyTable = new HluDataSet.historyDataTable();
foreach (DataRow r in newHistoryRecords.Rows)
{
HluDataSet.historyRow newRow = historyTable.NewhistoryRow();
for (int i = 0; i < historyTable.Columns.Count; i++)
{
if (i == _viewModelMain.HluDataset.history.history_idColumn.Ordinal)
{
newRow[i] = historyId++;
}
else if (newHistoryColumns[i] != -1)
{
if (!r.IsNull(newHistoryColumns[i]))
{
newRow[i] = r[newHistoryColumns[i]];
}
}
else
{
object val;
if (fixedValueDict.TryGetValue(i, out val))
{
newRow[i] = val;
}
}
}
historyTable.AddhistoryRow(newRow);
}
// insert new rows
if (_viewModelMain.HluTableAdapterManager.historyTableAdapter.Update(historyTable) == -1)
{
throw new Exception("Failed to update history table.");
}
if (startTransaction)
{
_viewModelMain.DataBase.CommitTransaction();
}
}
catch
{
if (startTransaction)
{
_viewModelMain.DataBase.RollbackTransaction();
}
throw;
}
}
//---------------------------------------------------------------------
// CHANGED: CR39 (Split and merge complete messages)
// Return true or false success so the main class knows
// whether to notify the user following the completion of
// the merge.
//
private bool PerformPhysicalMerge()
{
bool success = true;
try
{
HluDataSet.incid_mm_polygonsDataTable selectTable = new HluDataSet.incid_mm_polygonsDataTable();
_viewModelMain.GetIncidMMPolygonRows(ViewModelWindowMainHelpers.GisSelectionToWhereClause(
_viewModelMain.GisSelection.Select(), _viewModelMain.GisIDColumnOrdinals,
ViewModelWindowMain.IncidPageSize, selectTable), ref selectTable);
if (selectTable.Count == 0)
{
return(false);
}
else if (selectTable.Count != _viewModelMain.GisSelection.Rows.Count)
{
throw new Exception(String.Format("GIS Layer and database are out of sync:\n{0} map polygons, {1} rows in table {2}.",
_viewModelMain.FragsSelectedMapCount, selectTable.Count, _viewModelMain.HluDataset.incid_mm_polygons.TableName));
}
// lowest toid_fragment_id in selection assigned to result feature
string newToidFragmentID = selectTable.Min(r => r.toid_fragment_id);
if (selectTable.GroupBy(r => r.incid).Count() == 1)
{
int minFragmID = Int32.Parse(newToidFragmentID);
_mergeResultFeatureIndex = selectTable.Select((r, index) =>
Int32.Parse(r.toid_fragment_id) == minFragmID ? index : -1).First(i => i != -1);
}
else
{
_mergeFeaturesWindow = new WindowMergeFeatures();
_mergeFeaturesWindow.Owner = App.Current.MainWindow;
_mergeFeaturesWindow.WindowStartupLocation = WindowStartupLocation.CenterOwner;
_mergeFeaturesViewModelPhysical = new ViewModelMergeFeatures
<HluDataSet.incid_mm_polygonsDataTable, HluDataSet.incid_mm_polygonsRow>(selectTable,
_viewModelMain.GisIDColumnOrdinals, _viewModelMain.IncidTable.incidColumn.Ordinal,
null, _viewModelMain.GISApplication);
_mergeFeaturesViewModelPhysical.DisplayName = "Select Feature To Keep";
_mergeFeaturesViewModelPhysical.RequestClose += new ViewModelMergeFeatures
<HluDataSet.incid_mm_polygonsDataTable, HluDataSet.incid_mm_polygonsRow>
.RequestCloseEventHandler(_mergeFeaturesViewModelPhysical_RequestClose);
_mergeFeaturesWindow.DataContext = _mergeFeaturesViewModelPhysical;
_mergeResultFeatureIndex = -1;
_mergeFeaturesWindow.ShowDialog();
}
if (_mergeResultFeatureIndex != -1)
{
_viewModelMain.ChangeCursor(Cursors.Wait, "Processing ...");
bool startTransaction = _viewModelMain.DataBase.Transaction != null;
if (startTransaction)
{
_viewModelMain.DataBase.BeginTransaction(true, IsolationLevel.ReadCommitted);
}
try
{
_viewModelMain.ViewModelUpdate.UpdateIncidModifiedColumns(_viewModelMain.IncidsSelectedMap.ElementAt(0));
List <List <SqlFilterCondition> > resultFeatureWhereClause =
ViewModelWindowMainHelpers.GisSelectionToWhereClause(
new HluDataSet.incid_mm_polygonsRow[] { selectTable[_mergeResultFeatureIndex] },
_viewModelMain.GisIDColumnOrdinals, ViewModelWindowMain.IncidPageSize, selectTable);
if (resultFeatureWhereClause.Count != 1)
{
throw new Exception("Error getting result feature from database.");
}
List <List <SqlFilterCondition> > mergeFeaturesWhereClause =
ViewModelWindowMainHelpers.GisSelectionToWhereClause(
selectTable.Where((r, index) => index != _mergeResultFeatureIndex).ToArray(),
_viewModelMain.GisIDColumnOrdinals, ViewModelWindowMain.IncidPageSize, selectTable);
// historyTable contains rows of features merged into result feature (i.e. no longer existing)
// and last row with data of result feature (remaining in GIS, lowest toid_fragment_id of merged features)
// this last row must be removed before writing history
// but is needed to update geometry fields in incid_mm_polygons
DataTable historyTable = _viewModelMain.GISApplication.MergeFeatures(newToidFragmentID,
resultFeatureWhereClause[0].Select(c => c.Clone()).ToList(), _viewModelMain.HistoryColumns);
if (historyTable == null)
{
throw new Exception("GIS merge operation failed.");
}
DataTable resultTable = historyTable.Clone();
DataRow resultRow = historyTable.AsEnumerable().FirstOrDefault(r =>
r.Field <string>(_viewModelMain.HluDataset.history.toid_fragment_idColumn.ColumnName) == newToidFragmentID);
if (resultRow == null)
{
throw new Exception(String.Format(
"Failed to obtain geometry data of result feature from {0}.", _viewModelMain.GISApplication.ApplicationType));
}
resultTable.LoadDataRow(resultRow.ItemArray, true);
resultRow.Delete();
historyTable.AcceptChanges();
// synchronize DB shadow copy of GIS layer
MergeSynchronizeIncidMMPolygons(selectTable, resultTable, newToidFragmentID,
resultFeatureWhereClause[0], mergeFeaturesWhereClause);
// insert history rows (fixed values incid, toid, newToidFragmentID)
Dictionary <int, string> fixedValues = new Dictionary <int, string>();
fixedValues.Add(_viewModelMain.HluDataset.history.incidColumn.Ordinal, selectTable[0].incid);
fixedValues.Add(_viewModelMain.HluDataset.history.toidColumn.Ordinal, selectTable[0].toid);
fixedValues.Add(_viewModelMain.HluDataset.history.toid_fragment_idColumn.Ordinal, newToidFragmentID);
ViewModelWindowMainHistory vmHist = new ViewModelWindowMainHistory(_viewModelMain);
vmHist.HistoryWrite(fixedValues, historyTable, ViewModelWindowMain.Operations.PhysicalMerge);
if (startTransaction)
{
_viewModelMain.DataBase.CommitTransaction();
_viewModelMain.HluDataset.AcceptChanges();
}
// Re-count the incid records in the database.
_viewModelMain.IncidRowCount(true);
// Reset the incid and map selections but don't move
// to the first incid in the database.
_viewModelMain.ClearFilter(false);
// Synch with the GIS selection.
//---------------------------------------------------------------------
// FIX: 027 Force refill of Incid table after split/merge
// Force the Incid table to be refilled because it has been
// updated directly in the database rather than via the
// local copy.
_viewModelMain.RefillIncidTable = true;
//---------------------------------------------------------------------
_viewModelMain.ReadMapSelection(true);
}
catch
{
if (startTransaction)
{
_viewModelMain.DataBase.RollbackTransaction();
}
throw;
}
}
}
catch (Exception ex)
{
success = false;
MessageBox.Show("Merge operation failed. The error message returned was:\n\n" +
ex.Message, "HLU Merge Error", MessageBoxButton.OK, MessageBoxImage.Error);
}
finally { _viewModelMain.ChangeCursor(Cursors.Arrow, null); }
return(success);
}
//---------------------------------------------------------------------
//---------------------------------------------------------------------
// CHANGED: CR39 (Split and merge complete messages)
// Return true or false success so the main class knows
// whether to notify the user following the completion of
// the merge.
//
private bool PerformLogicalMerge(bool physicallyMerge)
{
bool success = true;
try
{
if (_viewModelMain.IncidsSelectedMapCount <= 0)
{
return(false);
}
_mergeFeaturesWindow = new WindowMergeFeatures();
_mergeFeaturesWindow.Owner = App.Current.MainWindow;
_mergeFeaturesWindow.WindowStartupLocation = WindowStartupLocation.CenterOwner;
_mergeFeaturesWindow.MaxHeight = App.Current.MainWindow.ActualHeight;
HluDataSet.incidDataTable selectTable = new HluDataSet.incidDataTable();
_viewModelMain.HluTableAdapterManager.incidTableAdapter.Fill(selectTable,
ViewModelWindowMainHelpers.IncidSelectionToWhereClause(ViewModelWindowMain.IncidPageSize,
_viewModelMain.IncidTable.incidColumn.Ordinal, _viewModelMain.IncidTable, _viewModelMain.IncidsSelectedMap));
HluDataSet.incid_mm_polygonsDataTable polygons = new HluDataSet.incid_mm_polygonsDataTable();
_viewModelMain.GetIncidMMPolygonRows(ViewModelWindowMainHelpers.GisSelectionToWhereClause(
_viewModelMain.GisSelection.Select(), _viewModelMain.GisIDColumnOrdinals,
ViewModelWindowMain.IncidPageSize, polygons), ref polygons);
_mergeFeaturesViewModelLogical = new ViewModelMergeFeatures <HluDataSet.incidDataTable,
HluDataSet.incidRow>(selectTable, _viewModelMain.GisIDColumnOrdinals,
_viewModelMain.IncidTable.incidColumn.Ordinal, polygons.Select(r => r).ToArray(),
_viewModelMain.GISApplication);
_mergeFeaturesViewModelLogical.DisplayName = "Select INCID To Keep";
_mergeFeaturesViewModelLogical.RequestClose += new ViewModelMergeFeatures <HluDataSet.incidDataTable,
HluDataSet.incidRow> .RequestCloseEventHandler(_mergeFeaturesViewModelLogical_RequestClose);
_mergeFeaturesWindow.DataContext = _mergeFeaturesViewModelLogical;
_mergeResultFeatureIndex = -1;
_mergeFeaturesWindow.ShowDialog();
if (_mergeResultFeatureIndex == -1)
{
return(false);
}
_viewModelMain.ChangeCursor(Cursors.Wait, "Processing ...");
_viewModelMain.DataBase.BeginTransaction(true, IsolationLevel.ReadCommitted);
try
{
string keepIncid = selectTable[_mergeResultFeatureIndex].incid;
// assign selected incid to selected features except keepIncid
DataTable historyTable = _viewModelMain.GISApplication.MergeFeaturesLogically(
keepIncid, _viewModelMain.HistoryColumns);
if ((historyTable == null) || (historyTable.Rows.Count == 0))
{
throw new Exception("Failed to update GIS layer.");
}
// assign selected incid and new toid_fragment_id to selected features except keepIncid in DB shadow copy
string toidFragmentFormat = String.Format("D{0}",
_viewModelMain.HluDataset.incid_mm_polygons.toid_fragment_idColumn.MaxLength);
List <KeyValuePair <int, object> > updateFields = new List <KeyValuePair <int, object> >();
var keepPolygon = polygons.FirstOrDefault(r => r.incid == keepIncid);
if (keepPolygon != null)
{
updateFields = (from c in polygons.Columns.Cast <DataColumn>()
where (c.Ordinal != _viewModelMain.HluDataset.incid_mm_polygons.incidColumn.Ordinal) &&
(c.Ordinal != _viewModelMain.HluDataset.incid_mm_polygons.toidColumn.Ordinal) &&
(c.Ordinal != _viewModelMain.HluDataset.incid_mm_polygons.toid_fragment_idColumn.Ordinal) &&
(c.Ordinal != _viewModelMain.HluDataset.incid_mm_polygons.shape_lengthColumn.Ordinal) &&
(c.Ordinal != _viewModelMain.HluDataset.incid_mm_polygons.shape_areaColumn.Ordinal)
select new KeyValuePair <int, object>(c.Ordinal, keepPolygon[c.Ordinal])).ToList();
}
var updatePolygons = from r in polygons
where r.incid != keepIncid
orderby r.toid, r.toid_fragment_id
select r;
// update shadow DB copy of GIS layer
foreach (HluDataSet.incid_mm_polygonsRow r in updatePolygons)
{
r.incid = keepIncid;
for (int i = 0; i < updateFields.Count; i++)
{
r[updateFields[i].Key] = updateFields[i].Value;
}
}
if (_viewModelMain.HluTableAdapterManager.incid_mm_polygonsTableAdapter.Update(polygons) == -1)
{
throw new Exception(String.Format("Failed to update {0} table.", _viewModelMain.HluDataset.incid_mm_polygons.TableName));
}
// insert history rows (fixed value keepIncid)
Dictionary <int, string> fixedValues = new Dictionary <int, string>();
fixedValues.Add(_viewModelMain.HluDataset.history.incidColumn.Ordinal, keepIncid);
ViewModelWindowMainHistory vmHist = new ViewModelWindowMainHistory(_viewModelMain);
vmHist.HistoryWrite(fixedValues, historyTable, ViewModelWindowMain.Operations.LogicalMerge);
// count incid records no longer in use
List <string> deleteIncids = new List <string>();
IDataReader delReader = _viewModelMain.DataBase.ExecuteReader(String.Format(
"SELECT {0} FROM {1} WHERE {0} IN ({2}) GROUP BY {0} HAVING COUNT(*) = 0",
_viewModelMain.DataBase.QuoteIdentifier(_viewModelMain.IncidTable.incidColumn.ColumnName),
_viewModelMain.DataBase.QualifyTableName(_viewModelMain.IncidTable.TableName),
selectTable.Aggregate(new StringBuilder(), (sb, r) => sb.Append("," +
_viewModelMain.DataBase.QuoteValue(r.incid))).Remove(0, 1)),
_viewModelMain.DataBase.Connection.ConnectionTimeout, CommandType.Text);
if (delReader == null)
{
throw new Exception("Error reading incid database table.");
}
while (delReader.Read())
{
deleteIncids.Add(delReader.GetString(0));
}
delReader.Close();
// delete any incid records no longer in use
if (deleteIncids.Count > 0)
{
int numAffected = _viewModelMain.DataBase.ExecuteNonQuery(String.Format(
"DELETE FROM {0} WHERE {1} IN ({2})",
_viewModelMain.DataBase.QualifyTableName(_viewModelMain.HluDataset.incid.TableName),
_viewModelMain.DataBase.QuoteValue(_viewModelMain.HluDataset.incid.incidColumn.ColumnName),
String.Join(",", deleteIncids.Select(i => _viewModelMain.DataBase.QuoteValue(i)).ToArray())),
_viewModelMain.DataBase.Connection.ConnectionTimeout, CommandType.Text);
if (numAffected > 0)
{
_viewModelMain.IncidRowCount(true);
}
}
_viewModelMain.ViewModelUpdate.UpdateIncidModifiedColumns(keepIncid);
if (physicallyMerge && (MessageBox.Show("Perform physical merge as well?", "HLU: Physical Merge",
MessageBoxButton.YesNo, MessageBoxImage.Question, MessageBoxResult.No) == MessageBoxResult.Yes))
{
// restore the selection
_viewModelMain.GisSelection.Clear();
foreach (HluDataSet.incid_mm_polygonsRow r in polygons)
{
DataRow newRow = _viewModelMain.GisSelection.NewRow();
for (int i = 0; i < _viewModelMain.GisIDColumnOrdinals.Length; i++)
{
newRow[i] = r[_viewModelMain.GisIDColumnOrdinals[i]];
}
_viewModelMain.GisSelection.Rows.Add(newRow);
}
PerformPhysicalMerge();
}
else
{
_viewModelMain.DataBase.CommitTransaction();
_viewModelMain.HluDataset.AcceptChanges();
// Re-count the incid records in the database.
_viewModelMain.IncidRowCount(true);
// Reset the incid and map selections but don't move
// to the first incid in the database.
_viewModelMain.ClearFilter(false);
// Synch with the GIS selection.
//---------------------------------------------------------------------
// FIX: 027 Force refill of Incid table after split/merge
// Force the Incid table to be refilled because it has been
// updated directly in the database rather than via the
// local copy.
_viewModelMain.RefillIncidTable = true;
//---------------------------------------------------------------------
_viewModelMain.ReadMapSelection(true);
}
}
catch
{
_viewModelMain.DataBase.RollbackTransaction();
throw;
}
}
catch (Exception ex)
{
success = false;
MessageBox.Show("Merge operation failed. The error message returned was:\n\n" +
ex.Message, "HLU Merge Error", MessageBoxButton.OK, MessageBoxImage.Error);
}
finally { _viewModelMain.ChangeCursor(Cursors.Arrow, null); }
return(success);
}
private void Export(int userExportId, bool exportDescriptions, bool selectedOnly)
{
string tempPath = null;
try
{
string tableAlias = GetTableAlias();
if (tableAlias == null)
{
throw new Exception("Failed to find a table alias that does not match a table name in the HLU dataset.");
}
// refresh export fields from DB
_viewModelMain.HluTableAdapterManager.exportsFieldsTableAdapter.ClearBeforeFill = true;
_viewModelMain.HluTableAdapterManager.exportsFieldsTableAdapter.Fill(
_viewModelMain.HluDataset.exports_fields, String.Format("{0} = {1} ORDER BY {2}, {3}",
_viewModelMain.DataBase.QuoteIdentifier(
_viewModelMain.HluDataset.exports_fields.export_idColumn.ColumnName), userExportId,
_viewModelMain.DataBase.QuoteIdentifier(
_viewModelMain.HluDataset.exports_fields.table_nameColumn.ColumnName),
_viewModelMain.DataBase.QuoteIdentifier(
_viewModelMain.HluDataset.exports_fields.field_ordinalColumn.ColumnName)));
if (_viewModelMain.HluDataset.exports_fields.Count == 0)
{
throw new Exception(String.Format("No export fields are defined for format '{0}'.",
_viewModelMain.HluDataset.exports.FindByexport_id(userExportId).export_name));
}
DataTable exportTable;
List <int> fieldCountList;
StringBuilder targetList;
StringBuilder fromClause;
int incidOrdinal;
ExportJoins(exportDescriptions, tableAlias, out exportTable,
out fieldCountList, out targetList, out fromClause, out incidOrdinal);
string whereClause = String.Empty;
List <List <SqlFilterCondition> > exportFilter = null;
if (!_viewModelExport.SelectedOnly)
{
SqlFilterCondition cond = new SqlFilterCondition("AND",
_viewModelMain.IncidTable, _viewModelMain.IncidTable.incidColumn, null);
cond.Operator = "IS NOT NULL";
exportFilter = new List <List <SqlFilterCondition> >(new List <SqlFilterCondition>[] {
new List <SqlFilterCondition>(new SqlFilterCondition[] { cond })
});
}
else
{
if ((_viewModelMain.IncidSelectionWhereClause == null) &&
(_viewModelMain.GisSelection != null) && (_viewModelMain.GisSelection.Rows.Count > 0))
{
_viewModelMain.IncidSelectionWhereClause = ViewModelWindowMainHelpers.GisSelectionToWhereClause(
_viewModelMain.GisSelection.Select(), _viewModelMain.GisIDColumnOrdinals,
ViewModelWindowMain.IncidPageSize, _viewModelMain.HluDataset.incid);
}
exportFilter = _viewModelMain.IncidSelectionWhereClause;
}
string sql = ScratchDb.UnionQuery(targetList.ToString(), fromClause.ToString(),
incidOrdinal, exportFilter, _viewModelMain.DataBase);
_viewModelMain.ChangeCursor(Cursors.Wait, "Exporting ...");
int exportRowCount;
tempPath = ExportMdb(sql, exportTable, incidOrdinal, fieldCountList, out exportRowCount);
if (!String.IsNullOrEmpty(tempPath) && (exportRowCount > 0))
{
_viewModelMain.GISApplication.Export(tempPath, exportTable.TableName, exportRowCount);
}
else
{
throw new Exception("Export query did not retrieve any rows");
}
_viewModelMain.IncidSelection = null;
_viewModelMain.GisSelection = null;
_viewModelMain.OnPropertyChanged("IsFiltered");
_viewModelMain.OnPropertyChanged("StatusIncid");
}
catch (Exception ex)
{
MessageBox.Show(String.Format("Export failed. The error message was:\n\n{0}.",
ex.Message), "HLU: Export", MessageBoxButton.OK, MessageBoxImage.Error);
}
finally
{
if (!String.IsNullOrEmpty(tempPath))
{
string[] tempFiles = Directory.GetFiles(Path.GetDirectoryName(tempPath),
Path.GetFileNameWithoutExtension(tempPath) + ".*");
foreach (string fName in tempFiles)
{
try { File.Delete(fName); }
catch { _viewModelMain.ExportMdbs.Add(fName); }
}
}
_viewModelMain.ChangeCursor(Cursors.Arrow, null);
}
}
/// <summary>
/// Physically split features on the GIS layer.
/// </summary>
private bool PerformPhysicalSplit()
{
bool success = true;
_viewModelMain.DataBase.BeginTransaction(true, IsolationLevel.ReadCommitted);
try
{
// find next available toid_fragment_id for selected toid
string lastToidFragmentID = _viewModelMain.RecIDs.MaxToidFragmentId(_viewModelMain.ToidsSelectedMap.ElementAt(0));
// get a filter from the GIS selection
List <List <SqlFilterCondition> > featuresFilter = ViewModelWindowMainHelpers.GisSelectionToWhereClause(
_viewModelMain.GisSelection.AsEnumerable().Skip(1).ToArray(), _viewModelMain.GisIDColumnOrdinals,
ViewModelWindowMain.IncidPageSize, _viewModelMain.HluDataset.incid_mm_polygons);
if (featuresFilter.Count != 1)
{
throw new Exception("Error finding features in database.");
}
// update records in GIS and collect new features resulting from split
DataTable newFeatures = _viewModelMain.GISApplication.SplitFeature(lastToidFragmentID, featuresFilter[0],
_viewModelMain.HluDataset.incid_mm_polygons.Columns.Cast <DataColumn>().Where(c =>
c.ColumnName != _viewModelMain.HluDataset.incid_mm_polygons.shape_lengthColumn.ColumnName &&
c.ColumnName != _viewModelMain.HluDataset.incid_mm_polygons.shape_areaColumn.ColumnName).ToArray());
if ((newFeatures == null) || (newFeatures.Rows.Count < 2))
{
throw new Exception("Failed to update GIS layer.");
}
ViewModelWindowMainHistory vmHist = new ViewModelWindowMainHistory(_viewModelMain);
vmHist.HistoryRenameGeometryPropertyColumns(
_viewModelMain.HluDataset.incid_mm_polygons.shape_lengthColumn.ColumnName,
_viewModelMain.HluDataset.incid_mm_polygons.shape_areaColumn.ColumnName, ref newFeatures);
// get a where clause for the original split feature
List <List <SqlFilterCondition> > originalFeatureWhereClause = ViewModelWindowMainHelpers.GisSelectionToWhereClause(
_viewModelMain.GisSelection.AsEnumerable().Take(1).ToArray(), _viewModelMain.GisIDColumnOrdinals,
ViewModelWindowMain.IncidPageSize, _viewModelMain.HluDataset.incid_mm_polygons);
if (originalFeatureWhereClause.Count != 1)
{
throw new Exception("Error finding features in database.");
}
// get the attributes of the split feature
HluDataSet.incid_mm_polygonsDataTable updTable = new HluDataSet.incid_mm_polygonsDataTable();
_viewModelMain.GetIncidMMPolygonRows(originalFeatureWhereClause, ref updTable);
if ((updTable == null) || (updTable.Rows.Count != 1))
{
throw new Exception("Failed to fetch incid_mm_polygon rows.");
}
// insert attributes of original split feature into history
DataTable history = updTable.Copy();
history.Columns[updTable.shape_lengthColumn.ColumnName].ColumnName = ViewModelWindowMain.HistoryGeometry1ColumnName;
history.Columns[updTable.shape_areaColumn.ColumnName].ColumnName = ViewModelWindowMain.HistoryGeometry2ColumnName;
string[] historyColNames = (new string[] { ViewModelWindowMain.HistoryGeometry1ColumnName, ViewModelWindowMain.HistoryGeometry2ColumnName }
.Concat(_viewModelMain.HistoryColumns.Select(c => c.ColumnName)).ToArray());
DataColumn[] delCols = history.Columns.Cast <DataColumn>().Where(c => !historyColNames.Contains(c.ColumnName)).ToArray();
foreach (DataColumn c in delCols)
{
history.Columns.Remove(c);
}
vmHist.HistoryWrite(null, history, ViewModelWindowMain.Operations.PhysicalSplit);
// update the original row
if (_viewModelMain.DataBase.ExecuteNonQuery(String.Format("UPDATE {0} SET {1} WHERE {2}",
_viewModelMain.DataBase.QualifyTableName(_viewModelMain.HluDataset.incid_mm_polygons.TableName),
String.Join(",", newFeatures.Rows[0].ItemArray.Select((i, index) =>
new
{
ColumnName = newFeatures.Columns[index].ColumnName,
value = i
})
.Where(a => _viewModelMain.GisIDColumns.Count(c => c.ColumnName == a.ColumnName) == 0)
.Select(a => String.Format("{0} = {1}", _viewModelMain.DataBase.QuoteIdentifier(a.ColumnName),
_viewModelMain.DataBase.QuoteValue(a.value))).ToArray()),
_viewModelMain.DataBase.WhereClause(false, true, true, originalFeatureWhereClause[0])),
_viewModelMain.DataBase.Connection.ConnectionTimeout, CommandType.Text) == -1)
{
throw new Exception("Failed to update original row in database copy of GIS layer.");
}
// build an insert statement for DB shadow copy of GIS layer
string insertStatement = String.Format("INSERT INTO {0} ({1}) VALUES (",
_viewModelMain.DataBase.QualifyTableName(_viewModelMain.HluDataset.incid_mm_polygons.TableName),
String.Join(",", newFeatures.Columns.Cast <DataColumn>().Select(c =>
_viewModelMain.DataBase.QuoteIdentifier(c.ColumnName)).ToArray())) + "{0})";
int toidFragID = Int32.Parse(lastToidFragmentID);
string numFormat = String.Format("D{0}", updTable.toid_fragment_idColumn.MaxLength);
// insert new features returned from GIS into DB shadow copy of GIS layer
for (int i = 1; i < newFeatures.Rows.Count; i++)
{
if (_viewModelMain.DataBase.ExecuteNonQuery(String.Format(insertStatement, String.Join(",",
newFeatures.Rows[i].ItemArray.Select((item, index) =>
_viewModelMain.DataBase.QuoteValue(newFeatures.Columns[index].ColumnName ==
updTable.toid_fragment_idColumn.ColumnName ?
(toidFragID + i).ToString(numFormat) : item)).ToArray())),
_viewModelMain.DataBase.Connection.ConnectionTimeout, CommandType.Text) == -1)
{
throw new Exception("Failed to insert new rows into database copy of GIS layer.");
}
}
_viewModelMain.ViewModelUpdate.UpdateIncidModifiedColumns(_viewModelMain.IncidsSelectedMap.ElementAt(0));
_viewModelMain.DataBase.CommitTransaction();
_viewModelMain.HluDataset.AcceptChanges();
}
catch (Exception ex)
{
_viewModelMain.DataBase.RollbackTransaction();
success = false;
MessageBox.Show("Split operation failed. The error message returned was:\n\n" +
ex.Message, "HLU Split Error", MessageBoxButton.OK, MessageBoxImage.Error);
}
finally
{
if (success)
{
_viewModelMain.IncidRowCount(true);
_viewModelMain.ClearFilter();
_viewModelMain.ReadMapSelection(true);
}
}
return(success);
}
private bool PerformLogicalSplit()
{
//if ((_viewModelMain.GisSelection.Rows.Count > 1) &&
// (_viewModelMain.HluDataset.incid_mm_polygons.Rows.Count == _viewModelMain.GisSelection.Rows.Count))
//{
// MessageBox.Show(String.Format("Cannot split: all features in map " +
// "selection set correspond to INCID '{0}'.", _viewModelMain.Incid), "HLU: Split",
// MessageBoxButton.OK, MessageBoxImage.Exclamation);
// return false;
//}
//else
//{
// check if selected feature is the only one pertaining to its incid
if (_viewModelMain.GisSelection.Rows.Count == 1)
{
int featCount = (int)_viewModelMain.DataBase.ExecuteScalar(String.Format(
"SELECT COUNT(*) FROM {0} WHERE {1} = {2}",
_viewModelMain.DataBase.QualifyTableName(_viewModelMain.HluDataset.incid_mm_polygons.TableName),
_viewModelMain.DataBase.QuoteIdentifier(_viewModelMain.HluDataset.incid_mm_polygons.incidColumn.ColumnName),
_viewModelMain.DataBase.QuoteValue(_viewModelMain.Incid)),
_viewModelMain.DataBase.Connection.ConnectionTimeout, CommandType.Text);
if (featCount == 1)
{
MessageBox.Show(String.Format("Cannot split: feature selected in map is the only" +
" feature corresponding to INCID {0}", _viewModelMain.Incid), "HLU: Split",
MessageBoxButton.OK, MessageBoxImage.Asterisk);
return(false);
}
}
bool success = true;
_viewModelMain.DataBase.BeginTransaction(true, IsolationLevel.ReadCommitted);
try
{
_viewModelMain.ViewModelUpdate.UpdateIncidModifiedColumns(_viewModelMain.CurrentIncid);
// create new incid by cloning the current one
string msg;
if (!CloneCurrentIncid(false, out msg))
{
throw new Exception(msg);
}
string newIncid = _viewModelMain.RecIDs.CurrentIncid;
// update GIS layer
DataTable historyTable = _viewModelMain.GISApplication.SplitFeaturesLogically(newIncid,
_viewModelMain.HistoryColumns.Concat(new DataColumn[] { new DataColumn(
_viewModelMain.HluDataset.history.modified_toid_fragment_idColumn.ColumnName.Replace(
_viewModelMain.HluDataset.incid_mm_polygons.toid_fragment_idColumn.ColumnName, String.Empty) +
GISApplication.GISApp.HistoryAdditionalFieldsDelimiter +
_viewModelMain.HluDataset.incid_mm_polygons.toid_fragment_idColumn.ColumnName,
_viewModelMain.HluDataset.history.modified_toid_fragment_idColumn.DataType) }).ToArray());
if (historyTable == null)
{
throw new Exception("Failed to update GIS layer.");
}
// update DB shadow copy of GIS layer
HluDataSet.incid_mm_polygonsDataTable polygons = new HluDataSet.incid_mm_polygonsDataTable();
_viewModelMain.GetIncidMMPolygonRows(ViewModelWindowMainHelpers.GisSelectionToWhereClause(
_viewModelMain.GisSelection.Select(), _viewModelMain.GisIDColumnOrdinals,
ViewModelWindowMain.IncidPageSize, polygons), ref polygons);
historyTable.PrimaryKey = historyTable.Columns.Cast <DataColumn>()
.Where(c => _viewModelMain.GisIDColumnOrdinals.Contains(c.Ordinal)).ToArray();
foreach (HluDataSet.incid_mm_polygonsRow r in polygons)
{
DataRow historyRow = historyTable.Rows.Find(r.ItemArray.Where((i, index) =>
_viewModelMain.GisIDColumnOrdinals.Contains(index)).ToArray());
r.toid_fragment_id = historyRow.Field <string>(
_viewModelMain.HluDataset.history.modified_toid_fragment_idColumn.ColumnName);
r.incid = newIncid;
}
if (_viewModelMain.HluTableAdapterManager.incid_mm_polygonsTableAdapter.Update(polygons) == -1)
{
throw new Exception(String.Format("Failed to update {0} table.", _viewModelMain.HluDataset.incid_mm_polygons.TableName));
}
_viewModelMain.ViewModelUpdate.UpdateIncidModifiedColumns(
historyTable.Rows[0][_viewModelMain.HluDataset.history.incidColumn.ColumnName].ToString());
// write history
Dictionary <int, string> fixedValues = new Dictionary <int, string>();
fixedValues.Add(_viewModelMain.HluDataset.history.incidColumn.Ordinal, newIncid);
historyTable.Columns[_viewModelMain.HluDataset.history.incidColumn.ColumnName].ColumnName =
_viewModelMain.HluDataset.history.modified_incidColumn.ColumnName;
ViewModelWindowMainHistory vmHist = new ViewModelWindowMainHistory(_viewModelMain);
vmHist.HistoryWrite(fixedValues, historyTable, ViewModelWindowMain.Operations.LogicalSplit);
_viewModelMain.DataBase.CommitTransaction();
_viewModelMain.HluDataset.AcceptChanges();
}
catch (Exception ex)
{
_viewModelMain.DataBase.RollbackTransaction();
success = false;
MessageBox.Show("Split operation failed. The error message returned was:\n\n" +
ex.Message, "HLU Split Error", MessageBoxButton.OK, MessageBoxImage.Error);
}
finally
{
if (success)
{
_viewModelMain.ClearFilter();
// re-count records
_viewModelMain.IncidRowCount(true);
// synch with GIS selection
_viewModelMain.ReadMapSelection(true);
}
}
//}
return(success);
}