public void EditOperations()
{
var featureLayer = MapView.Active.Map.GetLayersAsFlattenedList()[0] as FeatureLayer;
var polygon = new PolygonBuilder().ToGeometry();
var clipPoly = new PolygonBuilder().ToGeometry();
var cutLine = new PolylineBuilder().ToGeometry();
var modifyLine = cutLine;
var oid = 1;
#region Edit Operation Create Features
var createFeatures = new EditOperation();
createFeatures.Name = "Create Features";
//Create a feature with a polygon
createFeatures.Create(featureLayer, polygon);
//with a callback
createFeatures.Create(featureLayer, polygon, (object_id) => {
//TODO - use the oid of the created feature
//in your callback
});
//Do a create features and set attributes
var attributes = new Dictionary <string, object>();
attributes.Add("SHAPE", polygon);
attributes.Add("NAME", "Corner Market");
attributes.Add("SIZE", 1200.5);
attributes.Add("DESCRIPTION", "Corner Market");
createFeatures.Create(featureLayer, attributes);
//Create features using the current template
//Must be within a MapTool
createFeatures.Create(this.CurrentTemplate, polygon);
//Execute to execute the operation
//Must be called within QueuedTask.Run
createFeatures.Execute();
//or use async flavor
//await createFeatures.ExecuteAsync();
#endregion
#region Edit Operation Clip Features
var clipFeatures = new EditOperation();
clipFeatures.Name = "Clip Features";
clipFeatures.Clip(featureLayer, oid, clipPoly, ClipMode.PreserveArea);
//Execute to execute the operation
//Must be called within QueuedTask.Run
clipFeatures.Execute();
//or use async flavor
//await clipFeatures.ExecuteAsync();
#endregion
#region Edit Operation Cut Features
var select = MapView.Active.SelectFeatures(clipPoly);
var cutFeatures = new EditOperation();
cutFeatures.Name = "Cut Features";
cutFeatures.Cut(featureLayer, oid, cutLine);
//Cut all the selected features in the active view
//Select using a polygon (for example)
var kvps = MapView.Active.SelectFeatures(polygon).Select(
k => new KeyValuePair <MapMember, List <long> >(k.Key as MapMember, k.Value));
cutFeatures.Cut(kvps, cutLine);
//Execute to execute the operation
//Must be called within QueuedTask.Run
cutFeatures.Execute();
//or use async flavor
//await cutFeatures.ExecuteAsync();
#endregion
#region Edit Operation Delete Features
var deleteFeatures = new EditOperation();
deleteFeatures.Name = "Delete Features";
var table = MapView.Active.Map.StandaloneTables[0];
//Delete a row in a standalone table
deleteFeatures.Delete(table, oid);
//Delete all the selected features in the active view
//Select using a polygon (for example)
var selection = MapView.Active.SelectFeatures(polygon).Select(
k => new KeyValuePair <MapMember, List <long> >(k.Key as MapMember, k.Value));
deleteFeatures.Delete(selection);
//Execute to execute the operation
//Must be called within QueuedTask.Run
deleteFeatures.Execute();
//or use async flavor
//await deleteFeatures.ExecuteAsync();
#endregion
#region Edit Operation Duplicate Features
var duplicateFeatures = new EditOperation();
duplicateFeatures.Name = "Duplicate Features";
//Duplicate with an X and Y offset of 500 map units
duplicateFeatures.Duplicate(featureLayer, oid, 500.0, 500.0, 0.0);
//Execute to execute the operation
//Must be called within QueuedTask.Run
duplicateFeatures.Execute();
//or use async flavor
//await duplicateFeatures.ExecuteAsync();
#endregion
#region Edit Operation Explode Features
var explodeFeatures = new EditOperation();
explodeFeatures.Name = "Explode Features";
//Take a multipart and convert it into one feature per part
//Provide a list of ids to convert multiple
explodeFeatures.Explode(featureLayer, new List <long>()
{
oid
}, true);
//Execute to execute the operation
//Must be called within QueuedTask.Run
explodeFeatures.Execute();
//or use async flavor
//await explodeFeatures.ExecuteAsync();
#endregion
var destinationLayer = featureLayer;
#region Edit Operation Merge Features
var mergeFeatures = new EditOperation();
mergeFeatures.Name = "Merge Features";
//Merge three features into a new feature using defaults
//defined in the current template
mergeFeatures.Merge(this.CurrentTemplate as EditingFeatureTemplate, featureLayer, new List <long>()
{
10, 96, 12
});
//Merge three features into a new feature in the destination layer
mergeFeatures.Merge(destinationLayer, featureLayer, new List <long>()
{
10, 96, 12
});
//Use an inspector to set the new attributes of the merged feature
var inspector = new Inspector();
inspector.Load(featureLayer, oid);//base attributes on an existing feature
//change attributes for the new feature
inspector["NAME"] = "New name";
inspector["DESCRIPTION"] = "New description";
//Merge features into a new feature in the same layer using the
//defaults set in the inspector
mergeFeatures.Merge(featureLayer, new List <long>()
{
10, 96, 12
}, inspector);
//Execute to execute the operation
//Must be called within QueuedTask.Run
mergeFeatures.Execute();
//or use async flavor
//await mergeFeatures.ExecuteAsync();
#endregion
#region Edit Operation Modify single feature
var modifyFeature = new EditOperation();
modifyFeature.Name = "Modify a feature";
//use an inspector
var modifyInspector = new Inspector();
modifyInspector.Load(featureLayer, oid);//base attributes on an existing feature
//change attributes for the new feature
modifyInspector["SHAPE"] = polygon; //Update the geometry
modifyInspector["NAME"] = "Updated name"; //Update attribute(s)
modifyFeature.Modify(modifyInspector);
//update geometry and attributes using overload
var featureAttributes = new Dictionary <string, object>();
featureAttributes["NAME"] = "Updated name";//Update attribute(s)
modifyFeature.Modify(featureLayer, oid, polygon, featureAttributes);
//Execute to execute the operation
//Must be called within QueuedTask.Run
modifyFeature.Execute();
//or use async flavor
//await modifyFeatures.ExecuteAsync();
#endregion
#region Edit Operation Modify multiple features
//Search by attribute
var queryFilter = new QueryFilter();
queryFilter.WhereClause = "OBJECTID < 1000000";
//Create list of oids to update
var oidSet = new List <long>();
using (var rc = featureLayer.Search(queryFilter))
{
while (rc.MoveNext())
{
oidSet.Add(rc.Current.GetObjectID());
}
}
//create and execute the edit operation
var modifyFeatures = new EditOperation();
modifyFeatures.Name = "Modify features";
modifyFeatures.ShowProgressor = true;
var insp = new Inspector();
insp.Load(featureLayer, oidSet);
insp["MOMC"] = 24;
modifyFeatures.Modify(insp);
modifyFeatures.ExecuteAsync();
#endregion
#region Move features
//Get all of the selected ObjectIDs from the layer.
var firstLayer = MapView.Active.Map.GetLayersAsFlattenedList().OfType <FeatureLayer>().FirstOrDefault();
var selectionfromMap = firstLayer.GetSelection();
// set up a dictionary to store the layer and the object IDs of the selected features
var selectionDictionary = new Dictionary <MapMember, List <long> >();
selectionDictionary.Add(firstLayer as MapMember, selectionfromMap.GetObjectIDs().ToList());
var moveFeature = new EditOperation();
moveFeature.Name = "Move features";
moveFeature.Move(selectionDictionary, 10, 10); //specify your units along axis to move the geometry
moveFeature.Execute();
#endregion
#region Move feature to a specific coordinate
//Get all of the selected ObjectIDs from the layer.
var abLayer = MapView.Active.Map.GetLayersAsFlattenedList().OfType <FeatureLayer>().FirstOrDefault();
var mySelection = abLayer.GetSelection();
var selOid = mySelection.GetObjectIDs().FirstOrDefault();
var moveToPoint = new MapPointBuilder(1.0, 2.0, 3.0, 4.0, MapView.Active.Map.SpatialReference); //can pass in coordinates.
var modifyFeatureCoord = new EditOperation();
modifyFeatureCoord.Name = "Move features";
modifyFeatureCoord.Modify(abLayer, selOid, moveToPoint.ToGeometry()); //Modify the feature to the new geometry
modifyFeatureCoord.Execute();
#endregion
#region Edit Operation Planarize Features
var planarizeFeatures = new EditOperation();
planarizeFeatures.Name = "Planarize Features";
//Planarize one or more features
planarizeFeatures.Planarize(featureLayer, new List <long>()
{
oid
});
//Execute to execute the operation
//Must be called within QueuedTask.Run
planarizeFeatures.Execute();
//or use async flavor
//await planarizeFeatures.ExecuteAsync();
#endregion
#region Edit Operation Reshape Features
var reshapeFeatures = new EditOperation();
reshapeFeatures.Name = "Reshape Features";
reshapeFeatures.Reshape(featureLayer, oid, modifyLine);
//Reshape a set of features that intersect some geometry....
var selFeatures = MapView.Active.GetFeatures(modifyLine).Select(
k => new KeyValuePair <MapMember, List <long> >(k.Key as MapMember, k.Value));
reshapeFeatures.Reshape(selFeatures, modifyLine);
//Execute to execute the operation
//Must be called within QueuedTask.Run
reshapeFeatures.Execute();
//or use async flavor
//await reshapeFeatures.ExecuteAsync();
#endregion
var origin = MapPointBuilder.CreateMapPoint(0, 0, null);
#region Edit Operation Rotate Features
var rotateFeatures = new EditOperation();
rotateFeatures.Name = "Rotate Features";
//Rotate works on a selected set of features
//Get all features that intersect a polygon
var rotateSelection = MapView.Active.GetFeatures(polygon).Select(
k => new KeyValuePair <MapMember, List <long> >(k.Key as MapMember, k.Value));
//Rotate selected features 90 deg about "origin"
rotateFeatures.Rotate(rotateSelection, origin, Math.PI / 2);
//Execute to execute the operation
//Must be called within QueuedTask.Run
rotateFeatures.Execute();
//or use async flavor
//await rotateFeatures.ExecuteAsync();
#endregion
#region Edit Operation Scale Features
var scaleFeatures = new EditOperation();
scaleFeatures.Name = "Scale Features";
//Rotate works on a selected set of features
var scaleSelection = MapView.Active.GetFeatures(polygon).Select(
k => new KeyValuePair <MapMember, List <long> >(k.Key as MapMember, k.Value));
//Scale the selected features by 2.0 in the X and Y direction
scaleFeatures.Scale(scaleSelection, origin, 2.0, 2.0, 0.0);
//Execute to execute the operation
//Must be called within QueuedTask.Run
scaleFeatures.Execute();
//or use async flavor
//await scaleFeatures.ExecuteAsync();
#endregion
var mp1 = MapPointBuilder.CreateMapPoint(0, 0, null);
var mp2 = mp1;
var mp3 = mp1;
#region Edit Operation Split Features
var splitFeatures = new EditOperation();
splitFeatures.Name = "Split Features";
var splitPoints = new List <MapPoint>()
{
mp1, mp2, mp3
};
//Split the feature at 3 points
splitFeatures.Split(featureLayer, oid, splitPoints);
// split using percentage
var splitByPercentage = new SplitByPercentage()
{
Percentage = 33, SplitFromStartPoint = true
};
splitFeatures.Split(featureLayer, oid, splitByPercentage);
// split using equal parts
var splitByEqualParts = new SplitByEqualParts()
{
NumParts = 3
};
splitFeatures.Split(featureLayer, oid, splitByEqualParts);
// split using single distance
var splitByDistance = new SplitByDistance()
{
Distance = 27.3, SplitFromStartPoint = false
};
splitFeatures.Split(featureLayer, oid, splitByDistance);
// split using varying distance
var distances = new List <double>()
{
12.5, 38.2, 89.99
};
var splitByVaryingDistance = new SplitByVaryingDistance()
{
Distances = distances, SplitFromStartPoint = true, ProportionRemainder = true
};
splitFeatures.Split(featureLayer, oid, splitByVaryingDistance);
//Execute to execute the operation
//Must be called within QueuedTask.Run
splitFeatures.Execute();
//or use async flavor
//await splitAtPointsFeatures.ExecuteAsync();
#endregion
var linkLayer = featureLayer;
#region Edit Operation Transform Features
var transformFeatures = new EditOperation();
transformFeatures.Name = "Transform Features";
//Transform a selected set of features
var transformSelection = MapView.Active.GetFeatures(polygon).Select(
k => new KeyValuePair <MapMember, List <long> >(k.Key as MapMember, k.Value));
transformFeatures.Transform(transformSelection, linkLayer);
//Transform just a layer
transformFeatures.Transform(featureLayer, linkLayer);
//Perform an affine transformation
transformFeatures.TransformAffine(featureLayer, linkLayer);
//Execute to execute the operation
//Must be called within QueuedTask.Run
transformFeatures.Execute();
//or use async flavor
//await transformFeatures.ExecuteAsync();
#endregion
#region Edit Operation Perform a Clip, Cut, and Planarize
//Multiple operations can be performed by a single
//edit operation.
var clipCutPlanarizeFeatures = new EditOperation();
clipCutPlanarizeFeatures.Name = "Clip, Cut, and Planarize Features";
clipCutPlanarizeFeatures.Clip(featureLayer, oid, clipPoly);
clipCutPlanarizeFeatures.Cut(featureLayer, oid, cutLine);
clipCutPlanarizeFeatures.Planarize(featureLayer, new List <long>()
{
oid
});
//Note: An edit operation is a single transaction.
//Execute the operations (in the order they were declared)
clipCutPlanarizeFeatures.Execute();
//or use async flavor
//await clipCutPlanarizeFeatures.ExecuteAsync();
#endregion
#region Edit Operation Chain Edit Operations
//Chaining operations is a special case. Use "Chained Operations" when you require multiple transactions
//to be undo-able with a single "Undo".
//The most common use case for operation chaining is creating a feature with an attachement.
//Adding an attachment requires the object id (of a new feature) has already been created.
var editOperation1 = new EditOperation();
editOperation1.Name = string.Format("Create point in '{0}'", CurrentTemplate.Layer.Name);
long newFeatureID = -1;
//The Create operation has to execute so we can get an object_id
editOperation1.Create(this.CurrentTemplate, polygon, (object_id) => newFeatureID = object_id);
//Must be within a QueuedTask
editOperation1.Execute();
//or use async flavor
//await editOperation1.ExecuteAsync();
//Now, because we have the object id, we can add the attachment. As we are chaining it, adding the attachment
//can be undone as part of the "Undo Create" operation. In other words, only one undo operation will show on the
//Pro UI and not two.
var editOperation2 = editOperation1.CreateChainedOperation();
//Add the attachement using the new feature id
editOperation2.AddAttachment(this.CurrentTemplate.Layer, newFeatureID, @"C:\data\images\Hydrant.jpg");
//editOperation1 and editOperation2 show up as a single Undo operation on the UI even though
//we had two transactions
//Must be within a QueuedTask
editOperation2.Execute();
//or use async flavor
//await editOperation2.ExecuteAsync();
#endregion
#region SetOnUndone, SetOnRedone, SetOnComitted
// SetOnUndone, SetOnRedone and SetOnComittedManage can be used to manage
// external actions(such as writing to a log table) that are associated with
// each edit operation.
//get selected feature and update attribute
var selectedFeatures = MapView.Active.Map.GetSelection();
var testInspector = new Inspector();
testInspector.Load(selectedFeatures.Keys.First(), selectedFeatures.Values.First());
testInspector["Name"] = "test";
//create and execute the edit operation
var updateTestField = new EditOperation();
updateTestField.Name = "Update test field";
updateTestField.Modify(insp);
//actions for SetOn...
updateTestField.SetOnUndone(() =>
{
//Sets an action that will be called when this operation is undone.
Debug.WriteLine("Operation is undone");
});
updateTestField.SetOnRedone(() =>
{
//Sets an action that will be called when this editoperation is redone.
Debug.WriteLine("Operation is redone");
});
updateTestField.SetOnComitted((bool b) => //called on edit session save(true)/discard(false).
{
// Sets an action that will be called when this editoperation is committed.
Debug.WriteLine("Operation is committed");
});
updateTestField.Execute();
#endregion
}
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);
}
}
});
}
protected override async Task <bool> OnSketchCompleteAsync(Geometry geometry)
{
// get the embedded control
var vm = this.EmbeddableControl as ChooseTemplateViewModel;
if (vm == null)
{
return(false);
}
// ensure there's a template chosen
if (vm.SelectedTemplate == null)
{
vm.ShowMessage("Please choose a layer and template");
return(false);
}
// clear any message
vm.ClearMessage();
var template = vm.SelectedTemplate;
BasicFeatureLayer templateLayer = template.Layer as BasicFeatureLayer;
if (templateLayer == null)
{
return(false);
}
bool result = await QueuedTask.Run(() =>
{
// find the target feature from the geometry click
var targetFeatures = MapView.Active.GetFeatures(geometry);
if ((targetFeatures == null) || (targetFeatures.ToDictionary().Keys.Count == 0))
{
return(false);
}
// we will use the first feature returned
var targetLayer = targetFeatures.ToDictionary().Keys.First();
var targetOID = targetFeatures[targetLayer][0];
// At 2.4, EditOperation.TransferAttributes method is one of the few functions which honors the field mapping.
// The only method signature for EditOperation.TransferAttributes requires a source and target feature
// So our workflow will be
// 1. Create a temporary feature using the chosen template and empty geometry
// 2. Call TransferAttributes from the temporary feature to the target feature
// 3. Delete the temporary feature
// build an empty geometry according to the correct template layer type
Geometry emptyGeometry = null;
switch (templateLayer.ShapeType)
{
case esriGeometryType.esriGeometryPoint:
emptyGeometry = MapPointBuilderEx.CreateMapPoint();
break;
case esriGeometryType.esriGeometryPolyline:
emptyGeometry = PolylineBuilderEx.CreatePolyline();
break;
case esriGeometryType.esriGeometryPolygon:
emptyGeometry = PolygonBuilderEx.CreatePolygon();
break;
}
// some other geometry type
if (emptyGeometry == null)
{
return(false);
}
// create the temporary feature using the empty geometry
var op = new EditOperation();
op.Name = "Transfer attributes from template";
// note Create signature.. we are interested in the new ObjectID
var rowToken = op.Create(template, emptyGeometry);
// execute
var opResult = op.Execute();
// if create was successful
if (opResult)
{
var newObjectID = rowToken.ObjectID.Value;
// chain to create a new operation
var opChain = op.CreateChainedOperation();
// transfer the attributes between the temporary feature and the target feature
opChain.TransferAttributes(templateLayer, newObjectID, targetLayer, targetOID);
// and now delete the temporary feature
opChain.Delete(templateLayer, newObjectID);
opResult = opChain.Execute();
}
return(opResult);
});
return(result);
}
private async Task <Tuple <string, int> > ImportPlatAsync(CancelableProgressorSource cps)
{
var result = await QueuedTask.Run <Tuple <string, int> >(async() =>
{
// first we create a 'legal record' for the plat
Dictionary <string, object> RecordAttributes = new Dictionary <string, object>();
string sNewRecordName = $@"Plat {_selectedZone}-{_selectedSection}-{_selectedPlat}";
int importedCount = 0;
try
{
var editOper = new EditOperation()
{
Name = $@"Create Parcel Fabric Record: {sNewRecordName}",
ProgressMessage = "Create Parcel Fabric Record...",
ShowModalMessageAfterFailure = false,
SelectNewFeatures = false,
SelectModifiedFeatures = false
};
cps.Progressor.Value += 1;
if (cps.Progressor.CancellationToken.IsCancellationRequested)
{
editOper.Abort();
return(new Tuple <string, int> ("Cancelled", importedCount));
}
cps.Progressor.Status = (cps.Progressor.Value * 100 / cps.Progressor.Max) + @" % Completed";
cps.Progressor.Message = editOper.ProgressMessage;
RecordAttributes.Add(FieldNameName, sNewRecordName);
RecordAttributes.Add(FieldNameZone, _selectedZone);
RecordAttributes.Add(FieldNameSect, _selectedSection);
RecordAttributes.Add(FieldNamePlat, _selectedPlat);
var editRowToken = editOper.CreateEx(_recordLayer, RecordAttributes);
if (!editOper.Execute())
{
return(new Tuple <string, int>($@"Error [{editOper.Name}]: {editOper.ErrorMessage}", importedCount));
}
// now make the record the active record
var defOID = -1;
var lOid = editRowToken.ObjectID ?? defOID;
await _parcelFabricLayer.SetActiveRecordAsync(lOid);
}
catch (Exception ex)
{
return(new Tuple <string, int>($@"Error [Exception]: {ex.Message}", importedCount));
}
try
{
// Copy the selected set of polygons into the Tax Parcels
// However, since we need to set the polygon attributes manually we need to add each
// parcel one at a time
var qry = $@"{FieldNameZone} = {_selectedZone} and {FieldNameSect} = {_selectedSection} and {FieldNamePlat} = '{_selectedPlat}'";
var lstTmks = GetDistinctValues(_importParcelLineLayer, qry, FieldNameTmk);
lstTmks.Sort();
foreach (var selectedTmk in lstTmks)
{
importedCount++;
qry = $@"{FieldNameTmk} = {selectedTmk}";
var cnt = SelectSet(_importParcelLineLayer, qry);
cps.Progressor.Value += cnt;
if (cps.Progressor.CancellationToken.IsCancellationRequested)
{
return(new Tuple <string, int>("Cancelled", importedCount));
}
cps.Progressor.Status = (cps.Progressor.Value * 100 / cps.Progressor.Max) + @" % Completed";
cps.Progressor.Message = $@"Process parcel no: {selectedTmk}";
var editOper = new EditOperation()
{
Name = $@"Copy new parcel lines for: {sNewRecordName}",
ProgressMessage = "Create Parcel lines ...",
ShowModalMessageAfterFailure = false,
SelectNewFeatures = false,
SelectModifiedFeatures = false
};
var ids = new List <long>(_importParcelLineLayer.GetSelection().GetObjectIDs());
if (ids.Count == 0)
{
return(new Tuple <string, int>($@"Error [{editOper.Name}]: No selected lines were found. Please select line features and try again.", importedCount));
}
var parcelEditTkn = editOper.CopyLineFeaturesToParcelType(_importParcelLineLayer, ids, _taxLayerLines, _taxLayerPolys);
if (!editOper.Execute())
{
return(new Tuple <string, int>($@"Error [{editOper.Name}]: {editOper.ErrorMessage}", importedCount));
}
// Update the names for all new parcel features
var createdParcelFeatures = parcelEditTkn.CreatedFeatures;
var editOperUpdate = editOper.CreateChainedOperation();
// note: this only works for single parcels
Dictionary <string, object> ParcelAttributes = new Dictionary <string, object>();
// collect the attribute to be used for the polygon
// unfortunately the polygon attributes are not autopopulated so we have to do this here
foreach (KeyValuePair <MapMember, List <long> > kvp in createdParcelFeatures)
{
if (cps.Progressor.CancellationToken.IsCancellationRequested)
{
editOperUpdate.Abort();
return(new Tuple <string, int>("Cancelled", importedCount));
}
var mapMember = kvp.Key;
if (mapMember.Name.EndsWith("_Lines"))
{
var oids = kvp.Value;
foreach (long oid in oids)
{
var insp = new Inspector();
insp.Load(mapMember, oid);
var tmk = insp[FieldNameTmk];
if (tmk != null)
{
var sTmk = tmk.ToString();
if (sTmk.Length > 6)
{
var selectedIsland = sTmk.Substring(0, 1);
var selectedZone = sTmk.Substring(1, 1);
var selectedSection = sTmk.Substring(2, 1);
var selectedPlat = sTmk.Substring(3, 3);
ParcelAttributes.Add(FieldNameName, $@"{sTmk.Substring(0, 1)}-{sTmk.Substring(1, 1)}-{sTmk.Substring(2, 1)}-{sTmk.Substring(3, 3)}-{sTmk.Substring(6)}");
ParcelAttributes.Add(FieldNameTmk, tmk);
ParcelAttributes.Add(FieldNameIsland, selectedIsland);
ParcelAttributes.Add(FieldNameZone, selectedZone);
ParcelAttributes.Add(FieldNameSect, selectedSection);
ParcelAttributes.Add(FieldNamePlat, selectedPlat);
ParcelAttributes.Add(FieldNameParcel, insp[FieldNameParcel]);
ParcelAttributes.Add(FieldNameLink, insp[FieldNameLink]);
break;
}
}
}
}
if (ParcelAttributes.Count > 0)
{
break;
}
}
foreach (KeyValuePair <MapMember, List <long> > kvp in createdParcelFeatures)
{
if (cps.Progressor.CancellationToken.IsCancellationRequested)
{
editOperUpdate.Abort();
return(new Tuple <string, int>("Cancelled", importedCount));
}
var mapMember = kvp.Key;
if (!mapMember.Name.EndsWith("_Lines"))
{
var oids = kvp.Value;
foreach (long oid in oids)
{
editOperUpdate.Modify(mapMember, oid, ParcelAttributes);
}
}
}
if (!editOperUpdate.Execute())
{
return(new Tuple <string, int>($@"Error [{editOperUpdate.Name}]: {editOperUpdate.ErrorMessage}", importedCount));
}
}
}
catch (Exception ex)
{
return(new Tuple <string, int>($@"Error [Exception]: {ex.Message}", importedCount));
}
try
{
// Build all Parcels for the Active record in the parcel fabric (set in step one)
var theActiveRecord = _parcelFabricLayer.GetActiveRecord();
var guid = theActiveRecord.Guid;
var editOper = new EditOperation()
{
Name = "Build Parcels",
ProgressMessage = "Build Parcels...",
ShowModalMessageAfterFailure = true,
SelectNewFeatures = true,
SelectModifiedFeatures = true
};
cps.Progressor.Value += 1;
if (cps.Progressor.CancellationToken.IsCancellationRequested)
{
editOper.Abort();
return(new Tuple <string, int>("Cancelled", importedCount));
}
cps.Progressor.Status = (cps.Progressor.Value * 100 / cps.Progressor.Max) + @" % Completed";
cps.Progressor.Message = editOper.ProgressMessage;
editOper.BuildParcelsByRecord(_parcelFabricLayer, guid);
if (!editOper.Execute())
{
return(new Tuple <string, int>($@"Error [{editOper.Name}]: {editOper.ErrorMessage}", importedCount));
}
}
catch (Exception ex)
{
return(new Tuple <string, int>($@"Error [Exception]: {ex.Message}", importedCount));
}
return(new Tuple <string, int>(string.Empty, importedCount));
}, cps.Progressor);
return(result);
}
protected override /*async*/ Task <bool> OnSketchCompleteAsync(Geometry geometry)
{
Debug.WriteLine("OnSketchCompleteAsync, enter");
// Create an edit operation
var createOperation = new EditOperation();
createOperation.Name = string.Format("Create {0}", "points");
createOperation.SelectNewFeatures = true;
// Queue feature creation
//createOperation.Create(featureLayer, geometry);
var attributes = new Dictionary <string, object>();
attributes.Add("geom", geometry);
attributes.Add("user_id", DataHelper.userID);
//attributes.Add("attr01", "hi there");
//attributes.Add("attr02", 5);
long newFeatureID = -1;
createOperation.Create(featureLayer, attributes, (object_id) => newFeatureID = object_id); //TODO: how to get at other fields, like id?
// Execute the operation
//return createOperation.ExecuteAsync();
return(ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run(() =>
{
createOperation.Execute();
var attributeOperation = createOperation.CreateChainedOperation();
attributes = new Dictionary <string, object>();
attributes.Add("feature_id", newFeatureID);
attributes.Add("attr01", "Complete and Unabridged");
attributes.Add("attr02", 42);
ArcGIS.Core.Data.DatabaseConnectionProperties connectionProperties = new DatabaseConnectionProperties(EnterpriseDatabaseType.PostgreSQL)
{
AuthenticationMode = AuthenticationMode.DBMS,
Instance = @"127.0.0.1",
Database = "geomapmaker2",
User = "******",
Password = "******",
//Version = "dbo.DEFAULT"
};
using (Geodatabase geodatabase = new Geodatabase(connectionProperties))
//using (RelationshipClass relationshipClass = geodatabase.OpenDataset<RelationshipClass>("geomapmaker2.geomapmaker2.point_features_some_point_attributes"))
//using (FeatureClass featureClass = geodatabase.OpenDataset<FeatureClass>("geomapmaker2.geomapmaker2.point_features"))
using (Table attributeTable = geodatabase.OpenDataset <Table>("geomapmaker2.geomapmaker2.some_point_attributes"))
{
attributeOperation.Create(attributeTable, attributes);
return attributeOperation.ExecuteAsync();
/*
* QueryFilter queryFilter = new QueryFilter { WhereClause = "object_id = " + newFeatureID };
*
* using (RowCursor rowCursor = featureClass.Search(queryFilter, false))
* {
* while (rowCursor.MoveNext())
* {
* rowCursor.CurrentGetTable????
* }
*
* }
*/
}
}));
}