def testPublishLayersDialog(self):
pt1 = layers.resolveLayer(PT1)
pt2 = layers.resolveLayer(PT2)
dialog = PublishLayersDialog(self.catalogs, [pt1,pt2])
cancelWidget = dialog.buttonBox.button(dialog.buttonBox.Cancel)
QTest.mouseClick(cancelWidget, Qt.LeftButton)
self.assertIsNone(dialog.topublish)
cat = self.catalogs.values()[0]
for idx, ws in enumerate(cat.get_workspaces()):
if ws.name == WORKSPACE:
wsIdx = idx
if ws.name == WORKSPACEB:
wsIdxB = idx
dialog = PublishLayersDialog(self.catalogs, [pt1,pt2])
self.assertEquals(4, dialog.table.columnCount())
self.assertEquals(2, dialog.table.rowCount())
dialog.table.cellWidget(0, 1).setCurrentIndex(wsIdx)
dialog.table.cellWidget(1, 1).setCurrentIndex(wsIdxB)
okWidget = dialog.buttonBox.button(dialog.buttonBox.Ok)
QTest.mouseClick(okWidget, Qt.LeftButton)
self.assertIsNotNone(dialog.topublish)
self.assertEquals(WORKSPACE, dialog.topublish[0][2].name)
self.assertEquals(WORKSPACEB, dialog.topublish[1][2].name)
dialog = PublishLayersDialog({"catalog": cat, "catalog2:": cat}, [pt1,pt2])
self.assertEquals(5, dialog.table.columnCount())
self.assertEquals(2, dialog.table.rowCount())
dialog.table.cellWidget(0, 2).setCurrentIndex(wsIdx)
dialog.table.cellWidget(1, 2).setCurrentIndex(wsIdxB)
okWidget = dialog.buttonBox.button(dialog.buttonBox.Ok)
QTest.mouseClick(okWidget, Qt.LeftButton)
self.assertIsNotNone(dialog.topublish)
self.assertEquals(WORKSPACE, dialog.topublish[0][2].name)
self.assertEquals(WORKSPACEB, dialog.topublish[1][2].name)
def testPublishLayersDialog(self):
pt1 = layers.resolveLayer(PT1)
pt2 = layers.resolveLayer(PT2)
dialog = PublishLayersDialog(self.catalogs, [pt1,pt2])
cancelWidget = dialog.buttonBox.button(dialog.buttonBox.Cancel)
QTest.mouseClick(cancelWidget, Qt.LeftButton)
self.assertIsNone(dialog.topublish)
cat = self.catalogs.values()[0]
for idx, ws in enumerate(cat.get_workspaces()):
if ws.name == WORKSPACE:
wsIdx = idx
if ws.name == WORKSPACEB:
wsIdxB = idx
dialog = PublishLayersDialog(self.catalogs, [pt1,pt2])
self.assertEquals(4, dialog.table.columnCount())
self.assertEquals(2, dialog.table.rowCount())
dialog.table.cellWidget(0, 1).setCurrentIndex(wsIdx)
dialog.table.cellWidget(1, 1).setCurrentIndex(wsIdxB)
okWidget = dialog.buttonBox.button(dialog.buttonBox.Ok)
QTest.mouseClick(okWidget, Qt.LeftButton)
self.assertIsNotNone(dialog.topublish)
self.assertEquals(WORKSPACE, dialog.topublish[0][2].name)
self.assertEquals(WORKSPACEB, dialog.topublish[1][2].name)
dialog = PublishLayersDialog({"catalog": cat, "catalog2:": cat}, [pt1,pt2])
self.assertEquals(5, dialog.table.columnCount())
self.assertEquals(2, dialog.table.rowCount())
dialog.table.cellWidget(0, 2).setCurrentIndex(wsIdx)
dialog.table.cellWidget(1, 2).setCurrentIndex(wsIdxB)
okWidget = dialog.buttonBox.button(dialog.buttonBox.Ok)
QTest.mouseClick(okWidget, Qt.LeftButton)
self.assertIsNotNone(dialog.topublish)
self.assertEquals(WORKSPACE, dialog.topublish[0][2].name)
self.assertEquals(WORKSPACEB, dialog.topublish[1][2].name)
def testImportMultipleLayers(self):
importToPostGIS(self.explorer, self.conn,
[layers.resolveLayer(PT1),
layers.resolveLayer(PT2)], PUBLIC_SCHEMA, None, False,
False)
schema = Schema(self.conn, PUBLIC_SCHEMA)
self.assertIsNotNone(self.getTable(schema, PT1))
self.assertIsNotNone(self.getTable(schema, PT2))
def testRasterLayerRoundTrip(self):
self.cat.publishLayer(DEM, self.ws, name=DEM)
self.assertIsNotNone(self.cat.catalog.get_layer(DEM))
self.cat.addLayerToProject(DEM, DEM2)
layer = layers.resolveLayer(DEM2)
QgsMapLayerRegistry.instance().removeMapLayer(layer.id())
self.cat.catalog.delete(self.cat.catalog.get_layer(DEM), recurse=True)
def testRasterLayerRoundTrip(self):
self.cat.publishLayer(DEM, self.ws, name = DEM)
self.assertIsNotNone(self.cat.catalog.get_layer(DEM))
self.cat.addLayerToProject(DEM, DEM2)
layer = layers.resolveLayer(DEM2)
QgsMapLayerRegistry.instance().removeMapLayer(layer.id())
self.cat.catalog.delete(self.cat.catalog.get_layer(DEM), recurse = True)
def upload(self, layer, workspace=None, overwrite=True, name=None):
'''uploads the specified layer'''
if isinstance(layer, basestring):
layer = layers.resolveLayer(layer)
name = name if name is not None else layer.name()
title = name
name = name.replace(" ", "_")
try:
settings = QSettings()
restApi = bool(settings.value("/OpenGeo/Settings/GeoServer/UseRestApi", True, bool))
restApi = True # importer api is disabled for now
if layer.type() == layer.RasterLayer:
path = self.getDataFromLayer(layer)
if restApi:
self.catalog.create_coveragestore(name,
path,
workspace=workspace,
overwrite=overwrite)
else:
session = self.client.upload(path)
session.commit()
elif layer.type() == layer.VectorLayer:
provider = layer.dataProvider()
if provider.name() == 'postgres':
connName = self.getConnectionNameFromLayer(layer)
uri = QgsDataSourceURI(provider.dataSourceUri())
self.catalog.create_pg_featurestore(connName,
workspace = workspace,
overwrite = overwrite,
host = uri.host(),
database = uri.database(),
schema = uri.schema(),
port = uri.port(),
user = uri.username(),
passwd = uri.password())
self.catalog.create_pg_featuretype(uri.table(), connName, workspace, layer.crs().authid())
else:
path = self.getDataFromLayer(layer)
if restApi:
try:
self.catalog.create_shp_featurestore(name,
path,
workspace=workspace,
overwrite=overwrite)
except Exception, e:
if utils.isWindows():
#a WindowsError might be thrown by the create_shp_featurestore method
#when trying to unlink the temp zip file. We ignore it
if not isinstance(e, WindowsError):
raise e
else:
raise e
else:
shpFile = path['shp']
session = self.client.upload(shpFile)
session.commit()
def publishLayer (self, layer, workspace=None, overwrite=True, name=None,
abstract=None, permissions=None, keywords=()):
'''
Publishes a QGIS layer.
It creates the corresponding store and the layer itself.
If a pre-upload hook is set, its runs it and publishes the resulting layer
layer: the layer to publish, whether as a QgsMapLayer object or its name in the QGIS TOC.
workspace: the workspace to publish to. USes the default project if not passed
or None
name: the name for the published layer. Uses the QGIS layer name if not passed
or None
params: a dict with additional configuration parameters if needed
'''
if isinstance(layer, basestring):
layer = layers.resolveLayer(layer)
name = name if name is not None else layer.name()
sld = self.publishStyle(layer, overwrite, name)
layer = self.preprocess(layer)
self.upload(layer, workspace, overwrite, name)
if sld is not None:
#assign style to created store
publishing = self.catalog.get_layer(name)
publishing.default_style = self.catalog.get_style(name)
self.catalog.save(publishing)
def testVectorLayerRoundTrip(self):
self.cat.publishLayer(PT1, self.ws, name=PT1)
self.assertIsNotNone(self.cat.catalog.get_layer(PT1))
self.cat.addLayerToProject(PT1, PT1)
layer = layers.resolveLayer(PT1)
QgsMapLayerRegistry.instance().removeMapLayer(layer.id())
self.cat.catalog.delete(self.cat.catalog.get_layer(PT1), recurse=True)
def testVectorLayerRoundTrip(self):
self.cat.publishLayer(PT1, self.ws, name = PT1)
self.assertIsNotNone(self.cat.catalog.get_layer(PT1))
self.cat.addLayerToProject(PT1, PT1)
layer = layers.resolveLayer(PT1)
QgsMapLayerRegistry.instance().removeMapLayer(layer.id())
self.cat.catalog.delete(self.cat.catalog.get_layer(PT1), recurse = True)
def upload(self, layer, workspace=None, overwrite=True, name=None):
'''uploads the specified layer'''
if isinstance(layer, basestring):
layer = layers.resolveLayer(layer)
name = name if name is not None else layer.name()
title = name
name = name.replace(" ", "_")
settings = QSettings()
restApi = bool(settings.value("/OpenGeo/Settings/GeoServer/UseRestApi", True, bool))
if layer.type() not in (layer.RasterLayer, layer.VectorLayer):
msg = layer.name() + ' is not a valid raster or vector layer'
raise Exception(msg)
provider = layer.dataProvider()
try:
if provider.name() == 'postgres':
self._publishExisting(layer, workspace, overwrite)
elif restApi:
self._uploadRest(layer, workspace, overwrite, name)
else:
self._uploadImporter(layer, workspace, overwrite, name)
except UploadError, e:
msg = ('Could not save the layer %s, there was an upload '
'error: %s' % (layer.name(), str(e)))
e.args = (msg,)
raise
def testImportSingleLayerAsSingleGeometries(self):
importToPostGIS(self.explorer, self.conn, [layers.resolveLayer(PT1)],
PUBLIC_SCHEMA, PT1, False, True)
schema = Schema(self.conn, PUBLIC_SCHEMA)
table = self.getTable(schema, PT1)
self.assertIsNotNone(table)
self.assertEquals(-1, table.geomtype.find("MULTI"))
def upload(self, layer, workspace=None, overwrite=True, name=None):
'''uploads the specified layer'''
if isinstance(layer, basestring):
layer = layers.resolveLayer(layer)
name = name if name is not None else layer.name()
title = name
name = name.replace(" ", "_")
settings = QSettings()
restApi = bool(
settings.value("/OpenGeo/Settings/GeoServer/UseRestApi", True,
bool))
if layer.type() not in (layer.RasterLayer, layer.VectorLayer):
msg = layer.name() + ' is not a valid raster or vector layer'
raise Exception(msg)
provider = layer.dataProvider()
try:
if provider.name() == 'postgres':
self._publishExisting(layer, workspace, overwrite)
elif restApi:
self._uploadRest(layer, workspace, overwrite, name)
else:
self._uploadImporter(layer, workspace, overwrite, name)
except UploadError, e:
msg = ('Could not save the layer %s, there was an upload '
'error: %s' % (layer.name(), str(e)))
e.args = (msg, )
raise
def testDeleteTable(self):
importToPostGIS(self.explorer, self.conn, [layers.resolveLayer(PT1)], PUBLIC_SCHEMA, PT1, False, False);
self.getPGConnectionItem().refreshContent(self.explorer)
tableItem = self.getPGTableItem(PT1)
tableItem.deleteTable(self.explorer)
tableItem = self.getPGTableItem(PT1)
self.assertIsNone(tableItem)
def testDeleteTable(self):
importToPostGIS(self.explorer, self.conn, [layers.resolveLayer(PT1)],
PUBLIC_SCHEMA, PT1, False, False)
self.getPGConnectionItem().refreshContent(self.explorer)
tableItem = self.getPGTableItem(PT1)
tableItem.deleteTable(self.explorer)
tableItem = self.getPGTableItem(PT1)
self.assertIsNone(tableItem)
def okPressed(self):
if self.showLayerSelector:
self.layer = layers.resolveLayer(self.layerBox.currentText())
self.add = self.addCheck.isChecked()
self.dest = unicode(self.destBox.text())
if self.dest == "":
self.dest = None
self.ok = True
self.close()
def testDropPGTableInWorkspacesItem(self):
importToPostGIS(self.explorer, self.conn, [layers.resolveLayer(PT1)], PUBLIC_SCHEMA, PT1, False, False);
self.getPGConnectionItem().refreshContent(self.explorer)
tableItem = self.getPGTableItem(PT1)
self.assertIsNotNone(tableItem)
wsItem = self.getWorkspacesItem()
wsItem.acceptDroppedItems(self.tree, self.explorer, [tableItem])
layer = self.cat.get_layer(PT1)
self.assertIsNotNone(layer)
self.cat.delete(self.cat.get_layer(PT1), recurse = True)
def testDropPGTableInWorkspacesItem(self):
importToPostGIS(self.explorer, self.conn, [layers.resolveLayer(PT1)], PUBLIC_SCHEMA, PT1, False, False);
self.getPGConnectionItem().refreshContent(self.explorer)
tableItem = self.getPGTableItem(PT1)
self.assertIsNotNone(tableItem)
wsItem = self.getWorkspacesItem()
wsItem.acceptDroppedItems(self.tree, self.explorer, [tableItem])
layer = self.cat.get_layer(PT1)
self.assertIsNotNone(layer)
self.cat.delete(self.cat.get_layer(PT1), recurse = True)
def upload(self, layer, workspace=None, overwrite=True, name=None,
abstract=None, permissions=None, keywords=()):
'''uploads the specified layer'''
if isinstance(layer, basestring):
layer = layers.resolveLayer(layer)
name = name if name is not None else layer.name()
try:
settings = QSettings()
restApi = bool(settings.value("/OpenGeo/Settings/GeoServer/UseRestApi", True, bool))
if layer.type() == layer.RasterLayer:
path = self.getDataFromLayer(layer)
if restApi:
self.catalog.create_coveragestore(name,
path,
workspace=workspace,
overwrite=overwrite)
else:
self.client.upload(path)
elif layer.type() == layer.VectorLayer:
provider = layer.dataProvider()
if provider.name() == 'postgres':
connName = self.getConnectionNameFromLayer(layer)
uri = QgsDataSourceURI(provider.dataSourceUri())
self.catalog.create_pg_featurestore(connName,
workspace = workspace,
overwrite = overwrite,
host = uri.host(),
database = uri.database(),
schema = uri.schema(),
port = uri.port(),
user = uri.username(),
passwd = uri.password())
self.catalog.create_pg_featuretype(uri.table(), connName, workspace, layer.crs().authid())
else:
path = self.getDataFromLayer(layer)
if restApi:
self.catalog.create_shp_featurestore(name,
path,
workspace=workspace,
overwrite=overwrite)
else:
self.client.upload(path['shp'])
else:
msg = layer.name() + ' is not a valid raster or vector layer'
raise Exception(msg)
except UploadError, e:
msg = ('Could not save the layer %s, there was an upload '
'error: %s' % (layer.name(), str(e)))
e.args = (msg,)
raise
def publishLayer(self,
layer,
workspace=None,
overwrite=True,
name=None,
storename=None,
title=None):
'''
Publishes a QGIS layer.
It creates the corresponding store and the layer itself.
If a pre-upload hook is set, its runs it and publishes the resulting layer
layer: the layer to publish, whether as a QgsMapLayer object or its name in the QGIS TOC.
workspace: the workspace to publish to. USes the default workspace if not passed
or None
name: the name for the published layer. Uses the QGIS layer name if not passed
or None
storename: the name for layer's store, if different than layer name, e.g.
when creating a PG data store
'''
if isinstance(layer, basestring):
layer = layers.resolveLayer(layer)
name = name or layer.name()
title = title or name
name = xmlNameFixUp(name)
gslayer = self.catalog.get_layer(name)
if gslayer is not None and not overwrite:
return
sld = self.publishStyle(layer, overwrite, name)
layer = self.preprocess(layer)
if storename is not None:
storename = xmlNameFixUp(storename)
self.upload(layer,
workspace,
overwrite,
name,
storename=storename,
title=title)
if sld is not None:
#assign style to created store
publishing = self.catalog.get_layer(name)
publishing.default_style = self.catalog.get_style(name)
self.catalog.save(publishing)
def publishStyle(self, layer, overwrite = True, name = None):
'''
Publishes the style of a given layer style in the specified catalog. If the overwrite parameter is True,
it will overwrite a style with that name in case it exists
'''
if isinstance(layer, basestring):
layer = layers.resolveLayer(layer)
sld = getGsCompatibleSld(layer)
if sld is not None:
name = name if name is not None else layer.name()
self.catalog.create_style(name, sld, overwrite)
return sld
def testPreuploadVectorHook(self):
settings = QSettings()
oldHookFile = str(settings.value("/OpenGeo/Settings/GeoServer/PreuploadVectorHook", ""))
hookFile = os.path.join(os.path.dirname(__file__), "resources", "vector_hook.py")
settings.setValue("/OpenGeo/Settings/GeoServer/PreuploadVectorHook", hookFile)
self.cat.publishLayer(PT1, self.ws, name = HOOK)
self.assertIsNotNone(self.cat.catalog.get_layer(HOOK))
self.cat.addLayerToProject(HOOK)
layer = layers.resolveLayer(HOOK)
self.assertEqual(1, layer.featureCount())
QgsMapLayerRegistry.instance().removeMapLayer(layer.id())
settings.setValue("/OpenGeo/Settings/GeoServer/PreuploadVectorHook", oldHookFile)
self.cat.catalog.delete(self.cat.catalog.get_layer(HOOK), recurse = True)
def publishStyle(self, layer, overwrite=True, name=None):
'''
Publishes the style of a given layer style in the specified catalog. If the overwrite parameter is True,
it will overwrite a style with that name in case it exists
'''
if isinstance(layer, basestring):
layer = layers.resolveLayer(layer)
sld = getGsCompatibleSld(layer)
if sld is not None:
name = name if name is not None else layer.name()
name = name.replace(" ", "_")
self.catalog.create_style(name, sld, overwrite)
return sld
def testPreuploadVectorHook(self):
if not catalog.processingOk:
print 'skipping testPreuploadVectorHook, processing not installed'
return
settings = QSettings()
oldHookFile = str(settings.value("/OpenGeo/Settings/GeoServer/PreuploadVectorHook", ""))
hookFile = os.path.join(os.path.dirname(__file__), "resources", "vector_hook.py")
settings.setValue("/OpenGeo/Settings/GeoServer/PreuploadVectorHook", hookFile)
self.cat.publishLayer(PT1, self.ws, name = HOOK)
self.assertIsNotNone(self.cat.catalog.get_layer(HOOK))
self.cat.addLayerToProject(HOOK)
layer = layers.resolveLayer(HOOK)
self.assertEqual(1, layer.featureCount())
QgsMapLayerRegistry.instance().removeMapLayer(layer.id())
settings.setValue("/OpenGeo/Settings/GeoServer/PreuploadVectorHook", oldHookFile)
self.cat.catalog.delete(self.cat.catalog.get_layer(HOOK), recurse = True)
def publishLayer (self, layer, workspace=None, overwrite=True, name=None,
storename=None, title=None):
'''
Publishes a QGIS layer.
It creates the corresponding store and the layer itself.
If a pre-upload hook is set, its runs it and publishes the resulting layer
layer: the layer to publish, whether as a QgsMapLayer object or its name in the QGIS TOC.
workspace: the workspace to publish to. USes the default workspace if not passed
or None
name: the name for the published layer. Uses the QGIS layer name if not passed
or None
storename: the name for layer's store, if different than layer name, e.g.
when creating a PG data store
'''
if isinstance(layer, basestring):
layer = layers.resolveLayer(layer)
name = name or layer.name()
title = title or name
name = xmlNameFixUp(name)
gslayer = self.catalog.get_layer(name)
if gslayer is not None and not overwrite:
return
sld = self.publishStyle(layer, overwrite, name)
layer = self.preprocess(layer)
if storename is not None:
storename = xmlNameFixUp(storename)
self.upload(layer, workspace, overwrite, name,
storename=storename, title=title)
if sld is not None:
#assign style to created store
publishing = self.catalog.get_layer(name)
publishing.default_style = self.catalog.get_style(name)
self.catalog.save(publishing)
def publishLayer (self, layer, workspace=None, overwrite=True, name=None,
abstract=None, permissions=None, keywords=()):
'''
Publishes a QGIS layer.
It creates the corresponding store and the layer itself
If the layer is a group layer, it publishes all the layers individually and then creates
the layer group in the server
layer: the layer to publish, whether as a QgsMapLayer object or its name in the QGIS TOC.
catalog. A catalog object with information about the URL of the service to publish to.
workspace: the workspace to publish to. USes the default project if not passed
or None
name: the name for the published layer. Uses the QGIS layer name if not passed
or None
params: a dict with additional configuration parameters if needed
'''
if isinstance(layer, basestring):
layer = layers.resolveLayer(layer)
name = name if name is not None else layer.name()
sld = self.publishStyle(layer, overwrite, name)
self.upload(layer, workspace, overwrite, name)
if sld is not None:
#assign style to created store
publishing = self.catalog.get_layer(name)
publishing.default_style = self.catalog.get_style(name)
self.catalog.save(publishing)
def setUpClass(cls):
cls.explorer = OpenGeoExplorer(singletab = True)
cls.conn1 = getPostgresConnection("conn1")
cls.conn2 = getPostgresConnection("conn2")
cls.toImport = [layers.resolveLayer(PT1)]
def testImportSingleLayerAsSingleGeometries(self):
importToPostGIS(self.explorer, self.conn, [layers.resolveLayer(PT1)], PUBLIC_SCHEMA, PT1, False, True);
schema = Schema(self.conn, PUBLIC_SCHEMA)
table = self.getTable(schema, PT1)
self.assertIsNotNone(table)
self.assertEquals(-1, table.geomtype.find("MULTI"))
def okPressed(self):
self.message = self.text.toPlainText()
if self.showLayerSelector:
self.layer = layers.resolveLayer(self.layerBox.currentText())
self.close()
def upload(self, layer, workspace=None, overwrite=True, name=None):
'''uploads the specified layer'''
if isinstance(layer, basestring):
layer = layers.resolveLayer(layer)
name = name if name is not None else layer.name()
title = name
name = name.replace(" ", "_")
try:
settings = QSettings()
restApi = bool(
settings.value("/OpenGeo/Settings/GeoServer/UseRestApi", True,
bool))
restApi = True # importer api is disabled for now
if layer.type() == layer.RasterLayer:
path = self.getDataFromLayer(layer)
if restApi:
self.catalog.create_coveragestore(name,
path,
workspace=workspace,
overwrite=overwrite)
else:
session = self.client.upload(path)
session.commit()
elif layer.type() == layer.VectorLayer:
provider = layer.dataProvider()
if provider.name() == 'postgres':
connName = self.getConnectionNameFromLayer(layer)
uri = QgsDataSourceURI(provider.dataSourceUri())
self.catalog.create_pg_featurestore(
connName,
workspace=workspace,
overwrite=overwrite,
host=uri.host(),
database=uri.database(),
schema=uri.schema(),
port=uri.port(),
user=uri.username(),
passwd=uri.password())
self.catalog.create_pg_featuretype(uri.table(), connName,
workspace,
layer.crs().authid())
else:
path = self.getDataFromLayer(layer)
if restApi:
try:
self.catalog.create_shp_featurestore(
name,
path,
workspace=workspace,
overwrite=overwrite)
except WindowsError:
#this might be thrown by the create_shp_featurestore method
#when trying to unlink the temp zip file
pass
except Exception, e:
raise e
else:
shpFile = path['shp']
session = self.client.upload(shpFile)
session.commit()
def testImportMultipleLayers(self):
importToPostGIS(self.explorer, self.conn, [layers.resolveLayer(PT1), layers.resolveLayer(PT2)], PUBLIC_SCHEMA, None, False, False);
schema = Schema(self.conn, PUBLIC_SCHEMA)
self.assertIsNotNone(self.getTable(schema, PT1))
self.assertIsNotNone(self.getTable(schema, PT2))
def setUpClass(cls):
cls.explorer = OpenGeoExplorer(singletab = True)
cls.conn1 = getPostgresConnection("conn1")
cls.conn2 = getPostgresConnection("conn2")
cls.toImport = [layers.resolveLayer(PT1)]
