/// <summary>
/// This model class validates the selected features in a map.
/// </summary>
/// <param name="map">The map to validate</param>
/// <returns></returns>
public static Task <string> ValidateMap(Map map)
{
return(QueuedTask.Run <string>(() =>
{
StringBuilder validationStringBuilder = new StringBuilder();
// Get the selection from the map
Dictionary <MapMember, List <long> > mapMembersWithSelection = map.GetSelection();
// Step through each MapMember (FeatureLayer or StandaloneTable) that contains selected features
foreach (KeyValuePair <MapMember, List <long> > dictionaryItem in mapMembersWithSelection)
{
if (dictionaryItem.Key is FeatureLayer)
{
FeatureLayer featureLayer = dictionaryItem.Key as FeatureLayer;
using (Table table = featureLayer.GetTable())
{
validationStringBuilder.Append(ValidateTable(table, featureLayer.GetSelection()));
}
}
else if (dictionaryItem.Key is StandaloneTable)
{
StandaloneTable standaloneTable = dictionaryItem.Key as StandaloneTable;
using (Table table = standaloneTable.GetTable())
{
validationStringBuilder.Append(ValidateTable(table, standaloneTable.GetSelection()));
}
}
}
return validationStringBuilder.ToString();
}));
}
public async void AddNewRoute(string routeName)
{
var map = MapView.Active.Map;
if (!BuildOnSelect && SegmentsLayer.SelectionCount == 0)
{
MessageBox.Show("At least one segment must be selected!");
return;
}
await QueuedTask.Run(async() =>
{
using (var routesTable = RoutesStandaloneTable.GetTable())
using (var routeToHeadsTable = RouteToTrailheadsTable.GetTable())
using (var routeToSegmentsTable = RouteToTrailSegmentsTable.GetTable())
using (var routeBuf = routesTable.CreateRowBuffer())
using (var tempSegsFeatureClass = TempSegmentsLayer.GetFeatureClass())
{
var namesFilter = new QueryFilter()
{
WhereClause = $"Upper({RouteName}) = '{routeName.ToUpper().Replace("'", "''")}'"
};
using (var namesCursor = RoutesStandaloneTable.Search(namesFilter))
{
if (namesCursor.MoveNext())
{
MessageBox.Show($"There is already a route named: {routeName}!");
return;
}
}
var operation = new EditOperation();
operation.Name = "Create new trails route: " + routeName;
await EnsureIDsForSelectedAsync(operation);
await operation.ExecuteAsync();
if (!operation.IsSucceeded)
{
MessageBox.Show(operation.ErrorMessage);
return;
}
var operation2 = operation.CreateChainedOperation();
operation2.Callback(context =>
{
// create route row
routeBuf[RouteName] = routeName;
routeBuf[RouteID] = $"{{{Guid.NewGuid()}}}";
using (var routeRow = routesTable.CreateRow(routeBuf))
using (var headsCursor = HeadsLayer.GetSelection().Search(null, false))
using (var segmentCursor = SegmentsLayer.GetSelection().Search((QueryFilter)null, false))
{
var segments = new List <string>();
var parts = new Dictionary <int, List <Polyline> >();
if (BuildOnSelect)
{
// get segments from TempSegments layer
bool atLeastOne = false;
using (var tempSegsCursor = tempSegsFeatureClass.Search(null, false))
{
while (tempSegsCursor.MoveNext())
{
atLeastOne = true;
var row = tempSegsCursor.Current;
var partNum = int.Parse(row[RoutePart].ToString());
var segID = (string)row[USNG_SEG];
CreateRoutePart(segID, (string)routeRow[RouteID], partNum, context, routeToSegmentsTable);
segments.Add(segID);
var geometry = (Polyline)row["SHAPE"];
if (parts.ContainsKey(partNum))
{
parts[partNum].Add(geometry);
}
else
{
parts[partNum] = new List <Polyline>()
{
geometry
};
}
}
Reset();
tempSegsFeatureClass.DeleteRows(new QueryFilter());
context.Invalidate(tempSegsFeatureClass);
}
if (!atLeastOne)
{
context.Abort("There must be at least one feature in TempSegments!");
}
}
else
{
//get segments from selected features
while (segmentCursor.MoveNext())
{
var segRow = segmentCursor.Current;
var segID = (string)segRow[USNG_SEG];
const int partNum = 1;
CreateRoutePart(segID, routeRow[RouteID], partNum, context, routeToSegmentsTable);
segments.Add(segID);
var geometry = (Polyline)segRow["SHAPE"];
if (parts.ContainsKey(partNum))
{
parts[partNum].Add(geometry);
}
else
{
parts[partNum] = new List <Polyline>()
{
geometry
};
}
}
}
if (segments.Count > 1 && !ValidateConnectivity(parts))
{
context.Abort("Not all segments are connected!");
return;
}
// trailhead
if (HeadsLayer.SelectionCount > 0)
{
while (headsCursor.MoveNext())
{
using (var headBuffer = routeToHeadsTable.CreateRowBuffer())
{
headBuffer[RouteID] = (string)routeRow[RouteID];
headBuffer[USNG_TH] = headsCursor.Current[USNG_TH];
using (var headRow = routeToHeadsTable.CreateRow(headBuffer))
{
context.Invalidate(headRow);
}
}
}
}
context.Invalidate(routeRow);
}
}, routesTable, routeToSegmentsTable, routeToHeadsTable, tempSegsFeatureClass);
await operation2.ExecuteAsync();
if (operation2.IsSucceeded)
{
FrameworkApplication.AddNotification(new Notification
{
Title = FrameworkApplication.Title,
Message = $"Route: \"{routeName}\" added successfully!",
ImageUrl = "pack://application:,,,/ArcGIS.Desktop.Resources;component/Images/GenericCheckMark32.png"
});
SegmentsLayer.ClearSelection();
HeadsLayer.ClearSelection();
}
else
{
MessageBox.Show(operation2.ErrorMessage);
}
}
});
}
