def getParametersAsText(indexesForCatalogPath=[]):
""" Get a list of all arcpy parameters as text.
**Description:**
Uses `arcpy.GetParameterAsText`_ to assemble a list of strings representing parameters from the script that is
being executed. ie. the input parameters for an ArcGIS toolbox dialog box, an ArcGIS modelbuilder model, or
another python script, etc.
The optional *indexesForCatalogPath* argument allows you to indicate which indexes must have
the full catalog path retrieved. For example, if the layer name is the text returned for the parameter, you can
request the full path of the dataset for that parameter by adding its index to a list passed to this function.
This seems to be most critical for input parameters - the code produces an error for output parameters, so
don't include them in the list of integer indexes
**Arguments:**
* *indexesForCatalogPath* - Iterable with integer indexes of parameters to get a catalog path for.
**Returns:**
* list of strings
"""
textParameters = []
total = arcpy.GetArgumentCount()
for count in range(0, total):
try:
if count in indexesForCatalogPath:
# if hasattr(arcpy.GetParameter(count), "value"):
# arcpy.AddMessage("Parameter {0} has value attibute".format(count))
# else:
# arcpy.AddMessage("Parameter {0} has NO value attibute".format(count))
# check if input parameter is a lyr file with arcpy.Exists
if arcpy.Exists(arcpy.GetParameter(count)):
parameterAsText = arcpy.Describe(
arcpy.GetParameter(count)).catalogPath.strip("'")
else:
parameterAsText = arcpy.Describe(
arcpy.GetParameter(
count).dataSource).catalogPath.strip("'")
else:
parameterAsText = arcpy.GetParameterAsText(count).strip("'")
textParameters.append(parameterAsText)
except:
# We're going to make an assumption that something went wrong with getting parameters, and to preserve
# the argument index, add an ESRI null "#".
textParameters.append("#")
return textParameters
def main():
try:
# Get the input parameters to this tool
if arcpy.GetArgumentCount() != 3:
raise Exception("Incorrect number of arguments")
outputJxlFile = arcpy.GetParameterAsText(0)
mxdDir = arcpy.GetParameterAsText(1)
tawDir = arcpy.GetParameterAsText(2)
# Get any necessary licenses before importing the toolbox
checkOutLicenses("", ["JTX"])
# Import the Workflow Manager toolbox
wmxToolbox = getWorkflowManagerToolboxLocation()
arcpy.ImportToolbox(wmxToolbox, "WMXAdminUtils")
# Identify all of the MXD files
#
# TODO: Move this code into an "Upload All Map Documents" script?
fileList = os.listdir(mxdDir)
mxdFiles = []
for f in fileList:
(unused, ext) = os.path.splitext(f)
if ext.lower() == ".mxd":
mxdFiles.append(mxdDir + os.sep + f)
# Upload all of the MXDs to the DB
mxdCategory = "#"
mxdDescription = "#"
overwriteMxds = "OVERWRITE"
for mxd in mxdFiles:
temp = os.path.basename(mxd)
(targetName, unused) = os.path.splitext(temp)
arcpy.UploadMapDocument_WMXAdminUtils(mxd, targetName, mxdCategory,
mxdDescription,
overwriteMxds)
logPreviousToolMessages()
# Upload all of the Task Assistant workbooks to the DB
arcpy.UploadAllTaskAssistantWorkbooks_WMXAdminUtils(tawDir, "true")
logPreviousToolMessages()
# Back up the database to the specified JXL file
prettyPrint = "PRETTY_PRINT"
arcpy.BackupWorkflowManagerDatabase_WMXAdminUtils(
outputJxlFile, prettyPrint)
logPreviousToolMessages()
except Exception, ex:
printUsage()
arcpy.AddError("Caught exception: " + str(ex))
def main():
try:
arcpy.env.overwriteOutput = True
# Get the input parameters to this tool
if arcpy.GetArgumentCount() != 1:
raise Exception("Incorrect number of arguments")
excelWorksheetName = os.path.abspath(arcpy.GetParameterAsText(0))
# Get any necessary licenses before importing the toolbox
checkOutLicenses("", ["JTX"])
# Import the Workflow Manager toolbox
wmxDevUtilsToolbox = getWorkflowManagerToolboxLocation()
arcpy.ImportToolbox(wmxDevUtilsToolbox, "WMXAdminUtils")
# Save the existing workspaces to a file
arcpy.ExportDataWorkspacesToExcel_WMXAdminUtils(excelWorksheetName)
logPreviousToolMessages()
# List the current workspaces
result = arcpy.ListAllDataWorkspaces_WMXAdminUtils()
logPreviousToolMessages()
# Delete all of the workspaces from the DB
allWorkspaces = result.getOutput(0)
if len(allWorkspaces) > 0:
allWorkspaces = allWorkspaces.split(";")
for workspace in allWorkspaces:
workspace = workspace.strip("'")
workspace = workspace.strip("\"")
arcpy.DeleteDataWorkspace_WMXAdminUtils(workspace)
logPreviousToolMessages()
# List the workspaces again
result = arcpy.ListAllDataWorkspaces_WMXAdminUtils()
logPreviousToolMessages()
allWorkspaces = result.getOutput(0)
if len(allWorkspaces) > 0:
arcpy.AddError("Failed to delete all workspaces")
# Recreate the workspaces from the spreadsheet that was just saved
arcpy.CreateDataWorkspacesFromExcel_WMXAdminUtils(excelWorksheetName, "IGNORE_ALL_ERRORS")
logPreviousToolMessages()
except Exception, ex:
printUsage()
arcpy.AddError("Caught exception: " + str(ex))
def main(args):
""" If all checks passed this methode is called
"""
try:
_idf = IdentifyFeatures((args["e"], args["n"]), args["dist"])
_parz_info = "[]"
_count = 0
while len(json.loads(_parz_info)) == 0:
_parz_info = _idf.getparzinfo(float(args["dist"] + _count * 1.0))
_count += 1
arcpy.SetParameter(arcpy.GetArgumentCount() - 2, _parz_info)
arcpy.AddMessage("{0} parcell(s) found".format(
len(json.loads(_parz_info))))
return True
except Exception as _err:
arcpy.AddError(_err)
return False
def main():
try:
# Get the input parameters to this tool
if arcpy.GetArgumentCount() != 3:
raise Exception("Incorrect number of arguments")
dataWorkspaceName = arcpy.GetParameterAsText(0)
dataWorkspaceSde = arcpy.GetParameterAsText(1)
emailNotificationName = arcpy.GetParameterAsText(2)
# Get any necessary licenses before importing the toolbox
checkOutLicenses("", ["JTX"])
# Import the Workflow Manager toolbox
wmxToolbox = getWorkflowManagerToolboxLocation()
arcpy.ImportToolbox(wmxToolbox, "WMXAdminUtils")
arcpy.env.overwriteOutput = True
# Create the spatial notification
snName = "Monitor all FCs (Sample 1)"
snDesc = "This spatial notification will monitor all of the feature classes in the specified workspace for any changes"
summarize = "SUMMARIZE"
arcpy.CreateSpatialNotificationWithEmailNotifier_WMXAdminUtils(
snName, emailNotificationName, snDesc, summarize)
logPreviousToolMessages()
# Get the feature class list from the database
arcpy.env.workspace = dataWorkspaceSde
fcList = arcpy.ListFeatureClasses()
# Add a dataset condition for each feature class
changeCond = "ALWAYS"
for fc in fcList:
arcpy.AddDatasetConditionToSN_WMXAdminUtils(
snName, dataWorkspaceName, fc, changeCond, "#", "#", "#", "#")
logPreviousToolMessages()
except Exception, ex:
printUsage()
arcpy.AddError("Caught exception: " + str(ex))
#-------------------------------------------------------------------------------
# Name: module1
# Purpose:
#
# Author: calebma
#
# Created: 24/05/2016
# Copyright: (c) calebma 2016
# Licence: <your licence>
#-------------------------------------------------------------------------------
import arcpy
import sys
sys.path.append(r'\\arcserver1\GIS\MPWD\_Basemap\ESRI\Scripts\Toolbox')
from mpwd_lib import permits
if __name__ == '__main__':
# get arguments
args = [arcpy.GetParameter(i) for i in range(arcpy.GetArgumentCount() - 2)]
# run it
url, out_fs = permits.chicken_permits(*args)
arcpy.AddMessage(url)
# Map document file - usually passed via File Iterator, pass as parameter 0
file = arcpy.GetParameterAsText(0)
# Layers to hide - pass as string in parameter 1, delimit with pipe (|)
hideLayers = arcpy.GetParameterAsText(1).split("|")
# Layers to show - pass as string in parameter 2, delimit with pipe (|)
showLayers = arcpy.GetParameterAsText(2).split("|")
# Save the output in a different filename (same folder) - pass as string in parameter 3;
# if not set, will overwrite the original file
saveAs = re.sub(r'[\\/:"*?<>|]+', "", arcpy.GetParameterAsText(3))
# Add text replacement parameters
i = 3
replaceText = []
replaceTextWith = []
while x < arcpy.GetArgumentCount():
replaceText.append(arcpy.GetParameterAsText(x))
x += 1
replaceTextWidth.append(arcpy.GetParameterAsText(x))
x += 1
# Open map document
mxd = arcpy.mapping.MapDocument(file)
# Remove items in showLayers from hideLayers
for item in showLayers:
while hideLayers.count(item) > 0:
hideLayers.remove(item)
# Loop through all dataframes
for df in arcpy.mapping.ListDataFrames(mxd):
print "Started at %s..." % starttime
# Ensure the Aeronautical extension is available. Exit if it is not.
availability = arcpy.CheckExtension("Aeronautical")
if availability != "Available":
sys.exit('"Aeronautical" extension unavailable: %s' % availability)
try:
arcpy.CheckOutExtension("Aeronautical")
workspace = "FAA_Airports.gdb"
runwayCenterlinesFC = 'RunwayCenterlinesForSurfacesWithZ_NewElevations'
surfaceFC = 'ObstructionIdSurface'
approachTypesTable = "ApproachTypeCode"
# Use parameters from command line if provided.
paramCount = arcpy.GetArgumentCount()
if paramCount > 1:
workspace = arcpy.GetParameterAsText(0)
if paramCount > 2:
runwayCenterlines = arcpy.GetParameterAsText(1)
if paramCount > 3:
surfaceFC = arcpy.GetParameterAsText(2)
if paramCount > 4:
approachTypesTable = arcpy.GetParameterAsText(3)
del paramCount
# Make sure the workspace exists.
if not arcpy.Exists(workspace):
# "Error in accessing the workspace"
arcpy.AddIDMessage("ERROR", 198)
def main():
try:
# Get the input parameters to this tool
if arcpy.GetArgumentCount() != 0:
raise Exception("Incorrect number of arguments")
polygonFC = ".\\SampleData.gdb\\Quadrants"
# Get any necessary licenses before importing the toolbox
checkOutLicenses("", ["JTX"])
# Import the Workflow Manager toolbox
wmxToolbox = getWorkflowManagerToolboxLocation()
arcpy.ImportToolbox(wmxToolbox, "WMXAdminUtils")
arcpy.env.overwriteOutput = True
# Make a feature layer from the polygon FC passed in;
# features will be selected from this layer
polygonLayer = "PolygonLayer"
arcpy.MakeFeatureLayer_management(polygonFC, polygonLayer)
# Iterate through all of the features in this feature class
rows = arcpy.SearchCursor(polygonFC)
counter = 1
for row in rows:
# The OBJECTID field will be unique for all features,
# so retrieve its value for each feature and create a new
# selection based on this value.
objectID = row.OBJECTID
arcpy.SelectLayerByAttribute_management(
polygonLayer, "NEW_SELECTION", "OBJECTID = " + str(objectID))
# Create a new spatial notifier
snName = "Monitor Region " + str(counter) + " (Sample 3)"
notifSubject = "A match was found in region " + str(counter)
notifMessage = "----------\n"\
"Job: [SN:CHANGE_JOB_ID]\n"\
"Feature [SN:CHANGE_FEATURE_ID] was modified at [SN:CHANGE_TIME]"
notifSubscribers = buildSubscriberString(objectID)
snDesc = "This spatial notification will monitor all of the features in the region bounded by the polygon with OBJECTID " + str(
objectID)
summarize = "SUMMARIZE"
arcpy.CreateSpatialNotificationWithEmailNotifier2_WMXAdminUtils(
snName, notifSubject, notifMessage, notifSubscribers, "#", "#",
snDesc, summarize)
logPreviousToolMessages()
# Add an area condition for this spatial notifier
#
# NOTE: To see the full list of options available for each argument,
# launch the GP tool from ArcMap or ArcCatalog. The arguments
# correspond to options provided by Workflow Manager.
geomOp = "INTERSECTS"
doNotUseInverse = "USE_OPERATION"
useFeature = "USE_SELECTED_FEATURE"
arcpy.AddAreaEvaluatorToSN_WMXAdminUtils(snName, geomOp,
doNotUseInverse,
useFeature, polygonLayer)
logPreviousToolMessages()
# Increment the counter and move on to the next feature
counter += 1
# Free up any cursor objects and layers
if row != None:
del row
if rows != None:
del rows
arcpy.Delete_management(polygonLayer)
except Exception, ex:
printUsage()
arcpy.AddError("Caught exception: " + str(ex))
__author__ = "spowell"
import arcpy
try:
data_set = arcpy.GetParameterAsText(0)
is_compress_db = False
if arcpy.GetArgumentCount() > 1:
is_compress_db = arcpy.GetParameterAsText(1)
work_space = arcpy.env["scriptWorkspace"]
assert work_space
data_set_desc = arcpy.Describe(data_set)
if not data_set_desc.isVersioned:
arcpy.AddMessage(f"Disallowing new connections.")
arcpy.AcceptConnections(work_space, False)
arcpy.AddMessage(f"Disconnecting all Users.")
arcpy.DisconnectUser(work_space, "ALL")
arcpy.AddMessage(f"Registering {data_set} as Versioned.")
arcpy.RegisterAsVersioned_management(data_set, "EDITS_TO_BASE")
if is_compress_db:
arcpy.AddMessage(
f"Compressing geodatabase, this could take some time.")
arcpy.Compress_management(work_space)
arcpy.AddMessage(f"Accepting User Connections.")
arcpy.AcceptConnections(work_space, True)
else:
arcpy.AddMessage(
f"Nothing to version, {data_set} is already registered as versioned."
)
except Exception as e:
except arcpy.ExecuteError:
line, filename, synerror = trace()
log.error("error on line: %s" % line)
log.error("error in file name: %s" % __file__)
log.error("with error message: %s" % synerror)
log.error("ArcPy Error Message: %s" % arcpy.GetMessages(2))
except FunctionError as f_e:
messages = f_e.args[0]
arcpy.AddError(messages)
log.error("error in function: %s" % messages["function"])
log.error("error on line: %s" % messages["line"])
log.error("error in file name: %s" % __file__)
log.error("with error message: %s" % messages["synerror"])
log.error("ArcPy Error Message: %s" % messages["arc"])
except:
line, filename, synerror = trace()
log.error("error on line: %s" % line)
log.error("error in file name: %s" % __file__)
log.error("with error message: %s" % synerror)
finally:
logging.shutdown()
#--------------------------------------------------------------------------
if __name__ == "__main__":
env.overwriteOutput = True
argv = tuple(
arcpy.GetParameterAsText(i) for i in range(arcpy.GetArgumentCount()))
main(*argv)
import arcpy
# Get the spatial reference from the tool dialog.
txt_param = arcpy.GetParameterAsText(1)
spatial_ref = arcpy.GetParameter(0)
option_param = arcpy.GetParameterAsText(2)
# Display ArgumentCount
arcpy.AddMessage("ArgumentCount is: {0}".format(arcpy.GetArgumentCount()))
# Display txt_param
arcpy.AddMessage("txt_param is: {0}".format(txt_param))
# Display the Spatial Reference properties
arcpy.AddMessage("Name is: {0}".format(spatial_ref.name))
arcpy.AddMessage("Type is: {0}".format(spatial_ref.type))
arcpy.AddMessage("Factory code is: {0}".format(spatial_ref.factoryCode))
# FUNCTIONS ========================================
def Geo2Arithmetic(inAngle):
inAngle = math.fmod(inAngle, 360.0)
#0 to 90
if (inAngle >= 0.0 or inAngle <= 90.0):
outAngle = math.fabs(inAngle - 90.0)
# 90 to 360
if (inAngle >= 90.0 or inAngle < 360.0):
outAngle = 360.0 - (inAngle - 90.0)
return float(outAngle)
# ARGUMENTS & LOCALS ===============================
argCount = arcpy.GetArgumentCount()
inFeature = arcpy.GetParameterAsText(0)
range = float(arcpy.GetParameterAsText(1)) #1000.0 # meters
bearing = float(arcpy.GetParameterAsText(2)) #45.0 # degrees
traversal = float(arcpy.GetParameterAsText(3)) #60.0 # degrees
outFeature = arcpy.GetParameterAsText(4)
webMercator = ""
if argCount >= 6:
webMercator = arcpy.GetParameterAsText(5)
deleteme = []
debug = False
leftAngle = 0.0 # degrees
rightAngle = 90.0 # degrees
def main():
try:
# Error checking and argument fetching
if arcpy.GetArgumentCount() < 1:
raise InvalidArgumentError("Required argument missing")
# Set up the tool's parameters
paramIndex = 0
jobsTable = arcpy.GetParameterAsText(paramIndex)
paramIndex += 1
sqlQuery = arcpy.GetParameterAsText(paramIndex)
paramIndex += 1
wmxDbAlias = arcpy.GetParameterAsText(paramIndex)
paramIndex += 1
# Import the Workflow Manager toolbox
wmxToolbox = getWorkflowManagerToolboxLocation()
arcpy.ImportToolbox(wmxToolbox, "WMXAdminUtils")
# Get the list of jobs matching the query
result = arcpy.ListJobs_WMXAdminUtils(jobsTable, sqlQuery, wmxDbAlias)
logPreviousToolMessages()
numOutputs = result.outputCount
if numOutputs <= 0:
return
# Output is a semicolon-delimited list of job IDs, so split up the
# list, as required.
jobListString = result.getOutput(0)
if jobListString == None or len(jobListString) <= 0:
arcpy.AddMessage("No jobs matched query")
return
jobsToDelete = jobListString.split(";")
arcpy.AddMessage("Jobs to delete: " + str(jobListString))
# Set up the progress bar
arcpy.SetProgressor("step", "Deleting jobs...", 0, len(jobsToDelete), 1)
# Delete each job
jobCount = 0
jobsDeleted = []
for job in jobsToDelete:
arcpy.SetProgressorLabel("Deleting job " + str(job))
arcpy.DeleteJob_WMXAdminUtils(job, wmxDbAlias)
logPreviousToolMessages()
jobCount += 1
jobsDeleted.append(job)
arcpy.SetProgressorPosition(jobCount)
# Set the return value for this tool (a multivalue containing the list of IDs
# for the jobs that were deleted)
jobsDeletedStr = ""
for jobId in jobsDeleted:
jobsDeletedStr += jobId + ";"
jobsDeletedStr = jobsDeletedStr.rstrip(";")
arcpy.SetParameterAsText(paramIndex, jobsDeletedStr)
arcpy.AddMessage("Deleted jobs: " + jobsDeletedStr)
except Exception, ex:
arcpy.AddError("Caught exception: " + str(ex))
GPMsg()
pass
# return pivot point
try:
pivot_point = "{0} {1}".format(*pivot_point)
except:
pivot_point = None
return pivot_point
if __name__ == '__main__':
"""ArcGIS script tool interface
Arguments:
Input_features
Output_features
Rotation_angle
Rotation_point ("CENTER","LOWER_LEFT",...,"XY")
Pivot point (ignored unless Rotation_point is "XY")
Pivot point value (derived)
"""
# last argument is derived
numArgs = arcpy.GetArgumentCount() - 1
argv = tuple([arcpy.GetParameterAsText(i) for i in range(numArgs)])
xy = RotateFeatureClass(*argv)
# populate derived parameter (pivot point)
arcpy.SetParameterAsText(5, xy)
import arcpy
nparms = arcpy.GetArgumentCount()
arcpy.AddMessage("You have specifed " + str(nparms) + " parameters")
arcpy.AddMessage(arcpy.GetParameterAsText(0))
#inputs
inputFeats = arcpy.GetParameterAsText(0)
bufd = arcpy.GetParameterAsText(1)
#outputs
outFeats = arcpy.GetParameterAsText(2) #r"C:\temp\growthM\tempOut.shp"
#Code to do our Process Here:
arcpy.Buffer_analysis(inputFeats, outFeats, bufd)
#arcpy.SetParameterAsText(2, outFeats)
arcpy.AddMessage("Completed")
""" Entrypoint for the application.
- logs some basic infos
initialises the parameters and checks the input parameter sys.argv
Args:
Returns:
exitcode 0: no error
exitcode -1: could not init parameter
exitcode -2. could not get ParzInfo
Raises:
"""
_version = 0.5
arcpy.SetParameter(arcpy.GetArgumentCount() - 1, _version)
_exitcode, _args = init(sys.argv)
if _exitcode == 0:
try:
if main(_args):
arcpy.AddMessage("Parzinfo executed successfully")
else:
arcpy.AddError("could not get ParzInfo")
_exitcode = -2
except Exception as _err:
arcpy.AddError(_err)
else:
arcpy.AddError("could not init parameter")
_exitcode = -1
try:
arcpy.AddMessage("Creating Database Connection File...")
# Process: Create Database Connection File...
# Usage: out_file_location, out_file_name, DBMS_TYPE, instnace, account_authentication, username, password, database, save_username_password(must be true)
arcpy.CreateDatabaseConnection_management(out_folder_path=out_folder_path, out_name=Connection_File_Name, database_platform=database_type, instance=instance, database=database, account_authentication=account_authentication, username=dbuser_name, password=dbuser_pwd, save_user_pass="******")
for i in range(arcpy.GetMessageCount()):
if "000565" in arcpy.GetMessage(i): #Check if database connection was successful
arcpy.AddReturnMessage(i)
arcpy.AddMessage("++++++++++++++++++")
arcpy.AddMessage("Exiting!!")
arcpy.AddMessage("++++++++++++++++++")
sys.exit(3)
else:
arcpy.AddReturnMessage(i)
arcpy.AddMessage("++++++++++++++++++")
except:
for i in range(arcpy.GetMessageCount()):
arcpy.AddReturnMessage(i)
'''-------------------------------------------------------------------------------
# START script
-------------------------------------------------------------------------------'''
# This test allows the script to be used from the operating
# system command prompt (stand-alone), in a Python IDE,
# as a geoprocessing script tool, or as a module imported in
# another script
if __name__ == '__main__':
# Arguments are optional
argv = tuple(arcpy.GetParameterAsText(i)
for i in range(arcpy.GetArgumentCount()))
main(*argv)
def main():
try:
# Get the input parameters to this tool
if arcpy.GetArgumentCount() != 3:
raise Exception("Incorrect number of arguments")
adUsersGroup = arcpy.GetParameterAsText(0)
adGroupsGroup = arcpy.GetParameterAsText(1)
wmxAdminGroup = arcpy.GetParameterAsText(2)
# Get any necessary licenses before importing the toolbox
checkOutLicenses("", ["JTX"])
# Import the Workflow Manager toolbox
wmxToolbox = getWorkflowManagerToolboxLocation()
arcpy.ImportToolbox(wmxToolbox, "WMXAdminUtils")
# Run the active directory import
preserve = "NO_PRESERVE"
arcpy.ImportActiveDirectoryConfiguration_WMXAdminUtils(
adUsersGroup, adGroupsGroup, preserve)
logPreviousToolMessages()
# Ensure that all of the group permissions are in a known state
#
# The sequence of events shown here is arbitrary; a real-life example would
# likely be set up differently
# Grant everything to everyone
arcpy.ModifyPrivilegeAssignment_WMXAdminUtils("[All]", "[All]",
"GRANT")
logPreviousToolMessages()
# Remove some particular permissions from the groups
arcpy.ModifyPrivilegeAssignment_WMXAdminUtils("DeleteJobs", "[All]",
"REVOKE")
logPreviousToolMessages()
arcpy.ModifyPrivilegeAssignment_WMXAdminUtils("DeleteVersion", "[All]",
"REVOKE")
logPreviousToolMessages()
# Add the permissions back to the administrators group
arcpy.ModifyPrivilegeAssignment_WMXAdminUtils("[All]", wmxAdminGroup,
"GRANT")
logPreviousToolMessages()
# Now, make sure that all of the users in the admin group have administrator
# access to the WMX DB
result = arcpy.ListUsers_WMXAdminUtils(wmxAdminGroup)
logPreviousToolMessages()
userListString = result.getOutput(0)
if userListString != None and len(userListString) > 0:
users = userListString.split(";")
arcpy.ModifyAdministratorAccess_WMXAdminUtils(
"[All]", "REVOKE", "PRESERVE")
logPreviousToolMessages()
for user in users:
arcpy.ModifyAdministratorAccess_WMXAdminUtils(
user, "GRANT", "PRESERVE")
logPreviousToolMessages()
except Exception, ex:
printUsage()
arcpy.AddError("Caught exception: " + str(ex))
