def updateDomains(domainsFolder, targetGDB):
try:
arcpy.AddMessage("Starting: UpdateDomains")
# Update all coded (list) domains
path = os.path.normpath(
os.path.join(domainsFolder, "Coded_Domain_*.csv"))
for fname in glob.glob(path):
# Find the domain's name and description and then add it to the gdb
domainName, domainDescription = findNameAndDescription(
fname, "Coded_Domain_")
arcpy.AddMessage("Updating domain " + domainName + "...")
arcpy.TableToDomain_management(fname, "Value", "Name", targetGDB,
domainName, domainDescription,
"REPLACE")
# Update all range domains
path = os.path.normpath(
os.path.join(domainsFolder, "Range_Domain_*.csv"))
for fname in glob.glob(path):
# Find the domain's name and description and then add it to the gdb
domainName, domainDescription = findNameAndDescription(
fname, "Range_Domain_")
arcpy.AddMessage("Updating domain " + domainName + "...")
# Set the range domain's min and max values
with open(fname, 'r') as csvFile:
reader = csv.reader(csvFile, dialect='excel')
# Skip the header, use the second line
header = next(reader)
line = next(reader)
arcpy.CreateDomain_management(targetGDB, domainName,
domainDescription,
Utility.fieldTypeLookup(line[0]),
"RANGE")
arcpy.SetValueForRangeDomain_management(
targetGDB, domainName, int(line[1]), int(line[2]))
except Exception as err:
arcpy.AddError(
traceback.format_exception_only(type(err), err)[0].rstrip())
else:
arcpy.AddMessage("Success! - Completed: UpdateDomains")
finally:
arcpy.AddMessage("Exiting: UpdateDomains")
def add_additive_specification_range_domain_to_gdb(in_gdb, in_features, fields, domain_name, field_type="DOUBLE",
range_min=0, range_max=25):
"""This function will add additive shared-row specification domains for categorical fields
based on a CSV. Uses Pandas.
:param - in_gdb - input geodatabase to add domains to
:param - in_features - optional input that is used to assign domains to feature class is chosen.
:param - domain_name - name of new range domain
:param - field_type - field type used by domains
:param - fields - fields to assign domains too
:param - range_min - the minimum value allowed by the range domain
:param - range_max - the maximum value allowed by the range domain
"""
try:
domain_description = str(domain_name) + "_Range_Domain"
try:
srl.arc_print("Adding range domain for numeric values...")
arcpy.CreateDomain_management(in_gdb, domain_name, domain_description, field_type, "RANGE")
except:
arcpy.AddWarning("Could not create domain. Either it already exists or some other error...")
srl.arc_print("Set min and max values of domains...")
arcpy.SetValueForRangeDomain_management(in_gdb, domain_name, range_min, range_max)
srl.arc_print("Attempting to assign numeric fields ...")
for field in fields:
try:
if len(arcpy.ListFields(in_features, field)) > 0:
arcpy.AssignDomainToField_management(in_features, field, domain_name)
except:
arcpy.AddWarning("Could not assign domain to field {0}...".format(field))
except Exception as e:
srl.arc_print("Tool Script Error!")
import traceback, sys
tb = sys.exc_info()[2]
srl.arc_print("An error occurred on line %i" % tb.tb_lineno)
arcpy.AddError("The error occurred on line {0}...".format(tb.tb_lineno))
def check_and_create_domains(geodatabase):
"""
Checks if the domains already exist, if they do
then it checks the values and ranges
If the domains do not exist, they are created
:param geodatabase: (string) the path to the geodatabase to check
:return:
"""
domains = arcpy.da.ListDomains(geodatabase)
domain_names = [domain.name for domain in domains]
if 'ESRI_FIX_TYPE_DOMAIN' in domain_names:
for domain in domains:
if domain.name == 'ESRI_FIX_TYPE_DOMAIN':
# check if cvs 0,1,2,4,5 are in the codedValues
values = [cv for cv in domain.codedValues]
if not set(set([0, 1, 2, 4, 5])).issubset(values):
arcpy.AddError(
"ESRI_FIX_TYPE_DOMAIN is missing a coded value pair.")
return
else:
# Add the domain and values
arcpy.AddMessage(
'Adding ESRI_FIX_TYPE_DOMAIN domain to parent geodatabase...')
arcpy.CreateDomain_management(in_workspace=geodatabase,
domain_name="ESRI_FIX_TYPE_DOMAIN",
domain_description="Fix Type",
field_type="SHORT",
domain_type="CODED",
split_policy="DEFAULT",
merge_policy="DEFAULT")
arcpy.AddCodedValueToDomain_management(
in_workspace=geodatabase,
domain_name="ESRI_FIX_TYPE_DOMAIN",
code="0",
code_description="Fix not valid")
arcpy.AddCodedValueToDomain_management(
in_workspace=geodatabase,
domain_name="ESRI_FIX_TYPE_DOMAIN",
code="1",
code_description="GPS")
arcpy.AddCodedValueToDomain_management(
in_workspace=geodatabase,
domain_name="ESRI_FIX_TYPE_DOMAIN",
code="2",
code_description="Differential GPS")
arcpy.AddCodedValueToDomain_management(
in_workspace=geodatabase,
domain_name="ESRI_FIX_TYPE_DOMAIN",
code="4",
code_description="RTK Fixed")
arcpy.AddCodedValueToDomain_management(
in_workspace=geodatabase,
domain_name="ESRI_FIX_TYPE_DOMAIN",
code="5",
code_description="RTK Float")
# Check if 'NumSats" is a domain, if so check the range
if 'ESRI_NUM_SATS_DOMAIN' in domain_names:
if domain.name == "ESRI_NUM_SATS_DOMAIN":
if domain.range[0] != 0 or domain.range[1] != 99:
arcpy.AddError("ESRI_NUM_SATS_DOMAIN domain has invalid range")
return
else:
# Add the domain and set the range
arcpy.AddMessage("Adding ESRI_NUM_SATS_DOMAIN to parent database...")
arcpy.CreateDomain_management(
in_workspace=geodatabase,
domain_name="ESRI_NUM_SATS_DOMAIN",
domain_description="Number of Satellites",
field_type="SHORT",
domain_type="RANGE",
split_policy="DEFAULT",
merge_policy="DEFAULT")
arcpy.SetValueForRangeDomain_management(geodatabase,
"ESRI_NUM_SATS_DOMAIN", 0, 99)
if 'ESRI_POSITIONSOURCETYPE_DOMAIN' in domain_names:
for domain in domains:
if domain.name == 'ESRI_POSITIONSOURCETYPE_DOMAIN':
# check if cvs 0,1,2,3,4 are in the codedValues
values = [cv for cv in domain.codedValues]
if not set(set([0, 1, 2, 3, 4])).issubset(values):
arcpy.AddError(
"ESRI_POSITIONSOURCETYPE_DOMAIN is missing a coded value pair."
)
return
else:
# Add the domain and values
arcpy.AddMessage(
'Adding ESRI_POSITIONSOURCETYPE_DOMAIN domain to parent geodatabase...'
)
arcpy.CreateDomain_management(
in_workspace=geodatabase,
domain_name="ESRI_POSITIONSOURCETYPE_DOMAIN",
domain_description="Position Source Type",
field_type="SHORT",
domain_type="CODED",
split_policy="DEFAULT",
merge_policy="DEFAULT")
arcpy.AddCodedValueToDomain_management(
in_workspace=geodatabase,
domain_name="ESRI_POSITIONSOURCETYPE_DOMAIN",
code="0",
code_description="Unknown")
arcpy.AddCodedValueToDomain_management(
in_workspace=geodatabase,
domain_name="ESRI_POSITIONSOURCETYPE_DOMAIN",
code="1",
code_description="User defined")
arcpy.AddCodedValueToDomain_management(
in_workspace=geodatabase,
domain_name="ESRI_POSITIONSOURCETYPE_DOMAIN",
code="2",
code_description="Integrated (System) Location Provider")
arcpy.AddCodedValueToDomain_management(
in_workspace=geodatabase,
domain_name="ESRI_POSITIONSOURCETYPE_DOMAIN",
code="3",
code_description="External GNSS Receiver")
arcpy.AddCodedValueToDomain_management(
in_workspace=geodatabase,
domain_name="ESRI_POSITIONSOURCETYPE_DOMAIN",
code="4",
code_description="Network Location Provider")
arcpy.CreateFileGDB_management(out_folder, dbName)
logger.logGPMsg()
print "creating coded value domains"
for d in domains:
print d
arcpy.TableToDomain_management(domainsXLS + "\\" + d + "$", "CODE",
"CODE", gdb, "roadkill_" + d,
"roadkill_" + d)
logger.logGPMsg()
print "creating xyphoid range domain"
arcpy.CreateDomain_management(gdb, xyphoidDomainName, xyphoidDomainName,
"SHORT", "RANGE")
logger.logGPMsg()
arcpy.SetValueForRangeDomain_management(gdb, xyphoidDomainName, xyphoidMin,
xyphoidMax)
logger.logGPMsg()
print "creating Reports fc"
srPath = os.path.join(
arcpy.GetInstallInfo()["InstallDir"],
r"Coordinate Systems\Projected Coordinate Systems\UTM\NAD 1983\NAD 1983 UTM Zone 12N.prj"
)
spatial_reference = arcpy.SpatialReference(srPath)
arcpy.CreateFeatureclass_management(gdb, reports, "POINT", None, None,
None, spatial_reference)
logger.logGPMsg()
print "adding fields"
for f in fields:
print f
def create_fc_fields_with_domains(fgdb_path):
"""
:param fgdb_path: file path to the file geodatabase
:type fgdb_path: basestring
"""
arcpy.env.workspace = fgdb_path
arcpy.env.overwriteOutput = True
# ---------------------------------------------------------------
# define domains
#
# pattern:
#
# for coded domains
# create a domain object _in the GDB_ (not as a Python object)
# create a dictionary of domain code:description pairs
# load the dictionary into the domain
# use the domain when creating a feature class or use
# arcpy.AssignDomainToField_management()
#
# for range domains
# create a domain object _in the GDB_ (not as a Python object)
# set SetValueForRangeDomain_management
# use the domain when creating a feature class or use
# arcpy.AssignDomainToField_management()
#
# --------------------------------------------------------------
log.info("Creating feature class")
fc_name = "GDA94_fields_with_domains_polyline"
fc_path = os.path.join(fgdb_path, fc_name)
arcpy.CreateFeatureclass_management(
out_path=fgdb_path,
out_name=fc_name,
geometry_type="POLYLINE",
spatial_reference=arcpy.SpatialReference(4283)) # GDA94 lat/long)
log.info("Creating domains")
# --------------------------------------
domain_name = "text_field_coded_domain"
arcpy.CreateDomain_management(
in_workspace=fgdb_path,
domain_name=domain_name,
domain_description="uses a coded TEXT domain",
field_type="TEXT",
domain_type="CODED")
text_field_coded_domain_dict = {"R": "Red", "G": "Green", "B": "Blue"}
for code in text_field_coded_domain_dict:
arcpy.AddCodedValueToDomain_management(
in_workspace=fgdb_path,
domain_name=domain_name,
code=code,
code_description=text_field_coded_domain_dict[code])
arcpy.AddField_management(in_table=fc_path,
field_name="text_field_with_coded_domain",
field_type="TEXT",
field_length=50,
field_alias="has a TEXT coded domain",
field_domain="text_field_coded_domain")
# -----------------------------------------------------------------------------------
domain_name = "float_field_coded_domain"
arcpy.CreateDomain_management(
in_workspace=fgdb_path,
domain_name=domain_name,
domain_description="uses a coded FLOAT domain",
field_type="FLOAT",
domain_type="CODED")
float_field_coded_domain_dict = {
1.1: "one decimal place",
1.01: "two decimal places",
1.001: "three decimal places"
}
for code in float_field_coded_domain_dict:
arcpy.AddCodedValueToDomain_management(
in_workspace=fgdb_path,
domain_name=domain_name,
code=code,
code_description=float_field_coded_domain_dict[code])
arcpy.AddField_management(in_table=fc_path,
field_name="float_field_with_coded_domain",
field_type="FLOAT",
field_alias="has a FLOAT coded domain",
field_domain="float_field_coded_domain")
# -----------------------------------------------------------------------------------
domain_name = "float_field_range_domain"
arcpy.CreateDomain_management(
in_workspace=fgdb_path,
domain_name=domain_name,
domain_description="uses a FLOAT range domain",
field_type="FLOAT",
domain_type="RANGE")
arcpy.SetValueForRangeDomain_management(in_workspace=fgdb_path,
domain_name=domain_name,
min_value=1.1,
max_value=2.2)
arcpy.AddField_management(in_table=fc_path,
field_name="float_field_with_range_domain",
field_type="FLOAT",
field_alias="has a FLOAT range domain",
field_domain="float_field_range_domain")
# -----------------------------------------------------------------------------------
domain_name = "double_field_coded_domain"
arcpy.CreateDomain_management(
in_workspace=fgdb_path,
domain_name=domain_name,
domain_description="uses a coded DOUBLE domain",
field_type="DOUBLE",
domain_type="CODED")
double_field_coded_domain_dict = {
2.2: "one decimal place",
2.00000000001: "10 decimal places",
2.00000000000000000002: "20 decimal places"
}
for code in double_field_coded_domain_dict:
arcpy.AddCodedValueToDomain_management(
in_workspace=fgdb_path,
domain_name=domain_name,
code=code,
code_description=double_field_coded_domain_dict[code])
arcpy.AddField_management(in_table=fc_path,
field_name="double_field_with_coded_domain",
field_type="DOUBLE",
field_alias="has a DOUBLE coded domain",
field_domain="double_field_coded_domain")
# -----------------------------------------------------------------------------------
domain_name = "double_field_range_domain"
arcpy.CreateDomain_management(
in_workspace=fgdb_path,
domain_name=domain_name,
domain_description="uses a DOUBLE range domain",
field_type="DOUBLE",
domain_type="RANGE")
arcpy.SetValueForRangeDomain_management(in_workspace=fgdb_path,
domain_name=domain_name,
min_value=1.00000000000000000001,
max_value=20000000000000000000.2)
arcpy.AddField_management(in_table=fc_path,
field_name="double_field_with_range_domain",
field_type="DOUBLE",
field_alias="has a DOUBLE range domain",
field_domain="double_field_range_domain")
# -----------------------------------------------------------------------------------
domain_name = "short_field_coded_domain"
arcpy.CreateDomain_management(
in_workspace=fgdb_path,
domain_name=domain_name,
domain_description="uses a coded SHORT domain",
field_type="SHORT",
domain_type="CODED")
short_field_coded_domain_dict = {
101: "one O one",
102: "one O two",
103: "one O three"
}
for code in short_field_coded_domain_dict:
arcpy.AddCodedValueToDomain_management(
in_workspace=fgdb_path,
domain_name=domain_name,
code=code,
code_description=short_field_coded_domain_dict[code])
arcpy.AddField_management(in_table=fc_path,
field_name="short_field_with_coded_domain",
field_type="SHORT",
field_alias="has a SHORT coded domain",
field_domain="short_field_coded_domain")
# -----------------------------------------------------------------------------------
domain_name = "short_field_range_domain"
arcpy.CreateDomain_management(
in_workspace=fgdb_path,
domain_name=domain_name,
domain_description="uses a SHORT range domain",
field_type="SHORT",
domain_type="RANGE")
arcpy.SetValueForRangeDomain_management(in_workspace=fgdb_path,
domain_name=domain_name,
min_value=1000,
max_value=2000)
arcpy.AddField_management(in_table=fc_path,
field_name="short_field_with_range_domain",
field_type="SHORT",
field_alias="has a SHORT range domain",
field_domain="short_field_range_domain")
# -----------------------------------------------------------------------------------
domain_name = "long_field_coded_domain"
arcpy.CreateDomain_management(
in_workspace=fgdb_path,
domain_name=domain_name,
domain_description="uses a coded LONG domain",
field_type="LONG",
domain_type="CODED")
long_field_coded_domain_dict = {
40000: "forty thousand",
400000: "four hundred thousand",
4000000: "four million"
}
for code in long_field_coded_domain_dict:
arcpy.AddCodedValueToDomain_management(
in_workspace=fgdb_path,
domain_name=domain_name,
code=code,
code_description=long_field_coded_domain_dict[code])
arcpy.AddField_management(in_table=fc_path,
field_name="long_field_with_coded_domain",
field_type="LONG",
field_alias="has a LONG coded domain",
field_domain="long_field_coded_domain")
# -----------------------------------------------------------------------------------
domain_name = "long_field_range_domain"
arcpy.CreateDomain_management(
in_workspace=fgdb_path,
domain_name=domain_name,
domain_description="uses a LONG range domain",
field_type="LONG",
domain_type="RANGE")
arcpy.SetValueForRangeDomain_management(in_workspace=fgdb_path,
domain_name=domain_name,
min_value=12000000,
max_value=120000000)
arcpy.AddField_management(in_table=fc_path,
field_name="long_field_with_range_domain",
field_type="LONG",
field_alias="has a LONG range domain",
field_domain="long_field_range_domain")
# -----------------------------------------------------------------------------------
domain_name = "date_field_coded_domain"
arcpy.CreateDomain_management(
in_workspace=fgdb_path,
domain_name=domain_name,
domain_description="uses a coded DATE domain",
field_type="DATE",
domain_type="CODED")
date_field_coded_domain_dict = {
"01-02-1972": "Mic's Birthday",
"09-08-1969": "Donna's Birthday",
"22-04-2002": "Annie's Birthday"
}
for code in date_field_coded_domain_dict:
arcpy.AddCodedValueToDomain_management(
in_workspace=fgdb_path,
domain_name=domain_name,
code=code,
code_description=date_field_coded_domain_dict[code])
arcpy.AddField_management(in_table=fc_path,
field_name="date_field_with_coded_domain",
field_type="DATE",
field_alias="has a DATE coded domain",
field_domain="date_field_coded_domain")
# -----------------------------------------------------------------------------------
domain_name = "date_field_range_domain"
arcpy.CreateDomain_management(
in_workspace=fgdb_path,
domain_name=domain_name,
domain_description="uses a DATE range domain",
field_type="DATE",
domain_type="RANGE")
arcpy.SetValueForRangeDomain_management(in_workspace=fgdb_path,
domain_name=domain_name,
min_value="01-01-1972",
max_value="22-04-2002")
arcpy.AddField_management(in_table=fc_path,
field_name="date_field_with_range_domain",
field_type="DATE",
field_alias="has a DATE range domain",
field_domain="date_field_range_domain")
def createUN(jsonFile, outGDB):
cfgStr = open(jsonFile, 'r', encoding='gbk').read()
unObj = json.loads(cfgStr)
unName = unObj["unName"]
# 创建un和结构网络
arcpy.env.preserveGlobalIds = True
arcpy.env.overwriteOutput = True
arcpy.CreateFileGDB_management(os.path.dirname(outGDB),
os.path.basename(outGDB))
arcpy.pt.StageUtilityNetwork(outGDB, unObj["territoryFeaCls"],
unObj["feaDS"], unName)
# Tips:尽量使用相对路径，如有工具不支持再改用绝对路径
arcpy.env.workspace = os.path.join(outGDB, unObj["feaDS"])
# 导入fieldDomains，domain是面向GDB级的物理设置
for domain in unObj["fieldDomains"]:
dName = domain["name"]
if domain.get("dtype") == "RANGE":
arcpy.CreateDomain_management(outGDB, dName,
domain.get("desc", dName),
domain.get("ftype", "SHORT"),
"RANGE")
arcpy.SetValueForRangeDomain_management(outGDB, dName,
domain['min'],
domain['max'])
continue
table = arcpy.management.CreateTable('in_memory', dName)[0] # ？[0]
arcpy.AddField_management(table, 'code', domain.get("ftype", "SHORT"))
arcpy.AddField_management(table, 'name', 'TEXT', field_length=254)
with arcpy.da.InsertCursor(table, ('code', 'name')) as cur:
for v in domain["values"]:
cur.insertRow((v["code"], v["name"]))
arcpy.TableToDomain_management(table,
'code',
'name',
outGDB,
dName,
domain.get("desc", dName),
update_option='REPLACE')
arcpy.Delete_management(table)
# 创建除了structure以外的域网络
for dnObj in unObj["domainNetworks"]:
if dnObj["name"].lower() != "structure":
arcpy.AddDomainNetwork_un(unName, dnObj["name"], dnObj["tierDef"],
dnObj["controllerType"],
dnObj.get("alias"))
# 添加TerminalConfiguration,categories,netAttributes，这些是面向整个UN级的逻辑设置
# Tips:需要先创建至少一个域网络，才能添加TerminalConfiguration
terminalConfigs = unObj.get("terminalConfigs")
if terminalConfigs:
for terminalCfg in terminalConfigs:
if terminalCfg["dir"] == "DIRECTIONAL":
arcpy.AddTerminalConfiguration_un(
unName,
terminalCfg["name"],
"DIRECTIONAL",
terminals_directional=terminalCfg["terminals"],
valid_paths=terminalCfg["paths"],
default_path=terminalCfg.get("default"))
else:
arcpy.AddTerminalConfiguration_un(
unName,
terminalCfg["name"],
"BIDIRECTIONAL",
terminals_bidirectional=terminalCfg["terminals"],
valid_paths=terminalCfg["paths"],
default_path=terminalCfg.get("default"))
# TODO: 网络分组与分层的区别?
categories = unObj.get("categories")
if categories: ## 为什么加这种判断
for category in categories:
arcpy.AddNetworkCategory_un(unName, category)
# TODO：网络属性的可选设置有什么作用？
netAttributes = unObj.get("netAttributes")
if netAttributes:
for attrib in netAttributes:
arcpy.AddNetworkAttribute_un(unName, attrib["name"],
attrib["type"], attrib.get("inline"),
attrib.get("apportionable"),
attrib.get("domain"),
attrib.get("overridable"),
attrib.get("nullable"),
attrib.get("substitution"),
attrib.get("attrToSubstitution"))
# 添加子类，创建新字段，指定属性域，指定网络属性，这些是面向Table级的物理设置
for dnObj in unObj["domainNetworks"]:
# 子类已经自动设置为ASSETGROUP字段，添加自定义值
subtypes = dnObj.get("subtypes")
if subtypes:
for subtype in subtypes:
for v in subtype["values"]:
arcpy.AddSubtype_management(subtype["feaCls"], v["code"],
v["name"])
if subtype.get("default"):
arcpy.SetDefaultSubtype_management(subtype["feaCls"],
subtype.get("default"))
# 添加自定义字段
newFields = dnObj.get("newFields")
if newFields:
for field in newFields:
length = field.get(
"length") if field["type"].upper() == "TEXT" else None
arcpy.AddField_management(field["feaCls"],
field["name"],
field["type"],
field_length=length,
field_alias=field.get("alias"))
# 为字段指定属性域
fDomains = dnObj.get("fieldDomains")
if fDomains:
for fd in fDomains:
arcpy.AssignDomainToField_management(fd["feaCls"],
fd["fieldName"],
fd["domainName"],
fd.get("subtypeCodes"))
if fd.get("default"):
arcpy.AssignDefaultToField_management(
fd["feaCls"], fd["fieldName"], fd["default"],
fd.get("subtypeCodes"))
# 为字段指定网络属性
netAttributes = dnObj.get("netAttributes")
if netAttributes:
for attribute in netAttributes:
for field in attribute["fields"]:
fc, fName = field.split("/")
fObj = arcpy.ListFields(fc, fName)
if fObj:
arcpy.SetNetworkAttribute_un(unName, attribute["name"],
dnObj["name"], fc, fName)
# 为资产指定多项配置：端子配置、分组、边连通性、角色，这些是面向资产级的逻辑设置
with open(unObj.get("assetsCSV", "not exist"), 'r', encoding='gbk') as fp:
reader = csv.reader(fp) # 读取列为列表
header = next(
reader
) # ['domainNet', 'feaCls', 'assetName', 'categories', 'terminalCfg', 'edgeConnectivity', 'roleType', 'deletionType', 'viewScale', 'splitType']
assetCfg = namedtuple('assetCfg', header)
for row in reader:
row = assetCfg(*row)
asset = row.assetName.split('/')
if row.terminalCfg:
arcpy.SetTerminalConfiguration_un(unName, row.domainNet,
row.feaCls, *asset,
row.terminalCfg)
if row.categories:
arcpy.SetNetworkCategory_un(unName, row.domainNet, row.feaCls,
*asset, row.categories)
if row.edgeConnectivity: # 边联通非空
arcpy.SetEdgeConnectivity_un(unName, row.domainNet, row.feaCls,
*asset, row.edgeConnectivity)
if row.roleType:
arcpy.SetAssociationRole_un(unName, row.domainNet, row.feaCls,
*asset, row.roleType,
row.deletionType, row.viewScale,
row.splitType)
# 创建tier，并设置子网定义，这些是面向子网级的逻辑设置
# TODO: subnetwork_field_name有什么作用？subnetDef还有很多可选设置
for dnObj in unObj["domainNetworks"]:
dnName = dnObj["name"]
if dnName.lower() != "structure":
# tierGroups
tierGroups = dnObj.get("tierGroups")
if tierGroups and dnObj["tierDef"] == "HIERARCHICAL":
for groupName in tierGroups:
arcpy.AddTierGroup_un(unName, dnName, groupName)
tiers = dnObj.get("tiers")
if tiers:
for tier in tiers:
if dnObj["tierDef"] == "HIERARCHICAL":
arcpy.AddTier_un(
unName,
dnName,
tier["name"],
tier["rank"],
topology_type="MESH",
tier_group_name=tier.get("groupName"),
subnetwork_field_name=tier["subnetField"])
else:
arcpy.AddTier_un(unName,
dnName,
tier["name"],
tier["rank"],
topology_type=tier["topo"])
arcpy.SetSubnetworkDefinition_un(
unName,
dnName,
tier["name"],
tier["disjoint"],
tier["devices"],
tier["controllers"],
tier.get("lines"),
tier.get("aggregated"),
tier.get("diagrams"),
include_barriers=tier.get("barriers"),
traversability_scope=tier.get("traverse"))
# TODO: 导入rule
arcpy.ImportRules_un(unName, "All", "E:/ArcGIS/unnet/rules.csv")
# TODO: 导入数据
# 数据导入是基于子类的，把要素类路径写入到子类中，修改了demoUN域网络的子类型值
for dnObj in unObj["domainNetworks"]:
subtypes = dnObj.get("subtypes")
if subtypes:
for subtype in subtypes:
for v in subtype["values"]:
arcpy.Append_management(subtype["path"],
subtype["feaCls"],
"NO_TEST",
subtype=v["name"])
def testdata(request):
# create a testing gdb
print("Creating test geodatabase")
testgdbpath = os.path.join(arcpy.env.scratchFolder, "arc_utils_test.gdb")
if arcpy.Exists(testgdbpath):
print("Deleting " + testgdbpath)
arcpy.Delete_management(testgdbpath)
arcpy.CreateFileGDB_management(arcpy.env.scratchFolder,
"arc_utils_test.gdb")
#add a domain for each field in testfc
ftext_dom_name = "ftext_coded"
fint_dom_name = "fint_range"
arcpy.CreateDomain_management(in_workspace=testgdbpath,
domain_name=ftext_dom_name,
domain_description="text domain",
field_type="TEXT",
domain_type="CODED")
arcpy.CreateDomain_management(in_workspace=testgdbpath,
domain_name=fint_dom_name,
field_type="SHORT",
domain_type="RANGE")
ftextDict = {"val1": "val1", "val2": "val2", "val3": "val3"}
for code in ftextDict:
arcpy.AddCodedValueToDomain_management(testgdbpath, ftext_dom_name,
code, ftextDict[code])
arcpy.SetValueForRangeDomain_management(testgdbpath, fint_dom_name, 1, 12)
print("Creating test featureclass")
sr = arcpy.SpatialReference(4326)
fc_name = 'test_fc'
fc_fields = (('ftext', 'TEXT', None, None, 20, '', 'NULLABLE',
'NON_REQUIRED', ftext_dom_name),
('fint', 'SHORT', 0, 0, 0, '', 'NULLABLE', 'NON_REQUIRED',
fint_dom_name))
fc = arcpy.CreateFeatureclass_management(testgdbpath,
fc_name,
"POINT",
spatial_reference=sr)
for fc_field in fc_fields:
arcpy.AddField_management(fc, *fc_field)
print("loading data")
records = (("val1", 4), ("val2", 7), ("val1", 10), ("val2", 4),
("val1", 7), ("val2", 9))
with arcpy.da.InsertCursor(fc, ["ftext", "fint", "SHAPE@XY"]) as cursor:
for key, val in records:
lon = 122.3 + float(random.randint(-9, 9)) / 100
lat = 47.6 + float(random.randint(-9, 9)) / 100
cursor.insertRow([key, val, (lon, lat)])
# insert a couple of rows with null
with arcpy.da.InsertCursor(fc, ["ftext", "fint", "SHAPE@XY"]) as cursor:
cursor.insertRow(["val1", None, (122.399, 47.699)])
cursor.insertRow([None, 5, (122.399, 47.699)])
result = collections.namedtuple('testdata', 'gdb, fc')
result.gdb = testgdbpath
result.fc = fc
def testdata_teardown():
arcpy.Delete_management(testgdbpath)
request.addfinalizer(testdata_teardown)
return result
try:
arcpy.CreateDomain_management(gdb, domain["name"],
domain["description"],
domain["field_type"],
domain["domain_type"])
if domain["domain_type"] == "CODED":
domainValuesDict = domain["values"]
# Loop through all the domain codes in the dictionary and add them to the domain
for code in domainValuesDict:
arcpy.AddCodedValueToDomain_management(
gdb, domain["name"], code, domainValuesDict[code])
elif domain["domain_type"] == "RANGE":
# Set the min and max values for a range domain
arcpy.SetValueForRangeDomain_management(
gdb, domain["name"], domain["min"], domain["max"])
else:
print("Unknown type of domain: " + domain["domain_type"])
except Exception as domEx:
print(domEx)
# Create the layers
layerList = layer_json["layers"]
# Create dictionary object to populate with symbols and alias for the layers
layerSymbolDict = {}
layerAliasDict = {}
for layer in layerList:
print("Creating layer: " + layer["name"])
fc_path = workspace_path + '\\' + fc_name
#SR Definition
SRDefinition="PROJCS['WGS_1984_Web_Mercator_Auxiliary_Sphere',GEOGCS['GCS_WGS_1984',DATUM['D_WGS_1984',SPHEROID['WGS_1984',6378137.0,298.257223563]],PRIMEM['Greenwich',0.0],UNIT['Degree',0.0174532925199433]],PROJECTION['Mercator_Auxiliary_Sphere'],PARAMETER['False_Easting',0.0],PARAMETER['False_Northing',0.0],PARAMETER['Central_Meridian',0.0],PARAMETER['Standard_Parallel_1',0.0],PARAMETER['Auxiliary_Sphere_Type',0.0],UNIT['Meter',1.0]];-22041257.773878 -33265068.6042249 10000;-100000 10000;-100000 10000;0.001;0.001;0.001;IsHighPrecision"
#create a gdb
arcpy.CreateFileGDB_management(current_dir, fgdb_name)
# Create the coded value domains
# You can add additional domains below
arcpy.CreateDomain_management(workspace_path, 'GNSSFixType', 'GNSSFixType', 'SHORT', 'CODED', 'DUPLICATE', 'DEFAULT')
arcpy.AddCodedValueToDomain_management(workspace_path, 'GNSSFixType', 0, 'Fix not valid')
arcpy.AddCodedValueToDomain_management(workspace_path, 'GNSSFixType', 1, 'GPS')
arcpy.AddCodedValueToDomain_management(workspace_path, 'GNSSFixType', 2, 'Differential GPS')
arcpy.AddCodedValueToDomain_management(workspace_path, 'GNSSFixType', 4, 'RTK Fixed')
arcpy.AddCodedValueToDomain_management(workspace_path, 'GNSSFixType', 5, 'RTK Float')
arcpy.CreateDomain_management(workspace_path, 'Conditions', 'Sky Conditions', 'SHORT', 'CODED', 'DUPLICATE', 'DEFAULT')
arcpy.AddCodedValueToDomain_management(workspace_path, 'Conditions', 1, 'open sky')
arcpy.AddCodedValueToDomain_management(workspace_path, 'Conditions', 2, 'partiallyobscurred<25%')
arcpy.AddCodedValueToDomain_management(workspace_path, 'Conditions', 3, 'marginallyobscurred<50%')
arcpy.AddCodedValueToDomain_management(workspace_path, 'Conditions', 4, 'highlyobscurred<75%')
arcpy.CreateDomain_management(workspace_path, "NumSatellites", "NumSatellites", "SHORT", "RANGE", "DEFAULT", "DEFAULT")
arcpy.SetValueForRangeDomain_management(workspace_path, "NumSatellites", 0, 99)
print('All done. Your fgdb was created at ' + workspace_path)
print('Your feature class is called ' + fc_name)
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")
arcpy.AddCodedValueToDomain_management(workspace, domDict, code,
code)
except:
arcpy.AddWarning("Geen domein toegevoegd! Is al aanwezig.")
# Range Domein voor de ruwheden aanmaken 0.5-1.0
arcpy.AddMessage("Domein Ruwheid aanmaken...")
try:
arcpy.CreateDomain_management(in_workspace=workspace,
domain_name="Ruwheid",
domain_description="Ruwheid",
field_type="FLOAT",
domain_type="RANGE",
split_policy="DEFAULT",
merge_policy="DEFAULT")
arcpy.SetValueForRangeDomain_management(in_workspace=workspace,
domain_name="Ruwheid",
min_value="0.5",
max_value="1.0")
except:
arcpy.AddWarning("Geen domein toegevoegd. Is al aanwezig!")
arcpy.AddWarning("\n")
#---------------------------------------------------------
#---------------------------------------------------------
# Nu de kolommen toevoegen incl. domein
#---------------------------------------------------------
for kol in Kols:
if kol[2] == "":
try:
arcpy.AddMessage("Kolom " + str(kol[0]) + " toevoegen...")
arcpy.AddField_management(VakFC, kol[0], kol[1])
except:
arcpy.AddError(
