def get_featinfo(request, work, lyr):
"""
Geoserver getFeatureInfo data to a Json Response
"""
import requests
from django.http import JsonResponse
from gasp.cons.gsrv import con_gsrv
consrv = con_gsrv()
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=request.GET['WIDTH'],
height=request.GET['HEIGHT'],
x=request.GET['X'],
y=request.GET['Y'],
bbox=request.GET['BBOX'])
r = requests.get(url, headers={'Accept': 'application/json'})
return JsonResponse(r.json())
def backup(backup_file):
"""
"""
import requests
import json
from gasp.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 create_ws(name, overwrite=True):
"""
Create a new Geoserver Workspace
"""
import requests; import json
from gasp.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 get_wms(request, work):
"""
Get Web Map Service
"""
import requests
from django.http import HttpResponse
from gasp.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)
def get_capabilities():
"""
Get GetCapabilities XML Data
"""
import os
import xmltodict
from gasp.to.web import get_file
from gasp.cons.gsrv import con_gsrv
from gasp.pyt.char import random_str
from gasp.pyt.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 lst_stores(workspace):
"""
List all stores in a Workspace
"""
import requests
import json
from gasp.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 pub_pglyr(workspace, store, pg_table, title=None):
"""
Publish PostGIS table in geoserver
"""
import os; import requests
from gasp.pyt.char import random_str
from gasp.pyt.Xml import write_xml_tree
from gasp.pyt.oss import mkdir, del_folder
from gasp.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 pub_rst_lyr(layername, datastore, workspace, epsg_code):
"""
Publish a Raster layer
"""
import os; import requests
from gasp.pyt.char import random_str
from gasp.pyt.Xml import write_xml_tree
from gasp.pyt.oss import mkdir, del_folder
from gasp.gt.prop.prj import epsg_to_wkt
from gasp.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 add_rst_store(raster, store_name, workspace):
"""
Create a new store with a raster layer
"""
import os
import requests
from gasp.pyt.oss import del_file
from gasp.pyt.Xml import write_xml_tree
from gasp.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 del_lyr(lyr):
"""
Delete some layer
"""
import requests
from gasp.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 del_style(name):
"""
Delete a specific style
"""
import requests
import json
from gasp.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 del_store(workspace, name):
"""
Delete an existing Geoserver datastore
"""
import requests
import json
from gasp.cons.gsrv import con_gsrv
conf = con_gsrv()
url = ('{pro}://{host}:{port}/geoserver/rest/workspaces/{work}/'
'datastores/{ds}?recurse=true').format(host=conf['HOST'],
port=conf['PORT'],
work=workspace,
ds=name,
pro=conf['PROTOCOL'])
r = requests.delete(url, auth=(conf['USER'], conf['PASSWORD']))
return r
def create_style(name, sld, overwrite=None):
"""
Import SLD into a new Geoserver Style
"""
import requests
import os
from gasp.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 shp_to_store(shape, store_name, workspace):
"""
Create a new datastore
"""
import os
import requests
from gasp.pyt.oss import lst_ff, fprop
from gasp.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 gasp.pyt.ff.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 lst_lyr():
"""
List all layers in the geoserver
"""
import requests
from gasp.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 assign_style_to_layer(style, layer):
"""
Add a style to a geoserver layer
"""
import requests
import json
from gasp.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 get_wfs(request, work, lyr):
"""
GeoServer - Pass Web Feature Service using Django
"""
import requests
from django.http import JsonResponse
from gasp.cons.gsrv import con_gsrv
consrv = con_gsrv()
if 'val' in request.GET and 'attr' in request.GET:
_q = '&cql_filter={}=\'{}\''.format(request.GET['attr'],
request.GET['val'])
else:
_q = ''
if 'count' in request.GET:
_c = '&count={}'.format(str(request.GET['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 JsonResponse(wfs, content_type='json')
def import_datafolder(path_folder, store_name, workspace):
"""
Import all shapefiles in a directory to a GeoServer Store
"""
import requests
from gasp.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 gasp.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 lst_ws():
"""
Return a list with all avaiable workspaces in the GeoServer
"""
import requests
from gasp.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_pgstore(store, workspace, pg_con):
"""
Create a store for PostGIS data
"""
import os
import requests
from gasp.pyt.char import random_str
from gasp.pyt.Xml import write_xml_tree
from gasp.pyt.oss import mkdir, del_folder
from gasp.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
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"): pg_con["DATABASE"],
("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
