25 changes: 12 additions & 13 deletions python/plugins/processing/admintools/CreateStyleGeoServer.py
View file
Original file line number Diff line number Diff line change
Expand Up @@ -20,21 +20,24 @@
__author__ = 'Victor Olaya'
__date__ = 'October 2012'
__copyright__ = '(C) 2012, Victor Olaya'

# This will get replaced with a git SHA1 when you do a git archive

__revision__ = '$Format:%H$'

from qgis.core import *
from processing.admintools.GeoServerToolsAlgorithm import \
GeoServerToolsAlgorithm
from processing.parameters.ParameterString import ParameterString
from processing.admintools.GeoServerToolsAlgorithm import GeoServerToolsAlgorithm
from processing.parameters.ParameterFile import ParameterFile
from processing.parameters.ParameterBoolean import ParameterBoolean


class CreateStyleGeoServer(GeoServerToolsAlgorithm):

STYLE = "STYLE"
OVERWRITE = "OVERWRITE"
NAME = "NAME"
STYLE = 'STYLE'
OVERWRITE = 'OVERWRITE'
NAME = 'NAME'

def processAlgorithm(self, progress):
self.createCatalog()
Expand All @@ -43,14 +46,10 @@ def processAlgorithm(self, progress):
name = self.getParameterValue(self.NAME)
self.catalog.create_style(name, stylefile, overwrite)


def defineCharacteristics(self):
self.addBaseParameters()
self.name = "Add style"
self.group = "GeoServer management tools"
self.addParameter(ParameterString(self.NAME, "Style name"))
self.addParameter(ParameterFile(self.STYLE, "Style SLD file"))
self.addParameter(ParameterBoolean(self.OVERWRITE, "Overwrite"))



self.name = 'Add style'
self.group = 'GeoServer management tools'
self.addParameter(ParameterString(self.NAME, 'Style name'))
self.addParameter(ParameterFile(self.STYLE, 'Style SLD file'))
self.addParameter(ParameterBoolean(self.OVERWRITE, 'Overwrite'))
23 changes: 12 additions & 11 deletions python/plugins/processing/admintools/CreateWorkspace.py
View file
Original file line number Diff line number Diff line change
Expand Up @@ -20,32 +20,33 @@
__author__ = 'Victor Olaya'
__date__ = 'October 2012'
__copyright__ = '(C) 2012, Victor Olaya'

# This will get replaced with a git SHA1 when you do a git archive

__revision__ = '$Format:%H$'

from qgis.core import *
from processing.admintools.GeoServerToolsAlgorithm import \
GeoServerToolsAlgorithm
from processing.parameters.ParameterString import ParameterString
from processing.admintools.GeoServerToolsAlgorithm import GeoServerToolsAlgorithm
from processing.outputs.OutputString import OutputString


class CreateWorkspace(GeoServerToolsAlgorithm):

WORKSPACE = "WORKSPACE"
WORKSPACEURI = "WORKSPACEURI"
WORKSPACE = 'WORKSPACE'
WORKSPACEURI = 'WORKSPACEURI'

def processAlgorithm(self, progress):
self.createCatalog()
workspaceName = self.getParameterValue(self.WORKSPACE)
workspaceUri = self.getParameterValue(self.WORKSPACEURI)
self.catalog.create_workspace(workspaceName, workspaceUri)


def defineCharacteristics(self):
self.addBaseParameters()
self.name = "Create workspace"
self.group = "GeoServer management tools"
self.addParameter(ParameterString(self.WORKSPACE, "Workspace"))
self.addParameter(ParameterString(self.WORKSPACEURI, "Workspace URI"))
self.addOutput(OutputString(self.WORKSPACE, "Workspace"))


self.name = 'Create workspace'
self.group = 'GeoServer management tools'
self.addParameter(ParameterString(self.WORKSPACE, 'Workspace'))
self.addParameter(ParameterString(self.WORKSPACEURI, 'Workspace URI'))
self.addOutput(OutputString(self.WORKSPACE, 'Workspace'))
22 changes: 11 additions & 11 deletions python/plugins/processing/admintools/DeleteDatastore.py
View file
Original file line number Diff line number Diff line change
Expand Up @@ -20,17 +20,21 @@
__author__ = 'Victor Olaya'
__date__ = 'October 2012'
__copyright__ = '(C) 2012, Victor Olaya'

# This will get replaced with a git SHA1 when you do a git archive

__revision__ = '$Format:%H$'

from qgis.core import *
from processing.admintools.GeoServerToolsAlgorithm import \
GeoServerToolsAlgorithm
from processing.parameters.ParameterString import ParameterString
from processing.admintools.GeoServerToolsAlgorithm import GeoServerToolsAlgorithm


class DeleteDatastore(GeoServerToolsAlgorithm):

DATASTORE = "DATASTORE"
WORKSPACE = "WORKSPACE"
DATASTORE = 'DATASTORE'
WORKSPACE = 'WORKSPACE'

def processAlgorithm(self, progress):
self.createCatalog()
Expand All @@ -39,13 +43,9 @@ def processAlgorithm(self, progress):
ds = self.catalog.get_store(datastoreName, workspaceName)
self.catalog.delete(ds, recurse=True)


def defineCharacteristics(self):
self.addBaseParameters()
self.name = "Delete datastore"
self.group = "GeoServer management tools"
self.addParameter(ParameterString(self.DATASTORE, "Datastore name"))
self.addParameter(ParameterString(self.WORKSPACE, "Workspace"))



self.name = 'Delete datastore'
self.group = 'GeoServer management tools'
self.addParameter(ParameterString(self.DATASTORE, 'Datastore name'))
self.addParameter(ParameterString(self.WORKSPACE, 'Workspace'))
18 changes: 9 additions & 9 deletions python/plugins/processing/admintools/DeleteWorkspace.py
View file
Original file line number Diff line number Diff line change
Expand Up @@ -20,29 +20,29 @@
__author__ = 'Victor Olaya'
__date__ = 'October 2012'
__copyright__ = '(C) 2012, Victor Olaya'

# This will get replaced with a git SHA1 when you do a git archive

__revision__ = '$Format:%H$'

from qgis.core import *
from processing.admintools.GeoServerToolsAlgorithm import \
GeoServerToolsAlgorithm
from processing.parameters.ParameterString import ParameterString
from processing.admintools.GeoServerToolsAlgorithm import GeoServerToolsAlgorithm


class DeleteWorkspace(GeoServerToolsAlgorithm):

WORKSPACE = "WORKSPACE"
WORKSPACE = 'WORKSPACE'

def processAlgorithm(self, progress):
self.createCatalog()
workspaceName = self.getParameterValue(self.WORKSPACE)
ws = self.catalog.get_workspace(workspaceName)
self.catalog.delete(ws)


def defineCharacteristics(self):
self.addBaseParameters()
self.name = "Delete workspace"
self.group = "GeoServer management tools"
self.addParameter(ParameterString(self.WORKSPACE, "Workspace"))



self.name = 'Delete workspace'
self.group = 'GeoServer management tools'
self.addParameter(ParameterString(self.WORKSPACE, 'Workspace'))
26 changes: 15 additions & 11 deletions python/plugins/processing/admintools/GeoServerToolsAlgorithm.py
View file
Original file line number Diff line number Diff line change
Expand Up @@ -16,37 +16,41 @@
* *
***************************************************************************
"""
from processing.parameters.ParameterString import ParameterString
from processing.admintools.geoserver.catalog import Catalog

__author__ = 'Victor Olaya'
__date__ = 'October 2012'
__copyright__ = '(C) 2012, Victor Olaya'

# This will get replaced with a git SHA1 when you do a git archive

__revision__ = '$Format:%H$'

import os
from PyQt4 import QtGui
from processing.core.GeoAlgorithm import GeoAlgorithm
from processing.parameters.ParameterString import ParameterString
from processing.admintools.geoserver.catalog import Catalog


class GeoServerToolsAlgorithm(GeoAlgorithm):

URL = "URL"
USER = "USER"
PASSWORD = "PASSWORD"
URL = 'URL'
USER = 'USER'
PASSWORD = 'PASSWORD'

def getIcon(self):
return QtGui.QIcon(os.path.dirname(__file__) + "/../images/geoserver.png")
return QtGui.QIcon(os.path.dirname(__file__)
+ '/../images/geoserver.png')

def addBaseParameters(self):
self.addParameter(ParameterString(self.URL, "URL", "http://localhost:8080/geoserver/rest"))
self.addParameter(ParameterString(self.USER, "User", "admin"))
self.addParameter(ParameterString(self.PASSWORD, "Password", "geoserver"))
self.addParameter(ParameterString(self.URL, 'URL',
'http://localhost:8080/geoserver/rest'))
self.addParameter(ParameterString(self.USER, 'User', 'admin'))
self.addParameter(ParameterString(self.PASSWORD, 'Password',
'geoserver'))

def createCatalog(self):
url = self.getParameterValue(self.URL)
user = self.getParameterValue(self.USER)
password = self.getParameterValue(self.PASSWORD)
self.catalog = Catalog(url, user, password)


101 changes: 58 additions & 43 deletions python/plugins/processing/admintools/ImportIntoPostGIS.py
View file
Original file line number Diff line number Diff line change
Expand Up @@ -16,92 +16,107 @@
* *
***************************************************************************
"""
from processing.tools import dataobjects

__author__ = 'Victor Olaya'
__date__ = 'October 2012'
__copyright__ = '(C) 2012, Victor Olaya'

# This will get replaced with a git SHA1 when you do a git archive

__revision__ = '$Format:%H$'

import os
from processing.parameters.ParameterBoolean import ParameterBoolean
from processing.parameters.ParameterVector import ParameterVector
from processing.core.GeoAlgorithm import GeoAlgorithm
from processing.core.GeoAlgorithmExecutionException import GeoAlgorithmExecutionException
from qgis.core import *
from PyQt4.QtCore import *
from PyQt4.QtGui import *
from qgis.core import *
from processing.core.GeoAlgorithm import GeoAlgorithm
from processing.core.GeoAlgorithmExecutionException import \
GeoAlgorithmExecutionException
from processing.parameters.ParameterBoolean import ParameterBoolean
from processing.parameters.ParameterVector import ParameterVector
from processing.parameters.ParameterString import ParameterString
from processing.tools import dataobjects

from processing.admintools import postgis_utils


class ImportIntoPostGIS(GeoAlgorithm):

DATABASE = "DATABASE"
TABLENAME = "TABLENAME"
SCHEMA = "SCHEMA"
INPUT = "INPUT"
OVERWRITE = "OVERWRITE"
CREATEINDEX = "CREATEINDEX"
DATABASE = 'DATABASE'
TABLENAME = 'TABLENAME'
SCHEMA = 'SCHEMA'
INPUT = 'INPUT'
OVERWRITE = 'OVERWRITE'
CREATEINDEX = 'CREATEINDEX'

def getIcon(self):
return QIcon(os.path.dirname(__file__) + "/../images/postgis.png")
return QIcon(os.path.dirname(__file__) + '/../images/postgis.png')

