def execute(self, report, feature):
if feature.getType().get("LID_ACCIDENTE") == None:
# Si no es la tabla de accidentes no hacenos nada
return
titularidad_accidente = feature.get("TITULARIDAD_VIA")
storePeatones = feature.getStore().getStoresRepository().getStore(
"ARENA2_PEATONES")
accidente = feature.get("ID_ACCIDENTE")
if accidente != None:
builder = ExpressionUtils.createExpressionBuilder()
expression = builder.eq(builder.variable("ID_ACCIDENTE"),
builder.constant(accidente)).toString()
fset = storePeatones.getFeatureSet(expression)
totalPeatones = fset.size()
DisposeUtils.dispose(fset)
peatonesFromFeature = feature.get("TOTAL_PEATONES")
if totalPeatones != peatonesFromFeature:
report.add(
feature.get("ID_ACCIDENTE"),
CODERR_PEATONES_NO_COINCIDEN,
"Peatones no coinciden, entidad: %s , tablas peatones: %s'."
% (str(peatonesFromFeature), str(totalPeatones)),
fixerId="AssignPeatonesFromTableFixer",
selected=True,
TOTAL_PEATONES=totalPeatones)
DisposeUtils.dispose(storePeatones)
def updatePriority():
dataManager = DALLocator.getDataManager()
ws = dataManager.getDatabaseWorkspace("ARENA2_DB")
server = ws.getServerExplorer()
accidentesParameters = server.get("ARENA2_ACCIDENTES")
dataManager = DALLocator.getDataManager()
store = dataManager.openStore(accidentesParameters.getProviderName(),
accidentesParameters)
ft = store.getDefaultFeatureType()
eft = None #store.getDefaultFeatureType().getEditable()
if not store.isEditing():
store.edit()
if eft == None:
eft = store.getDefaultFeatureType().getEditable()
#tags = attr.getTags()
#tags.set(u'report.attr.label', u"FOREING_VALUE('ESTADO_ACCIDENTE.DESCRIPCION')")
e = eft.getEditableAttributeDescriptor("HORA_ACCIDENTE")
tags = e.getTags()
tags.set(u'dal.search.attribute.priority', 1)
if eft != None:
store.update(eft)
print eft.getAttributeDescriptor("HORA_ACCIDENTE").getDefaultFormat()
print eft.getAttributeDescriptor("KM").getDefaultFormat()
print "store editing:", store.isEditing()
if store.isEditing():
store.finishEditing()
print "finish"
DisposeUtils.dispose(store)
return
def updateft():
dataManager = DALLocator.getDataManager()
ws = dataManager.getDatabaseWorkspace("ARENA2_DB")
server = ws.getServerExplorer()
accidentesParameters = server.get("ARENA2_ACCIDENTES")
dataManager = DALLocator.getDataManager()
store = dataManager.openStore(accidentesParameters.getProviderName(),
accidentesParameters)
ft = store.getDefaultFeatureType()
eft = None #store.getDefaultFeatureType().getEditable()
if ft.get("OPERACION") == None:
if not store.isEditing():
store.edit()
if eft == None:
eft = store.getDefaultFeatureType().getEditable()
add_attribute_OPERACION(eft)
if ft.get("ESTADO_ACCIDENTE") == None:
if not store.isEditing():
store.edit()
if eft == None:
eft = store.getDefaultFeatureType().getEditable()
add_attribute_ESTADO_ACCIDENTE(eft)
if eft != None:
store.update(eft)
if store.isEditing():
store.finishEditing()
DisposeUtils.dispose(store)
return
def updateFormat():
dataManager = DALLocator.getDataManager()
ws = dataManager.getDatabaseWorkspace("ARENA2_DB")
server = ws.getServerExplorer()
accidentesParameters = server.get("ARENA2_ACCIDENTES")
dataManager = DALLocator.getDataManager()
store = dataManager.openStore(accidentesParameters.getProviderName(),
accidentesParameters)
ft = store.getDefaultFeatureType()
eft = None #store.getDefaultFeatureType().getEditable()
if not store.isEditing():
store.edit()
if eft == None:
eft = store.getDefaultFeatureType().getEditable()
e = eft.getEditableAttributeDescriptor("HORA_ACCIDENTE")
e.setDefaultFormat("%tR")
e = eft.getEditableAttributeDescriptor("KM")
e.setDefaultFormat("%.3f")
if eft != None:
store.update(eft)
print eft.getAttributeDescriptor("HORA_ACCIDENTE").getDefaultFormat()
print eft.getAttributeDescriptor("KM").getDefaultFormat()
print "store editing:", store.isEditing()
if store.isEditing():
store.finishEditing()
print "finish"
DisposeUtils.dispose(store)
return
def deleteChilds(self, accidentId):
server = self.workspace.getServerExplorer()
params = server.getOpenParameters()
for tableName in ("ARENA2_CROQUIS", "ARENA2_PEATONES",
"ARENA2_PASAJEROS", "ARENA2_CONDUCTORES",
"ARENA2_VEHICULOS"):
builder = server.createSQLBuilder()
delete = builder.delete()
delete.table().database(params.getDBName()).schema(
params.getSchema()).name(tableName)
delete.where().eq(builder.column("ID_ACCIDENTE"),
builder.expression().constant(accidentId))
sql = delete.toString()
sql = """DELETE FROM "%s" WHERE ID_ACCIDENTE = '%s'""" % (
tableName, accidentId)
#gvsig.logger("deleteChilds %r" % sql)
server.execute(sql)
DisposeUtils.dispose(server)
def updateDGT():
dataManager = DALLocator.getDataManager()
ws = dataManager.getDatabaseWorkspace("ARENA2_DB")
server = ws.getServerExplorer()
accidentesParameters = server.get("ARENA2_ACCIDENTES")
dataManager = DALLocator.getDataManager()
store = dataManager.openStore(accidentesParameters.getProviderName(),
accidentesParameters)
ft = store.getDefaultFeatureType()
eft = None #store.getDefaultFeatureType().getEditable()
myfuncs = [[add_attribute_TOTAL_VICTIMAS_DGT, "TOTAL_VICTIMAS_DGT"],
[add_attribute_TOTAL_MUERTOS_DGT, "TOTAL_MUERTOS_DGT"],
[add_attribute_TOTAL_GRAVES_DGT, "TOTAL_GRAVES_DGT"],
[add_attribute_TOTAL_LEVES_DGT, "TOTAL_LEVES_DGT"],
[add_attribute_TOTAL_ILESOS_DGT, "TOTAL_ILESOS_DGT"],
[add_attribute_TOTAL_VEHICULOS_DGT, "TOTAL_VEHICULOS_DGT"],
[add_attribute_TOTAL_CONDUCTORES_DGT, "TOTAL_CONDUCTORES_DGT"],
[add_attribute_TOTAL_PASAJEROS_DGT, "TOTAL_PASAJEROS_DGT"],
[add_attribute_TOTAL_PEATONES_DGT, "TOTAL_PEATONES_DGT"],
[add_attribute_NUM_TURISMOS_DGT, "NUM_TURISMOS_DGT"],
[add_attribute_NUM_FURGONETAS_DGT, "NUM_FURGONETAS_DGT"],
[add_attribute_NUM_CAMIONES_DGT, "NUM_CAMIONES_DGT"],
[add_attribute_NUM_AUTOBUSES_DGT, "NUM_AUTOBUSES_DGT"],
[add_attribute_NUM_CICLOMOTORES_DGT, "NUM_CICLOMOTORES_DGT"],
[add_attribute_NUM_MOTOCICLETAS_DGT, "NUM_MOTOCICLETAS_DGT"],
[add_attribute_NUM_BICICLETAS_DGT, "NUM_BICICLETAS_DGT"],
[add_attribute_NUM_OTROS_VEHI_DGT, "NUM_OTROS_VEHI_DGT"]]
for addattr in myfuncs:
if ft.get(addattr[1]) == None:
if not store.isEditing():
store.edit()
if eft == None:
eft = store.getDefaultFeatureType().getEditable()
addattr[0](eft)
if eft != None:
store.update(eft)
if store.isEditing():
store.finishEditing()
DisposeUtils.dispose(store)
return
def selfConfigureCodigoINE(ws): #workspace
#ws = self.getWorkspace()
server = ws.getServerExplorer()
# Tables to configure
tables_to_configure = [
"ARENA2_DIC_INE_MUNICIPIO", "ARENA2_DIC_INE_PROVINCIA",
"ARENA2_TR_INE_PROVINCIA", "ARENA2_TR_INE_MUNICIPIO"
]
for table_to_configure in tables_to_configure:
if not server.exists(server.get(table_to_configure)):
createTableAndFill(ws, table_to_configure)
if not ws.exists(table_to_configure):
updateTableWorkspace(ws, table_to_configure)
# Fields to add
accidentesParameters = server.get("ARENA2_ACCIDENTES")
dataManager = DALLocator.getDataManager()
store = dataManager.openStore(accidentesParameters.getProviderName(),
accidentesParameters)
ft = store.getDefaultFeatureType()
eft = None #store.getDefaultFeatureType().getEditable()
if ft.get("INE_PROVINCIA") == None:
if not store.isEditing():
store.edit()
if eft == None:
eft = store.getDefaultFeatureType().getEditable()
add_attribute_INE_PROVINCIA(eft)
if ft.get("INE_MUNICIPIO") == None:
if not store.isEditing():
store.edit()
if eft == None:
eft = store.getDefaultFeatureType().getEditable()
add_attribute_INE_MUNICIPIO(eft)
if eft != None:
store.update(eft)
if store.isEditing():
store.finishEditing()
DisposeUtils.dispose(store)
def selfConfigure(self, ws):
# crear campo ID_TRAMO
server = ws.getServerExplorer()
accidentesParameters = server.get("ARENA2_ACCIDENTES")
dataManager = DALLocator.getDataManager()
store = dataManager.openStore(accidentesParameters.getProviderName(),
accidentesParameters)
ft = store.getDefaultFeatureType()
eft = None #store.getDefaultFeatureType().getEditable()
if ft.get("ID_TRAMO") == None:
if not store.isEditing():
store.edit()
if eft == None:
eft = store.getDefaultFeatureType().getEditable()
add_attribute_ID_TRAMO(eft)
if eft != None:
store.update(eft)
if store.isEditing():
store.finishEditing()
DisposeUtils.dispose(store)
return
def execute(self, report, feature):
if feature.getType().get("LID_ACCIDENTE") == None:
# Si no es la tabla de accidentes no hacenos nada
return
titularidad_accidente = feature.get("TITULARIDAD_VIA")
storeVehiculos = feature.getStore().getStoresRepository().getStore(
"ARENA2_VEHICULOS")
accidente = feature.get("ID_ACCIDENTE")
if accidente != None:
## Rellenar por campos de la feature
# Mantiene el none
# no es lo mismo que llegue un None
# a que se confirme porque no tiene valores en la tabla
# de vehiculos con que es 0
conteoPorFeature = {
'NUM_TURISMOS': None,
'NUM_FURGONETAS': None,
'NUM_CAMIONES': None,
'NUM_AUTOBUSES': None,
'NUM_CICLOMOTORES': None,
'NUM_MOTOCICLETAS': None,
'NUM_BICICLETAS': None,
'NUM_OTROS_VEHI': None
}
for key in conteoPorFeature.keys():
value = feature.get(key)
conteoPorFeature[key] = value
## Conteo por la tabla asociada de vehiculos
builder = ExpressionUtils.createExpressionBuilder()
expression = builder.eq(builder.variable("ID_ACCIDENTE"),
builder.constant(accidente)).toString()
#fset = storeVehiculos.getFeatureSet(expression)
conteoPorTablas = {
'NUM_TURISMOS': 0,
'NUM_FURGONETAS': 0,
'NUM_CAMIONES': 0,
'NUM_AUTOBUSES': 0,
'NUM_CICLOMOTORES': 0,
'NUM_MOTOCICLETAS': 0,
'NUM_BICICLETAS': 0,
'NUM_OTROS_VEHI': 0
}
fset = storeVehiculos.getFeatureSet(expression).iterable()
for f in fset:
tipoVehiculo = f.get("TIPO_VEHICULO")
keyValue = self.getKeyFromTypeVehicle(tipoVehiculo)
if keyValue != None:
conteoPorTablas[keyValue] += 1
DisposeUtils.dispose(fset)
DisposeUtils.dispose(storeVehiculos)
toReport = False
builder = StringBuilder()
for key in conteoPorTablas.keys():
if conteoPorTablas[key] != conteoPorFeature[key]:
if toReport:
builder.append(", ")
toReport = True
builder.append(key + " valor:" +
str(conteoPorFeature[key]) +
" correccion:" + str(conteoPorTablas[key]))
if toReport:
report.add(
feature.get("ID_ACCIDENTE"),
CODERR_VEHICULOS_NO_COINCIDEN,
"Vehiculos no coinciden: %s." % (builder.toString(), ),
fixerId="UpdateCountVehicles",
selected=True,
NUM_TURISMOS=conteoPorTablas['NUM_TURISMOS'],
NUM_FURGONETAS=conteoPorTablas['NUM_FURGONETAS'],
NUM_CAMIONES=conteoPorTablas['NUM_CAMIONES'],
NUM_AUTOBUSES=conteoPorTablas['NUM_AUTOBUSES'],
NUM_CICLOMOTORES=conteoPorTablas['NUM_CICLOMOTORES'],
NUM_MOTOCICLETAS=conteoPorTablas['NUM_MOTOCICLETAS'],
NUM_BICICLETAS=conteoPorTablas['NUM_BICICLETAS'],
NUM_OTROS_VEHI=conteoPorTablas['NUM_OTROS_VEHI'])
def run(self):
try:
self.__count = 0
count_files = 0
title = self.status.getTitle()
repo = self.workspace.getStoresRepository()
accidentesStore = repo.getStore("ARENA2_ACCIDENTES")
if self.expressionFilter != None and not self.expressionFilter.isEmpty():
fsetAccidentes = accidentesStore.getFeatureStore().getFeatureSet(self.expressionFilter)
else:
fsetAccidentes = accidentesStore.getFeatureStore().getFeatureSet() ### SET FILTER
count = fsetAccidentes.getSize()
n = 0
self.status.message("Comprobando accidentes (%s)..." % "Accidentes")
self.status.setRangeOfValues(0,count)
self.status.setCurValue(0)
for feature in fsetAccidentes:
n+=1
self.status.setTitle("%s (%d/%d)" % (title, n, count))
rules = self.rules
# Regla para Accidentes
for rule in rules:
if rule != None:
#print "Feature: ", feature.get("ID_ACCIDENTE"), "Rule:", rule.getName(), "\n"
rule.execute(self.report, feature)
self.__count += 1
self.status.incrementCurrentValue()
# Regla por las tablas principales
mainTables = {"ARENA2_CONDUCTORES",
"ARENA2_PASAJEROS",
"ARENA2_PEATONES",
"ARENA2_VEHICULOS"}
idAccidente = feature.get("ID_ACCIDENTE")
for mainTable in mainTables:
storeToValidate = repo.getStore(mainTable)
#print "storeToValidate:", storeToValidate
fset = storeToValidate.getFeatureSet("ID_ACCIDENTE='%s'" % idAccidente)
#print "check child table: ", fset.getSize(), " over ", idAccidente
if fset!=None and fset.getSize()>0:
for feature in fset:
for rule in rules:
if rule != None:
rule.execute(self.report, feature)
DisposeUtils.disposeQuietly(fset)
DisposeUtils.dispose(storeToValidate)
storeToValidate = None
self.status.message("Comprobacion completada")
DisposeUtils.disposeQuietly(fsetAccidentes)
self.status.terminate()
for action in self.__actions:
action(self)
except java.lang.Throwable, ex:
logger("Error validando accidentes.", LOGGER_WARN, ex)
self.status.message("Error validando accidentes (%s)" % "Accidentes")
self.status.abort()
raise ex
except java.lang.Throwable, ex:
storeAccidentes.cancelEditing()
logger("Error transformando accidentes.", LOGGER_WARN, ex)
self.status.message("Error transformando accidentes (%s)")
self.status.abort()
raise ex
except:
storeAccidentes.cancelEditing()
ex = sys.exc_info()[1]
logger("Error transformando accidentes. " + str(ex), gvsig.LOGGER_WARN, ex)
self.status.message("Error transformando accidentes (%s)")
finally:
if storeAccidentes!= None:
storeAccidentes.finishEditing()
DisposeUtils.dispose(storeAccidentes)
class PostUpdateProcess(Runnable):
def __init__(self, importManager, workspace, report, status=None):
self.importManager = importManager
if status == None:
self.status = self.importManager.createStatus()
else:
self.status = status
self.workspace = workspace
self.report = report
self.__count = 0
self.__actions = list()
def add(self, action):
def run(self):
repo = self.workspace.getStoresRepository()
try:
self.__count = 0
count_files = 0
title = self.status.getTitle()
for fname in self.files:
self.status.setTitle("%s (%d/%d)" %
(title, count_files, len(self.files)))
count_files += 1
fname_tail = os.path.sep.join(fname.split(os.path.sep)[-3:])
input_store = self.openStore(fname)
if input_store == None:
self.status.abort()
return
children = input_store.getChildren()
count = 0
for name in children.keySet():
sourceStore = children.get(name)
count += sourceStore.getFeatureCount()
DisposeUtils.dispose(sourceStore)
self.status.setRangeOfValues(0, count)
self.status.setCurValue(0)
name = "ARENA2_ACCIDENTES"
self.status.message("Importando %s (%s)..." %
(name, fname_tail))
#print "Import "+name+"..."
#sourceStore = input_store
targetStore = (repo.getStore(name), repo.getStore(name))
self.copyTableAccidentes(input_store, targetStore)
DisposeUtils.dispose(targetStore[0])
DisposeUtils.dispose(targetStore[1])
for name in children.keySet():
self.status.message("Importando %s (%s)..." %
(name, fname_tail))
#print "Import "+name+"..."
sourceStore = children.get(name)
targetStore = repo.getStore(name)
if name == "ARENA2_INFORMES":
self.copyTableInformes(sourceStore, targetStore)
else:
self.copyTable(sourceStore, targetStore)
DisposeUtils.dispose(sourceStore)
DisposeUtils.dispose(targetStore)
DisposeUtils.dispose(input_store)
input_store = None
self.status.message("Creacion completada")
self.status.terminate()
for action in self.__actions:
action(self)
except java.lang.Exception, ex:
logger("Error importando accidentes.", LOGGER_WARN, ex)
self.status.abort()
def run(self):
fname = "???"
try:
self.__count = 0
count_files = 0
title = self.status.getTitle()
for fname in self.files:
self.status.setTitle("%s (%d/%d)" %
(title, count_files, len(self.files)))
count_files += 1
fname_tail = os.path.sep.join(fname.split(os.path.sep)[-3:])
self.input_store = self.openStore(fname)
# TODO
#Si el featureType tiene tags de errores de valores no encontrados
#
tags = self.input_store.getDefaultFeatureType().getTags()
if tags.get("notSupportedKeys") != None:
print "Tags new found: ", tags
#
if self.input_store == None:
self.status.abort()
return
count = self.input_store.getFeatureCount()
self.status.setRangeOfValues(0, count)
self.status.setCurValue(0)
rules = self.rules
self.status.message("Comprobando accidentes (%s)..." %
fname_tail)
input_features = self.input_store.iterator()
for feature in input_features:
for rule in rules:
if rule != None:
rule.execute(self.report, feature)
self.__count += 1
self.status.incrementCurrentValue()
DisposeUtils.disposeQuietly(input_features)
children = self.input_store.getChildren()
count = 0
for name in children.keySet():
childStore = children.get(name)
if childStore == None:
continue
fset = childStore.iterator()
for feature in fset:
for rule in rules:
if rule != None:
rule.execute(self.report, feature)
DisposeUtils.disposeQuietly(fset)
DisposeUtils.dispose(childStore)
self.input_store.dispose()
self.input_store = None
self.status.message("Comprobacion completada")
self.status.terminate()
for action in self.__actions:
action(self)
except java.lang.Throwable, ex:
logger("Error validando accidentes.", LOGGER_WARN, ex)
self.status.message("Error validando accidentes (%s)" % fname)
self.status.abort()
raise ex