Пример #1
0
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 {}
Пример #2
0
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)
Пример #3
0
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.')
Пример #4
0
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 {}
Пример #5
0
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)
Пример #6
0
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 {}
Пример #7
0
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 {}
Пример #8
0
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.'
        )
Пример #9
0
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)
Пример #10
0
 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)
Пример #11
0
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."
        )
Пример #12
0
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)
Пример #13
0
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)
Пример #14
0
 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) 
Пример #15
0
 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)     
Пример #16
0
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)
Пример #17
0
 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)
Пример #18
0
    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
Пример #19
0
 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     
Пример #20
0
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 {}
Пример #21
0
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)
Пример #22
0
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)
Пример #23
0
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)
Пример #24
0
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 {}
Пример #25
0
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 {}
Пример #26
0
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)
Пример #27
0
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)
Пример #28
0
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 {}
Пример #29
0
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);
Пример #30
0
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) 
Пример #31
0
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)
Пример #32
0
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)
Пример #33
0
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)
Пример #34
0
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)
Пример #35
0
 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')
Пример #36
0
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);
Пример #37
0
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 {}
Пример #38
0
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.')
Пример #39
0
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 {}
Пример #40
0
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)
Пример #41
0
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.'
        )
Пример #42
0
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)
Пример #43
0
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)
Пример #44
0
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)
Пример #45
0
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)
Пример #46
0
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)
Пример #47
0
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)
Пример #48
0
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)
Пример #49
0
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)
Пример #50
0
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)
Пример #51
0
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)
Пример #52
0
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)