def processAlgorithm(self, progress):
connection = self.getParameterValue(self.DATABASE)
schema = self.getParameterValue(self.SCHEMA)
overwrite = self.getParameterValue(self.OVERWRITE)
createIndex = self.getParameterValue(self.CREATEINDEX)
settings = QSettings()
mySettings = "/PostgreSQL/connections/"+ connection
mySettings = '/PostgreSQL/connections/' + connection
try:
database = settings.value(mySettings+"/database")
username = settings.value(mySettings+"/username")
host = settings.value(mySettings+"/host")
port = settings.value(mySettings+"/port", type = int)
password = settings.value(mySettings+"/password")
database = settings.value(mySettings + '/database')
username = settings.value(mySettings + '/username')
host = settings.value(mySettings + '/host')
port = settings.value(mySettings + '/port', type=int)
password = settings.value(mySettings + '/password')
except Exception, e:
raise GeoAlgorithmExecutionException("Wrong database connection name: " + connection)
raise GeoAlgorithmExecutionException(
'Wrong database connection name: ' + connection)

table = self.getParameterValue(self.TABLENAME);
table.replace(" ", "")
providerName = "postgres"
table = self.getParameterValue(self.TABLENAME)
table.replace(' ', '')
providerName = 'postgres'

try:
db = postgis_utils.GeoDB(host=host, port=port, dbname=database, user=username, passwd=password)
db = postgis_utils.GeoDB(host=host, port=port, dbname=database,
user=username, passwd=password)
except postgis_utils.DbError, e:
raise GeoAlgorithmExecutionException("Couldn't connect to database:\n"+e.message)
raise GeoAlgorithmExecutionException(
"Couldn't connect to database:\n" + e.message)

uri = QgsDataSourceURI()
uri.setConnection(host, str(port), database, username, password)
uri.setDataSource(schema, table, "the_geom", "")
uri.setDataSource(schema, table, 'the_geom', '')

options = {}
if overwrite:
options['overwrite'] = True

layerUri = self.getParameterValue(self.INPUT);
layerUri = self.getParameterValue(self.INPUT)
layer = dataobjects.getObjectFromUri(layerUri)
ret, errMsg = QgsVectorLayerImport.importLayer(layer, uri.uri(), providerName, self.crs, False, False, options)
(ret, errMsg) = QgsVectorLayerImport.importLayer(
layer,
uri.uri(),
providerName,
self.crs,
False,
False,
options,
)
if ret != 0:
raise GeoAlgorithmExecutionException(u"Error importing to PostGIS\n%s" % errMsg)
raise GeoAlgorithmExecutionException(
'Error importing to PostGIS\n%s' % errMsg)

if createIndex:
db.create_spatial_index(table, schema, "the_geom")
db.create_spatial_index(table, schema, 'the_geom')

db.vacuum_analyze(table, schema)

def defineCharacteristics(self):
self.name = "Import into PostGIS"
self.group = "PostGIS management tools"
self.addParameter(ParameterVector(self.INPUT, "Layer to import"))
self.addParameter(ParameterString(self.DATABASE, "Database (connection name)"))
self.addParameter(ParameterString(self.SCHEMA, "Schema (schema name)"))
self.addParameter(ParameterString(self.TABLENAME, "Table to import to"))
self.addParameter(ParameterBoolean(self.OVERWRITE, "Overwrite", True))
self.addParameter(ParameterBoolean(self.CREATEINDEX, "Create spatial index", True))





self.name = 'Import into PostGIS'
self.group = 'PostGIS management tools'
self.addParameter(ParameterVector(self.INPUT, 'Layer to import'))
self.addParameter(ParameterString(self.DATABASE,
'Database (connection name)'))
self.addParameter(ParameterString(self.SCHEMA, 'Schema (schema name)'))
self.addParameter(ParameterString(self.TABLENAME, 'Table to import to'
))
self.addParameter(ParameterBoolean(self.OVERWRITE, 'Overwrite', True))
self.addParameter(ParameterBoolean(self.CREATEINDEX,
'Create spatial index', True))
25 changes: 13 additions & 12 deletions python/plugins/processing/admintools/ImportRasterIntoGeoServer.py
View file
Original file line number Diff line number Diff line change
Expand Up @@ -20,20 +20,23 @@
__author__ = 'Victor Olaya'
__date__ = 'October 2012'
__copyright__ = '(C) 2012, Victor Olaya'

# This will get replaced with a git SHA1 when you do a git archive

__revision__ = '$Format:%H$'

from qgis.core import *
from processing.admintools.GeoServerToolsAlgorithm import \
GeoServerToolsAlgorithm
from processing.parameters.ParameterString import ParameterString
from processing.admintools.GeoServerToolsAlgorithm import GeoServerToolsAlgorithm
from processing.parameters.ParameterRaster import ParameterRaster


class ImportRasterIntoGeoServer(GeoServerToolsAlgorithm):

INPUT = "INPUT"
WORKSPACE = "WORKSPACE"
NAME = "NAME"
INPUT = 'INPUT'
WORKSPACE = 'WORKSPACE'
NAME = 'NAME'

def exportRasterLayer(self, inputFilename):
return inputFilename
Expand All @@ -46,15 +49,13 @@ def processAlgorithm(self, progress):
filename = self.exportRasterLayer(inputFilename)
workspace = self.catalog.get_workspace(workspaceName)
ds = self.catalog.create_coveragestore2(name, workspace)
ds.data_url = "file:" + filename;
ds.data_url = 'file:' + filename
self.catalog.save(ds)


def defineCharacteristics(self):
self.addBaseParameters()
self.name = "Import raster into GeoServer"
self.group = "GeoServer management tools"
self.addParameter(ParameterRaster(self.INPUT, "Layer to import"))
self.addParameter(ParameterString(self.WORKSPACE, "Workspace"))
self.addParameter(ParameterString(self.NAME, "Store name"))

self.name = 'Import raster into GeoServer'
self.group = 'GeoServer management tools'
self.addParameter(ParameterRaster(self.INPUT, 'Layer to import'))
self.addParameter(ParameterString(self.WORKSPACE, 'Workspace'))
self.addParameter(ParameterString(self.NAME, 'Store name'))
31 changes: 17 additions & 14 deletions python/plugins/processing/admintools/ImportVectorIntoGeoServer.py
View file
Original file line number Diff line number Diff line change
Expand Up @@ -20,21 +20,24 @@
__author__ = 'Victor Olaya'
__date__ = 'October 2012'
__copyright__ = '(C) 2012, Victor Olaya'

# This will get replaced with a git SHA1 when you do a git archive

__revision__ = '$Format:%H$'

import os
from qgis.core import *
from processing.admintools.GeoServerToolsAlgorithm import \
GeoServerToolsAlgorithm
from processing.parameters.ParameterVector import ParameterVector
from processing.tools import dataobjects
from processing.tools import dataobjects
from processing.parameters.ParameterString import ParameterString
from processing.admintools.GeoServerToolsAlgorithm import GeoServerToolsAlgorithm
from processing.tools import dataobjects


class ImportVectorIntoGeoServer(GeoServerToolsAlgorithm):

INPUT = "INPUT"
WORKSPACE = "WORKSPACE"
INPUT = 'INPUT'
WORKSPACE = 'WORKSPACE'

def processAlgorithm(self, progress):
self.createCatalog()
Expand All @@ -43,22 +46,22 @@ def processAlgorithm(self, progress):
workspaceName = self.getParameterValue(self.WORKSPACE)
filename = dataobjects.exportVectorLayer(layer)
basefilename = os.path.basename(filename)
basepathname = os.path.dirname(filename) + os.sep + basefilename[:basefilename.find('.')]
basepathname = os.path.dirname(filename) + os.sep \
+ basefilename[:basefilename.find('.')]
connection = {
'shp': basepathname + '.shp',
'shx': basepathname + '.shx',
'dbf': basepathname + '.dbf',
'prj': basepathname + '.prj'
}
'prj': basepathname + '.prj',
}

workspace = self.catalog.get_workspace(workspaceName)
self.catalog.create_featurestore(basefilename, connection, workspace)


def defineCharacteristics(self):
self.addBaseParameters()
self.name = "Import vector into GeoServer"
self.group = "GeoServer management tools"
self.addParameter(ParameterVector(self.INPUT, "Layer to import", [ParameterVector.VECTOR_TYPE_ANY]))
self.addParameter(ParameterString(self.WORKSPACE, "Workspace"))

