def alter_domain_name():
soucedomain = domain_dictionary('SPDM2_201803.gdb','Short')
for dmname, alias_codesc in soucedomain.items():
new_dmname = dmname[0:2]+'_' + dmname[2:]
#if del_nm == dmname:
if dmname[2] != '_':
arcpy.CreateDomain_management(outdataset, new_dmname, alias_codesc[0], 'Short', 'CODED')
print "创建域值"
for cod, desc in alias_codesc[1].items():
try:
arcpy.AddCodedValueToDomain_management(outdataset, new_dmname, int(cod), desc)
except arcpy.ExecuteError:
print arcpy.GetMessages()
print cod, desc
print type(cod)
arcpy.DeleteDomain_management(outdataset,dmname)
def alter_domiantype_single():
outdataset = r'D:\智能化管线项目\新气\新气数据处理\新气数据入库_0916\新库0910.gdb'
save_domain = domain_dictionary(outdataset, 'LONG') #
print save_domain
arcpy.DeleteDomain_management(outdataset, "gn_Reportstatus")
for dmname, alias_codesc in save_domain.items():
# if del_nm == dmname:
arcpy.CreateDomain_management(outdataset, "gn_Reportstatus", alias_codesc[0], 'Short', 'CODED')
print "创建域值"
for cod, desc in alias_codesc[1].items():
try:
arcpy.AddCodedValueToDomain_management(outdataset, "gn_Reportstatus", int(cod), desc)
except arcpy.ExecuteError:
print arcpy.GetMessages()
print cod, desc
print type(cod)
def PrepFeatClassForLibrary(featPath, logger, lstErrCnt):
# get all subtype codes in order to remove domains from subtypes
subtypeCodes = []
subtypes = arcpy.da.ListSubtypes(featPath)
for stcode, stdict in list(subtypes.items()):
subtypeCodes.append(stcode) # append subtype codes to a list
# Remove domains from subtypes and fields
lstDomains = []
ndx = featPath.rfind('/')
featWrkspc = featPath[0:ndx] # get just the workspace part of the featPath
featName = featPath.split('/')[-2] + '/' + featPath.split('/')[
-1] # geodatabase/name for log
lstFields = arcpy.ListFields(featPath)
for fld in lstFields:
if len(fld.domain) > 0:
if fld.domain not in lstDomains:
lstDomains.append(fld.domain)
try:
arcpy.RemoveDomainFromField_management(
featPath, fld.name,
subtypeCodes) # remove domain from all subtypes
except Exception as e:
logger.warning(
'\tUnable to remove domain from subtype on field ' +
fld.name)
#lstErrCnt[1] += 1 # Don't count warning so that email notification will ignore
try:
arcpy.RemoveDomainFromField_management(
featPath, fld.name) # remove domain from field
except Exception as e:
logger.warning('\tUnable to remove domain from field ' +
fld.name)
#lstErrCnt[1] += 1 # Don't count warning so that email notification will ignore
# delete the domains from the workspace
for dmn in lstDomains:
try:
arcpy.DeleteDomain_management(featWrkspc, dmn)
except Exception as e:
logger.warning('\tUnable to delete domain ' + dmn + ' on ' +
featName)
def detruireDomaineAttribut(self, workspace, classe):
#-------------------------------------------------------------------------------------
"""
Permet de détruire tous les domaines existants dans la Géodatabase.
Paramètres:
-----------
workspace : Nom de la géodatabase ou les domaines seront détruits.
classe : Liste des noms de classe contenus dans la géodatabase utilisés pour créer les domaines.
"""
#Définir le workspace par défaut
arcpy.env.workspace = workspace
#Extraire les FeatureClass de la Géodatabase
for fc in arcpy.ListFeatureClasses():
#Vérifier si la classe est présente dans la liste des classes
if fc.upper() in classe:
#Afficher le message pour détruire les domaines de la classe traité
arcpy.AddMessage(" ")
arcpy.AddMessage(u"- Détruire les subtypes de la classe : " + fc)
#Définir tous les Subtypes
subtypes = arcpy.da.ListSubtypes(fc)
#Vérifier si un Subtype est présent
if subtypes.values()[0]['SubtypeField'] <> "":
#Afficher le message
arcpy.AddMessage("SetSubtypeField_management('" + fc + "', #, True)")
#Enlever les subtypes d'une classe
arcpy.SetSubtypeField_management(fc, "#", True)
#Afficher les subtypes
#for stcode, stdict in list(subtypes.items()):
#Afficher le message
#arcpy.AddMessage(" RemoveSubtype_management('" + fc + "', '" + str(stcode) + "')")
#Détruire un subtype d'une classe
#arcpy.RemoveSubtype_management(fc, stcode)
#Afficher le message pour détruire les domaines de la classe traité
arcpy.AddMessage(u"- Détruire le domaine et la valeur par défaut pour chaque attribut de la classe : " + fc)
#Traiter tous les fields
for field in arcpy.ListFields(fc):
#Vérifier la présence d'un domaine
if field.domain <> "":
#Afficher le message
arcpy.AddMessage("RemoveDomainFromField_management('" + fc + "', '" + field.name + "')")
#Détruire un domaine dans un attribut d'une classe
arcpy.RemoveDomainFromField_management(fc, field.name)
#Vérifier si une valeur par défaut est présente
if field.defaultValue <> None:
#Afficher le message
arcpy.AddMessage("AssignDefaultToField_management('" + fc + "', '" + field.name + "' # # True)")
#Détruire la valeur par défaut de l'attribut d'une classe
arcpy.AssignDefaultToField_management(fc, field.name, "#", "#", True)
#Extraire les tables de la Géodatabase
for tbl in arcpy.ListTables():
#Vérifier si la table est présente dans la liste des classes
if tbl.upper() in classe:
#Afficher le message pour détruire les domaines de la classe traité
arcpy.AddMessage(" ")
arcpy.AddMessage(u"- Détruire les subtypes de la table : " + tbl)
#Définir tous les Subtypes
subtypes = arcpy.da.ListSubtypes(tbl)
#Vérifier si un Subtype est présent
if subtypes.values()[0]['SubtypeField'] <> "":
#Afficher le message
arcpy.AddMessage("SetSubtypeField_management('" + tbl + "', #, True)")
#Enlever les subtypes d'une classe
arcpy.SetSubtypeField_management(tbl, "#", True)
#Afficher les subtypes
#for stcode, stdict in list(subtypes.items()):
#Afficher le message
#arcpy.AddMessage(" RemoveSubtype_management('" + tbl + "', '" + str(stcode) + "')")
#Détruire un subtype d'une table
#arcpy.RemoveSubtype_management(tbl, stcode)
#Afficher le message pour détruire les domaines de la classe traité
arcpy.AddMessage(u"- Détruire le domaine et la valeur par défaut pour chaque attribut de la table : " + tbl)
#Traiter tous les fields
for field in arcpy.ListFields(tbl):
#Vérifier la présence d'un domaine
if field.domain <> "":
#Afficher le message
arcpy.AddMessage("RemoveDomainFromField_management('" + tbl + "', '" + field.name + "')")
#Détruire un domaine dans un attribut d'une classe
arcpy.RemoveDomainFromField_management(tbl, field.name)
#Vérifier si une valeur par défaut est présente
if field.defaultValue <> None:
#Afficher le message
arcpy.AddMessage("AssignDefaultToField_management('" + tbl + "', '" + field.name + "' # # True)")
#Détruire la valeur par défaut de l'attribut d'une table
arcpy.AssignDefaultToField_management(tbl, field.name, "#", "#", True)
#Envoyer un message
arcpy.AddMessage(" ")
arcpy.AddMessage(u"- Détruire les domaines non-utilisés dans la Géodatabase")
#Extraire la description de la Géodatabase
desc = arcpy.Describe(workspace)
#Extraire tous les domaines existants de la Géodatabase
domains = desc.domains
#Traiter tous les domaines
for domain in domains:
try:
#Détruire un domaine
arcpy.DeleteDomain_management(workspace, domain)
#Afficher le message
arcpy.AddMessage("DeleteDomain_management('" + workspace + "', '" + domain + "')")
#Gestion des erreurs
except Exception, err:
#Afficher l'erreur
arcpy.AddWarning(u"Le domaine est encore utilisé et ne peut être détruit : " + domain)
# Get domains that are assigned to a field
domains_used = []
for dirpath, dirnames, filenames in arcpy.da.Walk(myGDB, datatype=["FeatureClass", "Table"]):
for filename in filenames:
print "Checking {}".format(os.path.join(dirpath, filename))
print arcpy.GetMessages()
try:
## Check for normal field domains
for field in arcpy.ListFields(os.path.join(dirpath, filename)):
if field.domain:
domains_used.append(field.domain)
## Check for domains used in a subtype field
subtypes = arcpy.da.ListSubtypes(os.path.join(dirpath, filename))
for stcode, stdict in subtypes.iteritems():
if stdict["SubtypeField"] != u'':
for field, fieldvals in stdict["FieldValues"].iteritems():
if not fieldvals[1] is None:
domains_used.append(fieldvals[1].name)
except Exception, err:
print "Error:", err
# Get domains that exist in the geodatabase
domains_existing = [dom.name for dom in arcpy.da.ListDomains(myGDB)]
# Find existing domains that are not assigned to a field
domains_unused = set(domains_existing) ^ set(domains_used)
print "{} unused domains in {}".format(len(domains_unused), myGDB)
for domain in domains_unused:
arcpy.DeleteDomain_management(myGDB, domain)
print "{} deleted".format(domain)
edit.stopEditing(True)
###Join all active domains table to the all domains table
###Those domains in the all domains table that do not have a match are inactive
arcpy.AddJoin_management(allDomainsView, "dom_name", activeDomainsView,
"name", "KEEP_ALL")
with arcpy.da.SearchCursor(
allDomainsView,
["UUSD.DBO.domain_active.name", "UUSD.DBO.domain_all.dom_name"]) as sc:
for row in sc:
if row[0] == None:
inactiveDomains.append(row[1])
try:
arcpy.DeleteDomain_management(workspace, row[1])
except:
infile.write("\nCould not delete " + row[1] + ".\n" +
arcpy.GetMessages(2) + "\n")
#print inactiveDomains
inactiveDomains.sort()
print "\nLENGTH: " + str(len(inactiveDomains)) + "\n"
infile.write("INACTIVE DOMAINS\n")
for dom in inactiveDomains:
print dom
infile.write(dom + "\n")
infile.close()
sendEmail()
def main():
try:
# Connection path to geodatabse (as administrator if SDE)
myGDB = r"C:\GISConnections\[email protected]"
# Get domains that are assigned to a field
domainsUsed_names = []
for dirpath, dirnames, filenames in arcpy.da.Walk(myGDB, datatype=["FeatureClass", "Table"]):
for filename in filenames:
print "Checking {}".format(os.path.join(dirpath, filename))
## Check for normal field domains
for field in arcpy.ListFields(os.path.join(dirpath, filename)):
if field.domain:
domainsUsed_names.append(field.domain)
## Check for domains used in a subtype field
subtypes = arcpy.da.ListSubtypes(os.path.join(dirpath, filename))
for stcode, stdict in subtypes.iteritems():
if stdict["SubtypeField"] != u'':
for field, fieldvals in stdict["FieldValues"].iteritems():
if not fieldvals[1] is None:
domainsUsed_names.append(fieldvals[1].name)
## end for subtypes
## end for filenames
## end for geodatabase Walk
# List of all existing domains (as domain objects)
domainsExisting = arcpy.da.ListDomains(myGDB)
# Find existing domain names that are not in use (using set difference)
domainsUnused_names = (
set([dom.name for dom in domainsExisting]) - set(domainsUsed_names)
)
# Get domain objects for unused domain names
domainsUnused = [
dom for dom in domainsExisting
if dom.name in domainsUnused_names
]
print "{} unused domains in {}".format(len(domainsUnused), myGDB)
# Cleanup
del domainsExisting
del domainsUnused_names
# Delete unused domains by owner
## For local geodatabses, owner is an empty string ('')
with makeTempDir() as temp_dir:
descGDB = arcpy.Describe(myGDB)
for owner in set([dom.owner for dom in domainsUnused]):
if descGDB.workspaceType == "RemoteDatabase":
## Use temporary SDE connection as owner
myGDB = arcpy.CreateDatabaseConnection_management(
temp_dir, ## out_folder_path
owner+".sde", ## out_name
"ORACLE", ## database_platform
"GISTEST.WORLD", ## instance
"DATABASE_AUTH", ## account_authentication
owner, ## username
"myuserpass", ## password
)
print arcpy.GetMessages()
## Format result object as string for path to connection file
myGDB = str(myGDB)
# Get unused domains for current owner
domainsUnused_currentOwner = [
dom.name for dom in domainsUnused
if dom.owner == owner
]
for domain in domainsUnused_currentOwner:
arcpy.DeleteDomain_management(myGDB, domain)
print "\t{} deleted".format(domain)
## end for domainsExisting_owners
## end with temp_dir
finally:
# Cleanup
arcpy.ClearWorkspaceCache_management()
def obliterate(group, dataIn, inputGDB=None):
"""
Function to remove all feature classes, domain values, feature datasets,
& SDE tables from an Enterprise GDB.
Parameter 1 = The kind of input data.
Parameter 2 = A list of input data.
Parameter 3 (Optional) = An input GDB
"""
if group == 'feature classes':
arcpy.AddMessage('Deleting Feature Classes')
arcpy.AddMessage('\n')
if not dataIn:
arcpy.AddMessage('Empty input for feature classes')
else:
for el in dataIn:
arcpy.AddMessage(el)
arcpy.Delete_management(el)
elif group == 'tables':
arcpy.AddMessage('Deleting Tables')
arcpy.AddMessage('\n')
if not dataIn:
arcpy.AddMessage('Empty input for tables')
else:
for el in dataIn:
arcpy.AddMessage(el)
arcpy.Delete_management(el)
elif group == 'domains':
arcpy.AddMessage('Deleting Domains')
arcpy.AddMessage('\n')
if not dataIn:
arcpy.AddMessage('Empty input for domains')
else:
for el in dataIn:
name = el.name
arcpy.AddMessage(name)
arcpy.DeleteDomain_management(inputGDB, name)
elif group == 'datasets':
arcpy.AddMessage('Deleting Datasets')
arcpy.AddMessage('\n')
if not dataIn:
arcpy.AddMessage('Empty input for datasets')
else:
for el in dataIn:
arcpy.AddMessage('Feature dataset: ' + el)
# print('Feature classes:')
# for fc in arcpy.ListFeatureClasses(feature_dataset=el):
# arcpy.AddMessage(fc)
# arcpy.Delete_management(fc)
arcpy.Delete_management(el)
else:
arcpy.AddMessage('Bad input into function...')
"UNIT['Meter',1.0]];-400 -400 1000000000;-100000 10000;-100000 10000;8.98315284119522E-09;0.001;0.001;"
"IsHighPrecision", "", "0", "0", "0")
else:
pass
#______________________________________________________________________________#
#
# Adding Survey Fields
#______________________________________________________________________________#
DomGDB = arcpy.Describe(Geodatabase)
domains = DomGDB.Domains
dmCount = len(domains)
if dmCount > 0:
for domain in domains:
arcpy.DeleteDomain_management(Geodatabase, domain)
else:
pass
if CameraInput == "Associate Photo with Parcel":
arcpy.AddMessage("Step 8: Adding survey questions")
else:
arcpy.AddMessage("Step 2: Adding Survey questions")
try:
config = ConfigParser.ConfigParser()
except NameError:
config = configparser.ConfigParser()
config.read(config_file)
Domain1 = config.get('DOMAINS', "Domain1")
"WHITEOAK": "WHITEOAK",
"WILDCAT": "WILDCAT",
"X2": "X2",
"X4": "X4",
"X6": "X6",
"X7": "X7"
}
isDomain = False
#check if domain exists
desc = arcpy.Describe(gdb)
domains = desc.domains
for domain in domains:
if domain == domName:
# isDomain = True
print("Domain already exists.")
arcpy.DeleteDomain_management(gdb, domain)
print("Domain has been deleted.")
if isDomain <> True:
#create domain
arcpy.CreateDomain_management(gdb, domName, domName, "TEXT", "CODED")
print("Domain " + domName + " has been created")
#add coded value to domain
for code in domDict:
arcpy.AddCodedValueToDomain_management(gdb, domName, code,
domDict[code])
print(code + ", " + domDict[code])
else:
print("Domain already exists.")
recreate_domain(
workspace=workspace,
csv_path=csv_path,
code_field=code,
desc_field=desc,
domain_name= target_domain+'_1',
old_domain_obj = old_domain_obj)
replace_domain(
workspace=workspace,
old_domain=target_domain,
new_domain=target_domain+'_1')
arcpy.DeleteDomain_management(
in_workspace = workspace,
domain_name = target_domain)
recreate_domain(
workspace=workspace,
csv_path=csv_path,
code_field=code,
desc_field=desc,
domain_name= target_domain,
old_domain_obj = old_domain_obj)
replace_domain(
workspace=workspace,
old_domain=target_domain+'_1',
new_domain=target_domain)
def del_all_domains():
_domains = arcpy.da.ListDomains(get_workspace())
for _domain in _domains:
arcpy.DeleteDomain_management(get_workspace(), _domain.name)
print("Domain deleted: " + _domain.name)
def detruireDomaineAttribut(self, workspace):
#-------------------------------------------------------------------------------------
"""
Permet de détruire tous les domaines existants dans la Géodatabase.
Paramètres:
-----------
workspace : Nom de la géodatabase ou les domaines seront détruits.
"""
#Envoyer un message
arcpy.AddMessage(" ")
arcpy.AddMessage("- Détruire tous les domaines existants dans les classes de la Géodatabase")
#Définir le workspace par défaut
arcpy.env.workspace = workspace
#Extraire la description de la Géodatabase
#for fc in classe.split(","):
for fc in arcpy.ListFeatureClasses():
#Extraire les fields
fields = arcpy.ListFields(fc)
#Traiter tous les fields
for field in fields:
#Vérifier la présence d'un domaine
if len(field.domain) > 0:
#Vérifier si l'attribut est présent dans la liste des attribut
#if field.name in attribut:
#Afficher le message
arcpy.AddMessage(" RemoveDomainFromField_management('" + fc + "', '" + field.name + "')")
#Détruire un domaine dans un attribut d'une classe
arcpy.RemoveDomainFromField_management(fc, field.name)
#Envoyer un message
arcpy.AddMessage(" ")
arcpy.AddMessage("- Détruire tous les domaines existants dans la Géodatabase")
#Extraire la description de la Géodatabase
desc = arcpy.Describe(workspace)
#Extraire tous les domaines existants de la Géodatabase
domains = desc.domains
#Traiter tous les domaines
for domain in domains:
#Vérifier si c'est un domaine
#if "DOM_" in domain:
#Afficher le message
arcpy.AddMessage(" DeleteDomain_management('" + workspace + "', '" + domain + "')")
try:
#Détruire un domaine
arcpy.DeleteDomain_management(workspace, domain)
#Gestion des erreurs
except Exception, err:
#Afficher l'erreur
arcpy.AddWarning(err.message)
def AddRangeDomain(feature, workspace, domain_name, range_low, range_high):
"""
Applies the range domain to the feature. Removes domain from any existing
features if necessary.
:param feature: a feature class
:param workspace: the project's unique gdb
:param domain_name: the name of the domain as a string
:param range_low: integer or float
:param range_high: integer or float
:return: None
"""
# Check for existence of domain; update domain if present, add domain if
# not
desc = arcpy.Describe(workspace)
domains = desc.domains
if domain_name in domains:
arcpy.AddMessage(domain_name + " is already specified as a domain")
try:
# try removing from all fields in all feature classes
existingFeatures = arcpy.ListFeatureClasses()
for existingFeature in existingFeatures:
fields = arcpy.ListFields(existingFeature)
for field in fields:
if field.domain == domain_name:
table = os.path.join(workspace, existingFeature)
arcpy.RemoveDomainFromField_management(
table, field.name)
arcpy.AddMessage(domain_name +
" domain removed from " +
existingFeature + " " + field.name +
" field")
# try removing from all fields in all subtypes
subtypes = arcpy.da.ListSubtypes(existingFeature)
for stcode, stdict in list(subtypes.items()):
for stkey in list(stdict.keys()):
# if there is a Subtype Field
if not stdict['SubtypeField'] == '':
st_code = "'{}: {}'".format(stcode, stdict['Name'])
# if no Subtype Field, use "#" in RemoveDomainFromField
# for subtype_code
else:
st_code = "#"
if stkey == 'FieldValues':
fields = stdict[stkey]
for field, fieldvals in list(fields.items()):
# if field has a domain
if not fieldvals[1] is None:
# and the domain is in our list
if fieldvals[1].name == domain_name:
# remove the domain
arcpy.AddMessage(fieldvals[1].name +
" domain removed " +
"from " +
existingFeature +
" field: " + field +
" subtype: " +
st_code)
arcpy.RemoveDomainFromField_management(
existingFeature, field, st_code)
arcpy.DeleteDomain_management(workspace, domain_name)
arcpy.CreateDomain_management(workspace, domain_name,
domain_name + " must be integer",
"SHORT", "RANGE")
arcpy.SetValueForRangeDomain_management(workspace, domain_name,
range_low, range_high)
arcpy.AssignDomainToField_management(feature, domain_name,
domain_name)
arcpy.AddMessage(domain_name + " domain updated")
except arcpy.ExecuteError:
arcpy.AddMessage(domain_name + " domain could not be updated")
else:
arcpy.CreateDomain_management(workspace, domain_name,
domain_name + " must be integer",
"SHORT", "RANGE")
arcpy.SetValueForRangeDomain_management(workspace, domain_name,
range_low, range_high)
arcpy.AssignDomainToField_management(feature, domain_name, domain_name)
arcpy.AddMessage(domain_name + " domain updated")
def AddCodedTextDomain(feature_list,
workspace,
domain_name,
code_list,
assign_default=False,
populate_default=False):
"""
Applies the code_list as a domain to the list of feature classes.
Domain must be the same as the field name to which it is being applied.
:param feature_list: list of feature classes
:param workspace: the project's unique gdb
:param domain_name: name of the domain as a string, must be same as name
of field to which it is applied
:param code_list: list of codes as strings
:param assign_default: True to assign the first code in the code_list as
default
:param populate_default: True to populate existing features with the
default code
:return: None
"""
# Create unique list from provided
uniqueCodes = []
for code in code_list:
if code not in uniqueCodes:
uniqueCodes.append(code)
# Check for existence of domain; update domain if present, add domain if not
desc = arcpy.Describe(workspace)
domains = desc.domains
if domain_name in domains:
arcpy.AddMessage(domain_name + " is already specified as a domain")
try:
# try removing from all fields in all feature classes
existingFeatures = arcpy.ListFeatureClasses()
for existingFeature in existingFeatures:
fields = arcpy.ListFields(existingFeature)
for field in fields:
if field.domain == domain_name:
arcpy.RemoveDomainFromField_management(
existingFeature, field.name)
arcpy.AddMessage(domain_name +
" domain removed from " +
existingFeature + " " + field.name +
" field")
# try removing from all fields in all subtypes
# Credit to:(https://community.esri.com/thread/
# 198384-how-to-remove-domain-from-field-for-gdb)
subtypes = arcpy.da.ListSubtypes(existingFeature)
for stcode, stdict in list(subtypes.items()):
for stkey in list(stdict.keys()):
# if there is a Subtype Field
if not stdict['SubtypeField'] == '':
st_code = "'{}: {}'".format(stcode, stdict['Name'])
# if no Subtype Field, use "#" in RemoveDomainFromField
# for subtype_code
else:
st_code = "#"
if stkey == 'FieldValues':
fields = stdict[stkey]
for field, fieldvals in list(fields.items()):
# if field has a domain
if not fieldvals[1] is None:
# and the domain is in our list
if fieldvals[1].name == domain_name:
# remove the domain
arcpy.AddMessage(fieldvals[1].name +
" domain removed " +
"from " +
existingFeature +
" field: " + field +
" subtype: " +
st_code)
arcpy.RemoveDomainFromField_management(
existingFeature, field, st_code)
arcpy.DeleteDomain_management(workspace, domain_name)
arcpy.CreateDomain_management(workspace, domain_name,
"Valid " + domain_name + "s", "TEXT",
"CODED")
for code in uniqueCodes:
arcpy.AddCodedValueToDomain_management(workspace, domain_name,
code, code)
for feature in feature_list:
try:
arcpy.AssignDomainToField_management(
feature, domain_name, domain_name)
# Check to make sure subtypes exist
subtypes = arcpy.da.ListSubtypes(feature)
if len(subtypes
) == 1 and subtypes[0]['SubtypeField'] == '':
pass
else:
st_codes = [
str(stcode)
for stcode, stdict in list(subtypes.items())
]
arcpy.AssignDomainToField_management(
feature, domain_name, domain_name, st_codes)
except arcpy.ExecuteError:
arcpy.AddMessage("--------------------------------"
"\n" + domain_name +
" domain for feature \n\n" +
str(feature) + "\n\n" +
"could not be updated. Use "
"caution when populating attribute\n"
"---------------------------------")
arcpy.AddMessage(domain_name + " domain updated")
except arcpy.ExecuteError:
arcpy.AddMessage(domain_name + " domain could not be updated. Use "
"caution when populating attribute")
else:
arcpy.CreateDomain_management(workspace, domain_name,
"Valid " + domain_name + "s", "TEXT",
"CODED")
for code in uniqueCodes:
arcpy.AddCodedValueToDomain_management(workspace, domain_name,
code, code)
for feature in feature_list:
try:
arcpy.AssignDomainToField_management(feature, domain_name,
domain_name)
# Check to make sure subtypes exist
subtypes = arcpy.da.ListSubtypes(feature)
if len(subtypes) == 1 and subtypes[0]['SubtypeField'] == '':
pass
else:
st_codes = [
str(stcode)
for stcode, stdict in list(subtypes.items())
]
arcpy.AssignDomainToField_management(
feature, domain_name, domain_name, st_codes)
except arcpy.ExecuteError:
arcpy.AddMessage(domain_name +
" domain could not be updated. Use "
"caution when populating attribute")
arcpy.AddMessage(domain_name + " domain updated")
# Assign the first value as the default
if assign_default:
for feature in feature_list:
subtypes = arcpy.da.ListSubtypes(feature)
if len(subtypes) == 1 and subtypes[0]['SubtypeField'] == '':
arcpy.AssignDefaultToField_management(feature, domain_name,
uniqueCodes[0])
else:
st_codes = [
str(stcode) for stcode, stdict in list(subtypes.items())
]
arcpy.AssignDefaultToField_management(feature, domain_name,
uniqueCodes[0], st_codes)
# Populate field with default values if Null
if populate_default:
arcpy.AddMessage("Populating default values")
for feature in feature_list:
where_clause = "{0} = '' OR {0} IS NULL".format(
arcpy.AddFieldDelimiters(feature, domain_name))
with arcpy.da.UpdateCursor(feature, domain_name,
where_clause) as cursor:
for row in cursor:
row[0] = uniqueCodes[0]
cursor.updateRow(row)
def mainFunction(
geodatabase, configFile
): # Get parameters from ArcGIS Desktop tool by seperating by comma e.g. (var1 is 1st parameter,var2 is 2nd parameter,var3 is 3rd parameter)
try:
# Logging
if (enableLogging == "true"):
# Setup logging
logger, logMessage = setLogging(logFile)
# Log start of process
logger.info("Process started.")
# --------------------------------------- Start of code --------------------------------------- #
# Get a list of assigned domains
assignedDomains = []
# Get a list of the feature datasets in the database
arcpy.env.workspace = geodatabase
featureDatasetList = arcpy.ListDatasets("", "Feature")
# FUNCTION - Get the domains for these feature datasets
assignedDomains = assignedDomains + getDomains(
geodatabase, featureDatasetList, configFile, "Feature Dataset")
# Get a list of the feature classes in the database
featureClassList = arcpy.ListFeatureClasses()
# FUNCTION - Get the domains for these feature calsses
assignedDomains = assignedDomains + getDomains(
geodatabase, featureClassList, configFile, "Feature Class")
# Get a list of the tables in the database
mosaicList = arcpy.ListDatasets("", "Mosaic")
# FUNCTION - Get the domains for these tables
assignedDomains = assignedDomains + getDomains(geodatabase, mosaicList,
configFile, "Mosaic")
# Get a list of mosaic rasters in the database
tableList = arcpy.ListTables()
# FUNCTION - Get the domains for these tables
assignedDomains = assignedDomains + getDomains(
geodatabase, featureClassList, configFile, "Table")
# Get a list of domains on the geodatabase
geodatabaseDomains = arcpy.da.ListDomains(geodatabase)
# For each of the domains
for domain in geodatabaseDomains:
usedDomainCount = 0
# Check it is being used by looking at the assigned domains list
for assignedDomain in assignedDomains:
if (domain.name == assignedDomain):
usedDomainCount = usedDomainCount + 1
# If domain is not being used
if (usedDomainCount == 0):
# Don't remove domains on wcc_encroachments feature class (Wellington City Council) as there are subtypes and it's causing issues in this script
if ("Encroach" not in domain.name):
# Remove the domain from the geodatabase
arcpy.AddMessage("Removing domain " + domain.name +
" as not being used...")
# Logging
if (enableLogging == "true"):
logger.info("Removing domain " + domain.name +
" as not being used...")
arcpy.DeleteDomain_management(geodatabase, domain.name)
# --------------------------------------- End of code --------------------------------------- #
# If called from gp tool return the arcpy parameter
if __name__ == '__main__':
# Return the output if there is any
if output:
arcpy.SetParameterAsText(1, output)
# Otherwise return the result
else:
# Return the output if there is any
if output:
return output
# Logging
if (enableLogging == "true"):
# Log end of process
logger.info("Process ended.")
# Remove file handler and close log file
logging.FileHandler.close(logMessage)
logger.removeHandler(logMessage)
pass
# If arcpy error
except arcpy.ExecuteError:
# Build and show the error message
errorMessage = arcpy.GetMessages(2)
arcpy.AddError(errorMessage)
# Logging
if (enableLogging == "true"):
# Log error
logger.error(errorMessage)
# Remove file handler and close log file
logging.FileHandler.close(logMessage)
logger.removeHandler(logMessage)
if (sendErrorEmail == "true"):
# Send email
sendEmail(errorMessage)
# If python error
except Exception as e:
errorMessage = ""
# Build and show the error message
for i in range(len(e.args)):
if (i == 0):
errorMessage = str(e.args[i])
else:
errorMessage = errorMessage + " " + str(e.args[i])
arcpy.AddError(errorMessage)
# Logging
if (enableLogging == "true"):
# Log error
logger.error(errorMessage)
# Remove file handler and close log file
logging.FileHandler.close(logMessage)
logger.removeHandler(logMessage)
if (sendErrorEmail == "true"):
# Send email
sendEmail(errorMessage)
