public void MainMethodCode()
{
Uri arcgisOnlineURL = new Uri("http://services1.arcgis.com/47GG2ga246DGaLwa/arcgis/rest/services/FeatureServiceName/FeatureServer");
ServiceConnectionProperties arcGISOnline = new ServiceConnectionProperties(arcgisOnlineURL);
using (Geodatabase featureService = new Geodatabase(arcGISOnline))
{
using (FeatureClass featureClass = featureService.OpenDataset <FeatureClass>("0"))
{
// Use the feature class opened from layer ID 0.
}
using (Table table = featureService.OpenDataset <Table>("4"))
{
// Use the table opened from layer ID 4.
}
using (AttributedRelationshipClass attributedRelationshipClass = featureService.OpenDataset <AttributedRelationshipClass>("5"))
{
// Use the attributed relationship class opened from layer ID 5.
}
try
{
string idOfLayerWhichIsNotTable = "3";
featureService.OpenDataset <Table>(idOfLayerWhichIsNotTable);
}
catch (InvalidOperationException)
{
// Handle Exception.
}
}
}
private T GetDatasetFromGeodatabase <T>(Geodatabase gdb, string dataset, string featureDataset) where T : Table
{
if (!string.IsNullOrEmpty(featureDataset))
{
var fd = gdb.OpenDataset <FeatureDataset>(featureDataset);
if (fd != null)
{
return(fd.OpenDataset <T>(dataset));
}
}
return(gdb.OpenDataset <T>(dataset));
}
public ProcessingDataset OpenDataset(ProcessDatasetName name)
{
if (name == null)
{
return(null);
}
var featureClass = _geodatabase.OpenDataset <FeatureClass>(name.DatasetName); // MCT
var featureLayer = FindLayer(_map, featureClass);
var layerProxy = featureLayer != null ? new LayerProxyAGP(featureLayer, _mapView) : null;
return(new ProcessingDataset(name, featureClass, layerProxy, layerProxy));
}
/// <summary>
/// Since the LocalGovernment Geodatabase does not have AttributedRelationshipClasses, the following method illustrates the behavior
/// if such a dataset existed.
/// </summary>
public void MainMethodCode()
{
// Opening a Non-Versioned SQL Server instance.
DatabaseConnectionProperties connectionProperties = new DatabaseConnectionProperties(EnterpriseDatabaseType.SQLServer)
{
AuthenticationMode = AuthenticationMode.DBMS,
// Where testMachine is the machine where the instance is running and testInstance is the name of the SqlServer instance.
Instance = @"testMachine\testInstance",
// Provided that a database called LocalGovernment has been created on the testInstance and geodatabase has been enabled on the database.
Database = "LocalGovernment",
// Provided that a login called gdb has been created and corresponding schema has been created with the required permissions.
User = "******",
Password = "******",
Version = "dbo.DEFAULT"
};
using (Geodatabase geodatabase = new Geodatabase(connectionProperties))
using (AttributedRelationshipClass attributedRelationshipClass = geodatabase.OpenDataset <AttributedRelationshipClass>("LocalGovernment.GDB.ParcelToBuilding"))
using (FeatureClass parcelFeatureClass = geodatabase.OpenDataset <FeatureClass>("LocalGovernment.GDB.Parcel"))
using (FeatureClass buildingFeatureClass = geodatabase.OpenDataset <FeatureClass>("LocalGovernment.GDB.Building"))
{
QueryFilter parcelQueryFilter = new QueryFilter {
WhereClause = "APN = 1234 OR APN = 5678"
};
QueryFilter buildingQueryFilter = new QueryFilter {
WhereClause = "BUILDID = 4321 OR BUILDID = 8765"
};
Selection parcelsSelection = parcelFeatureClass.Select(parcelQueryFilter, SelectionType.ObjectID, SelectionOption.Normal);
Selection buildingSelection = buildingFeatureClass.Select(buildingQueryFilter, SelectionType.ObjectID, SelectionOption.Normal);
IReadOnlyList <AttributedRelationship> relationshipsForOrigin = null;
IReadOnlyList <AttributedRelationship> relationshipsForDestination = null;
try
{
relationshipsForOrigin = attributedRelationshipClass.GetRelationshipsForOriginRows(parcelsSelection.GetObjectIDs());
relationshipsForDestination = attributedRelationshipClass.GetRelationshipsForDestinationRows(buildingSelection.GetObjectIDs());
}
finally
{
Dispose(relationshipsForOrigin);
Dispose(relationshipsForDestination);
}
}
}
private void GetFeaturesAndAddAttachment()
{
// open the geodatabase
using (var geodatabase = new Geodatabase(@"c:\ProSDKWorkshop\data\generic.gdb"))
{
// open the SamplePoints feature class
var pointFeatureClass = geodatabase.OpenDataset <FeatureClass>("SamplePoints");
// retrieve all features from the feature class
using (var rowCursor = pointFeatureClass.Search())
{
while (rowCursor.MoveNext())
{
// for each feature
using (var currentFeature = rowCursor.Current as Feature)
{
// add the sample picture as an attachment
currentFeature.AddAttachment(new Attachment("SamplePicture", "image/png",
CreateMemoryStreamFromContentsOf(@"c:\ProSDKWorkshop\data\redlands.png")));
}
}
}
}
// add the feature class as a layer to the active map
LayerFactory.CreateFeatureLayer(new Uri(@"c:\ProSDKWorkshop\data\generic.gdb\SamplePoints"), MapView.Active.Map);
}
public static async Task KeyPointsIntegration()
{
await QueuedTask.Run(() =>
{
using (Geodatabase gdb1 = new Geodatabase(new FileGeodatabaseConnectionPath(new Uri(GeoDataTool.DefaultProject.DefaultGeodatabasePath))))
{
gdb1.ApplyEdits(() =>
{
FeatureClass voyageRiskKeyPoint = gdb1.OpenDataset <FeatureClass>(ConstDefintion.ConstFeatureClass_VoyageRiskKeyPoint);
FeatureClassDefinition voyageRiskKeyPointDefinition = gdb1.GetDefinition <FeatureClassDefinition>(ConstDefintion.ConstFeatureClass_VoyageRiskKeyPoint);
voyageRiskKeyPoint.DeleteRows(new QueryFilter()
{
WhereClause = "OBJECTID >= 1"
});
string shapeFieldName = voyageRiskKeyPointDefinition.GetShapeField();
RiskAssessment(gdb1, voyageRiskKeyPoint, ConstDefintion.ConstFeatureClass_VoyageMaskInternalPoint, 1);
RiskAssessment(gdb1, voyageRiskKeyPoint, ConstDefintion.ConstFeatureClass_VoyageMaskOutlinePoint, 0);
double midLocaRisk = Math.Pow(0.5, 3.03);
RiskAssessment(gdb1, voyageRiskKeyPoint, ConstDefintion.ConstFeatureClass_VoyageMaskLocaMidPoint, midLocaRisk);
RiskAssessment(gdb1, voyageRiskKeyPoint, ConstDefintion.ConstFeatureClass_VoyageMaskRiskMidPoint, 0.5);
});
}
});
}
protected override IEnumerable <BasicFeatureLayer> GetLayers(Map map)
{
if (string.IsNullOrEmpty(_path))
{
yield break;
}
// todo daro: ensure layers are not already in map
using (Geodatabase geodatabase = new Geodatabase(new FileGeodatabaseConnectionPath(new Uri(_path, UriKind.Absolute))))
{
IEnumerable <string> featureClassNames =
geodatabase.GetDefinitions <FeatureClassDefinition>()
.Select(definition => definition.GetName())
.Where(name => _issueFeatureClassNames.Contains(name));
foreach (string featureClassName in featureClassNames)
{
using (var featureClass = geodatabase.OpenDataset <FeatureClass>(featureClassName))
{
FeatureLayer featureLayer = LayerFactory.Instance.CreateFeatureLayer(
featureClass, MapView.Active.Map, LayerPosition.AddToTop);
featureLayer.SetExpanded(false);
featureLayer.SetVisibility(false);
yield return(featureLayer);
}
}
}
}
public async void setDomainValuesFile(string db, string dataset, string fieldName, string sourceTarget, bool resetUI)
{
List <ComboData> domain = new List <ComboData>();
await ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run(() =>
{
ArcGIS.Core.Data.TableDefinition def = null;
try
{
string table = dataset.Substring(dataset.LastIndexOf("\\") + 1);
ArcGIS.Core.Data.Geodatabase geodatabase = new Geodatabase(new FileGeodatabaseConnectionPath(new Uri(db)));
using (ArcGIS.Core.Data.Table tab = geodatabase.OpenDataset <ArcGIS.Core.Data.Table>(table))
{
def = tab.GetDefinition();
domain = getDomainValuesforTable(def, fieldName);
}
}
catch { raiseDomainErrorMessage(dataset, fieldName); }
return;
});
if (resetUI == true)
{
resetDomainValuesUI(domain, sourceTarget);
}
else
{
resetDomainValuesUIFromConfig(domain, sourceTarget);
}
return;
}
private ObservableCollection <string> GetAllCourse()
{
var task = QueuedTask.Run(() =>
{
ObservableCollection <string> result = new ObservableCollection <string>();
using (Geodatabase geodatabase = new Geodatabase(new FileGeodatabaseConnectionPath(new Uri(GeoDataTool.DefaultProject.DefaultGeodatabasePath))))
{
using (FeatureClass course = geodatabase.OpenDataset <FeatureClass>(ConstDefintion.ConstFeatureClass_Course))
{
using (RowCursor rowCursor = course.Search(null, false))
{
while (rowCursor.MoveNext())
{
using (Row row = rowCursor.Current)
{
result.Add(row.GetObjectID().ToString());
}
}
}
}
}
return(result);
});
return(task.Result);
}
public void GetTopologyRules()
{
using (Geodatabase geodatabase = new Geodatabase(new FileGeodatabaseConnectionPath(new Uri(@"C:\TestData\GrandTeton.gdb"))))
using (Topology topology = geodatabase.OpenDataset <Topology>("Backcountry_Topology"))
{
#region GetTopologyRules
using (TopologyDefinition topologyDefinition = topology.GetDefinition())
{
IReadOnlyList <TopologyRule> rules = topologyDefinition.GetRules();
Console.WriteLine($"There are {rules.Count} topology rules defined for the topology:");
Console.WriteLine("ID \t Origin Class \t Origin Subtype \t Destination Class \t Destination Subtype \t Rule Type");
foreach (TopologyRule rule in rules)
{
Console.Write($"{rule.ID}");
Console.Write(!String.IsNullOrEmpty(rule.OriginClass) ? $"\t{rule.OriginClass}" : "\t\"\"");
Console.Write(rule.OriginSubtype != null ? $"\t{rule.OriginSubtype.GetName()}" : "\t\"\"");
Console.Write(!String.IsNullOrEmpty(rule.DestinationClass) ? $"\t{rule.DestinationClass}" : "\t\"\"");
Console.Write(rule.DestinationSubtype != null ? $"\t{rule.DestinationSubtype.GetName()}" : "\t\"\"");
Console.Write($"\t{rule.RuleType}");
Console.WriteLine();
}
}
#endregion GetTopologyRules
}
}
public static async Task <string[]> QueryAoiEnvelopeAsync(Uri clipFileGdbUri, string clipName)
{
string[] arrRetValues = new string[2];
Geometry aoiGeo = null;
int intCount = 0;
await QueuedTask.Run(() =>
{
using (Geodatabase geodatabase = new Geodatabase(new FileGeodatabaseConnectionPath(clipFileGdbUri)))
using (Table table = geodatabase.OpenDataset <Table>(clipName))
{
//check for multiple buffer polygons and buffer AOI if we need to
QueryFilter queryFilter = new QueryFilter();
using (RowCursor cursor = table.Search(queryFilter, false))
{
while (cursor.MoveNext())
{
using (Feature feature = (Feature)cursor.Current)
{
aoiGeo = feature.GetShape();
}
intCount++;
}
}
}
});
if (intCount > 1)
{
string tmpClipBuffer = "tmpClipBuffer";
BA_ReturnCode success = await GeoprocessingTools.BufferAsync(clipFileGdbUri.LocalPath + "\\" + clipName, clipFileGdbUri.LocalPath + "\\" + tmpClipBuffer,
"0.5 Meters", "ALL");
if (success == BA_ReturnCode.Success)
{
await QueuedTask.Run(() =>
{
using (Geodatabase geodatabase = new Geodatabase(new FileGeodatabaseConnectionPath(clipFileGdbUri)))
using (Table table = geodatabase.OpenDataset <Table>(tmpClipBuffer))
{
//check for multiple buffer polygons and buffer AOI if we need to
QueryFilter queryFilter = new QueryFilter();
using (RowCursor cursor = table.Search(queryFilter, false))
{
while (cursor.MoveNext())
{
using (Feature feature = (Feature)cursor.Current)
{
aoiGeo = feature.GetShape(); // Replace unbuffered geometry with buffered
clipName = tmpClipBuffer;
}
}
}
}
});
}
}
arrRetValues[0] = aoiGeo.Extent.XMin + " " + aoiGeo.Extent.YMin + " " + aoiGeo.Extent.XMax + " " + aoiGeo.Extent.YMax;
arrRetValues[1] = clipFileGdbUri.LocalPath + "\\" + clipName;
return(arrRetValues);
}
private void GetFeaturesAndAddAttachment()
{
// TODO
// open the file geodatabase c:\ProSDKWorkshop\data\generic.gdb
using (Geodatabase geodatabase = new Geodatabase(@"c:\ProSDKWorkshop\data\generic.gdb"))
{
using (FeatureClass pointFeatureClass = geodatabase.OpenDataset <FeatureClass>("SamplePoints"))
{
using (RowCursor features = pointFeatureClass.Search())
{
while (features.MoveNext())
{
Feature currentFeature = features.Current as Feature;
currentFeature.AddAttachment(new Attachment("SamplePicture", "image/png",
CreateMemoryStreamFromContentsOf(@"C:\ProSDKWorkshop\data\redlands.png")));
}
}
}
}
// TODO
// open the SamplePoints feature class
// TODO
// retrieve all features by searching the feature class
// TODO
// for each feature add the attachment
// TODO
// add the sample picture as an attachment
// add the feature class as a layer to the active map
LayerFactory.CreateFeatureLayer(new Uri(@"c:\ProSDKWorkshop\data\generic.gdb\SamplePoints"), MapView.Active.Map);
}
public static Dictionary <string, FeatureClass> GetMapLayersFeatureClassMap(Geodatabase geodatabase)
{
Dictionary <string, FeatureClass> lyrFeatureClassMap = new Dictionary <string, FeatureClass>();
Map map = MapView.Active.Map;
if (map == null)
{
return(null);
}
var layers = map.GetLayersAsFlattenedList().OfType <FeatureLayer>();
foreach (var lyr in layers)
{
string fc = lyr.GetFeatureClass().GetName();
FeatureClass featureClass = geodatabase.OpenDataset <FeatureClass>(fc);
if (featureClass != null)
{
lyrFeatureClassMap.Add(lyr.Name, featureClass);
}
}
return(lyrFeatureClassMap);
}
protected void OnRowCreated(RowChangedEventArgs args)
{
// RowEvent callbacks are always called on the QueuedTask so there is no need
// to wrap your code within a QueuedTask.Run lambda.
// update a separate table when a row is created
// You MUST use the ArcGIS.Core.Data API to edit the table. Do NOT
// use a new edit operation in the RowEvent callbacks
try
{
// update Notes table with information about the new feature
var geoDatabase = new Geodatabase(new FileGeodatabaseConnectionPath(new Uri(Project.Current.DefaultGeodatabasePath)));
var table = geoDatabase.OpenDataset <Table>("Notes");
var tableDefinition = table.GetDefinition();
using (var rowbuff = table.CreateRowBuffer())
{
// add a description
rowbuff["Description"] = "OID: " + args.Row.GetObjectID().ToString() + " " + DateTime.Now.ToShortTimeString();
table.CreateRow(rowbuff);
}
}
catch (Exception e)
{
MessageBox.Show($@"Error in OnRowCreated for OID: {args.Row.GetObjectID()} : {e.ToString()}");
}
}
public static async Task <bool> AttributeExistsAsync(Uri gdbUri, string featureClassName, string fieldName)
{
bool bExists = false;
await QueuedTask.Run(() =>
{
try
{
using (Geodatabase geodatabase = new Geodatabase(new FileGeodatabaseConnectionPath(gdbUri)))
{
using (Table table = geodatabase.OpenDataset <Table>(featureClassName))
{
TableDefinition definition = table.GetDefinition();
int idxField = definition.FindField(fieldName);
if (idxField > -1)
{
bExists = true;
}
}
}
}
catch (Exception e)
{
Module1.Current.ModuleLogManager.LogError(nameof(AttributeExistsAsync),
"Exception: " + e.Message);
}
});
return(bExists);
}
private Task addFeatureLayer()
{
Debug.WriteLine("addFeatureLayer enter");
return(ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run(() =>
{
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 (FeatureClass featureClass = geodatabase.OpenDataset <FeatureClass>("geomapmaker2.geomapmaker2.line_features"))
{
var layerParamsQueryDefn = new FeatureLayerCreationParams(featureClass)
{
IsVisible = true,
DefinitionFilter = new CIMDefinitionFilter()
{
Name = "User",
DefinitionExpression = "user_id = " + DataHelper.userID
}
};
featureLayer = LayerFactory.Instance.CreateLayer <FeatureLayer>(layerParamsQueryDefn, MapView.Active.Map);
}
}
}));
}
/// <summary>
/// Calculate viewpoints along a vector line, e.g. road, path.
/// </summary>
/// <param name="gdbPath">Path to GDB</param>
/// <param name="featureClassName">Feature class</param>
/// <returns>Viewpoints</returns>
private HashSet <SpatialUtils.ViewpointProps> GetLine(String gdbPath, String featureClassName)
{
HashSet <SpatialUtils.ViewpointProps> result = new HashSet <SpatialUtils.ViewpointProps>(); //using hash set to prevent duplicates, possible speed up with array
using (Geodatabase geodatabase = new Geodatabase(new FileGeodatabaseConnectionPath(new Uri(gdbPath))))
using (FeatureClass featureClass = geodatabase.OpenDataset <FeatureClass>(featureClassName)) {
QueryFilter queryFilter = new QueryFilter {
SubFields = "POINT_X, POINT_Y, ORIG_FID",
PostfixClause = "ORDER BY ORIG_FID"
};
using (RowCursor rowCursor = featureClass.Search(queryFilter, false)) {
double previousX = Double.NaN;
double previousY = Double.NaN;
int previousFid = Int32.MinValue;
while (rowCursor.MoveNext())
{
using (Row row = rowCursor.Current) {
double pointX = Convert.ToDouble(row["POINT_X"]);
double pointY = Convert.ToDouble(row["POINT_Y"]);
int fid = Convert.ToInt32(row["ORIG_FID"]);
if (fid == previousFid)
{
double length = Math.Sqrt(Math.Pow(pointX - previousX, 2) + Math.Pow(pointY - previousY, 2));
int steps = (int)Math.Floor(length / stepLength);
double xStep = (pointX - previousX) / steps;
double yStep = (pointY - previousY) / steps;
for (int i = 0; i <= steps; i++)
{
Tuple <int, int> point = inputRaster.MapToPixel(previousX + xStep * i, previousY + yStep * i);
result.Add(new SpatialUtils.ViewpointProps()
{
X = point.Item1,
Y = point.Item2
});
}
}
else if (previousFid != Int32.MinValue) //endpoint
{
Tuple <int, int> point = inputRaster.MapToPixel(previousX, previousY);
result.Add(new SpatialUtils.ViewpointProps()
{
X = point.Item1,
Y = point.Item2
});
}
previousX = pointX;
previousY = pointY;
previousFid = fid;
}
}
}
}
return(result);
}
private async Task openDatabase(JObject props)
{
await ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run(() =>
{
//Get Layers that are NOT Group layers and are unchecked
//var layers = MapView.Active.Map.Layers.ToList();
//MapView.Active.Map.RemoveLayers(layers);
// Opening a Non-Versioned SQL Server instance.
ArcGIS.Core.Data.DatabaseConnectionProperties connectionProperties = new DatabaseConnectionProperties(EnterpriseDatabaseType.PostgreSQL)
{
AuthenticationMode = AuthenticationMode.DBMS,
// Where testMachine is the machine where the instance is running and testInstance is the name of the SqlServer instance.
//Instance = @"127.0.0.1",
Instance = props["instance"].ToString(),
// Provided that a database called LocalGovernment has been created on the testInstance and geodatabase has been enabled on the database.
//Database = "geomapmaker",
Database = props["database"].ToString(),
// Provided that a login called gdb has been created and corresponding schema has been created with the required permissions.
//User = "******",
User = props["user"].ToString(),
//Password = "******",
Password = props["password"].ToString(),
//Version = "dbo.DEFAULT"
};
using (Geodatabase geodatabase = new Geodatabase(connectionProperties))
{
DataHelper.connectionString = geodatabase.GetConnectionString();
Debug.WriteLine("DataHelper.connectionString set to " + DataHelper.connectionString);
// Use the geodatabase
/*
* CIMSqlQueryDataConnection sqldc = new CIMSqlQueryDataConnection()
* {
* WorkspaceConnectionString = geodatabase.GetConnectionString(),
* GeometryType = esriGeometryType.esriGeometryPoint,
* OIDFields = "OBJECTID",
* Srid = "4326",
* //SqlQuery = "select * from geomapmaker2.features where id = " + DataHelper.userID + " and ST_GeometryType(geom)='ST_Point'",
* Dataset = "somepoints"
* };
* FeatureLayer flyr = (FeatureLayer)LayerFactory.Instance.CreateLayer(sqldc, MapView.Active.Map, layerName: DataHelper.userName + "'s points");
*/
//FeatureClass fC = geodatabase.OpenDataset<FeatureClass>("somepoints");
//FeatureLayer flyr = LayerFactory.Instance.CreateFeatureLayer(fC, MapView.Active.Map);
var featureClasses = geodatabase.GetDefinitions <FeatureClassDefinition>();
foreach (FeatureClassDefinition fCD in featureClasses)
{
FeatureClass fC = geodatabase.OpenDataset <FeatureClass>(fCD.GetName());
FeatureLayer flyr = LayerFactory.Instance.CreateFeatureLayer(fC, MapView.Active.Map);
}
}
});
}
public Table OpenTable(string name)
{
// todo daro exception handling
using (Geodatabase geodatabase = OpenGeodatabase())
{
return(geodatabase.OpenDataset <Table>(name));
}
}
public void Measure_performance_query_items_from_GDB()
{
Polygon polygon = PolygonConstruction
.StartPolygon(0, 0)
.LineTo(0, 20)
.LineTo(20, 20)
.LineTo(20, 0)
.ClosePolygon();
Polygon areaOfInterest = PolygonConstruction
.StartPolygon(0, 0)
.LineTo(0, 100)
.LineTo(100, 100)
.LineTo(100, 0)
.ClosePolygon();
var rowCount = 10000;
TestUtils.InsertRows(_emptyIssuesGdb, _featureClassName, polygon, rowCount);
try
{
var uri = new Uri(_emptyIssuesGdb, UriKind.Absolute);
var geodatabase = new Geodatabase(new FileGeodatabaseConnectionPath(uri));
var table = geodatabase.OpenDataset <Table>(_featureClassName);
Dictionary <Geodatabase, List <Table> > tablesByGeodatabase = new Dictionary <Geodatabase, List <Table> >
{
{ geodatabase, new List <Table> {
table
} }
};
IRepository stateRepository = new XmlWorkItemStateRepository(@"C:\temp\states.xml", null, null);
IWorkItemRepository repository = new IssueItemRepository(tablesByGeodatabase, stateRepository);
IWorkList workList = new GdbQueryWorkList(repository, "work list");
workList.AreaOfInterest = areaOfInterest;
var filter = GdbQueryUtils.CreateSpatialFilter(areaOfInterest);
var watch = new Stopwatch();
watch.Start();
IEnumerable <IWorkItem> items = workList.GetItems(filter);
watch.Stop();
Console.WriteLine($"{watch.ElapsedMilliseconds} ms");
Assert.AreEqual(rowCount, items.Count());
}
finally
{
TestUtils.DeleteAllRows(_emptyIssuesGdb, _featureClassName);
}
}
public Row GetRow([NotNull] Geodatabase geodatabase)
{
Assert.ArgumentNotNull(geodatabase, nameof(geodatabase));
using (var table = geodatabase.OpenDataset <Table>(Table.Name))
{
return(GdbQueryUtils.GetRow(table, ObjectId));
}
}
private async Task <ObservableCollection <GDBBaseItem> > GetGDBItemsAsync()
{
var gdbItems = await QueuedTask.Run <ObservableCollection <GDBBaseItem> >(() =>
{
List <GDBBaseItem> lstGDBBaseItems = new List <GDBBaseItem>();
//Database becomes the root node
var path = Name;
var root = new DatabaseGDBItem {
DBName = System.IO.Path.GetFileName(Name), Name = path, Path = path
};
lstGDBBaseItems.Add(root);
// use the geodatabase to get all layers
var fGdbPath = new FileGeodatabaseConnectionPath(new Uri(Name, UriKind.Absolute));
using (var gdb = new Geodatabase(fGdbPath))
{
IReadOnlyList <Definition> fcList = gdb.GetDefinitions <FeatureClassDefinition>();
//Feature class
foreach (FeatureClassDefinition fcDef in fcList)
{
var fc = gdb.OpenDataset <FeatureClass>(fcDef.GetName());
var fd = fc.GetFeatureDataset();
var fc_path = (fd == null) ? path : path + @"\" + fd.GetName();
fc.Dispose();
fd?.Dispose();
switch (fcDef.GetShapeType())
{
case GeometryType.Point:
var pointfcItem = new PointFCGDBItem {
Name = fcDef.GetName(), Path = fc_path
};
root.Children.Add(pointfcItem);
break;
case GeometryType.Polyline:
var linefcItem = new LineFCGDBItem {
Name = fcDef.GetName(), Path = fc_path
};
root.Children.Add(linefcItem);
break;
case GeometryType.Polygon:
var polyfcItem = new PolygonFCGDBItem {
Name = fcDef.GetName(), Path = fc_path
};
root.Children.Add(polyfcItem);
break;
}
}
}
root.IsExpanded = true;
return(new ObservableCollection <GDBBaseItem>(lstGDBBaseItems));
});
return(gdbItems);
}
public void SetUp()
{
// http://stackoverflow.com/questions/8245926/the-current-synchronizationcontext-may-not-be-used-as-a-taskscheduler
SynchronizationContext.SetSynchronizationContext(new SynchronizationContext());
_geodatabase = new Geodatabase(new FileGeodatabaseConnectionPath(new Uri(_emptyIssuesGdb, UriKind.Absolute)));
// todo daro: test IssueRows as well!
_issuePoints = _geodatabase.OpenDataset <FeatureClass>(_issuePointsFeatureClassName);
}
/// <summary>
/// Illustrates how to use the HasValueChanged() method.
/// </summary>
/// <returns></returns>
private static async Task FileGeodatabaseWorkFlow()
{
using (Geodatabase fileGeodatabase = new Geodatabase(new FileGeodatabaseConnectionPath(new Uri(@"C:\Data\LocalGovernment.gdb"))))
using (FeatureClass featureClass = fileGeodatabase.OpenDataset <FeatureClass>("PollingPlace"))
{
EditOperation editOperation = new EditOperation();
editOperation.Callback(context =>
{
QueryFilter queryFilter = new QueryFilter {
WhereClause = "FULLADD LIKE '///%Lily Cache Ln///%'"
};
using (RowCursor rowCursor = featureClass.Search(queryFilter, false))
{
FeatureClassDefinition featureClassDefinition = featureClass.GetDefinition();
int shapeFieldIndex = featureClassDefinition.FindField(featureClassDefinition.GetShapeField());
while (rowCursor.MoveNext())
{
using (Feature feature = (Feature)rowCursor.Current)
{
MapPoint mapPoint = feature.GetShape() as MapPoint;
// Will be false.
bool beforeChange = feature.HasValueChanged(shapeFieldIndex);
// In order to update the Map and/or the attribute table.
// Has to be called before any changes are made to the row
context.Invalidate(feature);
MapPoint newShape = new MapPointBuilder(mapPoint.X + 10, mapPoint.Y, mapPoint.SpatialReference).ToGeometry();
feature.SetShape(newShape);
// Will be true.
bool afterChange = feature.HasValueChanged(shapeFieldIndex);
feature.Store();
//Will be false.
bool afterStore = feature.HasValueChanged(shapeFieldIndex);
// Has to be called after the store too
context.Invalidate(feature);
}
}
}
}, featureClass);
bool editResult = editOperation.Execute();
//This is required to persist the changes to the disk.
bool saveResult = await Project.Current.SaveEditsAsync();
}
}
/// <summary>
/// Illustrates deleting rows from a table in an enterprise geodatabase.
/// </summary>
/// <returns></returns>
private static async Task EnterpriseGeodabaseWorkFlow()
{
// Opening a Non-Versioned SQL Server instance.
DatabaseConnectionProperties connectionProperties = new DatabaseConnectionProperties(EnterpriseDatabaseType.SQLServer)
{
AuthenticationMode = AuthenticationMode.DBMS,
// Where testMachine is the machine where the instance is running and testInstance is the name of the SqlServer instance.
Instance = @"testMachine\testInstance",
// Provided that a database called LocalGovernment has been created on the testInstance and geodatabase has been enabled on the database.
Database = "LocalGovernment",
// Provided that a login called gdb has been created and corresponding schema has been created with the required permissions.
User = "******",
Password = "******",
Version = "dbo.DEFAULT"
};
using (Geodatabase geodatabase = new Geodatabase((connectionProperties)))
{
using (Table enterpriseTable = geodatabase.OpenDataset <Table>("LocalGovernment.GDB.piCIPCost"))
{
EditOperation editOperation = new EditOperation();
editOperation.Callback(context =>
{
QueryFilter openCutFilter = new QueryFilter {
WhereClause = "ACTION = 'Open Cut'"
};
using (RowCursor rowCursor = enterpriseTable.Search(openCutFilter, false))
{
while (rowCursor.MoveNext())
{
using (Row row = rowCursor.Current)
{
// In order to update the Map and/or the attribute table. Has to be called before the delete
context.Invalidate(row);
row.Delete();
}
}
}
}, enterpriseTable);
bool editResult = editOperation.Execute();
// If the table is non-versioned this is a no-op. If it is versioned, we need the Save to be done for the edits to be persisted.
bool saveResult = await Project.Current.SaveEditsAsync();
}
}
}
public static void UpdateFeatureGeometry(string path, string featureClassName, Geometry newGeometry, int oid)
{
using (var geodatabase = new Geodatabase(new FileGeodatabaseConnectionPath(new Uri(path, UriKind.Absolute))))
{
using (var featureClass = geodatabase.OpenDataset <FeatureClass>(featureClassName))
{
var feature = (Feature)GdbQueryUtils.GetRow(featureClass, oid);
feature.SetShape(newGeometry);
feature.Store();
}
}
}
public static Row GetRow(string path, string tableName, long oid)
{
var uri = new Uri(path, UriKind.Absolute);
using (var geodatabase = new Geodatabase(new FileGeodatabaseConnectionPath(uri)))
{
using (var table = geodatabase.OpenDataset <Table>(tableName))
{
return(GdbQueryUtils.GetRow(table, oid));
}
}
}
public static void UpdateDescription(string path, string featureClassName, int oid)
{
using (var geodatabase = new Geodatabase(new FileGeodatabaseConnectionPath(new Uri(path, UriKind.Absolute))))
{
using (var table = geodatabase.OpenDataset <Table>(featureClassName))
{
var row = GdbQueryUtils.GetRow(table, oid);
row["Description"] = "Moe";
row.Store();
}
}
}
public static bool HasFeatureClass(this Geodatabase gdb, string name)
{
try
{
var table = gdb.OpenDataset <FeatureClass>(name);
return(true);
}
catch (GeodatabaseTableException)
{
}
return(false);
}
/// <summary>
/// Given that
/// 1. A layer has been selected
/// 2. A RelationshipClass has been selected
/// 3. The Table/FeatureClass related to the Table/FeatureClass corresponding to the layer selected has Attachments enabled
///
/// Then, this method will
/// 1. Get all the rows of the Related Table/FeatureClass
/// 2. Find if any row has Attachments which have the same name as the value of "OldAttachmentName"
/// 3. Replace the Attachment Data for the matching Attachments with the Data corresponding to "NewAttachment"
/// </summary>
public void Work()
{
QueuedTask.Run(async() =>
{
using (Table table = (MapView.Active.Map.Layers.First(layer => layer.Name.Equals(SelectedLayer)) as FeatureLayer).GetTable())
{
Geodatabase geodatabase = null;
if (table != null && table.GetDatastore() is Geodatabase)
{
geodatabase = table.GetDatastore() as Geodatabase;
}
if (geodatabase == null)
{
return;
}
Table relatedTable = geodatabase.OpenDataset <Table>(relatedFeatureClass);
if (!relatedTable.IsAttachmentEnabled())
{
return;
}
if (String.IsNullOrEmpty(OldAttachmentName))
{
return;
}
if (String.IsNullOrEmpty(NewAttachment) || !File.Exists(NewAttachment))
{
return;
}
using (MemoryStream newAttachmentMemoryStream = CreateMemoryStreamFromContentsOf(NewAttachment))
{
using (RowCursor rowCursor = relatedTable.Search(null, false))
{
while (rowCursor.MoveNext())
{
using (Row row = rowCursor.Current)
{
IEnumerable <Attachment> attachments = row.GetAttachments(null, true).Where(attachment => attachment.GetName().Equals(oldAttachmentName));
foreach (Attachment attachment in attachments)
{
attachment.SetData(newAttachmentMemoryStream);
row.UpdateAttachment(attachment);
}
}
}
}
}
}
});
}
public static Dictionary<string, FeatureClass> GetMapLayersFeatureClassMap(Geodatabase geodatabase)
{
Dictionary<string, FeatureClass> lyrFeatureClassMap = new Dictionary<string, FeatureClass>();
Map map = MapView.Active.Map;
if (map == null)
return null;
var layers = map.GetLayersAsFlattenedList().OfType<FeatureLayer>();
foreach (var lyr in layers)
{
string fc = lyr.GetFeatureClass().GetName();
FeatureClass featureClass = geodatabase.OpenDataset<FeatureClass>(fc);
if (featureClass != null)
lyrFeatureClassMap.Add(lyr.Name, featureClass);
}
return lyrFeatureClassMap;
}
private async void ReadRows() {
if (_executeQuery)
return;
if (_gdbPath.IsEmpty())
return;
if (SelectedTableName.IsEmpty())
return;
_executeQuery = true;
_columns.Clear();
_timer.Start();
OnPropertyChanged("IsExecutingQuery");
string tableName = SelectedTableName.Split(new char[] { '(', ')' }, StringSplitOptions.RemoveEmptyEntries)[1].Trim();
var data = new ObservableCollection<DynamicDataRow>();
try {
//Note, we have to return something
await TaskUtils.StartSTATask<int>(() => {
using (Geodatabase gdb = new Geodatabase(_gdbPath)) {
var table = gdb.OpenDataset<Table>(tableName);
RowCursor cursor = table.Search();
IReadOnlyList<Field> flds = cursor.GetFields();
foreach (var fld in flds) {
_columns.Add(new ColumnData() {
AliasName = fld.AliasName ?? fld.Name,
Name = fld.Name,
FieldType = fld.FieldType
});
}
while (cursor.MoveNext()) {
var row = new DynamicDataRow();
for (int v = 0; v < flds.Count; v++) {
row[GetName(flds[v])] = GetValue(cursor.Current, v);
}
data.Add(row);
}
}
return 0;
});
}
finally {
ExtendListView.Columns = _columns;
_timer.Stop();
lock(_theLock) {
_rows.Clear();
_rows = null;
_rows = data;
}
if (_rows.Count > 0) {
TableHasNoRows = "";
}
else {
TableHasNoRows = "No rows returned";
}
_executeQuery = false;
OnPropertyChanged("Rows");
OnPropertyChanged("IsExecutingQuery");
}
}
