def get_layer_names(map='Map'):
doc = ArcGISProject('current')
m = doc.listMaps(map)[0]
return [
layer.name for layer in map.listLayers()
if layer.visible and layer.isFeatureLayer
]
def clear_map_layers():
"""Removes layers from maps within the ArcGIS Pro project template.
Does not remove the layers if they are group layers or basemaps.
"""
aprx = ArcGISProject(config.aprx)
for map_ in aprx.listMaps():
del_layers = [x for x in map_.listLayers(
) if not x.isGroupLayer and not x.isBasemapLayer]
if del_layers:
for d in del_layers:
map_.removeLayer(d)
aprx.save()
def main(project_path='traffic-map.aprx',
service_name="Traveler_Info",
folder_name="Traveler_Info"):
"""Publishes a project map to a service
"""
project_path = abspath(project_path)
if not exists(project_path):
raise FileNotFoundError("File not found: %s" % project_path)
# Open the project
AddMessage("Opening %s" % project_path)
aprx = ArcGISProject(project_path)
# Get the first map
the_map = aprx.listMaps()[0]
the_layers = the_map.listLayers()
# Create the output path string by replacing the file extension.
draft_path = re.sub(r"\.aprx$", ".sddraft", project_path)
if exists(draft_path):
AddMessage("Deleting preexisting file: %s" % draft_path)
os.remove(draft_path)
AddMessage("Creating %s from %s..." % (project_path, draft_path))
# Create the web layer SDDraft file.
try:
# ArcGIS Pro < 2.0: Fails here with a RuntimeError that has no message
# if ArcGIS Pro is not open and signed in to ArcGIS Online.
CreateWebLayerSDDraft(the_layers,
draft_path,
service_name,
"MY_HOSTED_SERVICES",
"FEATURE_ACCESS",
folder_name=folder_name,
copy_data_to_server=True,
summary="Test service",
tags="test,traffic,traveler",
description="Test Service",
use_limitations="For testing only")
except RuntimeError as ex:
if ex.args:
AddError("Error creating %s. %s" % (draft_path, ex.args))
else:
AddError("Error creating %s. No further info provided." %
draft_path)
else:
sd_path = re.sub(r"draft$", "", draft_path)
if exists(sd_path):
AddMessage("Deleting preexisting file: %s" % sd_path)
os.remove(sd_path)
service_definition = arcpy.server.StageService(draft_path)
arcpy.server.UploadServiceDefinition(service_definition,
"My Hosted Services")
def save_layer_file(user: str, lyr_file_name: str):
"""Saves a layer file based on the user and version name.
Parameters
----------
user : str
The user whose map contains the specified layer file
lyr_file_name : str
The name of the layer file that needs to be saved
"""
aprx = ArcGISProject(config.aprx)
user_map = aprx.listMaps(user)[0]
lyr = user_map.listLayers(lyr_file_name)[0]
lyr.saveACopy(f".\\.esri\\{lyr_file_name}.lyrx")
class MapLayoutHelper(object):
"""
A helper object to initialize a project, layout, and a map for easy access.
Usage:
MapLayoutHelper('CURRENT')
Constructor:
project - (optional) The path to the ArcGIS Pro project or the text "CURRENT"
if you are using an open proejct. The default is 'CURRENT'.
layout - (optional) The name of the layout to initialize. The default
is 'Template'
map - (optional) The name of the map element inside the layout provided.
The default is 'Map'
"""
def __init__(self, project='CURRENT', layout='Template', map='Map'):
from arcpy.mp import ArcGISProject
self.project = ArcGISProject(project)
self.layout = self.project.listLayouts(layout)[0]
self.map = self.layout.listElements('MAPFRAME_ELEMENT', map)[0]
class MapLayoutHelper(object):
"""
A helper object to initialize a project, layout, and a map for easy access.
Usage:
MapLayoutHelper('CURRENT')
Constructor:
project - (optional) The path to the ArcGIS Pro project or the text "CURRENT"
if you are using an open proejct. The default is 'CURRENT'.
layout - (optional) The name of the layout to initialize. The default
is 'Template'
map - (optional) The name of the map element inside the layout provided.
The default is 'Map'
"""
def __init__(self, project='CURRENT', layout='Template', map='Map'):
from arcpy.mp import ArcGISProject
self.project = ArcGISProject(project)
self.layout = self.project.listLayouts(layout)[0]
self.map = self.layout.listElements('MAPFRAME_ELEMENT', map)[0]
def add_to_aprx(self):
"""Adds the input layer to a .aprx Map based on the owner of the
data. For example, the UTIL.wFitting feature would be added to the
"UTIL" map of the designated .aprx file. The file path to the Pro
project is set in the config file.
"""
log.debug("Adding the layer to its edit aprx...")
aprx = ArcGISProject(config.aprx)
user_map = aprx.listMaps(f"{self.owner}")[0]
user_map.addDataFromPath(self.aprx_connection)
for map_lyr in user_map.listLayers():
if self.feature_name in map_lyr.dataSource:
layer = map_lyr
break
aprx.save()
# Create group layer if it does not exist
lyr_realpath = os.path.realpath(config.lyr)
lyr_basename = os.path.basename(config.lyr)
if self.version_name not in [x.name for x in user_map.listLayers()]:
# Add to the map
user_map.addLayer(LayerFile(lyr_realpath))
aprx.save()
# Rename the group layer to match the version name
layer_name = lyr_basename.strip('.lyrx')
for lyr in user_map.listLayers():
if lyr.name == layer_name:
lyr.name = self.version_name
break
# Move the data layer into the group layer
group_layer = user_map.listLayers(self.version_name)[0]
user_map.addLayerToGroup(group_layer, layer)
user_map.removeLayer(layer)
aprx.save()
def publish(map_name,
server,
service_name=None,
folder=None,
schema_locks=False,
overwrite=False,
feature_access=False,
feature_capabilities='Map,Query,Data',
instance_count=1,
project='CURRENT',
server_type='STANDALONE_SERVER',
service_type='MAP_SERVICE'):
if not service_name:
service_name = map_name
# get the map
sddraft_filename = f'{service_name}.sddraft'
sddraft_output_filename = join(output, sddraft_filename)
if type(project) == str:
pro = ArcGISProject(project)
else:
pro = project
mp = pro.listMaps(map_name)
if not len(mp):
AddError(f'could not locate map {map_name} in project {project}')
return
mp = mp[0]
# create service draft and export to draft file
AddMessage('Creating service draft...')
service_draft = CreateSharingDraft(server_type, service_type, service_name,
mp)
service_draft.targetServer = server
# set folder if necessary
if folder:
service_draft.serverFolder = folder
service_draft.exportToSDDraft(sddraft_output_filename)
# xml schema modifications
# open the xml for potential modifications
doc = read_draft(sddraft_output_filename)
# set instance count
set_instance_count(doc, instance_count)
# enable feature service?
if feature_access:
enable_feature_access(doc, feature_capabilities)
if not schema_locks:
disable_locking(doc)
if overwrite:
enable_overwrite(doc)
# save the modified xml
write_draft(sddraft_output_filename, doc)
# stage service
AddMessage('Staging service...')
sd_filename = f"{service_name}.sd"
sd_output_filename = join(output, sd_filename)
StageService_server(sddraft_output_filename, sd_output_filename)
# share to server
AddMessage('Uploading to server...')
UploadServiceDefinition_server(sd_output_filename, server)
AddMessage(f'Successfully published service {service_name} to {server}')
def get_layer_names(map="Map"):
doc = ArcGISProject("current")
m = doc.listMaps(map)[0]
return [layer.name for layer in map.listLayers() if layer.visible and layer.isFeatureLayer]
def updateNonHostedServices(prj_path, map_list, sd_draft_path, conn_file,
server_folder):
# set ArcGIS Project
aprx = ArcGISProject(prj_path)
# set up for reporting
successList = []
failList = []
# loop through maps in the list
for map_name in map_list:
m = aprx.listMaps(map_name)[0]
out_sddraft = join(sd_draft_path, map_name + ".sddraft")
# remove sd draft if it exists already
if exists(out_sddraft):
Delete_management(out_sddraft)
# Create MapServiceDraft and set service properties
service_draft = CreateSharingDraft("STANDALONE_SERVER", "MAP_SERVICE",
map_name, m)
service_draft.targetServer = conn_file
service_draft.serverFolder = server_folder
service_draft.overwriteExistingService = True # toggle based on publishing/republishing
try:
# Create Service Definition Draft file
service_draft.exportToSDDraft(out_sddraft)
# Stage Service
sd_filename = map_name + ".sd"
sd_output_filename = join(sd_draft_path, sd_filename)
# remove staged service if it exists
if exists(sd_output_filename):
Delete_management(sd_output_filename)
# stage the serve
StageService(out_sddraft, sd_output_filename)
# Share to ArcGIS Server
print("Uploading %s Service Definition..." % map_name)
UploadServiceDefinition(sd_output_filename, conn_file, map_name,
'', "FROM_SERVICE_DEFINITION",
server_folder, "STARTED", "USE_DEFINITION",
"NO_SHARE_ONLINE", "PRIVATE",
"NO_SHARE_ORGANIZATION", None)
successList.append(map_name)
print("Successfully Uploaded service %s." % map_name)
except Exception as e:
# if there was an error, add what service failed and the error to the fail list
failList.append(map_name + ": " + str(e))
print("Failed publishing %s." % map_name)
return [successList, failList]
def __init__(self, project='CURRENT', layout='Template', map='Map'):
from arcpy.mp import ArcGISProject
self.project = ArcGISProject(project)
self.layout = self.project.listLayouts(layout)[0]
self.map = self.layout.listElements('MAPFRAME_ELEMENT', map)[0]
def __init__(self, project='CURRENT', layout='Template', map='Map'):
from arcpy.mp import ArcGISProject
self.project = ArcGISProject(project)
self.layout = self.project.listLayouts(layout)[0]
self.map = self.layout.listElements('MAPFRAME_ELEMENT', map)[0]
