def transformMun(self, feature):
try:
if feature.get("COD_MUNICIPIO") == None:
return
mun = feature.get("COD_MUNICIPIO")
storeM = self.repo.getStore("ARENA2_TR_INE_MUNICIPIO")
#munOptions=mun.split("/")
#munOptions.append(mun)
#for j in munOptions:
builder = ExpressionUtils.createExpressionBuilder()
expression = builder.eq(
builder.lower(builder.variable("MUNICIPIO")),
builder.lower(builder.constant(mun))).toString()
munData = storeM.findFirst(expression)
if munData == None:
logger(
"El municipio " + mun +
" no se encuentra en la tabla ARENA2_TR_INE_MUNICIPIO",
LOGGER_INFO)
else:
feature.set("INE_MUNICIPIO", munData.get("MUN_INE"))
logger(
"El municipio " + mun + " actualizado con: " +
str(munData.get("MUN_INE")), LOGGER_INFO)
storeM.dispose()
except:
ex = sys.exc_info()[1]
logger("Error importando archivos." + str(ex), gvsig.LOGGER_WARN,
ex)
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 transformProv(self, feature):
try:
if feature.get("COD_PROVINCIA") == None:
return
prov = feature.get("COD_PROVINCIA")
storeP = self.repo.getStore("ARENA2_TR_INE_PROVINCIA")
provOptions = prov.split("/")
provOptions.append(prov)
for i in provOptions:
builder = ExpressionUtils.createExpressionBuilder()
expression = builder.eq(
builder.lower(builder.variable("PROVINCIA")),
builder.lower(builder.constant(i))).toString()
provData = storeP.findFirst(expression)
if provData == None:
logger(
"La provincia " + i +
" no se encuentra en la tabla ARENA2_TR_INE_PROVINCIA",
LOGGER_INFO)
continue
feature.set("INE_PROVINCIA", provData.get("PROV_INE"))
break
storeP.dispose()
except:
ex = sys.exc_info()[1]
logger("Error importando archivos." + str(ex), gvsig.LOGGER_WARN,
ex)
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")
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 findOwnership(fecha, carretera, pk):
if fecha == None or carretera == None or pk == None:
return None
strechesStore = getStretchFeatureStore()
query = getVigentStretchesQuery(strechesStore, fecha)
pk = pk * 1000
builder = ExpressionUtils.createExpressionBuilder()
builder.and( builder.eq(builder.variable("matricula"), builder.constant(carretera)))
builder.and( builder.le(builder.variable("pk_i"), builder.constant(pk)))
builder.and( builder.ge(builder.variable("pk_f"), builder.constant(pk)))
expression = builder.toString()
#expression = "matricula = '%s' and pk_i >= %s and pk_f <= %s" % (carretera, pk, pk)
query.addFilter(expression)
query.retrievesAllAttributes()
feature = strechesStore.findFirst(query)
#DisposeUtils.disposeQuietly(strechesStore)
if feature == None:
return None
return feature.get("titularidad")
def main(*args):
from java.util import Date
fecha = Date()
builder = ExpressionUtils.createExpressionBuilder()
print builder.and(
builder.group( builder.or(
builder.le(builder.variable("fecha_entrada"), builder.date(fecha)),
builder.is_null(builder.variable("fecha_entrada"))
)),
builder.group( builder.or(
builder.le(builder.variable("fecha_salida"), builder.date(fecha)),
builder.is_null(builder.variable("fecha_salida"))
))
).toString()
print builder.toString()
print getStretchFeatureStore()
print "f",findOwnership(fecha, 'CV301', 10)
print "f",findOwnership(fecha, 'CV-70', 49.7)
def getVigentStretchesQuery(store, fecha):
builder = ExpressionUtils.createExpressionBuilder()
filtro = builder.and(
builder.group( builder.or(
builder.le(builder.variable("fecha_entrada"), builder.date(fecha)),
builder.is_null(builder.variable("fecha_entrada"))
)),
builder.group( builder.or(
builder.le(builder.variable("fecha_salida"), builder.date(fecha)),
builder.is_null(builder.variable("fecha_salida"))
))
).toString()
#dateFormatter = SimpleDateFormat("dd/MM/yyyy")
#formatedDate = dateFormatter.format(fecha)
#filtro = "( fecha_entrada <= '%s' OR fecha_entrada IS NULL) AND ('%s' <= fecha_salida OR fecha_salida IS NULL)" % (
# formatedDate,
# formatedDate
#)
query = store.createFeatureQuery()
query.addFilter(filtro)
return query
def possibleMun(self, mun, storeM):
possibleMunData = {}
possibleMunData["possible"] = False
jDMaxM = 0
munOptions = mun.split("/")
munOptions.append(mun)
for i in munOptions:
builder = ExpressionUtils.createExpressionBuilder()
expression = builder.eq(
builder.lower(builder.variable("MUNICIPIO")),
builder.lower(builder.constant(i))).toString()
munData = storeM.findFirst(expression)
if munData == None:
for j in storeM:
munO = unicodedata.normalize('NFKD',
i).encode('ASCII', 'ignore')
munT = j.get("MUNICIPIO")
munT = unicodedata.normalize('NFKD', munT).encode(
'ASCII', 'ignore')
if isinstance(munT, basestring) and isinstance(
munO, basestring):
jaroDistance = StringUtils.getJaroWinklerDistance(
munT.lower(), munO.lower())
if jaroDistance > jDMaxM:
jDMaxM = jaroDistance
possibleMunData["Mun"] = j.get("MUNICIPIO")
possibleMunData["INEMun"] = j.get("MUN_INE")
possibleMunData["possible"] = True
else:
logger("El campo municipio " + str(mun) +
" o el campo " + str(j.get("MUNICIPIO")) +
" del diccionario tienen problemas",
LOGGER_WARN) #CAMBIAR
continue
return possibleMunData
def possibleProv(self, prov, storeP):
possibleProvData = {}
possibleProvData["possible"] = False
jDMaxP = 0
provOptions = prov.split("/")
provOptions.append(prov)
for i in provOptions:
builder = ExpressionUtils.createExpressionBuilder()
expression = builder.eq(
builder.lower(builder.variable("PROVINCIA")),
builder.lower(builder.constant(i))).toString()
provData = storeP.findFirst(expression)
if provData == None:
for j in storeP:
provO = unicodedata.normalize('NFKD',
i).encode('ASCII', 'ignore')
provT = j.get("PROVINCIA")
provT = unicodedata.normalize('NFKD', provT).encode(
'ASCII', 'ignore')
if isinstance(provT, basestring) and isinstance(
provO, basestring):
jaroDistance = StringUtils.getJaroWinklerDistance(
provT.lower(), provO.lower())
if jaroDistance > jDMaxP:
jDMaxP = jaroDistance
possibleProvData["Prov"] = j.get("PROVINCIA")
possibleProvData["INEProv"] = j.get("PROV_INE")
possibleProvData["possible"] = True
else:
logger("El campo provincia " + str(prov) +
" o el campo " + str(j.get("PROVINCIA")) +
" del diccionario tienen problemas",
LOGGER_WARN) #CAMBIAR
continue
return possibleProvData
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 preprocess(self, report, feature):
try:
prov = feature.get("COD_PROVINCIA")
storeP = self.repo.getStore("ARENA2_TR_INE_PROVINCIA")
mun = feature.get("COD_MUNICIPIO")
storeM = self.repo.getStore("ARENA2_TR_INE_MUNICIPIO")
#logger(prov)
#logger(mun)
builder = ExpressionUtils.createExpressionBuilder()
expression = builder.eq(
builder.lower(builder.variable("PROVINCIA")),
builder.lower(builder.constant(prov))).toString()
provData = storeP.findFirst(expression)
storeP.dispose()
builder = ExpressionUtils.createExpressionBuilder()
expression = builder.eq(
builder.lower(builder.variable("MUNICIPIO")),
builder.lower(builder.constant(mun))).toString()
munData = storeM.findFirst(expression)
storeM.dispose()
if provData != None and munData != None: # Si existe un resultado con equivalencia directa lo trata la transformacion
return
elif provData == None and munData != None:
report.add(feature.get("ID_ACCIDENTE"),
codigoINE.CODERR_CODIGO_INE_NO_ENCONTRADO,
"Imposible asignar el codigo INE de la provincia " +
str(prov),
fixerID="IgnoreCodigoINEError",
selected=True,
INE_PROVINCIA=None,
PPROVINCIA=None,
INE_MUNICIPIO=munData.get("MUN_INE"),
PMUNICIPIO=munData.get("MUNICIPIO"))
elif provData != None and munData == None:
report.add(feature.get("ID_ACCIDENTE"),
codigoINE.CODERR_CODIGO_INE_NO_ENCONTRADO,
"Imposible asignar el codigo INE del municipio " +
str(mun),
fixerID="IgnoreCodigoINEError",
selected=True,
INE_PROVINCIA=provData.get("PROV_INE"),
PPROVINCIA=provData.get("PROVINCIA"),
INE_MUNICIPIO=None,
PMUNICIPIO=None)
else:
report.add(feature.get("ID_ACCIDENTE"),
codigoINE.CODERR_CODIGO_INE_NO_ENCONTRADO,
"Imposible asignar el codigo INE de la provincia " +
str(prov) + " y el municipio " + str(mun),
fixerID="IgnoreCodigoINEError",
selected=True,
INE_PROVINCIA=None,
PPROVINCIA=None,
INE_MUNICIPIO=None,
PMUNICIPIO=None)
except:
ex = sys.exc_info()[1]
logger(
"Error al ejecutar la regla codigo INE (Antes de la importacion)"
+ str(ex), gvsig.LOGGER_WARN, ex)
return
def postprocess(self, report, feature):
try:
#COMPROBAR SI ESTAN VACIOS
if feature.get("INE_PROVINCIA") == None:
prov = feature.get("COD_PROVINCIA")
storeP = self.repo.getStore("ARENA2_TR_INE_PROVINCIA")
possibleProvData = self.possibleProv(prov, storeP)
if possibleProvData["possible"]:
report.add(
feature.get("ID_ACCIDENTE"),
codigoINE.CODERR_CODIGO_INE_PROVINCIA_NO_ENCONTRADO,
"No se ha podido asignar el codigo INE de la provincia "
+ str(prov),
fixerID="IgnoreCodigoINEError",
selected=True,
INE_PROVINCIA=possibleProvData["INEProv"],
PPROVINCIA=possibleProvData["Prov"])
storeP.dispose()
if feature.get("INE_MUNICIPIO") == None:
mun = feature.get("COD_MUNICIPIO")
storeM = self.repo.getStore("ARENA2_TR_INE_MUNICIPIO")
possibleMunData = self.possibleMun(mun, storeM)
if possibleMunData["possible"]:
report.add(
feature.get("ID_ACCIDENTE"),
codigoINE.CODERR_CODIGO_INE_MUNICIPIO_NO_ENCONTRADO,
"No se ha podido asignar el codigo INE del municipio "
+ str(mun),
fixerID="IgnoreCodigoINEError",
selected=True,
INE_MUNICIPIO=possibleMunData["INEMun"],
PMUNICIPIO=possibleMunData["Mun"])
storeM.dispose()
#COMPROBAR SI ESTAN BIEN
if feature.get("INE_PROVINCIA") != None:
prov = feature.get("COD_PROVINCIA")
ineProv = feature.get("INE_PROVINCIA")
storeP = self.repo.getStore("ARENA2_TR_INE_PROVINCIA")
builder = ExpressionUtils.createExpressionBuilder()
expression = builder.eq(
builder.lower(builder.variable("PROV_INE")),
builder.lower(builder.constant(ineProv))).toString()
provData = storeP.findFirst(expression)
if provData == None:
possibleProvData = self.possibleProv(prov, storeP)
if possibleProvData["possible"]:
report.add(
feature.get("ID_ACCIDENTE"),
codigoINE.CODERR_CODIGO_INE_PROVINCIA_ERRONEO,
"El codigo INE de la provincia " + str(prov) +
" es erroneo ",
fixerID="IgnoreCodigoINEError",
selected=True,
INE_PROVINCIA=possibleProvData["INEProv"],
PPROVINCIA=possibleProvData["Prov"])
expression = builder.eq(
builder.lower(builder.variable("PROVINCIA")),
builder.lower(builder.constant(prov))).toString()
provData = storeP.findFirst(expression)
if provData.get("PROV_INE") != ineProv:
possibleProvData = self.possibleProv(prov, storeP)
if possibleProvData["possible"]:
report.add(
feature.get("ID_ACCIDENTE"),
codigoINE.CODERR_CODIGO_INE_PROVINCIA_ERRONEO,
"El codigo INE de la provincia " + str(prov) +
" es erroneo ",
fixerID="IgnoreCodigoINEError",
selected=True,
INE_PROVINCIA=possibleProvData["INEProv"],
PPROVINCIA=possibleProvData["Prov"])
storeP.dispose()
if feature.get("INE_MUNICIPIO") != None:
mun = feature.get("COD_MUNICIPIO")
ineMun = feature.get("INE_MUNICIPIO")
storeM = self.repo.getStore("ARENA2_TR_INE_MUNICIPIO")
builder = ExpressionUtils.createExpressionBuilder()
expression = builder.eq(
builder.lower(builder.variable("MUN_INE")),
builder.lower(builder.constant(ineMun))).toString()
munData = storeM.findFirst(expression)
if munData == None:
possibleMunData = self.possibleMun(mun, storeM)
if possibleMunData["possible"]:
report.add(
feature.get("ID_ACCIDENTE"),
codigoINE.CODERR_CODIGO_INE_MUNICIPIO_ERRONEO,
"El codigo INE del municipio " + str(mun) +
" es erroneo ",
fixerID="IgnoreCodigoINEError",
selected=True,
INE_MUNICIPIO=possibleMunData["INEMun"],
PMUNICIPIO=possibleMunData["Mun"])
expression = builder.eq(
builder.lower(builder.variable("MUNICIPIO")),
builder.lower(builder.constant(mun))).toString()
munData = storeM.findFirst(expression)
if munData.get("MUN_INE") != ineMun:
possibleMunData = self.possibleMun(mun, storeM)
if possibleMunData["possible"]:
report.add(
feature.get("ID_ACCIDENTE"),
codigoINE.CODERR_CODIGO_INE_MUNICIPIO_ERRONEO,
"El codigo INE del municipio " + str(mun) +
" es erroneo ",
fixerID="IgnoreCodigoINEError",
selected=True,
INE_MUNICIPIO=possibleMunData["INEMun"],
PMUNICIPIO=possibleMunData["Mun"])
storeM.dispose()
else:
return
except:
ex = sys.exc_info()[1]
logger(
"Error al ejecutar la regla codigo INE (Despues de la importacion)"
+ str(ex), gvsig.LOGGER_WARN, ex)
return