Code

Dieses Skript ist nützlich für die Prüfung von Metadaten. Das Skript kann über mehrere enterprise Geodatabases hinweg ausgeführt werden und erstellt eine Ausgabe-CSV-Datei mit den folgenden Spalten: „Geodatabase“, „Feature Dataset“, „Feature Class“, „Spatial Reference“, „Zeilenanzahl“, „Spaltenanzahl“, „Metadatentitel“, „Metadatenbeschreibung“, „Metadatenzusammenfassung“, „Metadatennachweise“, „Metadatenzugriff“. Einschränkungen‘.

Um dieses Skript zu verwenden, müssen Sie Zeile 19 ändern, um auf Ihre SDE-Verbindungsdateien zu verweisen.

import csv
import os

from arcpy import Describe
from arcpy import env
from arcpy import GetCount_management
from arcpy import ListDatasets
from arcpy import ListFeatureClasses
from arcpy import ListFields
from arcpy import metadata as md

# the output CSV file name
output_csv_file = 'enterprise_gdbs_results.csv'

# or use this to make the output CSV file name the same as the script name
# output_csv_file = os.path.basename(__file__).replace('.py','.csv')

# change this path to use your SDE connection files
sde_connection_files = 'c:/gis/sde_connection_files'

with open(output_csv_file,'w',newline='') as csv_file:
    csv_writer = csv.writer(csv_file, delimiter=',')
    column_headers = [
        'Geodatabase', 'Feature Dataset', 'Feature Class', 
        'Spatial Reference', 'Row Count', 'Column Count', 
        'Metadata Title', 'Metadata Description', 'Metadata Summary',
        'Metadata Credits', 'Metadata Access Constraints'
    ]
    
    csv_writer.writerow(column_headers)

    for (folder, dirs, files) in os.walk(sde_connection_files):
        for file in files:
            if(not file.startswith('_') and file.endswith('.sde')):
                geodatabase = file.split('@')[1]

                wksp = os.path.join(folder,file)
                env.workspace = wksp

                datasets = ListDatasets(feature_type='feature')
                datasets = [''] + datasets if datasets is not None else []

                for dataset in datasets:
                    for feature_class in ListFeatureClasses(dataset):
                        desc = Describe(feature_class)
                        spatial_reference = desc.SpatialReference.factoryCode
                        count = GetCount_management(feature_class)[0]
                        column_count = len(ListFields(feature_class))
                        metadata = md.Metadata(feature_class)

                        row = [
                            geodatabase,dataset,feature_class,
                            spatial_reference,count,column_count,
                            metadata.title,metadata.description,
                            metadata.summary,metadata.credits,
                            metadata.accessConstraints    
                        ]

                        print(row)
                        
                        csv_writer.writerow(row)

Dieses Skript ist nützlich für die Prüfung von Metadaten. Das Skript kann über mehrere Datei-Geodatabases ausgeführt werden und erstellt eine Ausgabe-CSV-Datei mit den folgenden Spalten: „Zuletzt geändert“, „Datei-Geodatabase“, „Feature-Datensatz“, „Feature-Klasse“, „Raumbezug“, „Zeilenanzahl“, „Spaltenanzahl“, „Metadatentitel“, „Metadatenbeschreibung“, „Metadatenzusammenfassung“, „Metadatennachweise“, „Metadaten-Zugriffsbeschränkungen“.

import csv
import os
import time

from arcpy import Describe
from arcpy import env
from arcpy import GetCount_management
from arcpy import ListDatasets
from arcpy import ListFeatureClasses
from arcpy import ListFields
from arcpy import metadata as md

folder = r'...'
log = open('log.txt', 'w')
output_csv_file = os.path.basename(__file__).replace('.py','.csv')

with open(output_csv_file,'w',newline='') as csv_file:
    csv_writer = csv.writer(csv_file, delimiter=',')
    column_headers = [
        'Last Modified','File Geodatabase', 'Feature Dataset', 'Feature Class', 
        'Spatial Reference', 'Row Count', 'Column Count', 
        'Metadata Title', 'Metadata Description', 'Metadata Summary',
        'Metadata Credits', 'Metadata Access Constraints'
    ]
    
    csv_writer.writerow(column_headers)

    for (folder, dirs, files) in os.walk(folder):
        if(folder.endswith('.gdb')):
            print(folder)

            last_modified = '???'

            try:
                last_modified = time.ctime(max(os.stat(root).st_mtime for root,_,_ in os.walk(folder)))
            except:
                msg = 'Error getting last modified date for {}'.format(folder)
                print(msg)
                log.write('{}\n'.format(msg))
                pass

            fgdb = folder
            env.workspace = fgdb

            datasets = []

            try:
                datasets = ListDatasets(feature_type='feature')
                datasets = [''] + datasets if datasets is not None else []
            except:
                msg = 'Error getting datasets for {}'.format(folder)
                print(msg)
                log.write('{}\n'.format(msg))
                pass

            for dataset in datasets:
                for feature_class in ListFeatureClasses(dataset):
                    desc = Describe(feature_class)
                    spatial_reference = desc.SpatialReference.factoryCode
                    count = GetCount_management(feature_class)[0]
                    column_count = len(ListFields(feature_class))
                
                    metadata = None
                    row = []

                    try:
                        metadata = md.Metadata(feature_class)
                        row = [
                            last_modified,
                            fgdb,dataset,feature_class,
                            spatial_reference,count,column_count,
                            metadata.title,metadata.description,
                            metadata.summary,metadata.credits,
                            metadata.accessConstraints    
                        ]
                    except:
                        row = [
                            last_modified,
                            fgdb,dataset,feature_class,
                            spatial_reference,count,column_count,
                            'error','error','error','error','error'    
                        ]
                        pass

                    csv_writer.writerow(row)