self.name = 'Import vector into GeoServer'
self.group = 'GeoServer management tools'
self.addParameter(ParameterVector(self.INPUT, 'Layer to import',
[ParameterVector.VECTOR_TYPE_ANY]))
self.addParameter(ParameterString(self.WORKSPACE, 'Workspace'))
51 changes: 28 additions & 23 deletions python/plugins/processing/admintools/PostGISExecuteSQL.py
View file
Original file line number Diff line number Diff line change
Expand Up @@ -16,59 +16,64 @@
* *
***************************************************************************
"""
from processing.core.GeoAlgorithm import GeoAlgorithm

__author__ = 'Victor Olaya, Carterix Geomatics'
__date__ = 'October 2012'
__copyright__ = '(C) 2012, Victor Olaya, Carterix Geomatics'

# This will get replaced with a git SHA1 when you do a git archive

__revision__ = '$Format:%H$'

import os
from qgis.core import *
from PyQt4.QtCore import *
from PyQt4.QtGui import *
from processing.core.GeoAlgorithm import GeoAlgorithm
from processing.core.GeoAlgorithmExecutionException import \
GeoAlgorithmExecutionException
from processing.parameters.ParameterString import ParameterString
from processing.admintools import postgis_utils
from processing.core.GeoAlgorithmExecutionException import GeoAlgorithmExecutionException


class PostGISExecuteSQL(GeoAlgorithm):

DATABASE = "DATABASE"
SQL = "SQL"
DATABASE = 'DATABASE'
SQL = 'SQL'

def getIcon(self):
return QIcon(os.path.dirname(__file__) + "/../images/postgis.png")
return QIcon(os.path.dirname(__file__) + '/../images/postgis.png')

def processAlgorithm(self, progress):

connection = self.getParameterValue(self.DATABASE)
settings = QSettings()
mySettings = "/PostgreSQL/connections/"+ connection
mySettings = '/PostgreSQL/connections/' + connection
try:
database = settings.value(mySettings+"/database")
username = settings.value(mySettings+"/username")
host = settings.value(mySettings+"/host")
port = settings.value(mySettings+"/port", type = int)
password = settings.value(mySettings+"/password")
database = settings.value(mySettings + '/database')
username = settings.value(mySettings + '/username')
host = settings.value(mySettings + '/host')
port = settings.value(mySettings + '/port', type=int)
password = settings.value(mySettings + '/password')
except Exception, e:
raise GeoAlgorithmExecutionException("Wrong database connection name: " + connection)
raise GeoAlgorithmExecutionException(
'Wrong database connection name: ' + connection)
try:
self.db = postgis_utils.GeoDB(host=host, port=port, dbname=database, user=username, passwd=password)
self.db = postgis_utils.GeoDB(host=host, port=port,
dbname=database, user=username, passwd=password)
except postgis_utils.DbError, e:
raise GeoAlgorithmExecutionException("Couldn't connect to database:\n"+e.message)
raise GeoAlgorithmExecutionException(
"Couldn't connect to database:\n" + e.message)

sql = self.getParameterValue(self.SQL).replace("\n", " ")
sql = self.getParameterValue(self.SQL).replace('\n', ' ')
try:
self.db._exec_sql_and_commit(str(sql))
except postgis_utils.DbError, e:
raise GeoAlgorithmExecutionException("Error executing SQL:\n"+e.message)
raise GeoAlgorithmExecutionException('Error executing SQL:\n'
+ e.message)

def defineCharacteristics(self):
self.name = "PostGIS execute SQL"
self.group = "PostGIS management tools"
self.addParameter(ParameterString(self.DATABASE, "Database"))
self.addParameter(ParameterString(self.SQL, "SQL query", "", True))



self.name = 'PostGIS execute SQL'
self.group = 'PostGIS management tools'
self.addParameter(ParameterString(self.DATABASE, 'Database'))
self.addParameter(ParameterString(self.SQL, 'SQL query', '', True))
354 changes: 198 additions & 156 deletions python/plugins/processing/admintools/geoserver/catalog.py
View file

Large diffs are not rendered by default.

96 changes: 50 additions & 46 deletions python/plugins/processing/admintools/geoserver/layer.py
View file
Original file line number Diff line number Diff line change
Expand Up @@ -20,22 +20,28 @@
__author__ = 'Victor Olaya'
__date__ = 'November 2012'
__copyright__ = '(C) 2012, Victor Olaya'

# This will get replaced with a git SHA1 when you do a git archive

__revision__ = '$Format:%H$'

from processing.admintools.geoserver.support import ResourceInfo, xml_property, write_bool, url
from processing.admintools.geoserver.style import Style
from processing.admintools.geoserver.support import ResourceInfo, \
xml_property, write_bool, url


class _attribution(object):

def __init__(self, title, width, height):
self.title = title
self.width = width
self.height = height


def _read_attribution(node):
title = node.find("title")
width = node.find("logoWidth")
height = node.find("logoHeight")
title = node.find('title')
width = node.find('logoWidth')
height = node.find('logoHeight')

if title is not None:
title = title.text
Expand All @@ -46,69 +52,73 @@ def _read_attribution(node):

return _attribution(title, width, height)


def _write_attribution(builder, attr):
builder.start("attribution", dict())
builder.start('attribution', dict())
if attr.title is not None:
builder.start("title", dict())
builder.start('title', dict())
builder.data(attr.title)
builder.end("title")
builder.end('title')
if attr.width is not None:
builder.start("logoWidth", dict())
builder.start('logoWidth', dict())
builder.data(attr.width)
builder.end("logoWidth")
builder.end('logoWidth')
if attr.height is not None:
builder.start("logoHeight", dict())
builder.start('logoHeight', dict())
builder.data(attr.height)
builder.end("logoHeight")
builder.end("attribution")
builder.end('logoHeight')
builder.end('attribution')


def _write_default_style(builder, name):
builder.start("defaultStyle", dict())
builder.start('defaultStyle', dict())
if name is not None:
builder.start("name", dict())
builder.start('name', dict())
builder.data(name)
builder.end("name")
builder.end("defaultStyle")
builder.end('name')
builder.end('defaultStyle')


def _write_alternate_styles(builder, styles):
builder.start("styles", dict())
builder.start('styles', dict())
for s in styles:
builder.start("style", dict())
builder.start("name", dict())
builder.start('style', dict())
builder.start('name', dict())
builder.data(s.name)
builder.end("name")
builder.end("style")
builder.end("styles")
builder.end('name')
builder.end('style')
builder.end('styles')


class Layer(ResourceInfo):

def __init__(self, catalog, name):
super(Layer, self).__init__()
self.catalog = catalog
self.name = name

resource_type = "layer"
save_method = "PUT"
resource_type = 'layer'
save_method = 'PUT'

@property
def href(self):
return url(self.catalog.service_url, ["layers", self.name + ".xml"])
return url(self.catalog.service_url, ['layers', self.name + '.xml'])

@property
def resource(self):
if self.dom is None:
self.fetch()
name = self.dom.find("resource/name").text
name = self.dom.find('resource/name').text
return self.catalog.get_resource(name)

def _get_default_style(self):
if 'default_style' in self.dirty:
return self.dirty['default_style']
if self.dom is None:
self.fetch()
name = self.dom.find("defaultStyle/name")
# aborted data uploads can result in no default style
name = self.dom.find('defaultStyle/name')

# Aborted data uploads can result in no default style
if name is not None:
return self.catalog.get_style(name.text)
else:
Expand All @@ -117,41 +127,35 @@ def _get_default_style(self):
def _set_default_style(self, style):
if isinstance(style, Style):
style = style.name
self.dirty["default_style"] = style
self.dirty['default_style'] = style

def _get_alternate_styles(self):
if "alternate_styles" in self.dirty:
return self.dirty["alternate_styles"]
if 'alternate_styles' in self.dirty:
return self.dirty['alternate_styles']
if self.dom is None:
self.fetch()
styles = self.dom.findall("styles/style/name")
styles = self.dom.findall('styles/style/name')
return [Style(self.catalog, s.text) for s in styles]

def _set_alternate_styles(self, styles):
self.dirty["alternate_styles"] = styles
self.dirty['alternate_styles'] = styles

default_style = property(_get_default_style, _set_default_style)
styles = property(_get_alternate_styles, _set_alternate_styles)

attribution_object = xml_property("attribution", _read_attribution)
enabled = xml_property("enabled", lambda x: x.text == "true")
attribution_object = xml_property('attribution', _read_attribution)
enabled = xml_property('enabled', lambda x: x.text == 'true')

def _get_attr_text(self):
return self.attribution_object.title

def _set_attr_text(self, text):
self.dirty["attribution"] = _attribution(
text,
self.attribution_object.width,
self.attribution_object.height
)
self.dirty['attribution'] = _attribution(text,
self.attribution_object.width, self.attribution_object.height)
assert self.attribution_object.title == text

attribution = property(_get_attr_text, _set_attr_text)

writers = dict(
attribution = _write_attribution,
enabled = write_bool("enabled"),
default_style = _write_default_style,
alternate_styles = _write_alternate_styles
)
writers = dict(attribution=_write_attribution, enabled=write_bool('enabled'
), default_style=_write_default_style,
alternate_styles=_write_alternate_styles)
76 changes: 42 additions & 34 deletions python/plugins/processing/admintools/geoserver/layergroup.py
View file
Original file line number Diff line number Diff line change
Expand Up @@ -20,55 +20,62 @@
__author__ = 'David Winslow'
__date__ = 'November 2012'
__copyright__ = '(C) 2012, David Winslow'

# This will get replaced with a git SHA1 when you do a git archive

__revision__ = '$Format:%H$'

from processing.admintools.geoserver.support import ResourceInfo, bbox, write_bbox, \
write_string, xml_property, url
from processing.admintools.geoserver.support import ResourceInfo, bbox, \
write_bbox, write_string, xml_property, url


def _maybe_text(n):
if n is None:
return None
else:
return n.text


def _layer_list(node):
if node is not None:
return [_maybe_text(n.find("name")) for n in node.findall("layer")]
return [_maybe_text(n.find('name')) for n in node.findall('layer')]


def _style_list(node):
if node is not None:
return [_maybe_text(n.find("name")) for n in node.findall("style")]
return [_maybe_text(n.find('name')) for n in node.findall('style')]


def _write_layers(builder, layers):
builder.start("layers", dict())
builder.start('layers', dict())
for l in layers:
builder.start("layer", dict())
builder.start('layer', dict())
if l is not None:
builder.start("name", dict())
builder.start('name', dict())
builder.data(l)
builder.end("name")
builder.end("layer")
builder.end("layers")
builder.end('name')
builder.end('layer')
builder.end('layers')


def _write_styles(builder, styles):
builder.start("styles", dict())
builder.start('styles', dict())
for s in styles:
builder.start("style", dict())
builder.start('style', dict())
if s is not None:
builder.start("name", dict())
builder.start('name', dict())
builder.data(s)
builder.end("name")
builder.end("style")
builder.end("styles")
builder.end('name')
builder.end('style')
builder.end('styles')


class LayerGroup(ResourceInfo):
"""
Represents a layer group in geoserver
"""Represents a layer group in geoserver.
"""

resource_type = "layerGroup"
save_method = "PUT"
resource_type = 'layerGroup'
save_method = 'PUT'

def __init__(self, catalog, name):
super(LayerGroup, self).__init__()
Expand All @@ -80,30 +87,31 @@ def __init__(self, catalog, name):

@property
def href(self):
return url(self.catalog.service_url, ["layergroups", self.name + ".xml"])
return url(self.catalog.service_url, ['layergroups', self.name + '.xml'
])

styles = xml_property("styles", _style_list)
layers = xml_property("layers", _layer_list)
bounds = xml_property("bounds", bbox)
styles = xml_property('styles', _style_list)
layers = xml_property('layers', _layer_list)
bounds = xml_property('bounds', bbox)

writers = dict(
name = write_string("name"),
styles = _write_styles,
layers = _write_layers,
bounds = write_bbox("bounds")
)
writers = dict(name=write_string('name'), styles=_write_styles,
layers=_write_layers, bounds=write_bbox('bounds'))

def __str__(self):
return "<LayerGroup %s>" % self.name
return '<LayerGroup %s>' % self.name

__repr__ = __str__


class UnsavedLayerGroup(LayerGroup):
save_method = "POST"

save_method = 'POST'

def __init__(self, catalog, name, layers, styles, bounds):
super(UnsavedLayerGroup, self).__init__(catalog, name)
self.dirty.update(name = name, layers = layers, styles = styles, bounds = bounds)
self.dirty.update(name=name, layers=layers, styles=styles,
bounds=bounds)

@property
def href(self):
return "%s/layergroups?name=%s" % (self.catalog.service_url, self.name)
return '%s/layergroups?name=%s' % (self.catalog.service_url, self.name)
222 changes: 125 additions & 97 deletions python/plugins/processing/admintools/geoserver/resource.py
View file
Original file line number Diff line number Diff line change
Expand Up @@ -20,55 +20,68 @@
__author__ = 'David Winslow'
__date__ = 'November 2012'
__copyright__ = '(C) 2012, David Winslow'

# This will get replaced with a git SHA1 when you do a git archive

__revision__ = '$Format:%H$'

from processing.admintools.geoserver.support import ResourceInfo, xml_property, write_string, bbox, \
write_bbox, string_list, write_string_list, attribute_list, write_bool, url
from processing.admintools.geoserver.support import ResourceInfo, \
xml_property, write_string, bbox, write_bbox, string_list, \
write_string_list, attribute_list, write_bool, url


def md_link(node):
"""Extract a metadata link tuple from an xml node"""
mimetype = node.find("type")
mdtype = node.find("metadataType")
content = node.find("content")

mimetype = node.find('type')
mdtype = node.find('metadataType')
content = node.find('content')
if None in [mimetype, mdtype, content]:
return None
else:
return (mimetype.text, mdtype.text, content.text)


def metadata_link_list(node):
if node is not None:
return [md_link(n) for n in node.findall("metadataLink")]
return [md_link(n) for n in node.findall('metadataLink')]


def write_metadata_link_list(name):

def write(builder, md_links):
builder.start(name, dict())
for (mime, md_type, content_url) in md_links:
builder.start("metadataLink", dict())
builder.start("type", dict())
builder.start('metadataLink', dict())
builder.start('type', dict())
builder.data(mime)
builder.end("type")
builder.start("metadataType", dict())
builder.end('type')
builder.start('metadataType', dict())
builder.data(md_type)
builder.end("metadataType")
builder.start("content", dict())
builder.end('metadataType')
builder.start('content', dict())
builder.data(content_url)
builder.end("content")
builder.end("metadataLink")
builder.end("metadataLinks")
builder.end('content')
builder.end('metadataLink')
builder.end('metadataLinks')

return write


def featuretype_from_index(catalog, workspace, store, node):
name = node.find("name")
name = node.find('name')
return FeatureType(catalog, workspace, store, name.text)


def coverage_from_index(catalog, workspace, store, node):
name = node.find("name")
name = node.find('name')
return Coverage(catalog, workspace, store, name.text)


