public async Task <bool> GDBContainsMilitaryOverlay(GDBProjectItem gdbProjectItem)
{
if (gdbProjectItem == null)
{
return(false);
}
string militaryOverlayFeatureDatasetName = "militaryoverlay";
bool gdbContainsMilitaryOverlay = await
ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run <bool>(() =>
{
using (Datastore datastore = gdbProjectItem.GetDatastore())
{
// Unsupported datastores (non File GDB and non Enterprise GDB) will be of type UnknownDatastore
if (datastore is UnknownDatastore)
{
return(false);
}
Geodatabase geodatabase = datastore as Geodatabase;
if (geodatabase == null)
{
return(false);
}
var defs = geodatabase.GetDefinitions <FeatureDatasetDefinition>().Where(fd => fd.GetName().Contains(militaryOverlayFeatureDatasetName)).ToList();;
return(defs.Count > 0);
}
});
return(gdbContainsMilitaryOverlay);
}
private Table GetTable(GDBProjectItem selectedProjectItem, TableInfo selectedTable)
{
Table table = null;
var datastore = selectedProjectItem.GetDatastore();
if (datastore is Geodatabase)
{
table = (datastore as Geodatabase).OpenDataset <Table>(selectedTable.Name);
}
if (datastore is Database)
{
var database = (datastore as Database);
var queryDescription = database.GetQueryDescription(selectedTable.Name);
table = database.OpenTable(queryDescription);
}
return(table);
}
private async Task UpdateTables(GDBProjectItem selectedLeftGDBProjectItem, ObservableCollection <TableInfo> observedTables)
{
var tables = new List <TableInfo>();
await QueuedTask.Run(() =>
{
var datastore = selectedLeftGDBProjectItem.GetDatastore();
if (datastore is Geodatabase)
{
var geodatabase = datastore as Geodatabase;
var featureClassDefinitions = geodatabase.GetDefinitions <FeatureClassDefinition>();
var tableDefinitions = geodatabase.GetDefinitions <TableDefinition>();
tables.AddRange(
featureClassDefinitions.Select(
definition => new TableInfo {
Definition = definition, Name = definition.GetName()
}));
tables.AddRange(
tableDefinitions.Select(definition => new TableInfo {
Definition = definition, Name = definition.GetName()
}));
}
if (datastore is Database)
{
var database = datastore as Database;
var tableNames = database.GetTableNames();
foreach (var tableName in tableNames)
{
var tableDefinition = database.GetDefinition(database.GetQueryDescription(tableName));
tables.Add(new TableInfo {
Definition = tableDefinition, Name = tableDefinition.GetName()
});
}
}
});
observedTables.Clear();
observedTables.AddRange(tables);
}
public async void ContentSnippets2()
{
#region Create new project using Pro's default settings
//Get Pro's default project settings.
var defaultProjectSettings = Project.GetDefaultProjectSettings();
//Create a new project using the default project settings
await Project.CreateAsync(defaultProjectSettings);
#endregion
#region New project using a custom template file
//Settings used to create a new project
CreateProjectSettings projectSettings = new CreateProjectSettings()
{
//Sets the project's name
Name = "New Project",
//Path where new project will be stored in
LocationPath = @"C:\Data\NewProject",
//Sets the project template that will be used to create the new project
TemplatePath = @"C:\Data\MyProject1\CustomTemplate.aptx"
};
//Create the new project
await Project.CreateAsync(projectSettings);
#endregion
#region Create project using template available with ArcGIS Pro
//Settings used to create a new project
CreateProjectSettings proTemplateSettings = new CreateProjectSettings()
{
//Sets the project's name
Name = "New Project",
//Path where new project will be stored in
LocationPath = @"C:\Data\NewProject",
//Select which Pro template you like to use
TemplateType = TemplateType.Catalog
//TemplateType = TemplateType.LocalScene
//TemplateType = TemplateType.GlobalScene
//TemplateType = TemplateType.Map
};
//Create the new project
await Project.CreateAsync(proTemplateSettings);
#endregion
#region Open project
//Opens an existing project or project package
await Project.OpenAsync(@"C:\Data\MyProject1\MyProject1.aprx");
#endregion
#region Current project
//Gets the current project
var project = Project.Current;
#endregion
#region Get location of current project
//Gets the location of the current project; that is, the path to the current project file (*.aprx)
string projectPath = Project.Current.URI;
#endregion
#region Get the project's default gdb path
var projGDBPath = Project.Current.DefaultGeodatabasePath;
#endregion
#region Save project
//Saves the project
await Project.Current.SaveAsync();
#endregion
#region SaveAs project
//Saves a copy of the current project file (*.aprx) to the specified location with the specified file name,
//then opens the new project file
await Project.Current.SaveAsAsync(@"C:\Data\MyProject1\MyNewProject1.aprx");
#endregion
#region Close project
//A project cannot be closed using the ArcGIS Pro API.
//A project is only closed when another project is opened, a new one is created, or the application is shutdown.
#endregion
#region Adds item to the current project
//Adding a folder connection
string folderPath = "@C:\\myDataFolder";
var folder = await QueuedTask.Run(() => {
//Create the folder connection project item
var item = ItemFactory.Instance.Create(folderPath) as IProjectItem;
//If it is succesfully added to the project, return it otherwise null
return(Project.Current.AddItem(item) ? item as FolderConnectionProjectItem : null);
});
//Adding a Geodatabase:
string gdbPath = "@C:\\myDataFolder\\myData.gdb";
var newlyAddedGDB = await QueuedTask.Run(() => {
//Create the File GDB project item
var item = ItemFactory.Instance.Create(gdbPath) as IProjectItem;
//If it is succesfully added to the project, return it otherwise null
return(Project.Current.AddItem(item) ? item as GDBProjectItem : null);
});
#endregion
#region How to add a new map to a project
await QueuedTask.Run(() =>
{
//Note: see also MapFactory in ArcGIS.Desktop.Mapping
var map = MapFactory.Instance.CreateMap("New Map", MapType.Map, MapViewingMode.Map, Basemap.Oceans);
ProApp.Panes.CreateMapPaneAsync(map);
});
#endregion
#region Check if project needs to be saved
//The project's dirty state indicates changes made to the project have not yet been saved.
bool isProjectDirty = Project.Current.IsDirty;
#endregion
#region Get all the project items
IEnumerable <Item> allProjectItems = Project.Current.GetItems <Item>();
foreach (var pi in allProjectItems)
{
//Do Something
}
#endregion
#region Gets all the "MapProjectItems"
IEnumerable <MapProjectItem> newMapItemsContainer = project.GetItems <MapProjectItem>();
await QueuedTask.Run(() =>
{
foreach (var mp in newMapItemsContainer)
{
//Do Something with the map. For Example:
Map myMap = mp.GetMap();
}
});
#endregion
#region Gets a specific "MapProjectItem"
MapProjectItem mapProjItem = Project.Current.GetItems <MapProjectItem>().FirstOrDefault(item => item.Name.Equals("EuropeMap"));
#endregion
#region Gets all the "StyleProjectItems"
IEnumerable <StyleProjectItem> newStyleItemsContainer = null;
newStyleItemsContainer = Project.Current.GetItems <StyleProjectItem>();
foreach (var styleItem in newStyleItemsContainer)
{
//Do Something with the style.
}
#endregion
#region Gets a specific "StyleProjectItem"
var container = Project.Current.GetItems <StyleProjectItem>();
StyleProjectItem testStyle = container.FirstOrDefault(style => (style.Name == "ArcGIS 3D"));
StyleItem cone = null;
if (testStyle != null)
{
cone = testStyle.LookupItem(StyleItemType.PointSymbol, "Cone_Volume_3");
}
#endregion
#region Gets all the "GDBProjectItems"
IEnumerable <GDBProjectItem> newGDBItemsContainer = null;
newGDBItemsContainer = Project.Current.GetItems <GDBProjectItem>();
foreach (var GDBItem in newGDBItemsContainer)
{
//Do Something with the GDB.
}
#endregion
#region Gets a specific "GDBProjectItem"
GDBProjectItem GDBProjItem = Project.Current.GetItems <GDBProjectItem>().FirstOrDefault(item => item.Name.Equals("myGDB"));
#endregion
#region Gets all the "ServerConnectionProjectItem"
IEnumerable <ServerConnectionProjectItem> newServerConnections = null;
newServerConnections = project.GetItems <ServerConnectionProjectItem>();
foreach (var serverItem in newServerConnections)
{
//Do Something with the server connection.
}
#endregion
#region Gets a specific "ServerConnectionProjectItem"
ServerConnectionProjectItem serverProjItem = Project.Current.GetItems <ServerConnectionProjectItem>().FirstOrDefault(item => item.Name.Equals("myServer"));
#endregion
#region Gets all folder connections in a project
//Gets all the folder connections in the current project
var projectFolders = Project.Current.GetItems <FolderConnectionProjectItem>();
foreach (var FolderItem in projectFolders)
{
//Do Something with the Folder connection.
}
#endregion
#region Gets a specific folder connection
//Gets a specific folder connection in the current project
FolderConnectionProjectItem myProjectFolder = Project.Current.GetItems <FolderConnectionProjectItem>().FirstOrDefault(folderPI => folderPI.Name.Equals("myDataFolder"));
#endregion
#region Remove a specific folder connection
// Remove a folder connection from a project; the folder stored on the local disk or the network is not deleted
FolderConnectionProjectItem folderToRemove = Project.Current.GetItems <FolderConnectionProjectItem>().FirstOrDefault(myfolder => myfolder.Name.Equals("PlantSpecies"));
if (folderToRemove != null)
{
Project.Current.RemoveItem(folderToRemove as IProjectItem);
}
#endregion
#region Gets a specific "LayoutProjectItem"
LayoutProjectItem layoutProjItem = Project.Current.GetItems <LayoutProjectItem>().FirstOrDefault(item => item.Name.Equals("myLayout"));
#endregion
#region Gets all layouts in a project:
//Gets all the layouts in the current project
var projectLayouts = Project.Current.GetItems <LayoutProjectItem>();
foreach (var layoutItem in projectLayouts)
{
//Do Something with the layout
}
#endregion
#region Gets a specific "GeoprocessingProjectItem"
GeoprocessingProjectItem GPProjItem = Project.Current.GetItems <GeoprocessingProjectItem>().FirstOrDefault(item => item.Name.Equals("myToolbox"));
#endregion
#region Gets all GeoprocessingProjectItems in a project:
//Gets all the GeoprocessingProjectItem in the current project
var GPItems = Project.Current.GetItems <GeoprocessingProjectItem>();
foreach (var tbx in GPItems)
{
//Do Something with the toolbox
}
#endregion
#region Search project for a specific item
List <Item> _mxd = new List <Item>();
//Gets all the folder connections in the current project
var allFoldersItem = Project.Current.GetItems <FolderConnectionProjectItem>();
if (allFoldersItem != null)
{
//iterate through all the FolderConnectionProjectItems found
foreach (var folderItem in allFoldersItem)
{
//Search for mxd files in that folder connection and add it to the List<T>
//Note:ArcGIS Pro automatically creates and dynamically updates a searchable index as you build and work with projects.
//Items are indexed when they are added to a project.
//The first time a folder or database is indexed, indexing may take a while if it contains a large number of items.
//While the index is being created, searches will not return any results.
_mxd.AddRange(folderItem.GetItems());
}
}
#endregion
#region Get the Default Project Folder
var defaultProjectPath = System.IO.Path.Combine(
System.Environment.GetFolderPath(
Environment.SpecialFolder.MyDocuments),
@"ArcGIS\Projects");
#endregion
}
// TODO: we may be able to deprecate this method (GDBContainsSchema) and use the method above (GDBContainsMilitaryOverlay)
public async Task <bool> GDBContainsSchema(GDBProjectItem gdbProjectItem,
ProSymbolUtilities.SupportedStandardsType standard)
{
bool isSchemaComplete = await
ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run <bool>(() =>
{
if (gdbProjectItem == null)
{
return(false);
}
using (Datastore datastore = gdbProjectItem.GetDatastore())
{
// Unsupported datastores (non File GDB and non Enterprise GDB) will be of type UnknownDatastore
if (datastore is UnknownDatastore)
{
return(false);
}
Geodatabase geodatabase = datastore as Geodatabase;
if (geodatabase == null)
{
return(false);
}
// Set up Fields to check
List <string> fieldsToCheck = new List <string>();
if (ProSymbolUtilities.IsLegacyStandard(standard))
{
fieldsToCheck.Add("extendedfunctioncode");
}
else
{ // 2525d / app6d
fieldsToCheck.Add("symbolset");
fieldsToCheck.Add("symbolentity");
}
// Reset schema data model exists to false for each feature class
Dictionary <string, bool> featureClassExists = GetFeatureClassExistsMap(standard, geodatabase);
IReadOnlyList <FeatureClassDefinition> featureClassDefinitions = geodatabase.GetDefinitions <FeatureClassDefinition>();
bool stopLooking = false;
foreach (FeatureClassDefinition featureClassDefinition in featureClassDefinitions)
{
// Stop looking after the first feature class not found
if (stopLooking)
{
return(false);
}
string featureClassName = featureClassDefinition.GetName();
if (featureClassExists.ContainsKey(featureClassName))
{
// Feature Class Exists. Check for fields
bool fieldsExist = true;
// Don't do this for remote databases (too slow)
if (geodatabase.GetGeodatabaseType() != GeodatabaseType.RemoteDatabase)
{
foreach (string fieldName in fieldsToCheck)
{
IEnumerable <Field> foundFields = featureClassDefinition.GetFields().Where(x => x.Name == fieldName);
if (foundFields.Count() < 1)
{
fieldsExist = false;
return(false);
}
}
}
featureClassExists[featureClassName] = fieldsExist;
}
else
{
// Key doesn't exist, so ignore
}
}
foreach (KeyValuePair <string, bool> pair in featureClassExists)
{
if (pair.Value == false)
{
return(false);
}
}
// If here, schema is complete
// Save geodatabase path to use as the selected database
_databaseName = gdbProjectItem.Path;
_schemaExists = true;
_standard = standard;
return(true);
}
});
return(isSchemaComplete);
}