log.close()

Wenn Daten aus Shapefiles in Feature-Classes konvertiert werden oder wenn beim Ausführen von Geoverarbeitungswerkzeugen nicht sorgfältig vorgegangen wurde, können Feature-Classes manchmal über redundante Felder verfügen. Beispielsweise könnte eine Feature-Class ein Feld namens „OBJECTID“ haben und es könnte ein anderes Feld namens „OBJECTID_1“ in derselben Feature-Class geben. Eines dieser Felder sollte das OID-Feld für die Feature-Class sein. Manchmal ist jedoch auch nicht klar, welches OBJECTID-Feld das richtige ist. Das folgende Skript muss nicht wissen, welches Feld das OID-Feld ist, da Zeile 35 fehlschlägt, wenn das Feld nicht gelöscht werden kann, und das Skript weiter ausgeführt wird. Das folgende Skript zeigt zwei verschiedene Möglichkeiten, den Feldnamen zu überprüfen, d. h. der Feldname kann in Zeile 10 in die Liste aufgenommen werden oder dem Feldnamen kann in Zeile 33 „OBJECTID“ vorangestellt werden. Bei diesem Skript werden die gelöschten Felder in eine CSV-Datei ausgegeben. Der Name der Ausgabe-CSV-Datei ist derselbe wie das Python-Skript – siehe Zeile 12. Bevor Sie das Skript ausführen, empfiehlt es sich, Zeile 35 auszukommentieren, das Skript auszuführen und die Ausgabe-CSV-Datei zu überprüfen, um zu sehen, welche Felder gelöscht werden. Außerdem kann das einmal gelöschte Feld nicht wiederhergestellt werden. Daher sollten im Zweifelsfall zunächst die File-Geodatabases gesichert werden.

import csv
import os

from arcpy import env
from arcpy import ListDatasets
from arcpy import ListFeatureClasses
from arcpy import ListFields
from arcpy.management import DeleteField

fields_to_delete = ['objectid', 'objectid_1', 'objectid_12', 'shape_le_1', 'shape_leng', 'shape_length', 'shape__length', 'shape__area']
input_folder = r'...'
output_csv_file = os.path.basename(__file__).replace('.py','.csv')

with open(output_csv_file, 'w', newline='') as csv_file:
    csv_writer = csv.writer(csv_file)
    csv_writer.writerow(['File Geodatabase','Feature Dataset', 'Feature Class', 'Field'])

    for (folder, dirs, files) in os.walk(input_folder):
        if(folder.endswith('.gdb')):
            file_geodatabase = folder
            print('Processing {}'.format(file_geodatabase))

            env.workspace = file_geodatabase

            feature_datasets = ListDatasets(feature_type='feature')
            feature_datasets = [''] + feature_datasets if feature_datasets is not None else []

            for feature_dataset in feature_datasets:
                feature_classes = ListFeatureClasses(feature_dataset=feature_dataset)

                for feature_class in feature_classes:
                    for field in ListFields(feature_class):
                        if field.name.lower() in fields_to_delete or field.name.lower().startswith('objectid'):
                            try:
                                DeleteField(feature_class, field.name)
                                csv_writer.writerow([file_geodatabase, feature_dataset, feature_class, field.name])
                            
                            except:
                                pass

