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 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 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 main(*args):
# Test pq con original phrase no funciona
store = gvsig.currentLayer().getFeatureStore()
dm = DALLocator.getDataManager()
filterExpression = ExpressionEvaluatorLocator.getManager().createExpression()
filterExpression.setPhrase("")
spatialGeometry = geom.createGeometryFromWKT("POLYGON ((-74.26662451007567 40.497289998, -74.26662451007567 40.517289997999995, -74.24930400199999 40.527289998, -74.2319834939243 40.517289997999995, -74.2319834939243 40.497289998, -74.24930400199999 40.487289997999994, -74.26662451007567 40.497289998))")
spatialGeometry.setProjection(gvsig.currentLayer().getProjection())
## store, exp, spatialGeometry
print "Spatial"
builder = ExpressionEvaluatorLocator.getManager().createExpressionBuilder()
"""
expr1 = builder.and(
builder.custom(exp.getPhrase()),
builder.ST_Intersects(
builder.geometry(spatialGeometry),
builder.column("GEOMETRY")
)
).toString()
"""
expr1 = builder.ST_Intersects(
builder.geometry(spatialGeometry),
builder.column("GEOMETRY")
).toString()
## Creating new expression
eva = ExpressionEvaluatorLocator.getManager().createExpression()
eva.setPhrase(expr1)
evaluator = DALLocator.getDataManager().createExpresion(eva)
# Query
fq = store.createFeatureQuery()
fq.addFilter(evaluator)
fq.retrievesAllAttributes()
fset = store.getFeatureSet(fq)
print "SIZE: ",fset.getSize()
### Reusing expression
cloneExpression = filterExpression.clone()
print "not cloning"
cloneExpression.setPhrase(expr1)
evaluator = DALLocator.getDataManager().createExpresion(cloneExpression)
## Query
fq = store.createFeatureQuery()
fq.addFilter(evaluator)
fq.retrievesAllAttributes()
fset = store.getFeatureSet(fq)
print "SIZE: ",fset.getSize()
def initComponents(self):
i18n = ToolsLocator.getI18nManager()
toolsSwingManager = ToolsSwingLocator.getToolsSwingManager()
dataManager = DALLocator.getDataManager()
dataSwingManager = DALSwingLocator.getSwingManager()
taskManager = ToolsSwingLocator.getTaskStatusSwingManager()
expSwingManager = ExpressionEvaluatorSwingLocator.getManager()
self.btnVerAccidente.setText("")
self.btnExportIssues.setText("")
self.filter = expSwingManager.createExpressionPickerController(
self.txtFilter, self.btnFilter, self.btnFilterHistory,
self.btnFilterBookmarks)
self.taskStatusController = taskManager.createTaskStatusController(
self.lblTaskTitle, self.lblTaskMessage, self.pgbTaskProgress)
self.setVisibleTaskStatus(False)
self.tblIssues.setModel(self.report.getTableModel())
self.report.setCellEditors(self.tblIssues)
dataSwingManager.setStoreAction(self.btnVerAccidente, "ShowForm", True,
ShowFormFromIssueActionContext(self))
dataSwingManager.setStoreAction(self.btnExportIssues, "Export", True,
ExportFromIssueActionContext(self))
self.lblIssuesMessage.setText("")
self.tblIssues.getSelectionModel().addListSelectionListener(
self.issuesSelectionChanged)
self.tblIssues.setAutoCreateRowSorter(True)
self.btnModifyIssues.setEnabled(False)
self.btnVerAccidente.setEnabled(False)
self.btnExportIssues.setEnabled(False)
self.setPreferredSize(800, 500)
def loadRasterLayer (rasterfile, mode = "r" ):
## Load a Raster file in a Layer
sourceFileName[0]=rasterfile
if not isinstance (rasterfile,File):
rasterfile = File(rasterfile)
name, ext = splitext(rasterfile.getName())
view = currentView()
# Get the manager to use
dalManager = DALLocator.getDataManager()
mapContextManager = MapContextLocator.getMapContextManager()
if ext.lower() == ".ecw" or ext.lower() == ".jp2" :
# FIXME
pass
elif ext.lower() == ".mrsid":
# FIXME
pass
else:
# Create the parameters to open the raster store based in GDAL
params = dalManager.createStoreParameters("Gdal Store")
params.setFile(rasterfile)
# Create the raster store
dataStore = dalManager.createStore(params)
# Create a raster layer based in this raster store
layer = mapContextManager.createLayer(name, dataStore);
view.addLayer(layer)
return layer
def selectDuplicates(store, attrName):
mvstore = None
tempFile = None
status = ToolsLocator.getTaskStatusManager().createDefaultSimpleTaskStatus(
"SelectDuplicates")
status.add()
status.setAutoremove(True)
try:
dataManager = DALLocator.getDataManager()
dup = dataManager.createLargeMap()
dup.clear()
selection = store.createFeatureSelection()
status.setRangeOfValues(0, store.getFeatureCount())
n = 0
for f in store:
status.setCurValue(n)
value = f.get(attrName)
if dup.has_key(value):
selection.select(f)
else:
dup[value] = True
n += 1
store.setSelection(selection)
finally:
status.terminate()
def importData(issues_pathname, slot, slotsize, workspaceName):
status = LoggerTaskStatus("ImportArena2Files")
issues_pathname = issues_pathname % slot
fnames, slots = calculateSlots(folderData, slotsize, slot, status)
status.logger("import slot %d/%d" % (slot, slots))
if not connectToWorkspace(workspaceName, status):
return
importManager = getArena2ImportManager()
report = Report(importManager)
report.setEnabledEvents(False)
dataManager = DALLocator.getDataManager()
workspace = dataManager.getDatabaseWorkspace("ARENA2_DB")
if workspace==None:
status.logger("Can't access to workspace ARENA2_DB", gvsig.LOGGER_WARN)
return
issues = dataManager.openStore("CSV","File", issues_pathname)
report.addIssues(issues.getFeatureSet())
if len(report) != issues.getFeatureCount():
status.logger("Can't load issues in report", gvsig.LOGGER_WARN)
return
p = ImportProcess(importManager, fnames, workspace, report, status)
p.run()
def _updateAllUI(self):
# Input params dependant of layer
swm = DALSwingLocator.getSwingManager()
## Field with image data
ft1 = self.store.getDefaultFeatureType()
self.pickerFieldsImageData.setFeatureType(ft1)
# Output params
## Use absolute path from ield
self.pickerFieldsPath.setFeatureType(ft1)
## Export to folder using name
self.pickerFieldsName.setFeatureType(ft1)
## Expression for absolute path
self.pickerExpStore.setFeatureStore(self.store)
### Preview expression
## Sample feature
sampleFeature = None
try:
sampleFeature = store.getFeatureSelection().first()
if sampleFeature == None:
sampleFeature = store.first()
except:
logger("Not able to create Sample Feature for FieldCalculatorTool", LOGGER_WARN)
if sampleFeature!=None:
dataManager = DALLocator.getDataManager()
featureSymbolTable = dataManager.createFeatureSymbolTable()
featureSymbolTable.setFeature(sampleFeature)
self.pickerExp.setPreviewSymbolTable(featureSymbolTable.createParent())
def createTableAndFill(workspace, tableName):
# Create table
#self.status.message("Creando "+tableName)
#self.status.incrementCurrentValue()
server = workspace.getServerExplorer()
fname = getResource(__file__, "data", tableName + ".csv")
if fname == None:
return
parameters = getOpenStoreParametersOfDictionaryByPath(fname)
addparams = server.getAddParameters(tableName)
ft = addparams.getDefaultFeatureType()
dataManager = DALLocator.getDataManager()
store = dataManager.openStore(parameters.getProviderName(), parameters)
ft.copyFrom(store.getDefaultFeatureType())
store.dispose()
server.add(tableName, addparams, False)
# Fill table
#self.status.message("Importando "+tableName)
#self.status.incrementCurrentValue()
params_src = getOpenStoreParametersOfDictionaryByPath(fname)
params_dst = server.get(tableName)
store_src = dataManager.openStore(params_src.getProviderName(), params_src)
store_dst = dataManager.openStore(params_dst.getProviderName(), params_dst)
store_src.copyTo(store_dst)
store_src.dispose()
store_dst.dispose()
def validateData(folderData, issues_pathname, slot, slotsize, workspaceName):
status = LoggerTaskStatus("ValidateArena2Files")
issues_pathname = issues_pathname % slot
fnames, slots = calculateSlots(folderData, slotsize, slot, status)
status.logger("validate slot %d/%d" % (slot, slots))
if not connectToWorkspace(workspaceName, status):
return
importManager = getArena2ImportManager()
report = MyReport(importManager)
report.setEnabledEvents(False)
dataManager = DALLocator.getDataManager()
workspace = dataManager.getDatabaseWorkspace("ARENA2_DB")
if workspace == None:
status.logger("Can't access to workspace ARENA2_DB", gvsig.LOGGER_WARN)
p = ValidatorProcess(importManager, fnames, report, workspace, status)
p.run()
if os.path.exists(issues_pathname):
status.logger("removing file %r" % issues_pathname)
os.unlink(issues_pathname)
explorer = dataManager.openServerExplorer("FilesystemExplorer")
store = report.getStore()
status.logger("export issues to %r" % issues_pathname)
store.export(explorer, "CSV",
explorer.getAddParameters(File(issues_pathname)))
def test3():
from org.gvsig.fmap.dal import DALLocator
dataManager = DALLocator.getDataManager()
factory = Arena2ReaderFactory()
folder = '/home/jjdelcerro/arena2/quincenas'
fnames = list()
for root, dirs, files in os.walk(folder, followlinks=True):
for name in files:
pathname = os.path.join(root, name)
if pathname.lower().endswith(".xml"):
if factory.accept(File(pathname)):
gvsig.logger("found file: %r" % pathname)
fnames.append(pathname)
else:
gvsig.logger("skip file: %r" % pathname, gvsig.LOGGER_WARN)
fnames.sort()
#fnames = ( '/home/jjdelcerro/arena2/quincenas/Valencia/TV_46_2018_01_Q1/victimas.xml', )
maxfiles = len(fnames)
maxfiles = min(10,len(fnames))
for n in range(0,maxfiles):
fname = fnames[n]
gvsig.logger("Process: %d/%d %r" % (n, maxfiles, fname))
if not factory.accept(File(fname)):
gvsig.logger("File not supported ", gvsig.LOGGER_WARN)
continue
store = dataManager.openStore("ARENA2", "file", fname, "CRS", "EPSG:25830")
for feature in store:
pass
store.close()
store = None
def createReader(self, params):
f = params.getFile()
dataManager = DALLocator.getDataManager()
repo = BaseStoresRepository("ARENA2_"+f.getName())
for name in getDictionaryNames():
parameters = getOpenStoreParametersOfDictionary(name)
repo.add(name,parameters)
reader = Arena2Reader(self, params, repo)
return reader
def main(*args):
manager = DALLocator.getDataManager()
storeParameters = manager.createStoreParameters("H2Spatial")
database_file = gvsig.getResource(__file__, "data", "municipalities.mv.db")
storeParameters.setDynValue("database_file", database_file)
storeParameters.setDynValue("Table", "Muni")
storeH2 = manager.openStore("H2Spatial", storeParameters)
print storeH2, dir(storeH2)
def crearTabla_estaciones(connection):
tableName = "AFOROS_ESTACIONES"
dataManager = DALLocator.getDataManager()
server = dataManager.openServerExplorer(connection.getProviderName(),
connection)
params = server.getAddParameters(tableName)
ft = params.getDefaultFeatureType()
configurar_featuretype_estaciones(ft)
server.add(tableName, params, False)
def crearTabla_ARENA2_PASAJEROS(connection):
tableName = "ARENA2_PASAJEROS"
dataManager = DALLocator.getDataManager()
server = dataManager.openServerExplorer(connection.getProviderName(),
connection)
params = server.getAddParameters(tableName)
ft = params.getDefaultFeatureType()
configurar_featuretype_ARENA2_PASAJEROS(ft)
server.add(tableName, params, False)
def loadFileIntoH2(self, oml, outputPathFull):
path=gvsig.getTempFile(oml.getCodMun(),'')#os.path.join(self.getDownloadPath(),oml.get)
print "PATH FOR GML:", path
os.mkdir(path)
zip_ref = zipfile.ZipFile(outputPathFull, 'r')
zip_ref.extractall(path)
zip_ref.close()
gmlFile = 'A.ES.SDGC.CP.{0}.cadastralparcel.gml'.format(oml.getCodMun())
gmlFilePath = os.path.join(path, gmlFile)
if not os.path.exists(gmlFilePath):
print "fail"
return
manager = DALLocator.getDataManager()
storeParameters = manager.createStoreParameters("GMLDataStoreProvider")
#storeParameters.setDynValue("connectionString",None)
storeParameters.setDynValue("CRS",self.view.getProjection())
#storeParameters.setDynValue("defaultGeometryField",None)
storeParameters.setDynValue("file",gmlFilePath)
#storeParameters.setDynValue("gfsSchema",None)
#storeParameters.setDynValue("ignoreSpatialFilter",True)
storeParameters.setDynValue("layerName",oml.getCodMun())
#storeParameters.setDynValue("ProviderName",None)
#storeParameters.setDynValue("xsdSchema",None)
storeGML = manager.openStore("GMLDataStoreProvider",storeParameters)
#application = ApplicationLocator.getManager()
#mapcontextmanager = application.getMapContextManager()
#layer = mapcontextmanager.createLayer(oml.getId(),store)
#self.view.addLayer(layer)
# Open Store
storeParameters = manager.createStoreParameters("H2Spatial")
database_file=gvsig.getResource(__file__, "data", "municipalities.mv.db")
storeParameters.setDynValue("database_file",database_file)
storeParameters.setDynValue("Table","Muni")
storeH2 = manager.openStore("H2Spatial",storeParameters)
storeH2.edit()
fsetGML = storeGML.getFeatureSet()
for f in fsetGML:
value = {
'CODPROV': oml.getCodProv(),
'PROV': oml.getProv(),
'CODMUN': oml.getCodMun(),
'MUN': oml.getMun(),
'ID': oml.getId(),
'gml_id': f.get('gml_id'),
'GEOMETRY': f.getDefaultGeometry()
}
storeH2.append(value)
storeH2.commit()
storeGML.dispose()
storeH2.dispose()
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 testFormat():
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()
ehora = ft.getAttributeDescriptor("HORA_ACCIDENTE")
ekm = ft.getAttributeDescriptor("KM")
from java.sql import Timestamp
from java.util import Date
ts = Timestamp(Date().getTime())
print ehora.format(ts)
print ekm.format(10.282999895)
from java.lang import String
print String.format("%.3f", 10.39283)
print String.format("%tR", Timestamp(Date().getTime()))
def updateCalculatedField(self, columnSelectedDescriptor, store, exp):
i18nManager = ToolsLocator.getI18nManager()
try:
self.taskStatus.setRangeOfValues(0, 1)
self.taskStatus.setCurValue(0)
self.taskStatus.add()
#Process
newComputed = DALLocator.getDataManager(
).createFeatureAttributeEmulatorExpression(
store.getDefaultFeatureType(), exp)
#Check if required field is himself
for req in newComputed.getRequiredFieldNames():
if req == columnSelectedDescriptor.getName():
mss = i18nManager.getTranslation(
"_A_computed_field_can_not_have_itself_as_required_field_in_the_expression"
)
self.taskStatus.message(mss)
logger(mss, LOGGER_WARN)
raise Throwable(mss)
newFeatureType = gvsig.createFeatureType(
store.getDefaultFeatureType())
#DefaultEditableFeatureAttributeDescriptor
efd = newFeatureType.getEditableAttributeDescriptor(
columnSelectedDescriptor.getName())
efd.setFeatureAttributeEmulator(newComputed)
try:
store.edit()
store.update(newFeatureType)
store.commit()
self.taskStatus.incrementCurrentValue()
self.taskStatus.message(
i18nManager.getTranslation("_Computed_field_updated"))
except:
#store.cancelEditing()
self.taskStatus.message(
i18nManager.getTranslation(
"_Computed_field_calculation_has_some_errors"))
logger(
"Not able change Emulatore Expression Attribute in Feature Type",
LOGGER_ERROR)
except:
pass
finally:
if self.editingMode:
try:
store.edit()
except:
logger("Not able to put store into editing mode",
LOGGER_ERROR)
def addAccidentsLayer(self):
dataManager = DALLocator.getDataManager()
workspace = dataManager.getDatabaseWorkspace("ARENA2_DB")
if workspace == None:
msgbox("Debera conectarse al espacio de trabajo de ARENA2_DB")
return
repo = workspace.getStoresRepository()
store = repo.getStore("ARENA2_ACCIDENTES")
layer = MapContextLocator.getMapContextManager().createLayer(
"Accidentes", store)
gvsig.currentView().getMainWindow().getMapControl().addLayer(layer)
def reload(self):
#store = getCarreterasManager().getStretchFeatureStore()
dataManager = DALLocator.getDataManager()
pool = dataManager.getDataServerExplorerPool()
explorerParams = pool.get("carreteras_gva").getExplorerParameters()
explorerParams.setSchema("layers")
explorer = dataManager.openServerExplorer(
explorerParams.getProviderName(), explorerParams)
params = explorer.get("tramos_carreteras")
store = dataManager.openStore(params.getProviderName(), params)
self.setValue(store)
def create_DAL_ARENA2_AC_VE_CO_PA_PE_CR():
from tablas.ARENA2_AC_VE_CO_PA_PE_CR import configurar_featuretype_ARENA2_AC_VE_CO_PA_PE_CR
tableName = "ARENA2_AC_VE_CO_PA_PE_CR"
dataManager = DALLocator.getDataManager()
ft = dataManager.createFeatureType()
configurar_featuretype_ARENA2_AC_VE_CO_PA_PE_CR(ft)
dalfile = DALFile.getDALFile()
dalfile.setFeatureType(ft)
pathname = getResource(__file__, "../Arena2Reader/datos/recursos/",
tableName + ".dal")
dalfile.write(File(pathname))
def getProvinciasFeatureSet():
manager = DALLocator.getDataManager()
storeParameters = manager.createStoreParameters("H2Spatial")
database_file = gvsig.getResource(__file__,"data","catastroInfo.mv.db")
storeParameters.setDynValue("database_file",database_file)
storeParameters.setDynValue("Table","Provincias")
store = manager.openStore("H2Spatial",storeParameters)
print "*** GETTING FEATURE SET"""
featureSet = store.getFeatureSet()
print "*** YE FEATURE SET"
return featureSet, store
def openStore(self, fname):
dataManager = DALLocator.getDataManager()
try:
fname_tail = os.path.sep.join(fname.split(os.path.sep)[-3:])
self.status.message("Cargando accidentes...(%s)" % fname_tail)
store = dataManager.openStore("ARENA2", "file", fname, "CRS",
"EPSG:25830")
return store
except java.lang.Throwable, ex:
logger("Error cargando accidentes.", LOGGER_WARN, ex)
self.status.message("Error Cargando accidentes (%s)" % fname)
return None
def getOpenStoreParametersOfDictionaryByPath(fname):
dataManager = DALLocator.getDataManager()
#fname = getResource(__file__,"datos", "tablas",name+".csv")
parameters = dataManager.createStoreParameters("CSV")
parameters.setDynValue("profile", "STANDARD_PREFERENCE")
parameters.setDynValue("quotePolicy", "AlwaysQuoteMode")
parameters.setDynValue("delimiter", ";")
parameters.setDynValue("commentStartMarker", "#")
parameters.setDynValue("automaticTypesDetection", False)
parameters.setDynValue("firstLineHeader", True)
parameters.setFile(File(fname))
return parameters
def showAccidentsSearch(self):
dataSwingManager = DALSwingLocator.getSwingManager()
dataManager = DALLocator.getDataManager()
winManager = ToolsSwingLocator.getWindowManager()
workspace = dataManager.getDatabaseWorkspace("ARENA2_DB")
if workspace == None:
msgbox("Debera conectarse al espacio de trabajo de ARENA2_DB")
return
repo = workspace.getStoresRepository()
store = repo.getStore("ARENA2_ACCIDENTES")
panel = dataSwingManager.createFeatureStoreSearchPanel(store)
winManager.showWindow(panel.asJComponent(), "Busqueda de accidentes",
WindowManager.MODE.WINDOW)
def addArena2Workspace():
dataManager = DALLocator.getDataManager()
pool = dataManager.getDataServerExplorerPool()
for entry in pool:
if isinstance(entry.getExplorerParameters(),
JDBCServerExplorerParameters):
if entry.getName() == "ARENA2_DB":
workspace = dataManager.createDatabaseWorkspaceManager(
entry.getExplorerParameters())
if workspace.isValidStoresRepository():
dataManager.addDatabaseWorkspace(workspace)
break
def saveBuffer(self,filename):
manager = DALLocator.getDataManager ()
eparams = manager.createServerExplorerParameters(FilesystemServerExplorer.NAME)
eparams.setDynValue("initialpath",os.path.dirname(sourceFileName[0]))
serverExplorer = manager.openServerExplorer(eparams.getExplorerName(),eparams)
sparams = serverExplorer.getAddParameters("Gdal Store")
sparams.setDestination(os.path.dirname(sourceFileName[0]),filename)
sparams.setBuffer(self.buffer)
#at = AffineTransform(1, 0, 0, -1, 0, 0)
#sparams.setAffineTransform(at);
serverExplorer.add("Gdal Store", sparams, True)
def getMunicipiosFeatureSet(provincia):
manager = DALLocator.getDataManager()
storeParameters = manager.createStoreParameters("H2Spatial")
database_file = gvsig.getResource(__file__,"data","catastroInfo.mv.db")
storeParameters.setDynValue("database_file",database_file)
storeParameters.setDynValue("Table","Municipios")
store = manager.openStore("H2Spatial",storeParameters)
#try:
# query = u"""CODPROV='{0}'""".format(provincia)
# featureSet = store.getFeatureSet(query)
#except:
featureSet = store.getFeatureSet()
return featureSet, store
def __init__(self, importManager):
self.__dataManager = DALLocator.getDataManager()
self.__importManager = importManager
self.__ftype = None
self.__columnNames = list()
self.__issues_list = None
#self.__issues = self.createMemoryStore()
self.__issues = self.createH2Store()
for attr in self.__ftype:
if not attr.isHidden():
self.__columnNames.append(attr.getName())
self.__timer = None
self.__delayed_events = 0
self.__eventsEnableds = True
def main2(*args):
store = gvsig.currentLayer().getFeatureStore()
dm = DALLocator.getDataManager()
i="True"
evaluator = dm.createExpresion(i)
fq = store.createFeatureQuery()
fq.addFilter(evaluator)
fq.retrievesAllAttributes()
fset = store.getFeatureSet(fq)
count = 0
for f in fset:
count+=1
print count
###
print "Spatial"
spatialGeometry = geom.createGeometryFromWKT("POLYGON ((-74.26662451007567 40.497289998, -74.26662451007567 40.517289997999995, -74.24930400199999 40.527289998, -74.2319834939243 40.517289997999995, -74.2319834939243 40.497289998, -74.24930400199999 40.487289997999994, -74.26662451007567 40.497289998))")
spatialGeometry.setProjection(gvsig.currentLayer().getProjection())
builder = ExpressionEvaluatorLocator.getManager().createExpressionBuilder()
expr1 = builder.and(
builder.custom(i),
builder.ST_Intersects(
builder.geometry(spatialGeometry),
builder.column("GEOMETRY")
)
).toString()
eva = ExpressionEvaluatorLocator.getManager().createExpression()
eva.setPhrase(expr1)
evaluator = DALLocator.getDataManager().createExpresion(eva)
fq = store.createFeatureQuery()
fq.addFilter(evaluator)
fq.retrievesAllAttributes()
fset = store.getFeatureSet(fq)
count = 0
for f in fset:
count+=1
print count
def loadStore (self,rasterfile, mode = "r" ):
if not isinstance(rasterfile,File):
rasterfile = File(rasterfile)
name, ext = splitext(rasterfile.getName())
dalManager = DALLocator.getDataManager()
if ext.lower() == ".ecw" or ext.lower() == ".jp2" :
# FIXME
pass
elif ext.lower() == ".mrsid":
# FIXME
pass
else:
# Create the parameters to open the raster store based in GDAL
params = dalManager.createStoreParameters("Gdal Store")
params.setFile(rasterfile)
# Create the raster store
dataStore = dalManager.createStore(params)
return dataStore