class FeatureType(ResourceInfo):
resource_type = "featureType"
save_method = "PUT"

resource_type = 'featureType'
save_method = 'PUT'

def __init__(self, catalog, workspace, store, name):
super(FeatureType, self).__init__()
Expand All @@ -83,78 +96,89 @@ def __init__(self, catalog, workspace, store, name):

@property
def href(self):
return url(self.catalog.service_url,
["workspaces", self.workspace.name,
"datastores", self.store.name,
"featuretypes", self.name + ".xml"])

title = xml_property("title")
abstract = xml_property("abstract")
enabled = xml_property("enabled")
native_bbox = xml_property("nativeBoundingBox", bbox)
latlon_bbox = xml_property("latLonBoundingBox", bbox)
projection = xml_property("srs")
projection_policy = xml_property("projectionPolicy")
keywords = xml_property("keywords", string_list)
attributes = xml_property("attributes", attribute_list)
metadata_links = xml_property("metadataLinks", metadata_link_list)
return url(self.catalog.service_url, [
'workspaces',
self.workspace.name,
'datastores',
self.store.name,
'featuretypes',
self.name + '.xml',
])

title = xml_property('title')
abstract = xml_property('abstract')
enabled = xml_property('enabled')
native_bbox = xml_property('nativeBoundingBox', bbox)
latlon_bbox = xml_property('latLonBoundingBox', bbox)
projection = xml_property('srs')
projection_policy = xml_property('projectionPolicy')
keywords = xml_property('keywords', string_list)
attributes = xml_property('attributes', attribute_list)
metadata_links = xml_property('metadataLinks', metadata_link_list)

writers = dict(
title = write_string("title"),
abstract = write_string("abstract"),
enabled = write_bool("enabled"),
nativeBoundingBox = write_bbox("nativeBoundingBox"),
latLonBoundingBox = write_bbox("latLonBoundingBox"),
srs = write_string("srs"),
projectionPolicy = write_string("projectionPolicy"),
keywords = write_string_list("keywords"),
metadataLinks = write_metadata_link_list("metadataLinks")
)
title=write_string('title'),
abstract=write_string('abstract'),
enabled=write_bool('enabled'),
nativeBoundingBox=write_bbox('nativeBoundingBox'),
latLonBoundingBox=write_bbox('latLonBoundingBox'),
srs=write_string('srs'),
projectionPolicy=write_string('projectionPolicy'),
keywords=write_string_list('keywords'),
metadataLinks=write_metadata_link_list('metadataLinks'),
)


class CoverageDimension(object):

def __init__(self, name, description, dimension_range):
self.name = name
self.description = description
self.dimension_range = dimension_range


def coverage_dimension(node):
name = node.find("name")
name = name.text if name is not None else None
description = node.find("description")
description = description.text if description is not None else None
range_min = node.find("range/min")
range_max = node.find("range/max")
name = node.find('name')
name = (name.text if name is not None else None)
description = node.find('description')
description = (description.text if description is not None else None)
range_min = node.find('range/min')
range_max = node.find('range/max')
dimension_range = None
if None not in [min, max]:
dimension_range = float(range_min.text), float(range_max.text)
dimension_range = (float(range_min.text), float(range_max.text))
if None not in [name, description]:
return CoverageDimension(name, description, dimension_range)
else:
return None # should we bomb out more spectacularly here?
# Should we bomb out more spectacularly here?
return None


def coverage_dimension_xml(builder, dimension):
builder.start("coverageDimension", dict())
builder.start("name", dict())
builder.start('coverageDimension', dict())
builder.start('name', dict())
builder.data(dimension.name)
builder.end("name")
builder.end('name')

builder.start("description", dict())
builder.start('description', dict())
builder.data(dimension.description)
builder.end("description")
builder.end('description')

if dimension.range is not None:
builder.start("range", dict())
builder.start("min", dict())
builder.start('range', dict())
builder.start('min', dict())
builder.data(str(dimension.range[0]))
builder.end("min")
builder.start("max", dict())
builder.end('min')
builder.start('max', dict())
builder.data(str(dimension.range[1]))
builder.end("max")
builder.end("range")
builder.end('max')
builder.end('range')

builder.end('coverageDimension')

builder.end("coverageDimension")

class Coverage(ResourceInfo):

def __init__(self, catalog, workspace, store, name):
super(Coverage, self).__init__()
self.catalog = catalog
Expand All @@ -164,38 +188,42 @@ def __init__(self, catalog, workspace, store, name):

@property
def href(self):
return url(self.catalog.service_url,
["workspaces", self.workspace.name,
"coveragestores", self.store.name,
"coverages", self.name + ".xml"])

resource_type = "coverage"
save_method = "PUT"

title = xml_property("title")
abstract = xml_property("abstract")
enabled = xml_property("enabled")
native_bbox = xml_property("nativeBoundingBox", bbox)
latlon_bbox = xml_property("latLonBoundingBox", bbox)
projection = xml_property("srs")
projection_policy = xml_property("projectionPolicy")
keywords = xml_property("keywords", string_list)
request_srs_list = xml_property("requestSRS", string_list)
response_srs_list = xml_property("responseSRS", string_list)
supported_formats = xml_property("supportedFormats", string_list)
metadata_links = xml_property("metadataLinks", metadata_link_list)
return url(self.catalog.service_url, [
'workspaces',
self.workspace.name,
'coveragestores',
self.store.name,
'coverages',
self.name + '.xml',
])

resource_type = 'coverage'
save_method = 'PUT'

title = xml_property('title')
abstract = xml_property('abstract')
enabled = xml_property('enabled')
native_bbox = xml_property('nativeBoundingBox', bbox)
latlon_bbox = xml_property('latLonBoundingBox', bbox)
projection = xml_property('srs')
projection_policy = xml_property('projectionPolicy')
keywords = xml_property('keywords', string_list)
request_srs_list = xml_property('requestSRS', string_list)
response_srs_list = xml_property('responseSRS', string_list)
supported_formats = xml_property('supportedFormats', string_list)
metadata_links = xml_property('metadataLinks', metadata_link_list)

writers = dict(
title = write_string("title"),
abstract = write_string("abstract"),
enabled = write_bool("enabled"),
nativeBoundingBox = write_bbox("nativeBoundingBox"),
latLonBoundingBox = write_bbox("latLonBoundingBox"),
srs = write_string("srs"),
projection_policy = write_string("projectionPolicy"),
keywords = write_string_list("keywords"),
metadataLinks = write_metadata_link_list("metadataLinks"),
requestSRS = write_string_list("requestSRS"),
responseSRS = write_string_list("responseSRS"),
supportedFormats = write_string_list("supportedFormats")
)
title=write_string('title'),
abstract=write_string('abstract'),
enabled=write_bool('enabled'),
nativeBoundingBox=write_bbox('nativeBoundingBox'),
latLonBoundingBox=write_bbox('latLonBoundingBox'),
srs=write_string('srs'),
projection_policy=write_string('projectionPolicy'),
keywords=write_string_list('keywords'),
metadataLinks=write_metadata_link_list('metadataLinks'),
requestSRS=write_string_list('requestSRS'),
responseSRS=write_string_list('responseSRS'),
supportedFormats=write_string_list('supportedFormats'),
)
106 changes: 60 additions & 46 deletions python/plugins/processing/admintools/geoserver/store.py
View file
Original file line number Diff line number Diff line change
Expand Up @@ -20,25 +20,32 @@
__author__ = 'David Winslow'
__date__ = 'November 2012'
__copyright__ = '(C) 2012, David Winslow'

# This will get replaced with a git SHA1 when you do a git archive

__revision__ = '$Format:%H$'

from processing.admintools.geoserver.resource import featuretype_from_index, coverage_from_index
from processing.admintools.geoserver.support import ResourceInfo, xml_property, key_value_pairs, \
write_bool, write_dict, write_string, url
from processing.admintools.geoserver.workspace import Workspace
from processing.admintools.geoserver.resource import featuretype_from_index, \
coverage_from_index
from processing.admintools.geoserver.support import ResourceInfo, \
xml_property, key_value_pairs, write_bool, write_dict, write_string, url


def datastore_from_index(catalog, workspace, node):
name = node.find("name")
name = node.find('name')
return DataStore(catalog, workspace, name.text)


def coveragestore_from_index(catalog, workspace, node):
name = node.find("name")
name = node.find('name')
return CoverageStore(catalog, workspace, name.text)


class DataStore(ResourceInfo):
resource_type = "dataStore"
save_method = "PUT"

resource_type = 'dataStore'
save_method = 'PUT'

def __init__(self, catalog, workspace, name):
super(DataStore, self).__init__()
Expand All @@ -51,45 +58,50 @@ def __init__(self, catalog, workspace, name):

@property
def href(self):
return url(self.catalog.service_url,
["workspaces", self.workspace.name, "datastores", self.name + ".xml"])
return url(self.catalog.service_url, ['workspaces',
self.workspace.name, 'datastores', self.name + '.xml'])

enabled = xml_property("enabled", lambda x: x.text == "true")
name = xml_property("name")
connection_parameters = xml_property("connectionParameters", key_value_pairs)

writers = dict(enabled = write_bool("enabled"),
name = write_string("name"),
connectionParameters = write_dict("connectionParameters"))
enabled = xml_property('enabled', lambda x: x.text == 'true')
name = xml_property('name')
connection_parameters = xml_property('connectionParameters',
key_value_pairs)

writers = dict(enabled=write_bool('enabled'), name=write_string('name'),
connectionParameters=write_dict('connectionParameters'))

def get_resources(self):
res_url = url(self.catalog.service_url,
["workspaces", self.workspace.name, "datastores", self.name, "featuretypes.xml"])
res_url = url(self.catalog.service_url, ['workspaces',
self.workspace.name, 'datastores', self.name,
'featuretypes.xml'])
xml = self.catalog.get_xml(res_url)

def ft_from_node(node):
return featuretype_from_index(self.catalog, self.workspace, self, node)
return featuretype_from_index(self.catalog, self.workspace, self,
node)

return [ft_from_node(node) for node in xml.findall('featureType')]

return [ft_from_node(node) for node in xml.findall("featureType")]

class UnsavedDataStore(DataStore):
save_method = "POST"

save_method = 'POST'

def __init__(self, catalog, name, workspace):
super(UnsavedDataStore, self).__init__(catalog, workspace, name)
self.dirty.update(dict(
name=name, enabled=True, connectionParameters=dict()))
self.dirty.update(dict(name=name, enabled=True,
connectionParameters=dict()))

@property
def href(self):
path = [ "workspaces",
self.workspace.name, "datastores"]
path = ['workspaces', self.workspace.name, 'datastores']
query = dict(name=self.name)
return url(self.catalog.service_url, path, query)


class CoverageStore(ResourceInfo):

resource_type = 'coverageStore'
save_method = "PUT"
save_method = 'PUT'

def __init__(self, catalog, workspace, name):
super(CoverageStore, self).__init__()
Expand All @@ -103,40 +115,42 @@ def __init__(self, catalog, workspace, name):

@property
def href(self):
return url(self.catalog.service_url,
["workspaces", self.workspace.name, "coveragestores", self.name + ".xml"])
return url(self.catalog.service_url, ['workspaces',
self.workspace.name, 'coveragestores', self.name + '.xml'])

enabled = xml_property("enabled", lambda x: x.text == "true")
name = xml_property("name")
url = xml_property("url")
type = xml_property("type")

