def georeference_profile_page(request):
log.info('Request - Get georeference profile page.')
dbsession = request.db
userid = checkIsUser(request)
user = Users.by_username(userid, dbsession)
try:
log.debug('Query georeference profile information from database for user %s'%userid)
query_georefprocess = georeference_profile_query%userid
resultSet = dbsession.execute(query_georefprocess)
log.debug('Create response list')
georef_profile = []
for record in resultSet:
georef_profile.append({'georef_id':record['georef_id'], 'mtb_id':record['mtbid'],
'clip_params': record['clip_params'], 'time': record['time'], 'transformed': record['isttransformiert'],
'isvalide': record['isvalide'], 'titel': record['titel'], 'key': record['key'],
'time_georef':record['time_georef'],'boundingbox':record['box'][4:-1].replace(' ',','),'type':record['type'],
'published':record['published']})
log.debug('Response: %s'%georef_profile)
return {'georef_profile':georef_profile, 'points':user.bonuspunkte}
except Exception as e:
log.error('Error while trying to request georeference history information');
log.error(e)
return {}
def getTimestampsForId(request):
""" Returns a json document which contains a a list of messtischblatt tuples which
have the same blattnumber like the given object. """
try:
log.info('Receive request for timestamps for a given object number.')
dbsession = request.db
object_id = request.GET.get('id')
metadataObj = Metadata.by_id(object_id, dbsession)
spatial_relation_objects = VBlattschnittMtb.allForBlattnr(
metadataObj.blattnr, dbsession)
#create response
response = []
for rel_object in spatial_relation_objects:
if rel_object.isttransformiert:
response.append({
'id':
rel_object.mapid,
'time':
rel_object.time,
'extent':
Map.getExtent(rel_object.map, dbsession, DATABASE_SRID)
})
return {'maps': response}
except DBAPIError as e:
log.error(e)
log.error(traceback.format_exc())
raise HTTPInternalServerError(GENERAL_ERROR_MESSAGE)
def getPage_profileMtb(request):
try:
messtischblatt_id = None
if 'objectid' in request.params:
maps_id = request.params['objectid']
log.info('Receive get map profile page for id %s.'%messtischblatt_id)
georef = False
if 'georef' in request.params and request.params['georef'].lower() == 'true':
georef = True
if georef:
permalink = createPermalink(request, maps_id)
return HTTPFound(location=permalink)
mapObj = Map.by_id(maps_id, request.db)
metadata = Metadata.by_id(maps_id, request.db)
oai = createOAI(mapObj.id)
return {'zoomify':metadata.imagezoomify,'key':oai,
'titel_long': metadata.title,'titel_short': metadata.titleshort, 'permalink': metadata.apspermalink}
except:
log.error('Internal server error while trying to get profile page. Please try again or contact the page administrator.')
log.error(traceback.format_exc())
raise InternalAuthentificationError('Internal server error while trying to get profile page. Please try again or contact the page administrator.')
def getAdminEvaluationPage(request):
log.info('Request - Get georeference profile page.')
try:
resultSet = request.db.execute(georeference_evaluation_query)
log.debug('Create response list')
georef_profile = []
for record in resultSet:
encoded_clip_params = str(
convertUnicodeDictToUtf(ast.literal_eval(
record['clip_params']))).replace('\'', '"')
georef_profile.append({
'georef_id': record['georef_id'],
'mtb_id': record['mtbid'],
'clip_params': encoded_clip_params,
'time': record['time'],
'transformed': record['isttransformiert'],
'isvalide': record['isvalide'],
'titel': record['titel'],
'key': record['key'],
'time_georef': record['time_georef'],
'type': record['type'],
'userid': record['userid'],
'published': record['published']
})
log.debug('Response: %s' % georef_profile)
return {'georef_profile': georef_profile}
except Exception as e:
log.error(
'Error while trying to request georeference history information')
log.error(e)
return {}
def resetGeorefParameters(request):
try:
log.info('Receive a reset georeference parameter requests.')
login = checkIsUser(request)
dbsession = request.db
messtischblatt_id = request.params['mtbid']
georeference_process = Georeferenzierungsprozess.by_messtischblattid(messtischblatt_id, dbsession)
referenz = georeference_process.clipparameter
fehlerbeschreibung = 'Zuruecksetzen von Georeferenzierungsparameter für GeorefId=%s'%georeference_process.id
if login and messtischblatt_id and referenz and fehlerbeschreibung and Users.by_username(login, dbsession):
log.debug('Save reset process in table fehlermeldungen ...')
newFehlermeldung = Fehlermeldung(objektid = messtischblatt_id, referenz = referenz, nutzerid = login,
fehlerbeschreibung = fehlerbeschreibung, timestamp = getTimestampAsPGStr())
dbsession.add(newFehlermeldung)
log.debug('Remove georeference process ...')
dbsession.delete(georeference_process)
log.debug('Remove refmtblayer ...')
try:
refmtblayer = RefMtbLayer.by_id(MTB_LAYER_ID, messtischblatt_id, dbsession)
dbsession.delete(refmtblayer)
except:
log.debug('No entry for refmtblayer found ...')
pass
log.debug('Update messtischblatt db ...')
messtischblatt = Messtischblatt.by_id(messtischblatt_id, dbsession)
messtischblatt.isttransformiert = False
return json.dumps({'status':'confirmed'}, ensure_ascii=False, encoding='utf-8')
except DBAPIError:
log.error('Problems while trying to remove georeference parameter from the database ...')
return Response(conn_err_msg, content_type='text/plain', status_int=500)
def getUploadProfilePage(request):
log.debug('Request - Get Upload profile page.')
dbsession = request.db
username = checkIsUser(request)
user = Users.by_username(username, dbsession)
userid = user.id
try:
log.debug('Query Upload profile information from database for user %s'%userid)
query_uploadprofile = upload_profile_query%userid
resultSet = dbsession.execute(query_uploadprofile)
log.debug('Create response list')
upload_profile = []
for record in resultSet:
upload_profile.append({'upload_id':record['upload_id'], 'upload_mapid':record['upload_mapid'],
'time': record['time'], 'licence': record['licence'], 'title': record['title'],
'upload_time':record['upload_time'], 'imagepath':record['imagepath'], 'thumbnail': record['thumbnail']})
log.debug('Response: %s'%upload_profile)
return {'upload_profile':upload_profile}
except Exception as e:
log.error('Error while trying to request upload history information');
log.error(e)
return {}
return {}
def publishGeorefParameters(request):
log.info('Request - Publish georeference result.')
try:
log.debug('Parse parameters ...')
objectid = request.params['objectid']
georeferenceid = request.params['georeferenceid']
messtischblatt = Messtischblatt.by_id(objectid, request.db)
georeferenceprocess = Georeferenzierungsprozess.by_id(
georeferenceid, request.db)
log.debug('Udpate parameters')
georeferenceprocess.publish = True
messtischblatt.updated = False
return json.dumps(
{
'message':
'The georeference process is now published. The georeference map will soon be updated and than ready for accessing.'
},
ensure_ascii=False,
encoding='utf-8')
except Exception as e:
log.error(
'Error while trying to request georeference history information')
log.error(e)
return {}
def getPage_profileMtb(request):
try:
messtischblatt_id = None
if 'id' in request.params:
messtischblatt_id = request.params['id']
log.info('Receive get profile mtb page for id %s.' %
messtischblatt_id)
messtischblatt = Messtischblatt.by_id(messtischblatt_id, request.db)
user_id = authenticated_userid(request)
if user_id:
groups = groupfinder(user_id, request)
if groups and 'g:moderator' in groups or 'g:admin' in groups:
return {
'with_modify': True,
'zoomify_prop': messtischblatt.zoomify_properties,
'zoomify_width': messtischblatt.zoomify_width,
'zoomify_height': messtischblatt.zoomify_height,
'key': messtischblatt.dateiname
}
return {
'zoomify_prop': messtischblatt.zoomify_properties,
'zoomify_width': messtischblatt.zoomify_width,
'zoomify_height': messtischblatt.zoomify_height,
'key': messtischblatt.dateiname
}
except:
log.error(
'Internal server error while trying to get profile page. Please try again or contact the page administrator.'
)
raise InternalAuthentificationError(
'Internal server error while trying to get profile page. Please try again or contact the page administrator.'
)
def georeferenceGetProcess(request):
log.info('Receive request GetGeoreferenceProcess')
try:
request_data = None
if request.method == 'POST':
request_data = request.json_body
objectid = None
if 'objectid' in request_data:
validateId(request_data['objectid'])
objectid = int(request_data['objectid'])
log.debug('Objectid is valide: %s'%request_data)
georeferenceid = None
if 'georeferenceid' in request_data:
georeferenceid = int(request_data['georeferenceid'])
if georeferenceid:
response = createResponseForSpecificGeoreferenceProcess(objectid, georeferenceid, request)
else:
response = createGeneralResponse(objectid, request)
return json.dumps(response, ensure_ascii=False, encoding='utf-8')
except GeoreferenceParameterError as e:
message = 'Wrong or missing service parameter - %s'%e.value
log.error(message)
return HTTPBadRequest(message)
except Exception as e:
message = 'Problems while creating response for getprocess request - %s'%e
log.error(message)
return HTTPInternalServerError(message)
def __call__(self):
log.info("Start processing georeference validation result.")
try:
# parse query parameter and check if they are valide
self.__parseQueryParameter__()
self.__validateQueryParameter__()
self.__parseUserId__()
# initialize georef process
dbsession = self.request.db
georeferenceProcess = createGeoreferenceProcess(self.mtbid, dbsession, tmp_dir, log)
# create validation result and get destination path and georeference id
validationResultPath = os.path.join(dest_mapfilefolder,georeferenceProcess.messtischblatt.dateiname+"::"+str(getUniqueId())+".tif")
georefId, destPath = georeferenceProcess.fastGeoreference(self.userid,self.points,validationResultPath)
# create mapfile for georeference result
wms_url = createMapfile(georeferenceProcess.messtischblatt.dateiname, destPath,
src_mapfilepath, dest_mapfilefolder, mapfileInitParameter)
response = {'wms_url':wms_url,'layer_id':georeferenceProcess.messtischblatt.dateiname,'georefid':georefId}
return json.dumps(response, ensure_ascii=False, encoding='utf-8')
except GeoreferenceParameterError as e:
message = 'Wrong or missing service parameter - %s'%e.value
log.error(message)
return HTTPBadRequest(message)
except Exception as e:
message = 'Problems while computing validation result - %s'%e.value
log.error(message)
return HTTPInternalServerError(message)
def getPage_profileMtb(request):
try:
messtischblatt_id = None
if "objectid" in request.params:
messtischblatt_id = request.params["objectid"]
log.info("Receive get map profile page for id %s." % messtischblatt_id)
georef = False
if "georef" in request.params and request.params["georef"].lower() == "true":
georef = True
if georef:
permalink = createPermalink(request, messtischblatt_id)
return HTTPFound(location=permalink)
messtischblatt = Messtischblatt.by_id(messtischblatt_id, request.db)
metadata = MdCore.by_id(messtischblatt.id, request.db)
metadata_datensatz = MdDatensatz.by_ObjectId(messtischblatt.id, request.db)
return {
"zoomify_prop": messtischblatt.zoomify_properties,
"zoomify_width": messtischblatt.zoomify_width,
"zoomify_height": messtischblatt.zoomify_height,
"key": "vk20-md-%s" % messtischblatt.id,
"titel_long": metadata.titel,
"titel_short": metadata.titel_short,
"permalink": metadata_datensatz.permalink,
}
except:
log.error(
"Internal server error while trying to get profile page. Please try again or contact the page administrator."
)
raise InternalAuthentificationError(
"Internal server error while trying to get profile page. Please try again or contact the page administrator."
)
def georeferenceGetProcess(request):
log.info('Receive request GetGeoreferenceProcess')
try:
request_data = None
if request.method == 'POST':
request_data = request.json_body
objectid = None
if 'objectid' in request_data:
validateId(request_data['objectid'])
objectid = int(request_data['objectid'])
log.debug('Objectid is valide: %s' % request_data)
georeferenceid = None
if 'georeferenceid' in request_data:
georeferenceid = int(request_data['georeferenceid'])
if georeferenceid:
response = createResponseForSpecificGeoreferenceProcess(
objectid, georeferenceid, request)
else:
response = createGeneralResponse(objectid, request)
return json.dumps(response, ensure_ascii=False, encoding='utf-8')
except GeoreferenceParameterError as e:
message = 'Wrong or missing service parameter - %s' % e.value
log.error(message)
return HTTPBadRequest(message)
except Exception as e:
message = 'Problems while creating response for getprocess request - %s' % e
log.error(message)
return HTTPInternalServerError(message)
def georeferenceUpdate(request):
log.info('Receive request for processing georeference update result')
try:
userid = checkIsUser(request)
request_data = None
if request.method == 'POST':
request_data = request.json_body
mapObj = parseMapObjForId(request_data, 'id', request.db)
log.debug('Id is valide: %s' % request_data)
log.debug(
'Check if there exists a registered georeference process for this messtischblatt ...'
)
if Georeferenzierungsprozess.isGeoreferenced(mapObj.id,
request.db) == False:
response = {
'text':
'There is no registered georeference process for this messtischblatt. Please move back to the confirm process.'
}
return response
# actual only support this option if target srs is EPSG:4314
log.debug('Saving georeference process in the database ...')
if request_data['georeference']:
encoded_clip_params = convertUnicodeDictToUtf(
request_data['georeference'])
georefProcess = registerUpdateGeoreferenceProcessInDb(
mapObj, userid, str(encoded_clip_params), request.db)
log.debug('Create response ...')
# right now the premise is that for the updated gcps are equal to the removed gcps. For every
# updated gcps the users get new points
achievement_points = len(
request_data['georeference']['remove']['gcps']) * 5
response = {
'text':
'Georeference result updated. It will soon be ready for use.',
'georeferenceid': georefProcess.id,
'points': achievement_points,
'gcps': request_data['georeference']['new'],
'type': 'update'
}
return response
else:
log.error('The remove and new parameters are not valide - %s')
raise GeoreferenceParameterError(
'The remove and new parameters are not valide.')
except GeoreferenceParameterError as e:
log.error(e)
log.error(traceback.format_exc())
raise HTTPBadRequest(ERROR_MSG)
except Exception as e:
log.error(e)
log.error(traceback.format_exc())
raise HTTPInternalServerError(ERROR_MSG)
def __queryParameterAreValide__(self, isValideMtb, isValidePoints):
if isValideMtb and isValidePoints:
log.debug("MtbId: %s, Points: %s - are valide"%(self.mtbid,self.points))
return True
else:
message = "The query parameter are not valide"
log.error(message)
raise GeoreferenceParameterError(message)
def __queryParameterWithGeorefIdAreValide__(self, isValideMtb, isValideGeorefId):
if isValideMtb and isValideGeorefId:
log.debug("MtbId: %s, Georefid: %s - are valide"%(self.mtbid,self.georefid))
return True
else:
message = "The query parameter are not valide"
log.error(message)
raise GeoreferenceParameterError(message)
def getPermalinkForObjectidv2(request):
""" Contains a permalink url for the given objectid"""
try:
log.info('Receive get permalink request.')
objectid = request.GET.get('objectid')
dbsession = request.db
centroid = Map.getCentroid_byApsObjectid(objectid, dbsession, 900913)
mapid = Map.by_apsObjectId(objectid, dbsession).id
return HTTPFound(location=request.host_url + '/vkviewer/?welcomepage=off&z=5&c=%s,%s&oid=%s'%(centroid[0],centroid[1],mapid))
except DBAPIError:
log.error(traceback.format_exc())
raise HTTPBadRequest(GENERAL_ERROR_MESSAGE)
def __validateQueryParameterWithoutGeorefId__(self):
try:
isValideMtb = isValidePoints = False
isValideMtb = self.__validateMtbId__()
isValidePoints = self.__validatePoints__()
return self.__queryParameterWithoutGeorefIdAreValide__(isValideMtb, isValidePoints)
except Exception as e:
message = "Parameter for confirmation request without georef id are not valide - %s"%e.value
log.error(message)
raise GeoreferenceParameterError(message)
def __setAttribute__(self, name):
# parse the value from the request
value = self.request.params[name]
# check if the value is None
if value == None:
message = "Missing input value for query parameter %s" % name
log.error(message)
raise HTTPBadRequest(message)
# set attribute
setattr(self, name, value)
return True
def __validateQueryParameter__(self):
isValideMtb = isValidePoints = False
try:
# check if mtbid / points / userid is valide
isValideMtb = self.__validateMtbId__()
isValidePoints = self.__validatePoints__()
# now check if valMtbId and valPoints are True
self.__queryParameterAreValide__(isValideMtb, isValidePoints)
except Exception as e:
log.error(e.value)
raise
def georeference_profile_page(request):
log.info('Request - Get georeference profile page.')
dbsession = request.db
userid = checkIsUser(request)
user = Users.by_username(userid, dbsession)
try:
log.debug(
'Query georeference profile information from database for user %s'
% userid)
query_georefprocess = georeference_profile_query % userid
resultSet = dbsession.execute(query_georefprocess)
log.debug('Create response list')
georef_profile = []
for record in resultSet:
georef_profile.append({
'georef_id':
record['georef_id'],
'mtb_id':
record['mtbid'],
'clip_params':
record['clip_params'],
'time':
record['time'],
'transformed':
record['isttransformiert'],
'isvalide':
record['isvalide'],
'titel':
record['titel'],
'key':
record['key'],
'time_georef':
record['time_georef'],
'boundingbox':
record['box'][4:-1].replace(' ', ','),
'type':
record['type'],
'published':
record['published']
})
log.debug('Response: %s' % georef_profile)
return {'georef_profile': georef_profile, 'points': user.bonuspunkte}
except Exception as e:
log.error(
'Error while trying to request georeference history information')
log.error(e)
return {}
def getTimestamps_forBlattnr(request):
try:
dbsession = request.db
results = VBlattschnittMtb.allForBlattnr(request.GET.get('blattnr'), dbsession)
occurence = 0
timestamps = ''
for refGridMtb in results:
occurence += 1
timestamps += '%s,'%refGridMtb.time
return {'occurence':occurence,'timestamps':timestamps}
except DBAPIError as e:
log.error(e)
log.error(traceback.format_exc())
raise HTTPInternalServerError(GENERAL_ERROR_MESSAGE)
def getTimestamps_forBlattnr(request):
try:
dbsession = request.db
results = VBlattschnittMtb.allForBlattnr(request.GET.get('blattnr'),
dbsession)
occurence = 0
timestamps = ''
for refGridMtb in results:
occurence += 1
timestamps += '%s,' % refGridMtb.time
return {'occurence': occurence, 'timestamps': timestamps}
except DBAPIError as e:
log.error(e)
log.error(traceback.format_exc())
raise HTTPInternalServerError(GENERAL_ERROR_MESSAGE)
def resetGeorefParameters(request):
try:
log.info('Receive a reset georeference parameter requests.')
login = checkIsUser(request)
dbsession = request.db
messtischblatt_id = request.params['mtbid']
georeference_process = Georeferenzierungsprozess.by_messtischblattid(
messtischblatt_id, dbsession)
referenz = georeference_process.clipparameter
fehlerbeschreibung = 'Zuruecksetzen von Georeferenzierungsparameter für GeorefId=%s' % georeference_process.id
if login and messtischblatt_id and referenz and fehlerbeschreibung and Users.by_username(
login, dbsession):
log.debug('Save reset process in table fehlermeldungen ...')
newFehlermeldung = Fehlermeldung(
objektid=messtischblatt_id,
referenz=referenz,
nutzerid=login,
fehlerbeschreibung=fehlerbeschreibung,
timestamp=getTimestampAsPGStr())
dbsession.add(newFehlermeldung)
log.debug('Remove georeference process ...')
dbsession.delete(georeference_process)
log.debug('Remove refmtblayer ...')
try:
refmtblayer = RefMtbLayer.by_id(MTB_LAYER_ID,
messtischblatt_id, dbsession)
dbsession.delete(refmtblayer)
except:
log.debug('No entry for refmtblayer found ...')
pass
log.debug('Update messtischblatt db ...')
messtischblatt = Messtischblatt.by_id(messtischblatt_id, dbsession)
messtischblatt.isttransformiert = False
return json.dumps({'status': 'confirmed'},
ensure_ascii=False,
encoding='utf-8')
except DBAPIError:
log.error(
'Problems while trying to remove georeference parameter from the database ...'
)
return Response(conn_err_msg,
content_type='text/plain',
status_int=500)
def deleteGeorefParameters(request):
log.info('Request - Delete georeference result.')
try:
# remove georeference process
georeferenceid = request.params['georeferenceid']
georeferenceprocess = Georeferenzierungsprozess.by_id(georeferenceid, request.db)
messtischblattid = georeferenceprocess.messtischblattid
request.db.delete(georeferenceprocess)
# mark the messtischblatt as updated
messtischblatt = Messtischblatt.by_id(messtischblattid, request.db)
messtischblatt.udpated = True
return json.dumps({'message':'The georeference process has been removed.'}, ensure_ascii=False, encoding='utf-8')
except Exception as e:
log.error('Error while trying to request georeference history information');
log.error(e)
return {}
def publishGeorefParameters(request):
log.info('Request - Publish georeference result.')
try:
log.debug('Parse parameters ...')
objectid = request.params['objectid']
georeferenceid = request.params['georeferenceid']
messtischblatt = Messtischblatt.by_id(objectid, request.db)
georeferenceprocess = Georeferenzierungsprozess.by_id(georeferenceid, request.db)
log.debug('Udpate parameters')
georeferenceprocess.publish = True
messtischblatt.updated = False
return json.dumps({'message':'The georeference process is now published. The georeference map will soon be updated and than ready for accessing.'}, ensure_ascii=False, encoding='utf-8')
except Exception as e:
log.error('Error while trying to request georeference history information');
log.error(e)
return {}
def georeferenceUpdate(request):
log.info('Receive request for processing georeference update result')
try:
userid = checkIsUser(request)
request_data = None
if request.method == 'POST':
request_data = request.json_body
mapObj = parseMapObjForId(request_data, 'id', request.db)
log.debug('Id is valide: %s'%request_data)
log.debug('Check if there exists a registered georeference process for this messtischblatt ...')
if Georeferenzierungsprozess.isGeoreferenced(mapObj.id, request.db) == False:
response = {'text':'There is no registered georeference process for this messtischblatt. Please move back to the confirm process.'}
return response
# actual only support this option if target srs is EPSG:4314
log.debug('Saving georeference process in the database ...')
if request_data['georeference']:
encoded_clip_params = convertUnicodeDictToUtf(request_data['georeference'])
georefProcess = registerUpdateGeoreferenceProcessInDb(mapObj, userid, str(encoded_clip_params), request.db)
log.debug('Create response ...')
# right now the premise is that for the updated gcps are equal to the removed gcps. For every
# updated gcps the users get new points
achievement_points = len(request_data['georeference']['remove']['gcps'])*5
response = {'text':'Georeference result updated. It will soon be ready for use.','georeferenceid':georefProcess.id, 'points':achievement_points,
'gcps':request_data['georeference']['new'] ,'type':'update'}
return response
else:
log.error('The remove and new parameters are not valide - %s')
raise GeoreferenceParameterError('The remove and new parameters are not valide.')
except GeoreferenceParameterError as e:
log.error(e)
log.error(traceback.format_exc())
raise HTTPBadRequest(ERROR_MSG)
except Exception as e:
log.error(e)
log.error(traceback.format_exc())
raise HTTPInternalServerError(ERROR_MSG)
def getTimestampsForId(request):
""" Returns a json document which contains a a list of messtischblatt tuples which
have the same blattnumber like the given object. """
try:
log.info('Receive request for timestamps for a given object number.')
dbsession = request.db
object_id = request.GET.get('id')
metadataObj = Metadata.by_id(object_id, dbsession)
spatial_relation_objects = VBlattschnittMtb.allForBlattnr(metadataObj.blattnr, dbsession)
#create response
response = []
for rel_object in spatial_relation_objects:
if rel_object.isttransformiert:
response.append({'id':rel_object.mapid,'time':rel_object.time,'extent': Map.getExtent(rel_object.map, dbsession, DATABASE_SRID)})
return {'maps':response}
except DBAPIError as e:
log.error(e)
log.error(traceback.format_exc())
raise HTTPInternalServerError(GENERAL_ERROR_MESSAGE)
def deleteGeorefParameters(request):
log.info("Request - Delete georeference result.")
try:
# remove georeference process
georeferenceid = request.params["georeferenceid"]
georeferenceprocess = Georeferenzierungsprozess.by_id(georeferenceid, request.db)
messtischblattid = georeferenceprocess.messtischblattid
request.db.delete(georeferenceprocess)
# mark the messtischblatt as updated
messtischblatt = Messtischblatt.by_id(messtischblattid, request.db)
messtischblatt.udpated = True
return json.dumps(
{"message": "The georeference process has been removed."}, ensure_ascii=False, encoding="utf-8"
)
except Exception as e:
log.error("Error while trying to request georeference history information")
log.error(e)
return {}
def getProcesses(request):
try:
log.info('Request - Get georeference processes.')
if 'mapid' in request.params:
log.debug('Get processes for mapid %s ...'%request.params['mapid'])
queryData = request.db.query(Georeferenzierungsprozess, Metadata).join(Metadata, Georeferenzierungsprozess.mapid == Metadata.mapid)\
.filter(Georeferenzierungsprozess.mapid == request.params['mapid'])\
.order_by(desc(Georeferenzierungsprozess.id))
elif 'userid' in request.params:
log.debug('Get processes for userid %s ...'%request.params['userid'])
queryData = request.db.query(Georeferenzierungsprozess, Metadata).join(Metadata, Georeferenzierungsprozess.mapid == Metadata.mapid)\
.filter(Georeferenzierungsprozess.nutzerid == request.params['userid'])\
.order_by(desc(Georeferenzierungsprozess.id))
elif 'validation' in request.params:
log.debug('Get processes for adminvalidation %s ...'%request.params['validation'])
queryData = request.db.query(Georeferenzierungsprozess, Metadata).join(Metadata, Georeferenzierungsprozess.mapid == Metadata.mapid)\
.filter(Georeferenzierungsprozess.adminvalidation == request.params['validation'])\
.order_by(desc(Georeferenzierungsprozess.id))
else:
log.debug('Get all pending processes ...')
queryData = request.db.query(Georeferenzierungsprozess, Metadata).join(Metadata, Georeferenzierungsprozess.mapid == Metadata.mapid)\
.filter(or_(Georeferenzierungsprozess.adminvalidation == '', Georeferenzierungsprozess.adminvalidation == None))\
.order_by(desc(Georeferenzierungsprozess.id))
response = []
for record in queryData:
georef = record[0]
metadata = record[1]
# use encoded_georefParams for visualisation as string on the client side
encoded_georefParams = str(convertUnicodeDictToUtf(georef.georefparams)).replace('\'','"')
response.append({'georef_id':georef.id, 'mapid':georef.mapid,
'georef_params': encoded_georefParams, 'time': str(metadata.timepublish), 'processed': georef.processed,
'adminvalidation': georef.adminvalidation, 'title': metadata.title, 'apsobjectid': georef.messtischblattid,
'georef_time':str(georef.timestamp),'type':georef.type, 'userid': georef.nutzerid,
'georef_isactive':georef.isactive})
return response
except Exception as e:
log.error(e)
log.error(traceback.format_exc())
return HTTPInternalServerError(GENERAL_ERROR_MESSAGE);
def chooseGeoreferenceMap(request):
log.info('Call view getPage_chooseGeorefMtb.')
if 'blattnr' in request.params:
log.debug('Look for unreferenced messtischblaetter')
# get response from database
collection = []
metadata = Metadata.all_byBlattnr(request.GET.get('blattnr'), request.db)
for record in metadata:
map = Map.by_id(record.mapid, request.db)
if map.istaktiv and not map.isttransformiert and map.hasgeorefparams == 0:
item = {'mapid':map.id,'title':record.title}
collection.append(item)
log.debug('Create paginator for collection - %s'%collection)
page_url = PageURL_WebOb(request)
return {'paginator': Page(collection, 1, url=page_url, items_per_page=10)}
else:
log.error('Could not find a blattnr parameter value ...')
log.error(traceback.format_exc())
raise HTTPBadRequest(ERROR_MSG)
def report_error(request):
try:
log.debug('Report error is called')
dbsession = request.db
# parse parameter
login = checkIsUser(request)
objektid = request.params['id']
referenz = request.params['reference']
fehlerbeschreibung = request.params['message']
if login and objektid and referenz and fehlerbeschreibung:
# check if valide user
if Users.by_username(login, dbsession):
newFehlermeldung = Fehlermeldung(objektid = objektid, referenz = referenz, nutzerid = login,
fehlerbeschreibung = fehlerbeschreibung, timestamp = getTimestampAsPGStr())
dbsession.add(newFehlermeldung)
log.debug('Report error is registered in database')
return json.dumps({'status':'confirmed'}, ensure_ascii=False, encoding='utf-8')
except DBAPIError:
log.error('Problems while trying to register report error in database')
return Response(conn_err_msg, content_type='text/plain', status_int=500)
def georeference_profile_page(request):
log.info('Request - Get georeference profile page.')
dbsession = request.db
userid = checkIsUser(request)
user = Users.by_username(userid, dbsession)
try:
log.debug('Query georeference profile information from database for user %s'%userid)
queryData = request.db.query(Georeferenzierungsprozess, Metadata, Map).join(Metadata, Georeferenzierungsprozess.mapid == Metadata.mapid)\
.join(Map, Georeferenzierungsprozess.mapid == Map.id)\
.filter(Georeferenzierungsprozess.nutzerid == userid)\
.order_by(desc(Georeferenzierungsprozess.id))
log.debug('Create response list')
georef_profile = []
for record in queryData:
georef = record[0]
metadata = record[1]
mapObj = record[2]
boundingbox = Map.getBox2d(georef.mapid, dbsession, 900913)
georef_profile.append({'georef_id':georef.id, 'mapid':georef.mapid,
'clip_params': georef.georefparams, 'time': metadata.timepublish, 'transformed': georef.processed,
'isvalide': georef.adminvalidation, 'titel': metadata.title, 'key': mapObj.apsdateiname,
'time_georef':georef.timestamp,'boundingbox':boundingbox[4:-1].replace(' ',','),'type':georef.type,
'published':georef.processed})
log.debug('Response: %s'%georef_profile)
return {'georef_profile':georef_profile, 'points':user.bonuspunkte}
except Exception as e:
log.error('Error while trying to request georeference history information');
log.error(e)
log.error(traceback.format_exc())
raise HTTPInternalServerError(GENERAL_ERROR_MESSAGE)
def georeferenceConfirm(request):
log.info('Receive request for processing georeference validation result')
try:
userid = checkIsUser(request)
request_data = None
if request.method == 'POST':
request_data = request.json_body
mapObj = parseMapObjForId(request_data, 'id', request.db)
log.debug('Id is valide: %s'%request_data)
log.debug('Check if there is already a registered georeference process for this messtischblatt ...')
if Georeferenzierungsprozess.isGeoreferenced(mapObj.id, request.db):
msg = 'There is already a georeference process for this process. Please load again and start on the latest changes.'
log.debug(msg)
georeferenceid = Georeferenzierungsprozess.getActualGeoreferenceProcessForMapId(mapObj.id, request.db).id
response = {'text':msg,'georeferenceid':georeferenceid}
return response
# actual only support this option if target srs is EPSG:4314
log.debug('Start saving georeference process in the database ...')
epsg_code = int(str(request_data['georeference']['target']).split(':')[1])
if request_data['georeference']['source'] == 'pixel' and epsg_code == 4314:
log.debug('Create georeference process record ...')
timestamp = getTimestampAsPGStr()
georeference_parameter = str(convertUnicodeDictToUtf(request_data['georeference']))
georefProcess = Georeferenzierungsprozess(messtischblattid = mapObj.apsobjectid, nutzerid = userid,
georefparams = ast.literal_eval(georeference_parameter), clipparameter = georeference_parameter, timestamp = timestamp, isactive = True, type = 'new',
adminvalidation = '', processed = False, mapid = mapObj.id, overwrites = 0)
request.db.add(georefProcess)
request.db.flush()
log.debug('Create response ...')
response = {'text':'Georeference result saved. It will soon be ready for use.','georeferenceid':georefProcess.id, 'points':20,
'gcps':request_data['georeference'] ,'type':'confirm'}
return response
else:
raise GeoreferenceParameterError('Wrong or missing service parameter')
except GeoreferenceParameterError as e:
log.error(e)
log.error(traceback.format_exc())
raise HTTPBadRequest(ERROR_MSG)
except Exception as e:
log.error(e)
log.error(traceback.format_exc())
raise HTTPInternalServerError(ERROR_MSG)
def georeferenceValidation(request):
log.info('Receive request for processing georeference validation result')
try:
request_data = None
if request.method == 'POST':
request_data = request.json_body
if request_data:
validateId(request_data['id'])
log.debug('Request data is valide: %s'%request_data)
log.debug('Start creating validation result ...')
messtischblatt = Messtischblatt.by_id(request_data['id'], request.db)
# actual only support this option if target srs is EPSG:4314
epsg_code = int(str(request_data['georeference']['target']).split(':')[1])
if request_data['georeference']['source'] == 'pixel' and epsg_code == 4314:
log.debug('Parse gcps ...')
gcps = parseGcps(request_data['georeference']['gcps'])
log.debug('Process georeference parameter ...')
destPath = georeference(messtischblatt.original_path, os.path.join(GEOREFERENCE_MAPFILE_FOLDER,messtischblatt.dateiname+"::"+str(getUniqueId())+".vrt"),
GEOREFERENCE_TMP_DIR, gcps, epsg_code, epsg_code, 'polynom', log)
log.debug('Create temporary mapfile ...')
wms_url = createMapfile(messtischblatt.dateiname, destPath, GEOREFERENCE_MAPFILE_TEMPLATE, GEOREFERENCE_MAPFILE_FOLDER, GEOREFERENCE_MAPFILE_DEFAULT_PARAMS)
log.debug('Create response ...')
response = {'wms_url':wms_url,'layer_id':messtischblatt.dateiname,'extent':Messtischblatt.getExtent(messtischblatt.id, request.db)}
return json.dumps(response, ensure_ascii=False, encoding='utf-8')
else:
raise GeoreferenceParameterError('Wrong or missing service parameter')
except GeoreferenceParameterError as e:
message = 'Wrong or missing service parameter - %s'%e.value
log.error(message)
return HTTPBadRequest(message)
except Exception as e:
message = 'Problems while computing validation result - %s'%e.value
log.error(message)
return HTTPInternalServerError(message)
def __call__(self):
log.info("Start processing georeference confirmation request.")
try:
# parse query parameter and check if they are valide
self.__parseQueryParameter__()
self.__parseUserId__()
# initialize georef process
dbsession = self.request.db
georeferenceProcess = createGeoreferenceProcess(self.mtbid, dbsession, tmp_dir, log)
if hasattr(self, 'georefid'):
self.__validateQueryParameterWithGeorefId__()
return self.__confirmExistingGeorefProcess__(self.georefid, georeferenceProcess)
elif not hasattr(self, 'georefid'):
self.__validateQueryParameterWithoutGeorefId__()
return self.__registerNewConfirmedGeorefProcess__(georeferenceProcess)
else:
# error handling
log.error("Error while processing georeference confirmation request!")
raise
except GeoreferenceParameterError as e:
log.error('Wrong or missing service parameter - %s'%e)
return HTTPBadRequest('Wrong or missing service parameter')
except Exception as e:
log.error('Problems while computing validation result - %s'%e)
return HTTPInternalServerError('Problems while computing validation result')
def setProcessToIsValide(request):
log.info('Request - Set admin evaluation of georeference process to isvalide ....')
try:
# remove georeference process
if 'georeferenceid' in request.params:
georeferenceid = request.params['georeferenceid']
userid = checkIsUser(request)
comment = '' if 'comment' not in request.params else request.params['comment']
# check if georeference id exist
georeferenceprocess = Georeferenzierungsprozess.by_id(georeferenceid, request.db)
if georeferenceprocess:
newJob = createNewAdminJob(georeferenceprocess, 'isvalide', userid, comment)
request.db.add(newJob)
return {'message':'The georeference process has been set to isvalide.'}
else:
raise Exception('Missing parameter (georeferenceid) ...')
except Exception as e:
log.error(e)
log.error(traceback.format_exc())
return HTTPBadRequest(GENERAL_ERROR_MESSAGE);
def getAdminEvaluationPage(request):
log.info('Request - Get georeference profile page.')
try:
resultSet = request.db.execute(georeference_evaluation_query)
log.debug('Create response list')
georef_profile = []
for record in resultSet:
encoded_clip_params = str(convertUnicodeDictToUtf(ast.literal_eval(record['clip_params']))).replace('\'','"')
georef_profile.append({'georef_id':record['georef_id'], 'mtb_id':record['mtbid'],
'clip_params': encoded_clip_params, 'time': record['time'], 'transformed': record['isttransformiert'],
'isvalide': record['isvalide'], 'titel': record['titel'], 'key': record['key'],
'time_georef':record['time_georef'],'type':record['type'], 'userid': record['userid'],
'published':record['published']})
log.debug('Response: %s'%georef_profile)
return {'georef_profile':georef_profile}
except Exception as e:
log.error('Error while trying to request georeference history information');
log.error(e)
return {}
def getPage_profileMtb(request):
try:
messtischblatt_id = None
if 'id' in request.params:
messtischblatt_id = request.params['id']
log.info('Receive get profile mtb page for id %s.'%messtischblatt_id)
messtischblatt = Messtischblatt.by_id(messtischblatt_id, request.db)
user_id = authenticated_userid(request)
if user_id:
groups = groupfinder(user_id, request)
if groups and 'g:moderator' in groups or 'g:admin' in groups:
return {'with_modify':True, 'zoomify_prop':messtischblatt.zoomify_properties,
'zoomify_width':messtischblatt.zoomify_width,'zoomify_height':messtischblatt.zoomify_height,
'key':messtischblatt.dateiname}
return {'zoomify_prop':messtischblatt.zoomify_properties,'zoomify_width':messtischblatt.zoomify_width,
'zoomify_height':messtischblatt.zoomify_height,'key':messtischblatt.dateiname}
except:
log.error('Internal server error while trying to get profile page. Please try again or contact the page administrator.')
raise InternalAuthentificationError('Internal server error while trying to get profile page. Please try again or contact the page administrator.')
def getUploadProfilePage(request):
log.debug('Request - Get Upload profile page.')
dbsession = request.db
username = checkIsUser(request)
user = Users.by_username(username, dbsession)
userid = user.id
try:
log.debug(
'Query Upload profile information from database for user %s' %
userid)
query_uploadprofile = upload_profile_query % userid
resultSet = dbsession.execute(query_uploadprofile)
log.debug('Create response list')
upload_profile = []
for record in resultSet:
upload_profile.append({
'upload_id': record['upload_id'],
'upload_mapid': record['upload_mapid'],
'time': record['time'],
'licence': record['licence'],
'title': record['title'],
'upload_time': record['upload_time'],
'imagepath': record['imagepath'],
'thumbnail': record['thumbnail']
})
log.debug('Response: %s' % upload_profile)
return {'upload_profile': upload_profile}
except Exception as e:
log.error('Error while trying to request upload history information')
log.error(e)
return {}
return {}
def logContactRequest(request):
try:
log.info('Receive a contact message request.')
# check if there is a userid from a registered user
userid = checkIsUser(request)
if not userid:
userid = 'anonym'
if 'reference' in request.params:
reference = request.params['reference']
if 'message' in request.params:
message = request.params['message']
if 'email' in request.params:
email = request.params['email']
# check if the input parameters are valide
log.debug('Validate the query parameters ...')
if not email or not reference or not message:
raise MissingQueryParameterError('Missing query parameter ...')
if len(message) <= 5:
raise WrongParameterException('Message is to short. For a correct understanding of your matter please leave us a short explanation.')
# log into database
log.debug('Save contact message in the database ...')
fehlermeldung = Fehlermeldung(email = email, referenz = reference, nutzerid = userid,
fehlerbeschreibung = message, timestamp = getTimestampAsPGStr())
request.db.add(fehlermeldung)
# sending an email
log.debug('Instruct admin about new contact message ...');
reportErrorMessageToAdmin(fehlermeldung, 'Request - Contact form', userid)
log.debug('Create response message ...')
return json.dumps({'status':'confirmed'}, ensure_ascii=False, encoding='utf-8')
except MissingQueryParameterError:
log.error('Could not create correct error report because of missing query parameters.')
return Response(json.dumps({'error_message':'Missing form parameters','error_name':'MissingParameterException'}), content_type='application/json', status_int=500)
except WrongParameterException as e:
log.error(e.msg)
return Response(json.dumps({'error_message':e.msg,'error_name':'WrongParameterException'}), content_type='application/json', status_int=500)
except DBAPIError:
log.error('Problems while trying to register report error in database')
return Response(GENERAL_ERROR_MESSAGE, content_type='text/plain', status_int=500)
except Exception:
log.error('Unknown error while trying to process a contact message request ...')
return Response(GENERAL_ERROR_MESSAGE, content_type='text/plain', status_int=500)
def getPage_profileMtb(request):
try:
messtischblatt_id = None
if 'objectid' in request.params:
messtischblatt_id = request.params['objectid']
log.info('Receive get map profile page for id %s.' %
messtischblatt_id)
georef = False
if 'georef' in request.params and request.params['georef'].lower(
) == 'true':
georef = True
if georef:
permalink = createPermalink(request, messtischblatt_id)
return HTTPFound(location=permalink)
messtischblatt = Messtischblatt.by_id(messtischblatt_id, request.db)
metadata = MdCore.by_id(messtischblatt.id, request.db)
metadata_datensatz = MdDatensatz.by_ObjectId(messtischblatt.id,
request.db)
return {
'zoomify_prop': messtischblatt.zoomify_properties,
'zoomify_width': messtischblatt.zoomify_width,
'zoomify_height': messtischblatt.zoomify_height,
'key': 'vk20-md-%s' % messtischblatt.id,
'titel_long': metadata.titel,
'titel_short': metadata.titel_short,
'permalink': metadata_datensatz.permalink
}
except:
log.error(
'Internal server error while trying to get profile page. Please try again or contact the page administrator.'
)
raise InternalAuthentificationError(
'Internal server error while trying to get profile page. Please try again or contact the page administrator.'
)
def georeference_profile_page(request):
log.info('Request - Get georeference profile page.')
dbsession = request.db
userid = checkIsUser(request)
user = Users.by_username(userid, dbsession)
try:
log.debug(
'Query georeference profile information from database for user %s'
% userid)
queryData = request.db.query(Georeferenzierungsprozess, Metadata, Map).join(Metadata, Georeferenzierungsprozess.mapid == Metadata.mapid)\
.join(Map, Georeferenzierungsprozess.mapid == Map.id)\
.filter(Georeferenzierungsprozess.nutzerid == userid)\
.order_by(desc(Georeferenzierungsprozess.id))
log.debug('Create response list')
georef_profile = []
for record in queryData:
georef = record[0]
metadata = record[1]
mapObj = record[2]
boundingbox = Map.getBox2d(georef.mapid, dbsession, 900913)
georef_profile.append({
'georef_id':
georef.id,
'mapid':
georef.mapid,
'clip_params':
georef.georefparams,
'time':
metadata.timepublish,
'transformed':
georef.processed,
'isvalide':
georef.adminvalidation,
'titel':
metadata.title,
'key':
mapObj.apsdateiname,
'time_georef':
georef.timestamp,
'boundingbox':
boundingbox[4:-1].replace(' ', ','),
'type':
georef.type,
'published':
georef.processed
})
log.debug('Response: %s' % georef_profile)
return {'georef_profile': georef_profile, 'points': user.bonuspunkte}
except Exception as e:
log.error(
'Error while trying to request georeference history information')
log.error(e)
log.error(traceback.format_exc())
raise HTTPInternalServerError(GENERAL_ERROR_MESSAGE)
def chooseGeoreferenceMap(request):
log.info('Call view getPage_chooseGeorefMtb.')
if 'blattnr' in request.params:
log.debug('Look for unreferenced messtischblaetter')
# get response from database
collection = []
metadata = Metadata.all_byBlattnr(request.GET.get('blattnr'),
request.db)
for record in metadata:
map = Map.by_id(record.mapid, request.db)
if map.istaktiv and not map.isttransformiert and map.hasgeorefparams == 0:
item = {'mapid': map.id, 'title': record.title}
collection.append(item)
log.debug('Create paginator for collection - %s' % collection)
page_url = PageURL_WebOb(request)
return {
'paginator': Page(collection, 1, url=page_url, items_per_page=10)
}
else:
log.error('Could not find a blattnr parameter value ...')
log.error(traceback.format_exc())
raise HTTPBadRequest(ERROR_MSG)
def georeferenceUpdate(request):
log.info('Receive request for processing georeference update result')
try:
userid = checkIsUser(request)
request_data = None
if request.method == 'POST':
request_data = request.json_body
if request_data:
validateId(request_data['id'])
log.debug('Request data is valide: %s'%request_data)
log.debug('Check if there exists a registered georeference process for this messtischblatt ...')
messtischblatt = Messtischblatt.by_id(request_data['id'], request.db)
isAlreadyGeorefProcess = Georeferenzierungsprozess.by_messtischblattid(messtischblatt.id, request.db)
if isAlreadyGeorefProcess is None:
response = {'text':'There is no registered georeference process for this messtischblatt. Please move back to the confirm process.'}
return json.dumps(response, ensure_ascii=False, encoding='utf-8')
# actual only support this option if target srs is EPSG:4314
log.debug('Saving georeference process in the database ...')
if request_data['georeference']:
encoded_clip_params = convertUnicodeDictToUtf(request_data['georeference'])
georefProcess = registerNewGeoreferenceProcessInDb(messtischblatt.id, userid, str(encoded_clip_params), 'update', request.db)
log.debug('Set update status for messtischblatt ...')
messtischblatt.setIsUpdated(True)
log.debug('Create response ...')
# right now the premise is that for the updated gcps are equal to the removed gcps. For every
# updated gcps the users get new points
achievement_points = len(request_data['georeference']['remove']['gcps'])*5
#gcps = getJsonDictPasspointsForMapObject(messtischblatt.id, request.db)
response = {'text':'Georeference result updated. It will soon be ready for use.','georeferenceid':georefProcess.id, 'points':achievement_points,
'gcps':request_data['georeference']['new'] ,'type':'update'}
return json.dumps(response, ensure_ascii=False, encoding='utf-8')
else:
log.error('The remove and new parameters are not valide - %s')
raise GeoreferenceParameterError('The remove and new parameters are not valide.')
except GeoreferenceParameterError as e:
message = 'Wrong or missing service parameter - %s'%e.value
log.error(message)
return HTTPBadRequest(message)
except Exception as e:
message = 'Problems while computing validation result - %s'%e
log.error(message)
return HTTPInternalServerError(message)
def georeferenceValidation(request):
log.info('Receive request for processing georeference validation result')
try:
request_data = None
if request.method == 'POST':
request_data = request.json_body
mapObj = parseMapObjForId(request_data, 'id', request.db)
log.debug('Id is valide: %s'%request_data)
log.debug('Start creating validation result ...')
# actual only support this option if target srs is EPSG:4314
epsg_code = int(str(request_data['georeference']['target']).split(':')[1])
if request_data['georeference']['source'] == 'pixel' and epsg_code == 4314:
log.debug('Parse gcps ...')
gcps = parseGcps(request_data['georeference']['gcps'])
log.debug('Process georeference parameter ...')
destPath = georeference(mapObj.originalimage, os.path.join(GEOREFERENCE_MAPFILE_FOLDER,mapObj.apsdateiname+"::"+str(getUniqueId())+".vrt"),
GEOREFERENCE_TMP_DIR, gcps, epsg_code, epsg_code, 'polynom', log)
log.debug('Create temporary mapfile ...')
wms_url = createMapfile(mapObj.apsdateiname, destPath, GEOREFERENCE_MAPFILE_TEMPLATE, GEOREFERENCE_MAPFILE_FOLDER, GEOREFERENCE_MAPFILE_DEFAULT_PARAMS)
log.debug('Create response ...')
response = {'wms_url':wms_url,'layer_id':mapObj.apsdateiname,'extent':Map.getExtent(mapObj.id, request.db)}
return response
else:
raise GeoreferenceParameterError('Wrong or missing service parameter')
except GeoreferenceParameterError as e:
log.error(e)
log.error(traceback.format_exc())
raise HTTPBadRequest(ERROR_MSG)
except Exception as e:
log.error(e)
log.error(traceback.format_exc())
raise HTTPInternalServerError(ERROR_MSG)
def getPermalinkForObjectid(request):
""" Contains a permalink url for the given objectid"""
try:
log.debug('Receive get permalink request.')
objectid = request.GET.get('objectid')
# right now we need a bridge hear for moving from old number schema to new one
parsed_id = parseOAI(objectid)
# create the permalink
permalink = createPermalink(request, parsed_id)
return {'url': permalink}
except ParsingException as e:
log.debug(e)
return HTTPBadRequest(GENERAL_ERROR_MESSAGE)
except NotFoundException as e:
log.error(e)
log.error(traceback.format_exc())
raise HTTPNotFound(GENERAL_ERROR_MESSAGE)
except Exception as e:
log.error(e)
log.error(traceback.format_exc())
raise HTTPBadRequest(GENERAL_ERROR_MESSAGE)
def getWelcomePage(request):
log.info('Call view get_welcome_page.')
try:
dbsession = request.db
# get occurrence of georeferenced messtischblaetter
occurrenceGeorefMtbs = Map.getCountIsGeoref(dbsession)
possibleMtbs = Map.getCountIsActive(dbsession)
georefRelation = int(
(float(occurrenceGeorefMtbs) / float(possibleMtbs)) * 100)
# get paginator for user ranking list
paginator = Users.get_paginator(request, dbsession)
return {
'paginator': paginator,
'occurrence_mtbs': occurrenceGeorefMtbs,
'possible_mtbs': possibleMtbs,
'georef_rel': georefRelation
}
except Exception:
log.error(
'Error while creating paginator for user georeference ranking')
log.error(Exception)
log.error(traceback.format_exc())
raise HTTPInternalServerError(GENERAL_ERROR_MESSAGE)
def georeferenceUpdate(request):
log.info('Receive request for processing georeference update result')
try:
userid = checkIsUser(request)
request_data = None
if request.method == 'POST':
request_data = request.json_body
if request_data:
validateId(request_data['id'])
log.debug('Request data is valide: %s' % request_data)
log.debug(
'Check if there exists a registered georeference process for this messtischblatt ...'
)
messtischblatt = Messtischblatt.by_id(request_data['id'], request.db)
isAlreadyGeorefProcess = Georeferenzierungsprozess.by_messtischblattid(
messtischblatt.id, request.db)
if isAlreadyGeorefProcess is None:
response = {
'text':
'There is no registered georeference process for this messtischblatt. Please move back to the confirm process.'
}
return json.dumps(response, ensure_ascii=False, encoding='utf-8')
# actual only support this option if target srs is EPSG:4314
log.debug('Saving georeference process in the database ...')
if request_data['georeference']:
encoded_clip_params = convertUnicodeDictToUtf(
request_data['georeference'])
georefProcess = registerNewGeoreferenceProcessInDb(
messtischblatt.id, userid, str(encoded_clip_params), 'update',
request.db)
log.debug('Set update status for messtischblatt ...')
messtischblatt.setIsUpdated(True)
log.debug('Create response ...')
# right now the premise is that for the updated gcps are equal to the removed gcps. For every
# updated gcps the users get new points
achievement_points = len(
request_data['georeference']['remove']['gcps']) * 5
#gcps = getJsonDictPasspointsForMapObject(messtischblatt.id, request.db)
response = {
'text':
'Georeference result updated. It will soon be ready for use.',
'georeferenceid': georefProcess.id,
'points': achievement_points,
'gcps': request_data['georeference']['new'],
'type': 'update'
}
return json.dumps(response, ensure_ascii=False, encoding='utf-8')
else:
log.error('The remove and new parameters are not valide - %s')
raise GeoreferenceParameterError(
'The remove and new parameters are not valide.')
except GeoreferenceParameterError as e:
message = 'Wrong or missing service parameter - %s' % e.value
log.error(message)
return HTTPBadRequest(message)
except Exception as e:
message = 'Problems while computing validation result - %s' % e
log.error(message)
return HTTPInternalServerError(message)
def georeferenceConfirm(request):
log.info('Receive request for processing georeference validation result')
try:
userid = checkIsUser(request)
user = Users.by_username(userid, request.db)
request_data = None
if request.method == 'POST':
request_data = request.json_body
if request_data:
validateId(request_data['id'])
log.debug('Request data is valide: %s' % request_data)
log.debug(
'Check if there is already a registered georeference process for this messtischblatt ...'
)
messtischblatt = Messtischblatt.by_id(request_data['id'], request.db)
isAlreadyGeorefProcess = Georeferenzierungsprozess.by_messtischblattid(
messtischblatt.id, request.db)
if isAlreadyGeorefProcess is not None:
response = {
'text':
'There is already a registered georeference process for this messtischblatt. Please move forward to the update process.',
'georeferenceid': isAlreadyGeorefProcess.id
}
return json.dumps(response, ensure_ascii=False, encoding='utf-8')
# actual only support this option if target srs is EPSG:4314
log.debug('Start saving georeference process in the database ...')
epsg_code = int(
str(request_data['georeference']['target']).split(':')[1])
if request_data['georeference'][
'source'] == 'pixel' and epsg_code == 4314:
log.debug('Create georeference process record ...')
timestamp = getTimestampAsPGStr()
georeference_parameter = str(
convertUnicodeDictToUtf(request_data['georeference']))
georefProcess = Georeferenzierungsprozess(
messtischblattid=messtischblatt.id,
nutzerid=userid,
clipparameter=georeference_parameter,
timestamp=timestamp,
isvalide=True,
type='new',
refzoomify=True,
publish=False,
processed=False)
request.db.add(georefProcess)
request.db.flush()
log.debug('Creating passpoints ...')
# gcps = request_data['georeference']['gcps']
# passpoints = []
# for i in range(0,len(gcps)):
# unrefPoint = [gcps[i]['source'][0],gcps[i]['source'][1]]
# refPoint = 'POINT(%s %s)'%(gcps[i]['target'][0], gcps[i]['target'][1])
# passpoint = Passpoint(objectid = messtischblatt.id, userid = user.id, unrefpoint = unrefPoint,
# refpoint = refPoint, deprecated = False, timestamp = timestamp, georeferenceprocessid = georefProcess.id)
# request.db.add(passpoint)
# passpoints.append(passpoints)
log.debug('Create response ...')
##gcps = getJsonDictPasspointsForMapObject(messtischblatt.id, request.db)
response = {
'text':
'Georeference result saved. It will soon be ready for use.',
'georeferenceid': georefProcess.id,
'points': 20,
'gcps': request_data['georeference'],
'type': 'confirm'
}
return json.dumps(response, ensure_ascii=False, encoding='utf-8')
else:
raise GeoreferenceParameterError(
'Wrong or missing service parameter')
except GeoreferenceParameterError as e:
message = 'Wrong or missing service parameter - %s' % e.value
log.error(message)
return HTTPBadRequest(message)
except Exception as e:
message = 'Problems while computing validation result - %s' % e
log.error(message)
return HTTPInternalServerError(message)
def georeferenceGetProcess(request):
log.info('Receive request GetGeoreferenceProcess')
try:
request_data = None
if request.method == 'POST':
request_data = request.json_body
if 'georeferenceid' in request_data:
georeferenceid = int(request_data['georeferenceid'])
log.debug('Parsed parameters - georeferenceid: %s' %
georeferenceid)
mapObj = Map.by_id(
int(
Georeferenzierungsprozess.by_id(georeferenceid,
request.db).mapid),
request.db)
response = createResponseForSpecificGeoreferenceProcess(
mapObj, request, georeferenceid)
elif 'objectid' in request_data:
mapObjId = request_data['objectid']
log.debug('Parsed parameters - mapid: %s' % mapObjId)
mapObj = Map.by_id(int(mapObjId), request.db)
response = createGeneralResponse(mapObj, request)
else:
log.error(
'Could not find a georeferenceid or and objectid in the post request parameters ...'
)
raise GeoreferenceParameterError
return response
except GeoreferenceParameterError as e:
log.error(e)
log.error(traceback.format_exc())
raise HTTPBadRequest(ERROR_MSG)
except ProcessIsInvalideException as e:
log.error(e)
log.error(traceback.format_exc())
raise HTTPBadRequest(
'This georeference process is blocked for further work!')
except Exception as e:
log.error(e)
log.error(traceback.format_exc())
raise HTTPInternalServerError(ERROR_MSG)
def georeferenceConfirm(request):
log.info('Receive request for processing georeference validation result')
try:
userid = checkIsUser(request)
request_data = None
if request.method == 'POST':
request_data = request.json_body
mapObj = parseMapObjForId(request_data, 'id', request.db)
log.debug('Id is valide: %s' % request_data)
log.debug(
'Check if there is already a registered georeference process for this messtischblatt ...'
)
if Georeferenzierungsprozess.isGeoreferenced(mapObj.id, request.db):
msg = 'There is already a georeference process for this process. Please load again and start on the latest changes.'
log.debug(msg)
georeferenceid = Georeferenzierungsprozess.getActualGeoreferenceProcessForMapId(
mapObj.id, request.db).id
response = {'text': msg, 'georeferenceid': georeferenceid}
return response
# actual only support this option if target srs is EPSG:4314
log.debug('Start saving georeference process in the database ...')
epsg_code = int(
str(request_data['georeference']['target']).split(':')[1])
if request_data['georeference'][
'source'] == 'pixel' and epsg_code == 4314:
log.debug('Create georeference process record ...')
timestamp = getTimestampAsPGStr()
georeference_parameter = str(
convertUnicodeDictToUtf(request_data['georeference']))
georefProcess = Georeferenzierungsprozess(
messtischblattid=mapObj.apsobjectid,
nutzerid=userid,
georefparams=ast.literal_eval(georeference_parameter),
clipparameter=georeference_parameter,
timestamp=timestamp,
isactive=True,
type='new',
adminvalidation='',
processed=False,
mapid=mapObj.id,
overwrites=0)
request.db.add(georefProcess)
request.db.flush()
log.debug('Create response ...')
response = {
'text':
'Georeference result saved. It will soon be ready for use.',
'georeferenceid': georefProcess.id,
'points': 20,
'gcps': request_data['georeference'],
'type': 'confirm'
}
return response
else:
raise GeoreferenceParameterError(
'Wrong or missing service parameter')
except GeoreferenceParameterError as e:
log.error(e)
log.error(traceback.format_exc())
raise HTTPBadRequest(ERROR_MSG)
except Exception as e:
log.error(e)
log.error(traceback.format_exc())
raise HTTPInternalServerError(ERROR_MSG)
def store_image(request):
try:
log.debug('Receive a upload request.')
username = checkIsUser(request)
user = Users.by_username(username, request.db)
# check if need metadata is send
log.debug('Check if mandatory metadata is send ...')
params = request.params
if not 'title' in params or not 'titleshort' in params or \
not 'imagelicence' in params or not 'imageowner' in params:
raise MissingQueryParameterError('Missing query parameter ...')
# register upload process in database
log.debug('Register upload process to database ...')
uploadObj = Uploads(userid=user.id,
time=getTimestampAsPGStr(),
params='%s' % request.params)
request.db.add(uploadObj)
log.debug('Create and add mapObj ...')
mapObj = Map(istaktiv=False,
isttransformiert=False,
maptype='A',
hasgeorefparams=0)
request.db.add(mapObj)
request.db.flush()
# check if image allowed extensions
# ``filename`` contains the name of the file in string format.
log.debug('Create filename for persistent saving ...')
filename = request.POST['file'].filename
if not allowed_file(filename):
raise WrongParameterException(
'Format of the image is not supported through the upload API.')
# ``input_file`` contains the actual file data which needs to be
# stored somewhere.
inputFile = request.POST['file'].file
# Note that we are generating our own filename instead of trusting
# the incoming filename since that might result in insecure paths.
# Please note that in a real application you would not use /tmp,
# and if you write to an untrusted location you will need to do
# some extra work to prevent symlink attacks.
newFilename = '%s.%s' % ('df_dk_%s' % mapObj.id, filename.rsplit(
'.', 1)[1])
filePath = os.path.join(UPLOAD_DIR, newFilename)
# save file to disk
log.debug('Save file to datastore ...')
saveFile(inputFile, filePath)
# process thumbnails
log.debug('Create thumbnails ...')
thumbSmall = createSmallThumbnail(filePath, UPLOAD_THUMBS_SMALL_DIR)
thumbMid = createMidThumbnail(filePath, UPLOAD_THUMBS_MID_DIR)
log.debug('Create zoomify tiles')
zoomifyTiles = processZoomifyTiles(filePath, UPLOAD_ZOOMIFY_DIR, log)
# parse boundinbBox
pgBoundingBoxStr = parseBoundingBoxFromRequest(request.params)
# add geometry to map object and update other attributes
# work around --> should be replaced through adding the geomtry on initial adding
log.debug('Update mapObj and create metadataObj ...')
mapObj.apsdateiname = newFilename
mapObj.originalimage = filePath
Map.updateGeometry(mapObj.id, pgBoundingBoxStr, request.db)
request.db.flush()
# parse and create metadataObj
if 'title' in request.params:
title = request.params['title']
if 'titleshort' in request.params:
titleshort = request.params['titleshort']
if 'serientitle' in request.params:
serientitle = request.params['serientitle']
if 'description' in request.params:
description = request.params['description']
if 'timepublish' in request.params:
timepublish = request.params['timepublish']
if 'imagelicence' in request.params:
imagelicence = request.params['imagelicence']
if 'scale' in request.params:
scale = request.params['scale']
if 'imageowner' in request.params:
imageowner = request.params['imageowner']
# create metadata obj
# the creating of the paths are right now quite verbose
imagezoomify = UPLOAD_SERVICE_URL_ZOOMIFY + os.path.basename(
filePath).split('.')[0] + '/ImageProperties.xml'
thumbssmall = UPLOAD_SERVICE_URL_THUMBS_SMALL + os.path.basename(
thumbSmall)
thumbsmid = UPLOAD_SERVICE_URL_THUMBS_MID + os.path.basename(thumbMid)
metadataObj = Metadata(mapid=mapObj.id,
title=title,
titleshort=titleshort,
serientitle=serientitle,
description=description,
timepublish="%s-01-01 00:00:00" % (timepublish),
imagelicence=imagelicence,
imageowner=imageowner,
scale=scale,
imagezoomify=imagezoomify,
thumbssmall=thumbssmall,
thumbsmid=thumbsmid)
request.db.add(metadataObj)
# update uploadObj and create response
uploadObj.mapid = mapObj.id
log.debug('Create response ...')
target_url = request.route_url('upload-profile')
return HTTPFound(location=target_url)
# Exception handling
except NotFoundException as e:
log.exception(e)
ERR_MSG = GENERAL_ERROR_MESSAGE + "We're sorry, but something went wrong. Please be sure that your file respects the upload conditions."
return HTTPBadRequest(ERR_MSG)
except DBAPIError as e:
log.error('Database error within a upload process')
log.exception(e)
return HTTPInternalServerError(GENERAL_ERROR_MESSAGE)
except MissingQueryParameterError or WrongParameterException as e:
log.exception(e)
raise HTTPBadRequest(GENERAL_ERROR_MESSAGE)
except Exception as e:
log.exception(e)
raise HTTPInternalServerError(GENERAL_ERROR_MESSAGE)
