def lst_stores(workspace):
"""
List all stores in a Workspace
"""
import requests
import json
from glass.cons.gsrv import con_gsrv
conf = con_gsrv()
url = '{pro}://{host}:{port}/geoserver/rest/workspaces/{work}/datastores'.format(
host=conf['HOST'],
port=conf['PORT'],
work=workspace,
pro=conf['PROTOCOL'])
r = requests.get(url,
headers={'Accept': 'application/json'},
auth=(conf['USER'], conf['PASSWORD']))
ds = r.json()
if 'dataStore' in ds['dataStores']:
return [__ds['name'] for __ds in ds['dataStores']['dataStore']]
else:
return []
def get(self, request, work, lyr, format=None):
"""
Geoserver getFeatureInfo data to a Json Response
"""
import requests
from glass.cons.gsrv import con_gsrv
consrv = con_gsrv()
data = request.data
url = (
'{pr}://{host}:{port}/geoserver/wfs?'
'INFO_FORMAT=application/json&'
'REQUEST=GetFeatureInfo&EXCEPTIONS=application/vnd.ogc.se_xml&'
'SERVICE=WMS&VERSION=1.1.1&'
'WIDTH={width}&HEIGHT={height}&'
'X={x}&Y={y}&BBOX={bbox}&LAYERS={work}:{lyr}&'
'QUERY_LAYERS={work}:{lyr}&TYPENAME={work}:{lyr}&'
'CRS=EPSG:4326'
).format(
pr=consrv['PROTOCOL'], host=consrv['HOST'], port=consrv['PORT'],
work=work, lyr=lyr, width=data['WIDTH'], height=data['HEIGHT'],
x=data['X'], y=data['Y'], bbox=data['BBOX']
)
r = requests.get(url, headers={'Accept': 'application/json'})
return Response(r.json(), status=status.HTTP_200_OK)
def get_wms(request, work):
"""
Get Web Map Service
"""
import requests
from django.http import HttpResponse
from glass.cons.gsrv import con_gsrv
srvcon = con_gsrv()
r = requests.get('{}://{}:{}/geoserver/{}/wms?'.format(
srvcon['PROTOCOL'], srvcon['HOST'], srvcon['PORT'], work
),params={
'service' : request.GET['service'],
'version' : request.GET['version'],
'request' : request.GET['request'],
'layers' : request.GET['layers'],
'width' : request.GET['width'],
'height' : request.GET['height'],
'bbox' : request.GET['bbox'],
'format' : request.GET['format'],
'transparent' : request.GET['transparent'],
'styles' : request.GET['styles'],
'srs' : request.GET['srs']
})
return HttpResponse(r.content, content_type="image/png")
def create_ws(name, overwrite=True):
"""
Create a new Geoserver Workspace
"""
import requests
import json
from glass.cons.gsrv import con_gsrv
conf = con_gsrv()
url = '{pro}://{host}:{port}/geoserver/rest/workspaces'.format(
host=conf['HOST'], port=conf['PORT'], pro=conf['PROTOCOL'])
if overwrite:
GEO_WORK = lst_ws()
if name in GEO_WORK:
del_ws(name)
r = requests.post(url,
data=json.dumps({'workspace': {
'name': name
}}),
headers={'content-type': 'application/json'},
auth=(conf['USER'], conf['PASSWORD']))
return r
def backup(backup_file):
"""
"""
import requests
import json
from glass.cons.gsrv import con_gsrv
conf = con_gsrv()
url = '{pro}://{host}:{port}/geoserver/rest/br/backup/'.format(
host=conf['HOST'], port=conf['PORT'], pro=conf["PROTOCOL"])
backup_parameters = {
"backup": {
"archiveFile": backup_file,
"overwrite": True,
"options": {
#"option": ["BK_BEST_EFFORT=true"]
}
# filter
}
}
r = requests.post(url,
headers={'content-type': 'application/json'},
data=json.dumps(backup_parameters),
auth=(conf['USER'], conf['PASSWORD']))
return r
def get_capabilities():
"""
Get GetCapabilities XML Data
"""
import os
import xmltodict
from glass.pys.web import get_file
from glass.cons.gsrv import con_gsrv
from glass.pys.char import random_str
from glass.pys.oss import del_file
conparam = con_gsrv()
url = ("{}://{}:{}/geoserver/wms?request=GetCapabilities"
"&service=WMS&version=1.1.1").format(conparam["PROTOCOL"],
conparam["HOST"],
conparam["PORT"])
xml = get_file(
url,
os.path.join(os.path.dirname(os.path.abspath(__file__)),
random_str(10) + '.xml'))
with open(xml) as xmlf:
xmld = xmltodict.parse(xmlf.read())
del_file(xml)
return xmld
def add_rst_store(raster, store_name, workspace):
"""
Create a new store with a raster layer
"""
import os
import requests
from glass.pys.oss import del_file
from glass.pys.Xml import write_xml_tree
from glass.cons.gsrv import con_gsrv
conf = con_gsrv()
url = ('{pro}://{host}:{port}/geoserver/rest/workspaces/{work}/'
'coveragestores?configure=all').format(host=conf['HOST'],
port=conf['PORT'],
work=workspace,
pro=conf['PROTOCOL'])
# Create obj with data to be written in the xml
xmlTree = {
"coverageStore": {
"name": store_name,
"workspace": workspace,
"enabled": "true",
"type": "GeoTIFF",
"url": raster
}
}
treeOrder = {
"coverageStore": ["name", "workspace", "enabled", "type", "url"]
}
# Write XML
xml_file = write_xml_tree(xmlTree,
os.path.join(os.path.dirname(raster),
'new_store.xml'),
nodes_order=treeOrder)
# Send request
with open(xml_file, 'rb') as f:
r = requests.post(url,
data=f,
headers={'content-type': 'text/xml'},
auth=(conf['USER'], conf['PASSWORD']))
del_file(xml_file)
return r
def pub_rst_lyr(layername, datastore, workspace, epsg_code):
"""
Publish a Raster layer
"""
import os
import requests
from glass.pys.char import random_str
from glass.pys.Xml import write_xml_tree
from glass.pys.oss import mkdir, del_folder
from glass.g.prop.prj import epsg_to_wkt
from glass.cons.gsrv import con_gsrv
conf = con_gsrv()
url = ('{pro}://{host}:{port}/geoserver/rest/workspaces/{work}/'
'coveragestores/{storename}/coverages').format(host=conf['HOST'],
port=conf['PORT'],
work=workspace,
storename=datastore,
pro=conf['PROTOCOL'])
# Create obj with data to be written in the xml
xmlTree = {
"coverage": {
"name": layername,
"title": layername,
"nativeCRS": str(epsg_to_wkt(epsg_code)),
"srs": 'EPSG:{}'.format(str(epsg_code)),
}
}
# Write XML
wTmp = mkdir(
os.path.join(os.path.dirname(os.path.abspath(__file__)),
random_str(7)))
xml_file = write_xml_tree(xmlTree, os.path.join(wTmp, 'rst_lyr.xml'))
# Create layer
with open(xml_file, 'rb') as f:
r = requests.post(url,
data=f,
headers={'content-type': 'text/xml'},
auth=(conf['USER'], conf['PASSWORD']))
del_folder(wTmp)
return r
def pub_pglyr(workspace, store, pg_table, title=None):
"""
Publish PostGIS table in geoserver
"""
import os
import requests
from glass.pys.char import random_str
from glass.pys.Xml import write_xml_tree
from glass.pys.oss import mkdir, del_folder
from glass.cons.gsrv import con_gsrv
gs_con = con_gsrv()
# Create folder to write xml
wTmp = mkdir(
os.path.join(os.path.dirname(os.path.abspath(__file__)),
random_str(7)))
# Create obj with data to be written in the xml
lyr_title = "Title {}".format(pg_table) if not title else title
elements = {"featureType": {"name": pg_table, "title": lyr_title}}
# Write the xml
xml_file = write_xml_tree(elements,
os.path.join(wTmp, '{}.xml'.format(pg_table)))
# Create Geoserver Layer
url = ('{pro}://{host}:{port}/geoserver/rest/workspaces/{wname}/'
'datastores/{store_name}/featuretypes').format(
host=gs_con['HOST'],
port=gs_con['PORT'],
wname=workspace,
store_name=store,
pro=gs_con['PROTOCOL'])
with open(xml_file, 'rb') as __xml:
r = requests.post(url,
data=__xml,
headers={'content-type': 'text/xml'},
auth=(gs_con['USER'], gs_con['PASSWORD']))
__xml.close()
del_folder(wTmp)
return r
def del_lyr(lyr):
"""
Delete some layer
"""
import requests
from glass.cons.gsrv import con_gsrv
conf = con_gsrv()
url = '{}://{}:{}/geoserver/rest/layers/{}'.format(conf['PROTOCOL'],
conf["HOST"],
conf["PORT"], lyr)
r = requests.delete(url, auth=(conf["USER"], conf["PASSWORD"]))
return r
def lst_lyr():
"""
List all layers in the geoserver
"""
import requests
from glass.cons.gsrv import con_gsrv
conf = con_gsrv()
url = '{pro}://{host}:{port}/geoserver/rest/layers'.format(
host=conf['HOST'], port=conf['PORT'], pro=conf['PROTOCOL'])
r = requests.get(url,
headers={'Accept': 'application/json'},
auth=(conf['USER'], conf['PASSWORD']))
layers = r.json()
return [l['name'] for l in layers['layers']['layer']]
def del_ws(name):
"""
Delete an existing GeoServer Workspace
"""
import requests
import json
from glass.cons.gsrv import con_gsrv
conf = con_gsrv()
url = ('{pro}://{host}:{port}/geoserver/rest/workspaces/{work}?'
'recurse=true').format(host=conf['HOST'],
port=conf['PORT'],
work=name,
pro=conf['PROTOCOL'])
r = requests.delete(url, auth=(conf['USER'], conf['PASSWORD']))
return r
def del_style(name):
"""
Delete a specific style
"""
import requests
import json
from glass.cons.gsrv import con_gsrv
conf = con_gsrv()
url = ('{pro}://{host}:{port}/geoserver/rest/styles/{stl}?'
'recurse=true').format(host=conf['HOST'],
port=conf['PORT'],
stl=name,
pro=conf['PROTOCOL'])
r = requests.delete(url, auth=(conf['USER'], conf['PASSWORD']))
return r
def get(self, request, work, lyr, format=None):
"""
GeoServer - Pass Web Feature Service using Django
"""
import requests
from glass.cons.gsrv import con_gsrv
consrv = con_gsrv()
# Request data
data = request.data
if 'val' in data and 'attr' in data:
_q = '&cql_filter={}=\'{}\''.format(
data['attr'], data['val']
)
else:
_q = ''
if 'count' in data:
_c = '&count={}'.format(str(data['count']))
else:
_c = ''
url = (
'{pr}://{host}:{port}/geoserver/{work_}/ows?'
'service=WFS&version=2.0.0&request=GetFeature&'
'typeName={work_}:{lyrn}&outputFormat=application/json&'
'{c}{q}'
).format(
pr=consrv['PROTOCOL'], host=consrv['HOST'], port=consrv['PORT'],
work_=work, lyrn=lyr, q=_q, c=_c
)
r = requests.get(url, headers={'Accept' : 'application/json'})
wfs = r.json()
return Response(wfs, status=status.HTTP_200_OK)
def lst_ws():
"""
Return a list with all avaiable workspaces in the GeoServer
"""
import requests
from glass.cons.gsrv import con_gsrv
conf = con_gsrv()
url = '{pro}://{host}:{port}/geoserver/rest/workspaces'.format(
host=conf['HOST'], port=conf['PORT'], pro=conf['PROTOCOL'])
r = requests.get(url,
headers={'Accept': 'application/json'},
auth=(conf['USER'], conf['PASSWORD']))
workspaces = r.json()
if 'workspace' in workspaces['workspaces']:
return [w['name'] for w in workspaces['workspaces']['workspace']]
else:
return []
def create_style(name, sld, overwrite=None):
"""
Import SLD into a new Geoserver Style
"""
import requests
import os
from glass.cons.gsrv import con_gsrv
conf = con_gsrv()
if overwrite:
GEO_STYLES = lst_styles()
if name in GEO_STYLES:
del_style(name)
url = '{pro}://{host}:{port}/geoserver/rest/styles'.format(
host=conf['HOST'], port=conf['PORT'], pro=conf['PROTOCOL'])
xml = '<style><name>{n}</name><filename>{filename}</filename></style>'.format(
n=name, filename=os.path.basename(sld))
r = requests.post(url,
data=xml,
headers={'content-type': 'text/xml'},
auth=(conf['USER'], conf['PASSWORD']))
url = '{pro}://{host}:{port}/geoserver/rest/styles/{n}'.format(
host=conf['HOST'], port=conf['PORT'], n=name, pro=conf['PROTOCOL'])
with open(sld, 'rb') as f:
r = requests.put(
url,
data=f,
headers={'content-type': 'application/vnd.ogc.sld+xml'},
auth=(conf['USER'], conf['PASSWORD']))
return r
def assign_style_to_layer(style, layer):
"""
Add a style to a geoserver layer
"""
import requests
import json
from glass.cons.gsrv import con_gsrv
conf = con_gsrv()
url = '{pro}://{host}:{port}/geoserver/rest/layers/{lyr}/styles'.format(
host=conf['HOST'], port=conf['PORT'], lyr=layer, pro=conf['PROTOCOL'])
r = requests.post(url,
data=json.dumps({'style': {
'name': style
}}),
headers={'content-type': 'application/json'},
auth=(conf['USER'], conf['PASSWORD']))
return r
def shp_to_store(shape, store_name, workspace):
"""
Create a new datastore
"""
import os
import requests
from glass.pys.oss import lst_ff, fprop
from glass.cons.gsrv import con_gsrv
conf = con_gsrv()
url = ('{pro}://{host}:{port}/geoserver/rest/workspaces/{work}/datastores/'
'{store}/file.shp').format(host=conf['HOST'],
port=conf['PORT'],
work=workspace,
store=store_name,
pro=conf['PROTOCOL'])
shpp = fprop(shape, ['fn', 'ff'])
fn, ff = shpp['filename'], shpp['fileformat']
if ff != '.zip':
from glass.pys.zzip import zip_files
shp_fld = os.path.dirname(shape)
shapefiles = lst_ff(shp_fld, filename=fn)
shape = os.path.join(shp_fld, fn + '.zip')
zip_files(shapefiles, shape)
with open(shape, 'rb') as f:
r = requests.put(url,
data=f,
headers={'content-type': 'application/zip'},
auth=(conf['USER'], conf['PASSWORD']))
return r
def import_datafolder(path_folder, store_name, workspace):
"""
Import all shapefiles in a directory to a GeoServer Store
"""
import requests
from glass.cons.gsrv import con_gsrv
conf = con_gsrv()
url = ('{pro}://{host}:{port}/geoserver/rest/workspaces/{work}/datastores/'
'{store}/external.shp?configure=all').format(host=conf['HOST'],
port=conf['PORT'],
work=workspace,
store=store_name,
pro=conf['PROTOCOL'])
r = requests.put(url,
data='file://' + path_folder,
headers={'content-type': 'text/plain'},
auth=(conf['USER'], conf['PASSWORD']))
return r
def lst_styles():
"""
List Styles in Geoserver
"""
import requests
from glass.cons.gsrv import con_gsrv
conf = con_gsrv()
url = '{pro}://{host}:{port}/geoserver/rest/styles'.format(
host=conf['HOST'], port=conf['PORT'], pro=conf['PROTOCOL'])
r = requests.get(url,
headers={'Accept': 'application/json'},
auth=(conf['USER'], conf['PASSWORD']))
styles = r.json()
if 'style' in styles['styles']:
return [style['name'] for style in styles['styles']['style']]
else:
return []
def create_pgstore(store, workspace, db, dbset='default'):
"""
Create a store for PostGIS data
"""
import os
import requests
from glass.pys.char import random_str
from glass.pys.Xml import write_xml_tree
from glass.pys.oss import mkdir, del_folder
from glass.cons.gsrv import con_gsrv
from glass.cons.psql import con_psql
gs_con = con_gsrv()
pg_con = con_psql(db_set=dbset)
# Create folder to write xml
wTmp = mkdir(
os.path.join(os.path.dirname(os.path.abspath(__file__)),
random_str(7)))
# Create obj with data to be written in the xml
tree_order = {
"dataStore": [
"name", "type", "enabled", "workspace", "connectionParameters",
"__default"
],
"connection:Parameters": [("entry", "key", "port"),
("entry", "key", "user"),
("entry", "key", "passwd"),
("entry", "key", "dbtype"),
("entry", "key", "host"),
("entry", "key", "database"),
("entry", "key", "schema")]
}
xml_tree = {
"dataStore": {
"name": store,
"type": "PostGIS",
"enabled": "true",
"workspace": {
"name": workspace
},
"connectionParameters": {
("entry", "key", "port"): pg_con["PORT"],
("entry", "key", "user"): pg_con["USER"],
("entry", "key", "passwd"): pg_con["PASSWORD"],
("entry", "key", "dbtype"): "postgis",
("entry", "key", "host"): pg_con["HOST"],
("entry", "key", "database"): db,
("entry", "key", "schema"): "public"
},
"__default": "false"
}
}
# Write xml
xml_file = write_xml_tree(xml_tree,
os.path.join(wTmp, 'pgrest.xml'),
nodes_order=tree_order)
# Create Geoserver Store
url = ('{pro}://{host}:{port}/geoserver/rest/workspaces/{wname}/'
'datastores.xml').format(host=gs_con['HOST'],
port=gs_con['PORT'],
wname=workspace,
pro=gs_con['PROTOCOL'])
with open(xml_file, 'rb') as f:
r = requests.post(url,
data=f,
headers={'content-type': 'text/xml'},
auth=(gs_con['USER'], gs_con['PASSWORD']))
f.close()
del_folder(wTmp)
return r