Vor der Veröffentlichung von Kartendiensten oder Feature-Services empfiehlt es sich, zunächst die Feature-Class-Ausdehnungen neu zu berechnen. Dies liegt daran, dass die Feature-Class-Ausdehnung gelegentlich falsch sein kann. Es gibt verschiedene Ursachen, die dazu führen können, dass die Feature-Class-Ausdehnung falsch ist, einschließlich der Ausführung von Geoverarbeitungsaufgaben für die Daten, die die Ausdehnung der Daten ändern. Außerdem kann die Feature-Class-Ausdehnung beim Importieren von Daten falsch sein, da die anfängliche Feature-Class-Ausdehnung möglicherweise auf der Grundlage einer Teilmenge der importierten Daten berechnet wurde. Der erste einfache Weg, um zu erkennen, dass die Ausdehnung der Feature-Class falsch ist, besteht darin, dass beim Klicken auf die Schaltfläche „Auf Ebene zoomen“ die Karte nicht auf die richtige Ausdehnung gezoomt wird. Ein weiteres Zeichen dafür, dass die Ebenenausdehnung falsch ist, ist, dass die Ebene nicht korrekt gerendert wird. Wenn Sie beispielsweise eine große GeoJSON-Datei importieren, wird diese in ArcGIS Pro möglicherweise erst dann korrekt gerendert, wenn die Ausdehnung für diese Feature-Class neu berechnet wurde.

import os

from arcpy import env
from arcpy import ListDatasets
from arcpy import ListFeatureClasses
from arcpy.management import RecalculateFeatureClassExtent

input_folder = r'...'

for (folder, dirs, files) in os.walk(input_folder):
    if(folder.endswith('.gdb')):
        env.workspace = folder

        feature_datasets = ListDatasets(feature_type='feature')
        feature_datasets = [''] + feature_datasets if feature_datasets is not None else []

        for feature_dataset in feature_datasets:
            feature_classes = ListFeatureClasses(feature_dataset=feature_dataset)

            for feature_class in feature_classes:
                print('{}\t{}\t{}'.format(folder, feature_dataset, feature_class))
                RecalculateFeatureClassExtent(feature_class)

Dieses Skript dient zum Auflisten aller Shapefiles in einem Verzeichnis, um zu verstehen, wie viele Shapefiles Sie haben, damit diese in Feature-Classes in File-Geodatabases oder Enterprise-Geodatabases migriert werden können. Beachten Sie, dass Shapefiles aus mehreren Gründen generell vermieden werden sollten. Das Shapefile-Format ist ein sehr altes Format und es gibt viel bessere Formate für den Austausch räumlicher Daten. Shapefiles haben eine schlechte Komprimierung und wenn Daten in Shapefiles exportiert werden, werden die Feldnamen auf zehn Zeichen gekürzt, was es schwierig machen kann, den ursprünglichen Feldnamen zu erraten. Verwenden Sie Geodatabase-Feature-Classes, Geopackages, GeoJSON oder andere Formate, bevor Sie die Verwendung von Shapefiles in Betracht ziehen.

import csv
import os

# change the input folder here for the directory you want to search
input_folder = r'\\...\...'

# change the file name here to the output file you want
results_file = 'shapefiles.csv'

extns = ['.aih', '.ain', '.atx', '.cpg', '.dbf', '.fbn', '.fbx', '.ixs', '.mxs', '.prj', '.sbn', '.sbx', '.shp', '.shx', '.xml']

with open(results_file, 'w', newline='') as csvfile:
    csvwriter = csv.writer(csvfile)
    column_headers = ['Folder','Shapefile'] + extns
    csvwriter.writerow(column_headers)

    for (folder, dirs, files) in os.walk(input_folder):
        for file in files:
            if(file.endswith('.shp')):
                shapefile_name = file.replace('.shp','')

                line = [folder,shapefile_name]

                for extn in extns:
                    file_path = os.path.join(folder,'{}{}'.format(shapefile_name,extn))
                    file_exists = 'Y' if os.path.exists(file_path) else 'N'
                    line.append(file_exists)
                
                csvwriter.writerow(line)

Dieses Skript listet die Layer-Informationen für MXDs (ArcMap-Dateien) und APRXs (ArcGIS Pro-Dateien) auf. Die Ergebnisse werden in eine CSV-Datei ausgegeben und enthalten diese Spalten:

Beachten Sie, dass ArcMap Python 2 und verwendet ArcGIS Pro verwendet Python 3. Damit das Skript mit Python 3 für MXD-Dateien funktioniert, konvertieren wir im folgenden Skript die MXD in eine APRX. Dieser APRX befindet sich nur im Speicher und wird nicht auf der Festplatte gespeichert (kann aber bei Bedarf auf der Festplatte gespeichert werden).

Um dies unten auszuführen, ändern Sie die Zeilen 5 und 7 und erstellen Sie manuell einen leeren APRX, der in den Speicher geklont werden kann (Zeile 7).

import csv
import os

from arcpy.mp import ArcGISProject

directory = r'\\...\...'
blank_aprx = r'\\...\...\temp.aprx'
results_file = os.path.basename(__file__).replace('.py','.csv')