writers = dict(enabled = write_bool("enabled"),
name = write_string("name"),
url = write_string("url"),
type = write_string("type"))
enabled = xml_property('enabled', lambda x: x.text == 'true')
name = xml_property('name')
url = xml_property('url')
type = xml_property('type')

writers = dict(enabled=write_bool('enabled'), name=write_string('name'),
url=write_string('url'), type=write_string('type'))

def get_resources(self):
res_url = url(self.catalog.service_url,
["workspaces", self.workspace.name, "coveragestores", self.name, "coverages.xml"])
res_url = url(self.catalog.service_url, ['workspaces',
self.workspace.name, 'coveragestores', self.name,
'coverages.xml'])

xml = self.catalog.get_xml(res_url)

def cov_from_node(node):
return coverage_from_index(self.catalog, self.workspace, self, node)
return coverage_from_index(self.catalog, self.workspace, self,
node)

return [cov_from_node(node) for node in xml.findall('coverage')]

return [cov_from_node(node) for node in xml.findall("coverage")]

class UnsavedCoverageStore(CoverageStore):
save_method = "POST"

save_method = 'POST'

def __init__(self, catalog, name, workspace):
super(UnsavedCoverageStore, self).__init__(catalog, workspace, name)
self.dirty.update(name=name, enabled = True, type="GeoTIFF",
url = "file:data/")
self.dirty.update(name=name, enabled=True, type='GeoTIFF',
url='file:data/')

@property
def href(self):
return url(self.catalog.service_url,
["workspaces", self.workspace.name, "coveragestores"], dict(name=self.name))
return url(self.catalog.service_url, ['workspaces',
self.workspace.name, 'coveragestores'],
dict(name=self.name))
32 changes: 19 additions & 13 deletions python/plugins/processing/admintools/geoserver/style.py
View file
Original file line number Diff line number Diff line change
Expand Up @@ -20,12 +20,17 @@
__author__ = 'David Winslow'
__date__ = 'November 2012'
__copyright__ = '(C) 2012, David Winslow'

# This will get replaced with a git SHA1 when you do a git archive

__revision__ = '$Format:%H$'

from processing.admintools.geoserver.support import ResourceInfo, url, xml_property
from processing.admintools.geoserver.support import ResourceInfo, url, \
xml_property


class Style(ResourceInfo):

def __init__(self, catalog, name):
super(Style, self).__init__()
assert isinstance(name, basestring)
Expand All @@ -36,12 +41,12 @@ def __init__(self, catalog, name):

@property
def href(self):
return url(self.catalog.service_url, ["styles", self.name + ".xml"])
return url(self.catalog.service_url, ['styles', self.name + '.xml'])

def body_href(self):
return url(self.catalog.service_url, ["styles", self.name + ".sld"])
return url(self.catalog.service_url, ['styles', self.name + '.sld'])

filename = xml_property("filename")
filename = xml_property('filename')

def _get_sld_dom(self):
if self._sld_dom is None:
Expand All @@ -50,22 +55,23 @@ def _get_sld_dom(self):

@property
def sld_title(self):
user_style = self._get_sld_dom().find("{http://www.opengis.net/sld}NamedLayer/{http://www.opengis.net/sld}UserStyle")
title_node = user_style.find("{http://www.opengis.net/sld}Title")
return title_node.text if title_node is not None else None
user_style = \
self._get_sld_dom().find('{http://www.opengis.net/sld}NamedLayer/{http://www.opengis.net/sld}UserStyle')
title_node = user_style.find('{http://www.opengis.net/sld}Title')
return (title_node.text if title_node is not None else None)

@property
def sld_name(self):
user_style = self._get_sld_dom().find("{http://www.opengis.net/sld}NamedLayer/{http://www.opengis.net/sld}UserStyle")
name_node = user_style.find("{http://www.opengis.net/sld}Name")
return name_node.text if name_node is not None else None
user_style = \
self._get_sld_dom().find('{http://www.opengis.net/sld}NamedLayer/{http://www.opengis.net/sld}UserStyle')
name_node = user_style.find('{http://www.opengis.net/sld}Name')
return (name_node.text if name_node is not None else None)

@property
def sld_body(self):
content = self.catalog.http.request(self.body_href())[1]
return content

def update_body(self, body):
headers = { "Content-Type": "application/vnd.ogc.sld+xml" }
self.catalog.http.request(
self.body_href(), "PUT", body, headers)
headers = {'Content-Type': 'application/vnd.ogc.sld+xml'}
self.catalog.http.request(self.body_href(), 'PUT', body, headers)
176 changes: 105 additions & 71 deletions python/plugins/processing/admintools/geoserver/support.py
View file
Original file line number Diff line number Diff line change
Expand Up @@ -20,7 +20,9 @@
__author__ = 'David Winslow'
__date__ = 'November 2012'
__copyright__ = '(C) 2012, David Winslow'

# This will get replaced with a git SHA1 when you do a git archive

__revision__ = '$Format:%H$'

import logging
Expand All @@ -30,49 +32,51 @@
from zipfile import ZipFile
from processing.tools.system import *

logger = logging.getLogger('gsconfig.support')

logger = logging.getLogger("gsconfig.support")

FORCE_DECLARED = "FORCE_DECLARED"
## The projection handling policy for layers that should use coordinates
## directly while reporting the configured projection to clients. This should be
## used when projection information is missing from the underlying datastore.
# The projection handling policy for layers that should use coordinates
# directly while reporting the configured projection to clients. This
# should be used when projection information is missing from the
# underlying datastore.
FORCE_DECLARED = 'FORCE_DECLARED'

# The projection handling policy for layers that should use the
# projection information from the underlying storage mechanism directly,
# and ignore the projection setting.
FORCE_NATIVE = 'FORCE_NATIVE'

FORCE_NATIVE = "FORCE_NATIVE"
## The projection handling policy for layers that should use the projection
## information from the underlying storage mechanism directly, and ignore the
## projection setting.
# The projection handling policy for layers that should use the
# projection information from the underlying storage mechanism to
# reproject to the configured projection.
REPROJECT = 'REPROJECT'

REPROJECT = "REPROJECT"
## The projection handling policy for layers that should use the projection
## information from the underlying storage mechanism to reproject to the
## configured projection.

def url(base, seg, query=None):
"""
Create a URL from a list of path segments and an optional dict of query
parameters.
"""Create a URL from a list of path segments and an optional dict
of query parameters.
"""

seg = (urllib.quote(s.strip('/')) for s in seg)
if query is None or len(query) == 0:
query_string = ''
else:
query_string = "?" + urllib.urlencode(query)
query_string = '?' + urllib.urlencode(query)
path = '/'.join(seg) + query_string
adjusted_base = base.rstrip('/') + '/'
return urlparse.urljoin(adjusted_base, path)

def xml_property(path, converter = lambda x: x.text):

def xml_property(path, converter=lambda x: x.text):

def getter(self):
if path in self.dirty:
return self.dirty[path]
else:
if self.dom is None:
self.fetch()
node = self.dom.find(path)
return converter(self.dom.find(path)) if node is not None else None
return (converter(self.dom.find(path)) if node
is not None else None)

def setter(self, value):
self.dirty[path] = value
Expand All @@ -82,77 +86,99 @@ def delete(self):

return property(getter, setter, delete)


def bbox(node):
if node is not None:
minx = node.find("minx")
maxx = node.find("maxx")
miny = node.find("miny")
maxy = node.find("maxy")
crs = node.find("crs")
crs = crs.text if crs is not None else None

if (None not in [minx, maxx, miny, maxy]):
minx = node.find('minx')
maxx = node.find('maxx')
miny = node.find('miny')
maxy = node.find('maxy')
crs = node.find('crs')
crs = (crs.text if crs is not None else None)

if None not in [minx, maxx, miny, maxy]:
return (minx.text, maxx.text, miny.text, maxy.text, crs)
else:
return None
else:
return None


def string_list(node):
if node is not None:
return [n.text for n in node.findall("string")]
return [n.text for n in node.findall('string')]


def attribute_list(node):
if node is not None:
return [n.text for n in node.findall("attribute/name")]
return [n.text for n in node.findall('attribute/name')]


def key_value_pairs(node):
if node is not None:
return dict((entry.attrib['key'], entry.text) for entry in node.findall("entry"))
return dict((entry.attrib['key'], entry.text) for entry in
node.findall('entry'))


def write_string(name):

def write(builder, value):
builder.start(name, dict())
if (value is not None):
if value is not None:
builder.data(value)
builder.end(name)

return write


def write_bool(name):

def write(builder, b):
builder.start(name, dict())
builder.data("true" if b else "false")
builder.data(('true' if b else 'false'))
builder.end(name)

return write


def write_bbox(name):

def write(builder, b):
builder.start(name, dict())
bbox_xml(builder, b)
builder.end(name)

return write


def write_string_list(name):

def write(builder, words):
builder.start(name, dict())
for w in words:
builder.start("string", dict())
builder.start('string', dict())
builder.data(w)
builder.end("string")
builder.end('string')
builder.end(name)

return write


def write_dict(name):

def write(builder, pairs):
builder.start(name, dict())
for k, v in pairs.iteritems():
builder.start("entry", dict(key=k))
for (k, v) in pairs.iteritems():
builder.start('entry', dict(key=k))
builder.data(v)
builder.end("entry")
builder.end('entry')
builder.end(name)

return write


class ResourceInfo(object):

def __init__(self):
self.dom = None
self.dirty = dict()
Expand All @@ -168,12 +194,12 @@ def refresh(self):
self.fetch()

def serialize(self, builder):
# GeoServer will disable the resource if we omit the <enabled> tag,
# so force it into the dirty dict before writing
if hasattr(self, "enabled"):
# GeoServer will disable the resource if we omit the <enabled>
# tag, so force it into the dirty dict before writing
if hasattr(self, 'enabled'):
self.dirty['enabled'] = self.enabled

for k, writer in self.writers.items():
for (k, writer) in self.writers.items():
if k in self.dirty:
writer(builder, self.dirty[k])

Expand All @@ -185,59 +211,67 @@ def message(self):
msg = tostring(builder.close())
return msg


def prepare_upload_bundle(name, data):
"""GeoServer's REST API uses ZIP archives as containers for file formats such
as Shapefile and WorldImage which include several 'boxcar' files alongside
the main data. In such archives, GeoServer assumes that all of the relevant
files will have the same base name and appropriate extensions, and live in
the root of the ZIP archive. This method produces a zip file that matches
these expectations, based on a basename, and a dict of extensions to paths or
file-like objects. The client code is responsible for deleting the zip
archive when it's done."""
#we ut the zip file in the processing temp dir, so it is deleted at the end.
"""GeoServer's REST API uses ZIP archives as containers for file
formats such as Shapefile and WorldImage which include several
'boxcar' files alongside the main data.
In such archives, GeoServer assumes that all of the relevant files
will have the same base name and appropriate extensions, and live
in the root of the ZIP archive. This method produces a zip file
that matches these expectations, based on a basename, and a dict of
extensions to paths or file-like objects. The client code is
responsible for deleting the zip archive when it's done.
"""

# We put the zip file in the Processing temp dir, so it is
# deleted at the end.
f = getTempFilename('zip')
zip_file = ZipFile(f, 'w')
for ext, stream in data.iteritems():
fname = "%s.%s" % (name, ext)
if (isinstance(stream, basestring)):
for (ext, stream) in data.iteritems():
fname = '%s.%s' % (name, ext)
if isinstance(stream, basestring):
zip_file.write(stream, fname)
else:
zip_file.writestr(fname, stream.read())
zip_file.close()
return f


