def setUpClass(cls):
tool = PythonTool()
parameters = tool.getParameterInfo()
params = tool.processParameters(parameters=parameters)
out_f = params["connection_folder"]
out_n = params["edit_connection_name"]
plat = params["platform"]
inst = params["instance"]
cls.weaver_attributes = params["table_attributes"]
edit_version_name = params["edit_version_name"]
sql_table = params["sql_table"]
gdb_table = params["gdb_table"]
gdb_table_name = params["gdb_table_name"]
opt = params["opt"]
cls.sde_file = params["gis_gdb"]
manager = Manager(opt=opt, connection_folder=out_f, target_sde=cls.sde_file,
new_version=edit_version_name, new_connection=out_n, platform=plat, instance=inst)
manager.clean_previous()
cls.version_sde_file = manager.connect_version()
result = Tool.compare_tables(sql_table=sql_table, gdb_table=gdb_table)
cls.match_fields = result["match_fields"]
cls.add_rows = result["add_rows"]
cls.exist_rows = result["exist_rows"]
cls.folio_ids = result["folioIds"]
env.workspace = cls.version_sde_file
cls.editor = da.Editor(cls.version_sde_file)
cls.version_gdb_table = arcpy.ListTables("*{}*".format(gdb_table_name))[0]
def setUp(self):
params = self.params
out_f = self.out_f
out_n = self.out_n
plat = self.plat
inst = self.inst
edit_version_name = self.edit_version_name
opt = self.opt
self.manager = Manager(opt=opt, connection_folder=out_f, target_sde=self.sde_file,
new_version=edit_version_name, new_connection=out_n,
platform=plat, instance=inst)
class TestVersionManager(TestCase):
@classmethod
def setUpClass(cls):
tool = PythonTool()
parameters = tool.getParameterInfo()
params = tool.process_parameters(parameters=parameters)
cls.out_f = params["connection_folder"]
cls.out_n = params["edit_connection_name"]
cls.plat = params["platform"]
cls.inst = params["instance"]
cls.opt = params["opt"]
cls.sde_file = params["gis_gdb"]
cls.edit_version_name = params["edit_version_name"]
cls.params = params
def setUp(self):
params = self.params
out_f = self.out_f
out_n = self.out_n
plat = self.plat
inst = self.inst
edit_version_name = self.edit_version_name
opt = self.opt
self.manager = Manager(opt=opt, connection_folder=out_f, target_sde=self.sde_file,
new_version=edit_version_name, new_connection=out_n,
platform=plat, instance=inst)
def tearDown(self):
self.manager = None
@classmethod
def tearDownClass(cls):
try:
cls.params = None
os.remove(cls.version_sde)
except:
pass
def test_clean_previous(self):
result = self.manager.clean_previous()
self.assertTrue(result)
def test_connect_version(self):
out_f = self.out_f
edit_version_name = self.edit_version_name
self.version_sde = self.manager.connect_version()
self.assertEqual("{}\\{}.sde".format(out_f, edit_version_name), self.version_sde)
os.remove(self.version_sde)
def test_rec_post(self):
self.manager.clean_previous()
self.manager.connect_version()
result = self.manager.rec_post()
self.assertTrue(result)
def execute(self, parameters, messages):
"""The method calls classes defined in external files."""
arcpy.AddMessage("WeaverGDBUpdate.execute()")
params = self.process_parameters(parameters=parameters)
connection_folder = params["connection_folder"]
platform = params["platform"]
instance = params["instance"]
sde_file = params["gis_gdb"]
table_db = params["table_db"]
bldgs = params["bldgs"]
sql_table = params["sql_table"]
gdb_table = params["gdb_table"]
gdb_table_name = params["gdb_table_name"]
buildings_name = params["buildings_name"]
edit_connection_name = params["edit_connection_name"]
edit_version_name = params["edit_version_name"]
building_attributes = params["building_attributes"]
weaver_attributes = params["weaver_attributes"]
opt = params["opt"]
try:
# These values need to be removed when the user parameters are created
result = UpdateNoiseMitSDE.compare_tables(sql_table=sql_table, gdb_table=gdb_table)
compare_result = result["compare_result"]
folioIds = result["folioIds"]
match_fields = result["match_fields"]
add_rows = result["add_rows"]
exist_rows = result["exist_rows"]
# compare result if True means that changes need to be made to the GDB Table and thus the Buildings
if compare_result:
arcpy.AddMessage({"# rows to add": len(add_rows),
"# rows to remove": len(exist_rows)})
# create VersionManager class object to create new version, connect to it,
# and create an sde connection file, set as current workspace
version_manager = VersionManager(opt, connection_folder, sde_file, edit_version_name, edit_connection_name, platform, instance)
version_manager.clean_previous()
version_sde_file = version_manager.connect_version()
if os.path.exists(version_sde_file):
arcpy.AddMessage(version_sde_file)
else:
raise Exception("version_sde_file not created")
editor = da.Editor(version_sde_file)
editor.startEditing()
env.workspace = version_sde_file
gdb_table = arcpy.ListTables("*{}*".format(gdb_table_name))[0]
if arcpy.Exists(gdb_table):
# create GDBTableUpdater class object
weaver_updater = GDBTableUpdater(weaver_attributes, folioIds, match_fields, gdb_table, add_rows, exist_rows,
version_sde_file, editor)
# should return True when editing is complete
table_updated = weaver_updater.perform_update()
# create BuildingUpdater class object
version_buildings = self.get_versioned_fc(version_sde_file, buildings_name)
if arcpy.Exists(version_buildings):
try:
building_updater = BuildingsUpdater(folioIds, version_buildings, gdb_table, building_attributes,
weaver_attributes, version_sde_file, editor)
# should return True when editing it complete
buildings_updated = building_updater.update_buildings()
editor.stopEditing(True)
del editor
try:
version_manager.rec_post()
except Exception as e:
arcpy.AddError("Exception occurred during the rec/post operation, " +
"the edits were saved in the version however the version will be removed without the " +
"edits having been posted to the default version :: {} :: {}".format(e.message,
traceback.print_exc()))
except Exception as e:
editor.stopEditing(False)
del editor
arcpy.AddError("Exception occured during buildings updates, edits have not been saved :: {}"\
":: {}".format(e.message, traceback.print_exc()))
else:
editor.stopEditing(False)
del editor
arcpy.AddError("Unable to determine the buildings feature class\
using the version connection")
else:
editor.stopEditing(False)
del editor
arcpy.AddError("Unable to determine the gdb table\
using the version connection")
version_manager.clean_previous()
del version_manager
# Verify that the edits where posted
# TODO- determine failproof methods for isolating the changed features and viewing the change
env.workspace = sde_file
fields = [x for x in building_attributes.itervalues()]
cursor = da.SearchCursor(bldgs, fields,
"{} in ('{}')".format(building_attributes["Folio Number"], "','".join(folioIds)))
try:
values = cursor.next()
arcpy.AddMessage("This is an edited row in the buildings table :: {}".format(values))
except StopIteration:
arcpy.AddMessage("No buildings found with folioIDs in {}".format(folioIds))
del cursor
else:
arcpy.AddMessage("The files are identical, no edits needed")
return True
except:
exc_type, exc_value, exc_traceback = sys.exc_info()
arcpy.AddError(repr(traceback.format_exception(exc_type, exc_value, exc_traceback)))