# create a CSV file
with open(results_file, 'w', newline='') as csvfile:
    csvwriter = csv.writer(csvfile)

    # write out the column headers in the CSV file
    csvwriter.writerow(['File Path','Folder','File Name','File Type','Map / Data Frame','Layer Name','Layer Source','Is Broken','Definition Query'])

    # loop through all of the folders and files in the input directory
    for folder, dirs, files in os.walk(directory):
        for file in files:
            file_path = os.path.join(folder,file)
            
            # check if it is an MXD file - we need to convert the MXD to APRX (in-memory) because we cannot use Python 3 with MXDs
            if file.endswith('.mxd'):     
                file_type = 'mxd'
                aprx = ArcGISProject(blank_aprx)
                aprx.importDocument(file_path)

            #  check if it is an APRX file
            elif file.endswith('.aprx'):
                file_type = 'aprx'
                aprx = ArcGISProject(file_path)
            
            else:
                # file is not an MXD or APRX, so skip the loop below
                continue

            # list all layers within the 'maps' (for APRXs), or 'data frames' (for MXDs)
            for map in aprx.listMaps():
                for layer in map.listLayers():
                    # if the layer is not a group layer and has a data source
                    if layer.supports('dataSource'):
                        # check if the layer is broken
                        isBroken = layer.isBroken if layer.supports('isBroken') else 'n/a'
                        # check if the layer has a definition query (the WHERE clause in a normal SQL statement - definition queries use SQL)
                        definitionQuery = layer.definitionQuery if layer.supports('definitionQuery') else 'n/a'
                        line = [file_path, folder, file, file_type, map.name, layer.name, layer.dataSource, isBroken, definitionQuery]

                        # write the results to CSV
                        csvwriter.writerow(line)

            # delete the in-memory aprx
            del aprx

print('Results file: {}'.format(results_file))

Dieses Skript listet die Serviceinformationen für alle Services auf und gibt die Ergebnisse als CSV aus. Die Spaltenüberschriften in der CSV sind unten aufgeführt:

Bevor Sie das Skript ausführen, ändern Sie die Parameter von Zeile 22 bis 31.

import csv
import json
import requests

def getToken(url, params):
    response = requests.post(url, params)
    token = json.loads(response.text)['token']
    return token

def fetchUrl(url):
    params = {
        'f': 'json',
        'token': token
    }

    response = requests.post(url, params)
    data = json.loads(response.text)

    return data

web_adaptor = 'arcgis' # web adaptor or load balancer 
token_url = 'https://{}/portal/sharing/rest/generateToken'.format(map_server)

params = {
    'f': 'json',
    'referer': 'https://.../portal/sharing/rest/generateToken',
    'username': 'portaladmin',
    'password': '**************'
}

token = getToken(token_url, params)

''' 
    ArcGIS Admin URL - we are using the admin URL, not the 
    Services Directory URL because the Services Directory will 
    only list the services that are started/running.  We also
    want to know about the stopped services.
'''
admin_url = 'https://{}/{}/admin/services'.format(map_server,web_adaptor)

params = {
    'f': 'json',
    'token': token
}

response = requests.get(admin_url, params)
data = json.loads(response.text)

folders = data['folders']
foldersToExclude = ['System','Utilities']

for folder in foldersToExclude:
    folders.remove(folder)

services = data['services'] 

with open('map_service_info.csv', 'w', newline='') as csv_file:
    csv_writer = csv.writer(csv_file)

    column_names = ['Map Server', 'Folder', 'Service name', 'Service type', 'URL', 'Published By', 'Path', 'Service Description', 'Copyright Info']
    csv_writer.writerow(column_names)

    for service in services:
        folder = ''
        service_name = service['serviceName']
        service_type = service['type']
        url = '{}/{}.{}'.format(admin_url,service_name,service_type)
       
        service_info = fetchUrl(url)
        service_description = service_info['description']
        user_name = service_info['properties']['userName'] if 'userName' in service_info['properties'] else ''
        copyright_info = service_info['properties']['copyright'] if 'copyright' in service_info['properties'] else ''
        path = service_info['properties']['path'] if 'path' in service_info['properties'] else ''

        row = [map_server, folder, service_name, service_type, url, user_name, path, service_description, copyright_info]
        csv_writer.writerow(row)

    for folder in folders:
        url = '{}/{}'.format(admin_url,folder)
        folder_info = fetchUrl(url)

        for service in folder_info['services']:
            folder = folder_info['folderName']
            service_name = service['serviceName']
            service_type = service['type']
            url = '{}/{}/{}.{}'.format(admin_url, folder, service_name, service_type, url)

            service_info = fetchUrl(url)
            service_description = service_info['description']
            user_name = service_info['properties']['userName'] if 'userName' in service_info['properties'] else ''
            copyright_info = service_info['properties']['copyright'] if 'copyright' in service_info['properties'] else ''
            path = service_info['properties']['path'] if 'path' in service_info['properties'] else ''

            row = [map_server, folder, service_name, service_type, url, user_name, path, service_description, copyright_info]
            csv_writer.writerow(row)