def atom_link(node):
if 'href' in node.attrib:
return node.attrib['href']
else:
l = node.find("{http://www.w3.org/2005/Atom}link")
l = node.find('{http://www.w3.org/2005/Atom}link')
return l.get('href')


def atom_link_xml(builder, href):
builder.start("atom:link", {
builder.start('atom:link', {
'rel': 'alternate',
'href': href,
'type': 'application/xml',
'xmlns:atom': 'http://www.w3.org/2005/Atom'
})
builder.end("atom:link")
'xmlns:atom': 'http://www.w3.org/2005/Atom',
})
builder.end('atom:link')


def bbox_xml(builder, box):
minx, maxx, miny, maxy, crs = box
builder.start("minx", dict())
(minx, maxx, miny, maxy, crs) = box
builder.start('minx', dict())
builder.data(minx)
builder.end("minx")
builder.start("maxx", dict())
builder.end('minx')
builder.start('maxx', dict())
builder.data(maxx)
builder.end("maxx")
builder.start("miny", dict())
builder.end('maxx')
builder.start('miny', dict())
builder.data(miny)
builder.end("miny")
builder.start("maxy", dict())
builder.end('miny')
builder.start('maxy', dict())
builder.data(maxy)
builder.end("maxy")
builder.end('maxy')
if crs is not None:
builder.start("crs", {"class": "projected"})
builder.start('crs', {'class': 'projected'})
builder.data(crs)
builder.end("crs")

builder.end('crs')
7 changes: 4 additions & 3 deletions python/plugins/processing/admintools/geoserver/util.py
View file
Original file line number Diff line number Diff line change
Expand Up @@ -20,11 +20,12 @@
__author__ = 'David Winslow'
__date__ = 'November 2012'
__copyright__ = '(C) 2012, David Winslow'

# This will get replaced with a git SHA1 when you do a git archive

__revision__ = '$Format:%H$'

# shapefile_and_friends = None
# shapefile_plus_sidecars = shapefile_and_friends("test/data/states")

def shapefile_and_friends(path):
return dict((ext, path + "." + ext) for ext in ['shx', 'shp', 'dbf', 'prj'])
return dict((ext, path + '.' + ext) for ext in ['shx', 'shp', 'dbf', 'prj'
])
29 changes: 18 additions & 11 deletions python/plugins/processing/admintools/geoserver/workspace.py
View file
Original file line number Diff line number Diff line change
Expand Up @@ -20,17 +20,23 @@
__author__ = 'David Winslow'
__date__ = 'November 2012'
__copyright__ = '(C) 2012, David Winslow'

# This will get replaced with a git SHA1 when you do a git archive

__revision__ = '$Format:%H$'

from processing.admintools.geoserver.support import xml_property, write_bool, ResourceInfo, url
from processing.admintools.geoserver.support import xml_property, write_bool, \
ResourceInfo, url


def workspace_from_index(catalog, node):
name = node.find("name")
name = node.find('name')
return Workspace(catalog, name.text)


class Workspace(ResourceInfo):
resource_type = "workspace"

resource_type = 'workspace'

def __init__(self, catalog, name):
super(Workspace, self).__init__()
Expand All @@ -39,20 +45,21 @@ def __init__(self, catalog, name):

@property
def href(self):
return url(self.catalog.service_url, ["workspaces", self.name + ".xml"])
return url(self.catalog.service_url, ['workspaces', self.name + '.xml'
])

@property
def coveragestore_url(self):
return url(self.catalog.service_url, ["workspaces", self.name, "coveragestores.xml"])
return url(self.catalog.service_url, ['workspaces', self.name,
'coveragestores.xml'])

@property
def datastore_url(self):
return url(self.catalog.service_url, ["workspaces", self.name, "datastores.xml"])
return url(self.catalog.service_url, ['workspaces', self.name,
'datastores.xml'])

enabled = xml_property("enabled", lambda x: x.lower() == 'true')
writers = dict(
enabled = write_bool("enabled")
)
enabled = xml_property('enabled', lambda x: x.lower() == 'true')
writers = dict(enabled=write_bool('enabled'))

def __repr__(self):
return "%s @ %s" % (self.name, self.href)
return '%s @ %s' % (self.name, self.href)
1,381 changes: 768 additions & 613 deletions python/plugins/processing/admintools/postgis_utils.py
View file

Large diffs are not rendered by default.

54 changes: 32 additions & 22 deletions python/plugins/processing/algs/AddTableField.py
View file
Original file line number Diff line number Diff line change
Expand Up @@ -20,42 +20,49 @@
__author__ = 'Victor Olaya'
__date__ = 'August 2012'
__copyright__ = '(C) 2012, Victor Olaya'

# This will get replaced with a git SHA1 when you do a git archive

__revision__ = '$Format:%H$'

from PyQt4.QtCore import *
from PyQt4.QtGui import *
from qgis.core import *
from processing.core.GeoAlgorithm import GeoAlgorithm
from processing.tools import dataobjects, vector
from processing.parameters.ParameterVector import ParameterVector
from processing.parameters.ParameterString import ParameterString
from processing.parameters.ParameterNumber import ParameterNumber
from processing.parameters.ParameterSelection import ParameterSelection
from processing.outputs.OutputVector import OutputVector
from processing.tools import dataobjects, vector


class AddTableField(GeoAlgorithm):

OUTPUT_LAYER = "OUTPUT_LAYER"
INPUT_LAYER = "INPUT_LAYER"
FIELD_NAME = "FIELD_NAME"
FIELD_TYPE = "FIELD_TYPE"
FIELD_LENGTH = "FIELD_LENGTH"
FIELD_PRECISION = "FIELD_PRECISION"
OUTPUT_LAYER = 'OUTPUT_LAYER'
INPUT_LAYER = 'INPUT_LAYER'
FIELD_NAME = 'FIELD_NAME'
FIELD_TYPE = 'FIELD_TYPE'
FIELD_LENGTH = 'FIELD_LENGTH'
FIELD_PRECISION = 'FIELD_PRECISION'

TYPE_NAMES = ["Integer", "Float", "String"]
TYPE_NAMES = ['Integer', 'Float', 'String']
TYPES = [QVariant.Int, QVariant.Double, QVariant.String]

def defineCharacteristics(self):
self.name = "Add field to attributes table"
self.group = "Vector table tools"
self.name = 'Add field to attributes table'
self.group = 'Vector table tools'

self.addParameter(ParameterVector(self.INPUT_LAYER, "Input layer", [ParameterVector.VECTOR_TYPE_ANY], False))
self.addParameter(ParameterString(self.FIELD_NAME, "Field name"))
self.addParameter(ParameterSelection(self.FIELD_TYPE, "Field type", self.TYPE_NAMES))
self.addParameter(ParameterNumber(self.FIELD_LENGTH, "Field length", 1, 255, 10))
self.addParameter(ParameterNumber(self.FIELD_PRECISION, "Field precision", 0, 10, 0))
self.addOutput(OutputVector(self.OUTPUT_LAYER, "Output layer"))
self.addParameter(ParameterVector(self.INPUT_LAYER, 'Input layer',
[ParameterVector.VECTOR_TYPE_ANY], False))
self.addParameter(ParameterString(self.FIELD_NAME, 'Field name'))
self.addParameter(ParameterSelection(self.FIELD_TYPE, 'Field type',
self.TYPE_NAMES))
self.addParameter(ParameterNumber(self.FIELD_LENGTH, 'Field length',
1, 255, 10))
self.addParameter(ParameterNumber(self.FIELD_PRECISION,
'Field precision', 0, 10, 0))
self.addOutput(OutputVector(self.OUTPUT_LAYER, 'Output layer'))

def processAlgorithm(self, progress):
fieldType = self.getParameterValue(self.FIELD_TYPE)
Expand All @@ -64,24 +71,27 @@ def processAlgorithm(self, progress):
fieldPrecision = self.getParameterValue(self.FIELD_PRECISION)
output = self.getOutputFromName(self.OUTPUT_LAYER)

layer = dataobjects.getObjectFromUri(self.getParameterValue(self.INPUT_LAYER))
layer = dataobjects.getObjectFromUri(
self.getParameterValue(self.INPUT_LAYER))

provider = layer.dataProvider()
fields = provider.fields()
fields.append(QgsField(fieldName, self.TYPES[fieldType], "", fieldLength, fieldPrecision))
writer = output.getVectorWriter(fields, provider.geometryType(), layer.crs())
fields.append(QgsField(fieldName, self.TYPES[fieldType], '',
fieldLength, fieldPrecision))
writer = output.getVectorWriter(fields, provider.geometryType(),
layer.crs())
outFeat = QgsFeature()
inGeom = QgsGeometry()
nElement = 0
features = vector.features(layer)
nFeat = len(features)
for inFeat in features:
progress.setPercentage(int((100 * nElement)/nFeat))
progress.setPercentage(int(100 * nElement / nFeat))
nElement += 1
inGeom = inFeat.geometry()
outFeat.setGeometry( inGeom )
outFeat.setGeometry(inGeom)
atMap = inFeat.attributes()
atMap.append(None)
outFeat.setAttributes(atMap)
writer.addFeature( outFeat )
writer.addFeature(outFeat)
del writer
35 changes: 19 additions & 16 deletions python/plugins/processing/algs/AutoincrementalField.py
View file
Original file line number Diff line number Diff line change
Expand Up @@ -20,50 +20,53 @@
__author__ = 'Victor Olaya'
__date__ = 'August 2012'
__copyright__ = '(C) 2012, Victor Olaya'

# This will get replaced with a git SHA1 when you do a git archive

__revision__ = '$Format:%H$'

from processing.core.GeoAlgorithm import GeoAlgorithm
from PyQt4.QtCore import *
from qgis.core import *
from processing.core.GeoAlgorithm import GeoAlgorithm
from processing.parameters.ParameterVector import ParameterVector
from processing.tools import dataobjects, vector
from processing.outputs.OutputVector import OutputVector
from processing.tools import dataobjects, vector


class AutoincrementalField(GeoAlgorithm):

INPUT = "INPUT"
OUTPUT = "OUTPUT"
INPUT = 'INPUT'
OUTPUT = 'OUTPUT'

def processAlgorithm(self, progress):
output = self.getOutputFromName(self.OUTPUT)
vlayer = dataobjects.getObjectFromUri(self.getParameterValue(self.INPUT))
vlayer = \
dataobjects.getObjectFromUri(self.getParameterValue(self.INPUT))
vprovider = vlayer.dataProvider()
fields = vprovider.fields()
fields.append(QgsField("AUTO", QVariant.Int))
writer = output.getVectorWriter(fields, vprovider.geometryType(), vlayer.crs() )
fields.append(QgsField('AUTO', QVariant.Int))
writer = output.getVectorWriter(fields, vprovider.geometryType(),
vlayer.crs())
inFeat = QgsFeature()
outFeat = QgsFeature()
inGeom = QgsGeometry()
nElement = 0
features = vector.features(vlayer)
nFeat = len(features)
for inFeat in features:
progress.setPercentage(int((100 * nElement)/nFeat))
progress.setPercentage(int(100 * nElement / nFeat))
nElement += 1
inGeom = inFeat.geometry()
outFeat.setGeometry( inGeom )
outFeat.setGeometry(inGeom)
attrs = inFeat.attributes()
attrs.append(nElement)
outFeat.setAttributes(attrs)
writer.addFeature(outFeat)
del writer

def defineCharacteristics(self):
self.name = "Add autoincremental field"
self.group = "Vector table tools"
self.addParameter(ParameterVector(self.INPUT, "Input layer", [ParameterVector.VECTOR_TYPE_ANY]))
self.addOutput(OutputVector(self.OUTPUT, "Output layer"))



