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 geocodificar(fecha, carretera, pk):
if fecha == None or carretera == None or pk == None:
return (None, None, "Fecha%s, carretera%s o pk%s nulo" % (
iif(fecha==None, "*",""),
iif(carretera==None, "*",""),
iif(pk==None, "*","")
)
)
strechesStore = getStretchFeatureStore()
query = getVigentStretchesQuery(strechesStore, fecha)
builder = ExpressionUtils.createExpressionBuilder()
expression = builder.eq(builder.variable("matricula"), builder.constant(carretera)).toString()
#expression = "matricula = '%s'" % carretera
try:
query.addFilter(expression)
query.retrievesAllAttributes()
streches = strechesStore.getFeatureSet(query).iterable()
if streches.isEmpty():
return (None, None, "Carretera '%s' no encontrada" % carretera)
pk = pk * 1000
for strech in streches:
location = getLRSManager().getMPointFromGeometry(strech.getDefaultGeometry(), pk)
if location != None:
# LRS devuelve un Point2DM y falla al guardarse en la BBDD (H2 por lo menos)
location = GeometryUtils.createPoint(location.getX(), location.getY())
return (location, strech, None)
return (None, None, "kilometro %s no encontrado en '%s'." % (pk,carretera))
finally:
DisposeUtils.disposeQuietly(streches)
def geocodificar(fecha, carretera, pk):
if fecha == None or carretera == None or pk == None:
return (None, "Fecha, carretera o pk nulo")
strechesStore = getStretchFeatureStore()
query = getVigentStretchesQuery(strechesStore, fecha)
expression = "matricula = '%s'" % carretera
try:
query.addFilter(expression)
query.retrievesAllAttributes()
streches = strechesStore.getFeatureSet(query)
if len(streches) < 1:
return (None, "Carretera '%s' no encontrada" % carretera)
for strech in streches:
location = getLRSManager().getMPointFromGeometry(
strech.getDefaultGeometry(), pk)
if location != None:
# LRS devuelve un Point2DM y falla al guardarse en la BBDD (H2 por lo menos)
location = GeometryUtils.createPoint(location.getX(),
location.getY())
return (location, None)
return (None, "kilometro %s no encontrado en '%s'." % (pk, carretera))
finally:
DisposeUtils.disposeQuietly(streches)
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 calcularArea(currentView, currentLayer):
area = 0
if currentView != None:
if currentLayer != None:
features = currentLayer.features() # Entidades
message = ""
if features != None:
try:
polygonsLayer = currentLayer
polygonFeatures = polygonsLayer.features()
for polygonFeature in polygonFeatures:
area += polygonFeature.geometry().area()
area = area * 10000 # area *10000 para obtener el area en kilometros cuadrados
except:
ex = sys.exc_info()[1] # Captura de excepciones
message = ex.__class__.__name__ + " - " + str(ex)
finally:
DisposeUtils.disposeQuietly(
features) # Liberacion de recursos
if message != "":
title = "Error"
messageType = commonsdialog.FORBIDEN
root = None
commonsdialog.msgbox(message, title, messageType, root)
else:
message = "En la vista actual no hay seleccionada ninguna capa, debe seleccionar una capa."
title = "Error: se debe seleccionar una capa"
messageType = commonsdialog.FORBIDEN
root = None
commonsdialog.msgbox(message, title, messageType, root)
else:
message = "No se encuentra ninguna vista para comenzar a trabajar"
title = "Error: sin vista"
messageType = commonsdialog.FORBIDEN
root = None
commonsdialog.msgbox(message, title, messageType, root)
return area
def processExportImage(featureSet,
field,
formatName,
outparams,
taskStatus=None):
if not formatName in ["PNG", "JPEG", "GIF"]:
logger("Not valid format for export images", LOGGER_ERROR)
return
sm = ToolsSwingLocator.getToolsSwingManager()
si = sm.createSimpleImage()
if taskStatus != None:
taskStatus.setRangeOfValues(0, featureSet.getSize())
if isinstance(field, FeatureAttributeDescriptor):
field = field.getName()
try:
ooption = outparams["option"]
oparams = outparams["params"]
n = 0
if ooption == 1:
for f in featureSet:
if taskStatus != None:
n += 1
taskStatus.setCurValue(n)
if taskStatus.isCancellationRequested():
return
value = f.get(field)
if value == None or value == "":
continue
si.set(value)
im = si.getBufferedImage()
if im == None:
logger(
"Not able to get Bufferded Image from field " +
str(field) + " value:" + str(value), LOGGER_ERROR)
continue
# Save image
ofield = oparams["field"]
if isinstance(ofield, FeatureAttributeDescriptor):
ofield = ofield.getName()
output = f.get(ofield)
ImageIO.write(im, formatName, output)
elif ooption == 2:
for f in featureSet:
if taskStatus != None:
n += 1
taskStatus.setCurValue(n)
if taskStatus.isCancellationRequested():
return
value = f.get(field)
if value == None or value == "":
continue
si.set(value)
im = si.getBufferedImage()
if im == None:
logger(
"Not able to get Bufferded Image from field " +
str(field) + " value:" + str(value), LOGGER_ERROR)
continue
ofield = oparams["field"]
if isinstance(ofield, FeatureAttributeDescriptor):
ofield = ofield.getName()
oname = f.get(ofield)
if oname == None or oname == "": continue
outputPath = oparams["path"].getAbsolutePath()
output = getUniqueValueFileByField(oname, outputPath,
formatName)
ImageIO.write(im, formatName, output)
elif ooption == 3:
s = ExpressionEvaluatorLocator.getManager().createSymbolTable()
fst = DALLocator.getDataManager().createFeatureSymbolTable()
s.addSymbolTable(fst)
exp = oparams["expression"]
if exp.isEmpty():
logger("Expression is empty", LOGGER_ERROR)
return
for f in featureSet:
if taskStatus != None:
n += 1
taskStatus.setCurValue(n)
if taskStatus.isCancellationRequested():
return
value = f.get(field)
if value == None or value == "":
continue
si.set(value)
im = si.getBufferedImage()
fst.setFeature(f)
output = exp.execute(s)
outputex = output + "." + formatName.lower()
if os.path.exists(outputex):
logger("Already exists: " + outputex, LOGGER_ERROR)
continue
ImageIO.write(im, formatName, File(outputex))
except:
ex = str(sys.exc_info()[1])
logger(
"Not able to export: " + ex + " caused on: " +
ex.__class__.__name__, LOGGER_ERROR)
try:
DisposeUtils.disposeQuietly(featureSet)
except:
logger("Not able dispose export images feature set", LOGGER_ERROR)
def calcularArea(currentView, currentLayer):
# Ejemplo de inputbox
message = "Ingrese el valor del " + unichr(
225) + "rea de referencia en km2"
title = "Ingreso de datos"
messageType = commonsdialog.QUESTION
root = None
currentProject = gvsig.currentProject() # Proyecto actual
# Vista actual
print "Vista actual:", currentView
# Capas
print "Capas de la vista actual:"
if currentView != None:
currentViewLayers = currentView.getLayers()
for currentViewLayer in currentViewLayers:
print " ", currentViewLayer
# Capa actual
print "Sumatory of all of the areas in the polygon layer: ", currentLayer
valorReferencia = float(
commonsdialog.inputbox(message, title, messageType, root))
print "valor Referencia: ", valorReferencia
area = 0
if currentView != None:
if currentLayer != None:
polygonsLayer = currentLayer
# Creamos esquema con el tipo de geometria correspondiente
schema = polygonsLayer.getSchema()
newSchema = createSchema(schema)
# Creamos la capa nueva con el nuevo esquema
newPolygonsLayer = createShape(newSchema)
newPolygonsLayer.edit()
features = currentLayer.features() # Entidades
message = ""
if features != None:
try:
polygonFeatures = polygonsLayer.features()
contador = 0
for polygonFeature in polygonFeatures:
area += polygonFeature.geometry().area()
#print("area: ",area)
polygon = dict()
for field in schema:
#print "prueba: "+str(field.getDataTypeName())
if str(field.getDataTypeName()) != "Double":
polygon[field.getName()] = polygonFeature.get(
field.getName())
else:
polygon[field.getName()] = long(
polygonFeature.get(field.getName()))
tempArea = polygonFeature.geometry().area() * 1000
if tempArea > valorReferencia:
newPolygonsLayer.append(polygon)
contador = contador + 1
#newfeature = self.createNewFeature(output_store, polygonFeature)
#newfeature["GEOMETRY"] = polygon
#output_store.insert(newfeature)
area = area * 10000 # area *10000 para obtener el area en kilometros cuadrados
#self.addOutputText("OutputText", "Area: ")
#self.addOutputNumericalValue("OutputNumerical", "area")
newPolygonsLayer.commit()
newPolygonsLayer.setName("Capa de poligonos mayores")
currentView.addLayer(newPolygonsLayer)
except:
ex = sys.exc_info()[1] # Captura de excepciones
message = ex.__class__.__name__ + " - " + str(ex)
finally:
DisposeUtils.disposeQuietly(
features) # Liberacion de recursos
if message != "":
title = "Error"
messageType = commonsdialog.FORBIDEN
root = None
commonsdialog.msgbox(message, title, messageType, root)
else:
mensajeCartel(
"En la vista actual no hay seleccionada ninguna capa, debe seleccionar una capa.",
"Error: se debe seleccionar una capa", commonsdialog.FORBIDEN)
else:
mensajeCartel("No se encuentra ninguna vista para comenzar a trabajar",
"Error: sin vista", commonsdialog.FORBIDEN)
return area
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 updateRealField(self, columnSelectedDescriptor, store, exp, expFilter,
useFilterType, dialog, prefs):
i18nManager = ToolsLocator.getI18nManager()
try:
ftype = store.getDefaultFeatureType()
s = ExpressionEvaluatorLocator.getManager().createSymbolTable()
fst = DALLocator.getDataManager().createFeatureSymbolTable()
s.addSymbolTable(fst)
store.edit()
#store.beginComplexNotification() #beginEditingGroup("field-calculator-update")
# Create fset
if useFilterType == 0:
fset = store.getSelection()
if store.getSelection().getSize() == 0:
logger("Selection is empty", LOGGER_WARN)
self.taskStatus.message(
i18nManager.getTranslation("_Selection_is_empty"))
return
elif useFilterType == 1:
if expFilter != None and not expFilter.isPhraseEmpty(
) and not expFilter.isEmpty():
fq = store.createFeatureQuery()
fq.addFilter(expFilter)
fq.retrievesAllAttributes()
fset = store.getFeatureSet(fq)
else:
fset = store.getFeatureSet()
else:
fset = store.getFeatureSet()
# set taskstatus
self.taskStatus.setRangeOfValues(0, fset.getSize())
self.taskStatus.setCurValue(0)
self.taskStatus.add()
# Limit of changes before commit
limit = prefs["limit_rows_in_memory"]
# Update features
for f in fset:
if self.taskStatus.isCancellationRequested():
break
fst.setFeature(f)
v = exp.execute(s) # value de la expression
c = f.getEditable()
c.set(columnSelectedDescriptor.getName(), v)
fset.update(c)
#if commitingMode:
if limit != -1 and self.store.getPendingChangesCount() > limit:
fset.commitChanges()
#self.taskStatus.setCurValue(count)
self.taskStatus.incrementCurrentValue()
except:
ex = sys.exc_info()[1]
#ex.__class__.__name__, str(ex)
logger("Exception updated features: " + str(ex), LOGGER_ERROR)
finally:
#store.endEditingGroup()
try:
DisposeUtils.disposeQuietly(fset)
except:
logger("Not able to dispone fset", LOGGER_ERROR)
if self.modeExitTool:
try:
store.finishEditing()
except:
logger("Not able to save store changes", LOGGER_ERROR)
try:
store.cancelEditing()
except:
logger("Not able to cancel editing", LOGGER_ERROR)
if self.editingMode:
try:
store.edit()
except:
logger("Not able to put store into editing mode",
LOGGER_ERROR)
else:
logger("Field Calculator Tool expression applied", LOGGER_INFO)
if self.editingMode == False:
try:
store.finishEditing()
except:
logger("Not able to puto layer into editing again",
LOGGER_ERROR)
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
def processImportFields(tableTarget,
fieldTarget,
tableSource,
fieldSource,
data,
translator,
taskStatus=None):
### Init processimportfields"
# Update ft
#translator = NamesTranslator.createTrimTranslator(11)
storeTarget = tableTarget.getFeatureStore()
storeSource = tableSource.getFeatureStore()
ftTarget = storeTarget.getDefaultFeatureType()
ftSource = storeSource.getDefaultFeatureType()
#Names translator init
#for attr in ftTarget:
# translator.addSource(attr.getName())
#
if storeTarget == storeSource:
logger("Can't use same store for import tables", LOGGER_ERROR)
return
# Checks
## Ningun del nombre de los campos nuevos usados existe ya en la tabla previa
for d in data:
used = ftTarget.getAttributeDescriptor(d['idname'])
if used != None:
logger("Field " + d['idname'] + " already created in table",
LOGGER_ERROR)
return
# Process
newftTarget = gvsig.createFeatureType(ftTarget)
newftSource = gvsig.createFeatureType(ftSource)
for d in data:
name = d["idfield"]
descriptor = newftSource.getEditableAttributeDescriptor(name)
newname = d["idname"]
descriptor.setName(newname)
newftTarget.addLike(descriptor)
try:
storeTarget.edit()
storeTarget.update(newftTarget)
storeTarget.commit()
except:
logger("Not able to update feature type", LOGGER_ERROR)
return
# Update values
storeTarget.edit()
fsetSource = tableSource.getFeatureStore().getFeatureSet()
if taskStatus != None:
taskStatus.setRangeOfValues(0, fsetSource.getSize())
taskStatus.setCurValue(0)
taskStatus.add()
for fSource in fsetSource:
if taskStatus != None and taskStatus.isCancellationRequested():
break
if taskStatus != None:
taskStatus.incrementCurrentValue()
# QUERY
builder = storeTarget.createExpressionBuilder()
## Eq expression
expFilter = builder.eq(builder.column(fieldTarget),
builder.constant(
fSource.get(fieldSource))).toString()
exp = ExpressionEvaluatorLocator.getManager().createExpression()
exp.setPhrase(expFilter)
evaluator = DALLocator.getDataManager().createExpresion(exp)
#filterValue = str(field2)+"="+str(fTarget.get(fieldTarget))
fqTarget = storeTarget.createFeatureQuery()
fqTarget.setFilter(evaluator)
#for d in data: #need al attributos to get editable valid
# if not ftSource.getAttributeDescriptor(d["idfield"]).isReadOnly():
# fq1.addAttributeName(d["idname"])
#defaultGeometry = ftTarget.getDefaultGeometryAttributeName()
#fqTarget.addAttributeName(defaultGeometry)
fqTarget.retrievesAllAttributes()
# UPDATE VALUES
fsetTarget = storeTarget.getFeatureSet(fqTarget)
for ftTarget in fsetTarget:
efTarget = ftTarget.getEditable()
for d in data:
if newftTarget.getAttributeDescriptor(
d["idname"]).isReadOnly():
#logger("Field is read only", LOGGER_WARN)
continue
value = fSource.get(d["idfield"])
efTarget.set(d["idname"], value)
fsetTarget.update(efTarget)
if storeTarget.canCommitChanges(
) and storeTarget.getPendingChangesCount() > 100000:
storeTarget.commitChanges()
storeTarget.commit()
try:
pass
except:
ex = sys.exc_info()[1]
logger("Not able to update features value: " + str(ex), LOGGER_ERROR)
try:
DisposeUtils.disposeQuietly(fsetTarget)
DisposeUtils.disposeQuietly(fsetSource)
store1.cancelEditing()
except:
logger("Not able to cancel editing", LOGGER_ERROR)
finally:
DisposeUtils.disposeQuietly(fsetTarget)
DisposeUtils.disposeQuietly(fsetSource)