self.name = 'Add autoincremental field'
self.group = 'Vector table tools'
self.addParameter(ParameterVector(self.INPUT, 'Input layer',
[ParameterVector.VECTOR_TYPE_ANY]))
self.addOutput(OutputVector(self.OUTPUT, 'Output layer'))
44 changes: 22 additions & 22 deletions python/plugins/processing/algs/BarPlot.py
View file
Original file line number Diff line number Diff line change
Expand Up @@ -20,7 +20,9 @@
__author__ = 'Victor Olaya'
__date__ = 'January 2013'
__copyright__ = '(C) 2013, Victor Olaya'

# This will get replaced with a git SHA1 when you do a git archive

__revision__ = '$Format:%H$'

import matplotlib.pyplot as plt
Expand All @@ -33,44 +35,42 @@
from processing.core.GeoAlgorithm import GeoAlgorithm
from processing.outputs.OutputHTML import OutputHTML
from processing.tools import *
from processing.tools import dataobjects


class BarPlot(GeoAlgorithm):

INPUT = "INPUT"
OUTPUT = "OUTPUT"
NAME_FIELD = "NAME_FIELD"
VALUE_FIELD = "VALUE_FIELD"
INPUT = 'INPUT'
OUTPUT = 'OUTPUT'
NAME_FIELD = 'NAME_FIELD'
VALUE_FIELD = 'VALUE_FIELD'

def processAlgorithm(self, progress):
uri = self.getParameterValue(self.INPUT)
layer = dataobjects.getObjectFromUri(uri)
layer = getObjectFromUri(uri)
namefieldname = self.getParameterValue(self.NAME_FIELD)
valuefieldname = self.getParameterValue(self.VALUE_FIELD)
output = self.getOutputValue(self.OUTPUT)
values = vector.getAttributeValues(layer, namefieldname, valuefieldname)
values = vector.getAttributeValues(layer, namefieldname,
valuefieldname)
plt.close()

ind = np.arange(len(values[namefieldname]))
width = 0.8
plt.bar(ind, values[valuefieldname], width, color='r')

plt.xticks(ind, values[namefieldname], rotation = 45)
plotFilename = output +".png"
plt.xticks(ind, values[namefieldname], rotation=45)
plotFilename = output + '.png'
lab.savefig(plotFilename)
f = open(output, "w")
f.write("<img src=\"" + plotFilename + "\"/>")
f = open(output, 'w')
f.write('<img src="' + plotFilename + '"/>')
f.close()

def defineCharacteristics(self):
self.name = "Bar plot"
self.group = "Graphics"
self.addParameter(ParameterTable(self.INPUT, "Input table"))
self.addParameter(ParameterTableField(self.NAME_FIELD, "Category name field", self.INPUT))
self.addParameter(ParameterTableField(self.VALUE_FIELD, "Value field", self.INPUT))
self.addOutput(OutputHTML(self.OUTPUT, "Output"))





self.name = 'Bar plot'
self.group = 'Graphics'
self.addParameter(ParameterTable(self.INPUT, 'Input table'))
self.addParameter(ParameterTableField(self.NAME_FIELD,
'Category name field', self.INPUT))
self.addParameter(ParameterTableField(self.VALUE_FIELD, 'Value field',
self.INPUT))
self.addOutput(OutputHTML(self.OUTPUT, 'Output'))
55 changes: 29 additions & 26 deletions python/plugins/processing/algs/CreateConstantRaster.py
View file
Original file line number Diff line number Diff line change
@@ -1,13 +1,8 @@
from processing.core.RasterWriter import RasterWriter
from processing.parameters.ParameterRaster import ParameterRaster



# -*- coding: utf-8 -*-

"""
***************************************************************************
AutoincrementalField.py
CreateConstantRaster.py
---------------------
Date : August 2012
Copyright : (C) 2012 by Victor Olaya
Expand All @@ -25,42 +20,50 @@
__author__ = 'Victor Olaya'
__date__ = 'August 2012'
__copyright__ = '(C) 2012, Victor Olaya'

# This will get replaced with a git SHA1 when you do a git archive

__revision__ = '$Format:%H$'

from processing.core.GeoAlgorithm import GeoAlgorithm
from PyQt4.QtCore import *
from qgis.core import *
from processing.core.RasterWriter import RasterWriter
from processing.core.GeoAlgorithm import GeoAlgorithm
from processing.parameters.ParameterRaster import ParameterRaster
from processing.parameters.ParameterNumber import ParameterNumber
from processing.outputs.OutputRaster import OutputRaster
from processing.tools import dataobjects

class CreateConstantRaster(GeoAlgorithm):

INPUT = "INPUT"
OUTPUT = "OUTPUT"
NUMBER = "NUMBER"
class CreateConstantRaster(GeoAlgorithm):

#===========================================================================
# def getIcon(self):
# return QtGui.QIcon(os.path.dirname(__file__) + "/../images/toolbox.png")
#===========================================================================
INPUT = 'INPUT'
OUTPUT = 'OUTPUT'
NUMBER = 'NUMBER'

def processAlgorithm(self, progress):
output = self.getOutputFromName(self.OUTPUT)
value = self.getOutputValue(self.NUMBER)
layer = dataobjects.getObjectFromUri(self.getParameterValue(self.INPUT))
cellsize = (layer.extent().xMaximum() - layer.extent().xMinimum())/layer.width()
w = RasterWriter(output.getCompatibleFileName(self), layer.extent().xMinimum(), layer.extent().yMinimum(), layer.extent().xMaximum(),
layer.extent().yMaximum(), cellsize, 1, self.crs)
layer = dataobjects.getObjectFromUri(
self.getParameterValue(self.INPUT))
cellsize = (layer.extent().xMaximum() - layer.extent().xMinimum()) \
/ layer.width()
w = RasterWriter(output.getCompatibleFileName(self),
layer.extent().xMinimum(),
layer.extent().yMinimum(),
layer.extent().xMaximum(),
layer.extent().yMaximum(),
cellsize,
1,
self.crs,
)
w.matrix[:] = value
w.close()

def defineCharacteristics(self):
self.name = "Create constant raster layer"
self.group = "Raster tools"
self.addParameter(ParameterRaster(self.INPUT, "Reference layer"))
self.addParameter(ParameterNumber(self.NUMBER, "Constant value", default = 1.0));
self.addOutput(OutputRaster(self.OUTPUT, "Output layer"))


self.name = 'Create constant raster layer'
self.group = 'Raster tools'
self.addParameter(ParameterRaster(self.INPUT, 'Reference layer'))
self.addParameter(ParameterNumber(self.NUMBER, 'Constant value',
default=1.0))
self.addOutput(OutputRaster(self.OUTPUT, 'Output layer'))
42 changes: 24 additions & 18 deletions python/plugins/processing/algs/EquivalentNumField.py
View file
Original file line number Diff line number Diff line change
Expand Up @@ -20,56 +20,62 @@
__author__ = 'Victor Olaya'
__date__ = 'August 2012'
__copyright__ = '(C) 2012, Victor Olaya'

# This will get replaced with a git SHA1 when you do a git archive

__revision__ = '$Format:%H$'

from processing.core.GeoAlgorithm import GeoAlgorithm
from PyQt4.QtCore import *
from qgis.core import *
from processing.core.GeoAlgorithm import GeoAlgorithm
from processing.parameters.ParameterVector import ParameterVector
from processing.tools import dataobjects, vector
from processing.outputs.OutputVector import OutputVector
from processing.parameters.ParameterTableField import ParameterTableField
from processing.outputs.OutputVector import OutputVector
from processing.tools import dataobjects, vector


class EquivalentNumField(GeoAlgorithm):

INPUT = "INPUT"
OUTPUT = "OUTPUT"
FIELD = "FIELD"
INPUT = 'INPUT'
OUTPUT = 'OUTPUT'
FIELD = 'FIELD'

def processAlgorithm(self, progress):
fieldname = self.getParameterValue(self.FIELD)
output = self.getOutputFromName(self.OUTPUT)
vlayer = dataobjects.getObjectFromUri(self.getParameterValue(self.INPUT))
vlayer = dataobjects.getObjectFromUri(
self.getParameterValue(self.INPUT))
vprovider = vlayer.dataProvider()
fieldindex = vlayer.fieldNameIndex(fieldname)
fields = vprovider.fields()
fields.append(QgsField("NUM_FIELD", QVariant.Int))
writer = output.getVectorWriter(fields, vprovider.geometryType(), vlayer.crs() )
fields.append(QgsField('NUM_FIELD', QVariant.Int))
writer = output.getVectorWriter(fields, vprovider.geometryType(),
vlayer.crs())
outFeat = QgsFeature()
inGeom = QgsGeometry()
nElement = 0
classes = {}
features = vector.features(vlayer)
nFeat = len(features)
for feature in features:
progress.setPercentage(int((100 * nElement)/nFeat))
progress.setPercentage(int(100 * nElement / nFeat))
nElement += 1
inGeom = feature.geometry()
outFeat.setGeometry( inGeom )
outFeat.setGeometry(inGeom)
atMap = feature.attributes()
clazz = atMap[fieldindex]
if clazz not in classes:
classes[clazz] = len(classes.keys())
atMap.append(classes[clazz])
outFeat.setAttributes(atMap)
writer.addFeature( outFeat )
writer.addFeature(outFeat)
del writer

def defineCharacteristics(self):
self.name = "Create equivalent numerical field"
self.group = "Vector table tools"
self.addParameter(ParameterVector(self.INPUT, "Input layer", [ParameterVector.VECTOR_TYPE_ANY]))
self.addParameter(ParameterTableField(self.FIELD, "Class field", self.INPUT))
self.addOutput(OutputVector(self.OUTPUT, "Output layer"))

self.name = 'Create equivalent numerical field'
self.group = 'Vector table tools'
self.addParameter(ParameterVector(self.INPUT, 'Input layer',
[ParameterVector.VECTOR_TYPE_ANY]))
self.addParameter(ParameterTableField(self.FIELD, 'Class field',
self.INPUT))
self.addOutput(OutputVector(self.OUTPUT, 'Output layer'))
45 changes: 25 additions & 20 deletions python/plugins/processing/algs/Explode.py
View file
Original file line number Diff line number Diff line change
Expand Up @@ -20,68 +20,73 @@
__author__ = 'Victor Olaya'
__date__ = 'August 2012'
__copyright__ = '(C) 2012, Victor Olaya'

# This will get replaced with a git SHA1 when you do a git archive

__revision__ = '$Format:%H$'

from processing.core.GeoAlgorithm import GeoAlgorithm
from PyQt4.QtCore import *
from PyQt4.QtGui import *
from qgis.core import *
from processing.core.GeoAlgorithm import GeoAlgorithm
from processing.parameters.ParameterVector import ParameterVector
from processing.tools import dataobjects, vector
from processing.outputs.OutputVector import OutputVector
from processing.tools import dataobjects, vector


class Explode(GeoAlgorithm):

INPUT = "INPUT"
OUTPUT = "OUTPUT"
INPUT = 'INPUT'
OUTPUT = 'OUTPUT'

def processAlgorithm(self, progress):
vlayer = dataobjects.getObjectFromUri(self.getParameterValue(self.INPUT))
vlayer = dataobjects.getObjectFromUri(
self.getParameterValue(self.INPUT))
output = self.getOutputFromName(self.OUTPUT)
vprovider = vlayer.dataProvider()
fields = vprovider.fields()
writer = output.getVectorWriter(fields, QGis.WKBLineString, vlayer.crs() )
writer = output.getVectorWriter(fields, QGis.WKBLineString,
vlayer.crs())
outFeat = QgsFeature()
inGeom = QgsGeometry()
nElement = 0
features = vector.features(vlayer)
nFeat = len(features)
for feature in features:
nElement += 1
progress.setPercentage((nElement*100)/nFeat)
progress.setPercentage(nElement * 100 / nFeat)
inGeom = feature.geometry()
atMap = feature.attributes()
segments = self.extractAsSingleSegments( inGeom )
outFeat.setAttributes( atMap )
segments = self.extractAsSingleSegments(inGeom)
outFeat.setAttributes(atMap)
for segment in segments:
outFeat.setGeometry(segment)
writer.addFeature(outFeat)
del writer


def extractAsSingleSegments( self, geom ):
def extractAsSingleSegments(self, geom):
segments = []
if geom.isMultipart():
multi = geom.asMultiPolyline()
for polyline in multi:
segments.extend( self.getPolylineAsSingleSegments(polyline))
segments.extend(self.getPolylineAsSingleSegments(polyline))
else:
segments.extend( self.getPolylineAsSingleSegments(geom.asPolyline()))
segments.extend(self.getPolylineAsSingleSegments(
geom.asPolyline()))
return segments

def getPolylineAsSingleSegments(self, polyline):
segments = []
for i in range(len(polyline)-1):
for i in range(len(polyline) - 1):
ptA = polyline[i]
ptB = polyline[i+1]
ptB = polyline[i + 1]
segment = QgsGeometry.fromPolyline([ptA, ptB])
segments.append(segment)
return segments

def defineCharacteristics(self):
self.name = "Explode lines"
self.group = "Vector geometry tools"
self.addParameter(ParameterVector(self.INPUT, "Input layer", [ParameterVector.VECTOR_TYPE_LINE]))
self.addOutput(OutputVector(self.OUTPUT, "Output layer"))

self.name = 'Explode lines'
self.group = 'Vector geometry tools'
self.addParameter(ParameterVector(self.INPUT, 'Input layer',
[ParameterVector.VECTOR_TYPE_LINE]))
self.addOutput(OutputVector(self.OUTPUT, 'Output layer'))
137 changes: 75 additions & 62 deletions python/plugins/processing/algs/FieldPyculator.py
View file
Original file line number Diff line number Diff line change
Expand Up @@ -5,7 +5,7 @@
FieldPyculator.py
---------------------
Date : August 2012
Copyright : (C) 2012 by Victor Olaya & NextGIS
Copyright : (C) 2012 by Victor Olaya
Email : volayaf at gmail dot com
***************************************************************************
* *
Expand All @@ -20,53 +20,58 @@
__author__ = 'Victor Olaya & NextGIS'
__date__ = 'August 2012'
__copyright__ = '(C) 2012, Victor Olaya & NextGIS'

# This will get replaced with a git SHA1 when you do a git archive

__revision__ = '$Format:%H$'

import sys
from PyQt4.QtCore import *
from qgis.core import *
from processing.core.GeoAlgorithm import GeoAlgorithm
from processing.tools import dataobjects, vector
from processing.core.GeoAlgorithmExecutionException import GeoAlgorithmExecutionException
from processing.core.GeoAlgorithmExecutionException import \
GeoAlgorithmExecutionException
from processing.parameters.ParameterVector import ParameterVector
from processing.parameters.ParameterString import ParameterString
from processing.parameters.ParameterNumber import ParameterNumber
from processing.parameters.ParameterSelection import ParameterSelection
from processing.outputs.OutputVector import OutputVector
from processing.tools import dataobjects, vector


class FieldsPyculator(GeoAlgorithm):

INPUT_LAYER = "INPUT_LAYER"
FIELD_NAME = "FIELD_NAME"
FIELD_TYPE = "FIELD_TYPE"
FIELD_LENGTH = "FIELD_LENGTH"
FIELD_PRECISION = "FIELD_PRECISION"
GLOBAL = "GLOBAL"
FORMULA = "FORMULA"
OUTPUT_LAYER ="OUTPUT_LAYER"
RESULT_VAR_NAME = "value"

TYPE_NAMES = ["Integer", "Float", "String"]
INPUT_LAYER = 'INPUT_LAYER'
FIELD_NAME = 'FIELD_NAME'
FIELD_TYPE = 'FIELD_TYPE'
FIELD_LENGTH = 'FIELD_LENGTH'
FIELD_PRECISION = 'FIELD_PRECISION'
GLOBAL = 'GLOBAL'
FORMULA = 'FORMULA'
OUTPUT_LAYER = 'OUTPUT_LAYER'
RESULT_VAR_NAME = 'value'

TYPE_NAMES = ['Integer', 'Float', 'String']
TYPES = [QVariant.Int, QVariant.Double, QVariant.String]

#===========================================================================
# def getIcon(self):
# return QtGui.QIcon(os.path.dirname(__file__) + "/../images/qgis.png")
#===========================================================================

def defineCharacteristics(self):
self.name = "Advanced Python field calculator"
self.group = "Vector table tools"
self.addParameter(ParameterVector(self.INPUT_LAYER, "Input layer", [ParameterVector.VECTOR_TYPE_ANY], False))
self.addParameter(ParameterString(self.FIELD_NAME, "Result field name", "NewField"))
self.addParameter(ParameterSelection(self.FIELD_TYPE, "Field type", self.TYPE_NAMES))
self.addParameter(ParameterNumber(self.FIELD_LENGTH, "Field length", 1, 255, 10))
self.addParameter(ParameterNumber(self.FIELD_PRECISION, "Field precision", 0, 10, 0))
self.addParameter(ParameterString(self.GLOBAL, "Global expression", multiline = True, optional = True))
self.addParameter(ParameterString(self.FORMULA, "Formula", "value = ", multiline = True))
self.addOutput(OutputVector(self.OUTPUT_LAYER, "Output layer"))
self.name = 'Advanced Python field calculator'
self.group = 'Vector table tools'
self.addParameter(ParameterVector(self.INPUT_LAYER, 'Input layer',
[ParameterVector.VECTOR_TYPE_ANY], False))
self.addParameter(ParameterString(self.FIELD_NAME, 'Result field name'
, 'NewField'))
self.addParameter(ParameterSelection(self.FIELD_TYPE, 'Field type',
self.TYPE_NAMES))
self.addParameter(ParameterNumber(self.FIELD_LENGTH, 'Field length',
1, 255, 10))
self.addParameter(ParameterNumber(self.FIELD_PRECISION,
'Field precision', 0, 10, 0))
self.addParameter(ParameterString(self.GLOBAL, 'Global expression',
multiline=True, optional=True))
self.addParameter(ParameterString(self.FORMULA, 'Formula', 'value = ',
multiline=True))
self.addOutput(OutputVector(self.OUTPUT_LAYER, 'Output layer'))

def processAlgorithm(self, progress):
fieldName = self.getParameterValue(self.FIELD_NAME)
Expand All @@ -77,58 +82,65 @@ def processAlgorithm(self, progress):
globalExpression = self.getParameterValue(self.GLOBAL)
output = self.getOutputFromName(self.OUTPUT_LAYER)

layer = dataobjects.getObjectFromUri(self.getParameterValue(self.INPUT_LAYER))
layer = dataobjects.getObjectFromUri(
self.getParameterValue(self.INPUT_LAYER))
provider = layer.dataProvider()
fields = provider.fields()
fields.append(QgsField(fieldName, self.TYPES[fieldType], "", fieldLength, fieldPrecision))
writer = output.getVectorWriter(fields, provider.geometryType(), layer.crs())
fields.append(QgsField(fieldName, self.TYPES[fieldType], '',
fieldLength, fieldPrecision))
writer = output.getVectorWriter(fields, provider.geometryType(),
layer.crs())
outFeat = QgsFeature()
new_ns = {}

#run global code
if globalExpression.strip() != "":
# Run global code
if globalExpression.strip() != '':
try:
bytecode = compile(globalExpression, '<string>', 'exec')
exec bytecode in new_ns
except:
raise GeoAlgorithmExecutionException("FieldPyculator code execute error\n" +
"Global code block can't be executed!%s \n %s" %
(unicode(sys.exc_info()[0].__name__), unicode(sys.exc_info()[1])))
raise GeoAlgorithmExecutionException(
'FieldPyculator code execute error\n'
+ "Global code block can't be executed!%s \n %s"
% (unicode(sys.exc_info()[0].__name__),
unicode(sys.exc_info()[1])))

#replace all fields tags
# Replace all fields tags
fields = provider.fields()
num = 0
for field in fields:
field_name = unicode(field.name())
replval = '__attr[' + str(num) + ']'
code = code.replace("<" + field_name + ">", replval)
code = code.replace('<' + field_name + '>', replval)
num += 1

#replace all special vars
# Replace all special vars
code = code.replace('$id', '__id')
code = code.replace('$geom', '__geom')
need_id = code.find("__id") != -1
need_geom = code.find("__geom") != -1
need_attrs = code.find("__attr") != -1
need_id = code.find('__id') != -1
need_geom = code.find('__geom') != -1
need_attrs = code.find('__attr') != -1

#compile
# Compile
try:
bytecode = compile(code, '<string>', 'exec')
except:
raise GeoAlgorithmExecutionException("FieldPyculator code execute error\n"+
"Field code block can't be executed! %s \n %s",
unicode(sys.exc_info()[0].__name__), unicode(sys.exc_info()[1]))
raise GeoAlgorithmExecutionException(
'FieldPyculator code execute error\n'
+ "Field code block can't be executed! %s \n %s",
unicode(sys.exc_info()[0].__name__),
unicode(sys.exc_info()[1]))

#run
# Run
features = vector.features(layer)
nFeatures = len(features)
nElement = 1
for feat in features:
progress.setPercentage(int((100 * nElement)/nFeatures))
progress.setPercentage(int(100 * nElement / nFeatures))
attrs = feat.attributes()
feat_id = feat.id()

#add needed vars
# Add needed vars
if need_id:
new_ns['__id'] = feat_id

Expand All @@ -140,29 +152,30 @@ def processAlgorithm(self, progress):
pyattrs = [a for a in attrs]
new_ns['__attr'] = pyattrs

#clear old result
if new_ns.has_key(self.RESULT_VAR_NAME):
# Clear old result
if self.RESULT_VAR_NAME in new_ns:
del new_ns[self.RESULT_VAR_NAME]

#exec
# Exec
exec bytecode in new_ns

#check result
if not new_ns.has_key(self.RESULT_VAR_NAME):
raise GeoAlgorithmExecutionException("FieldPyculator code execute error\n" +
"Field code block does not return '%s1' variable! Please declare this variable in your code!" %
self.RESULT_VAR_NAME)
# Check result
if self.RESULT_VAR_NAME not in new_ns:
raise GeoAlgorithmExecutionException(
'FieldPyculator code execute error\n'
+ "Field code block does not return '%s1' variable! \
Please declare this variable in your code!"
% self.RESULT_VAR_NAME)

#write feature
# Write feature
nElement += 1
outFeat.setGeometry( feat.geometry() )
outFeat.setGeometry(feat.geometry())
attrs.append(new_ns[self.RESULT_VAR_NAME])
outFeat.setAttributes(attrs)
writer.addFeature(outFeat)

del writer


def checkParameterValuesBeforeExecuting(self):
##TODO check that formula is correct and fields exist
# TODO check that formula is correct and fields exist
pass
Loading