def validate_form(self, form):
"""
validation personnalisée du form
"""
# Essai de récupérer en BD la vue sql déclarée
# Delete n'a pas d'attribut view_name
view_name = getattr(form, 'view_name', '')
schema_name = getattr(form, 'schema_name', '')
geometry_field = getattr(form, 'geometry_field', None)
geometry_srid = getattr(form, 'geometry_srid', None)
if (is_form_submitted() and view_name and schema_name):
try:
query = GenericQuery(DB.session,
view_name.data,
schema_name.data,
geometry_field=geometry_field.data,
filters=[])
query.return_query()
if geometry_field.data and geometry_srid.data is None:
raise KeyError(
"field Geometry srid is mandatory with Geometry field")
except Exception as exp:
flash(exp, category='error')
return False
return super(ExportView, self).validate_form(form)
def etalab_export():
"""
TODO : METHODE NON FONCTIONNELLE A EVALUEE
"""
if not blueprint.config.get('etalab_export'):
return to_json_resp(
{
'api_error': 'etalab_disabled',
'message': 'Etalab export is disabled'
},
status=501)
from datetime import time
from geonature.utils.env import DB
from .rdf import OccurrenceStore
conf = current_app.config.get('EXPORTS')
export_etalab = conf.get('etalab_export')
seeded = False
if os.path.isfile(export_etalab):
seeded = True
midnight = datetime.combine(datetime.today(), time.min)
mtime = datetime.fromtimestamp(os.path.getmtime(export_etalab))
ts_delta = mtime - midnight
if not seeded or ts_delta.total_seconds() < 0:
store = OccurrenceStore()
query = GenericQuery(DB.session,
'export_occtax_sinp',
'pr_occtax',
geometry_field=None,
filters=[])
data = query.return_query()
for record in data.get('items'):
event = store.build_event(record)
obs = store.build_human_observation(event, record)
store.build_location(obs, record)
occurrence = store.build_occurrence(event, record)
organism = store.build_organism(occurrence, record)
identification = store.build_identification(organism, record)
store.build_taxon(identification, record)
try:
with open(export_etalab, 'w+b') as xp:
store.save(store_uri=xp)
except FileNotFoundError:
response = Response(
response="FileNotFoundError : {}".format(export_etalab),
status=500,
mimetype='application/json')
return response
return send_from_directory(os.path.dirname(export_etalab),
os.path.basename(export_etalab))
def _get_data(self,
export_,
geom_column_header=None,
filters=None,
limit=10000,
offset=0):
"""
Fonction qui retourne les données de l'export passé en paramètre
en applicant des filtres s'il y a lieu
.. :quickref: lance une requete qui récupère les données pour un export donné
:query Export export_: Définition de l'export
:query str geom_column_header: Nom de la colonne géometry si elle existe
:query {} filters: Filtres à appliquer sur les données
:query int limit: Nombre maximum de données à retourner
:query int offset: Numéro de page à retourner
**Returns:**
.. sourcecode:: http
{
'total': Number total of results,
'total_filtered': Number of results after filteer ,
'page': Page number,
'limit': Limit,
'items': data on GeoJson format
'licence': information of licence associated to data
}
"""
if not filters:
filters = dict()
query = GenericQuery(self.session, export_.view_name,
export_.schema_name, geom_column_header, filters,
limit, offset)
data = query.return_query()
# Ajout licence
if export_:
export_license = (export_.as_dict(True)).get('licence', None)
data['license'] = dict()
data['license']['name'] = export_license.get('name_licence', None)
data['license']['href'] = export_license.get('url_licence', None)
return (query.view.db_cols, data)
def get_visite_oedic(id_base_visit):
limit = int(request.args.get('limit', 1000))
offset = int(request.args.get('offset', 0))
data = GenericQuery(
DB.session, 'v_visites_oedic', 'monitoring_oedic', None,
{"id_base_visit": id_base_visit}, limit, offset
).return_query()
if not data.get('items', None):
return None
out = data['items'][0]
return out
def get_all_visites_chiro(id_base_site):
limit = int(request.args.get('limit', 1000))
offset = int(request.args.get('offset', 0))
data = GenericQuery(DB.session, 'v_visites_chiro', 'monitoring_chiro',
None, {
"id_base_site": id_base_site
}, limit, offset).return_query()
data["total"] = data["total_filtered"]
return data
def get_sites_chiro():
'''
Retourne la liste des sites chiro
'''
limit = int(request.args.get('limit', 1000))
offset = int(request.args.get('offset', 0))
data = GenericQuery(DB.session, 'v_sites_chiro', 'monitoring_chiro',
"geom", {}, limit, offset).return_query()
data["total"] = data["total_filtered"]
return data
def get_all_observations_oedic(id_base_visit):
limit = int(request.args.get('limit', 1000))
offset = int(request.args.get('offset', 0))
data = GenericQuery(
DB.session, 'v_observations_oedic', 'monitoring_oedic', None,
{"id_base_visit": id_base_visit}, limit, offset
).return_query()
data["total"] = data["total_filtered"]
return data
def get_contact_taxons_chiro(id_base_visit):
'''
retourne toutes les observations de taxons liées à une visite
identifiée par `id_base_visit`
'''
limit = int(request.args.get('limit', 1000))
offset = int(request.args.get('offset', 0))
data = GenericQuery(DB.session, 'v_obs_taxons', 'monitoring_chiro', None, {
"id_base_visit": id_base_visit
}, limit, offset).return_query()
data["total"] = data["total_filtered"]
return data
def get_biometries_chiro(id_contact_taxon):
'''
Récupération de l'ensemble des biométries
associé à un contact taxon
'''
limit = int(request.args.get('limit', 1000))
offset = int(request.args.get('offset', 0))
data = GenericQuery(DB.session, 'v_biometrie', 'monitoring_chiro', None, {
"id_contact_taxon": id_contact_taxon
}, limit, offset).return_query()
data["total"] = data["total_filtered"]
return data
def get_one_site_oedic(id_site):
limit = int(request.args.get('limit', 1000))
offset = int(request.args.get('offset', 0))
data = GenericQuery(
DB.session, 'v_sites_oedic', 'monitoring_oedic', None,
{"id_base_site": id_site}, limit, offset
).return_query()
if data:
data = data['items'][0]
return data
def get_observation_oedic(id_visite_observation):
limit = int(request.args.get('limit', 1000))
offset = int(request.args.get('offset', 0))
data = GenericQuery(
DB.session, 'v_observations_oedic', 'monitoring_oedic', None,
{"id_visite_observation": id_visite_observation}, limit, offset
).return_query()
print(data)
if data:
data = data['items'][0]
return data
def get_all_inventaires_chiro():
data = GenericQuery(DB.session, 'v_inventaires_chiro', 'monitoring_chiro',
"geom", {}, 1000, 0).return_query()
data["total"] = data["total_filtered"]
return data
def get_generic_view(view_schema, view_name):
'''
Service générique permettant de requeter une vue
Parameters
----------
limit : nombre limit de résultats à retourner
offset : numéro de page
geometry_field : nom de la colonne contenant la géométrie
Si elle est spécifiée les données seront retournés en geojson
FILTRES :
nom_col=val: Si nom_col fait partie des colonnes
de la vue alors filtre nom_col=val
ilikenom_col=val: Si nom_col fait partie des colonnes
de la vue et que la colonne est de type texte
alors filtre nom_col ilike '%val%'
filter_d_up_nom_col=val: Si nom_col fait partie des colonnes
de la vue et que la colonne est de type date
alors filtre nom_col >= val
filter_d_lo_nom_col=val: Si nom_col fait partie des colonnes
de la vue et que la colonne est de type date
alors filtre nom_col <= val
filter_d_eq_nom_col=val: Si nom_col fait partie des colonnes
de la vue et que la colonne est de type date
alors filtre nom_col == val
filter_n_up_nom_col=val: Si nom_col fait partie des colonnes
de la vue et que la colonne est de type numérique
alors filtre nom_col >= val
filter_n_lo_nom_col=val: Si nom_col fait partie des colonnes
de la vue et que la colonne est de type numérique
alors filtre nom_col <= val
ORDONNANCEMENT :
orderby: char
Nom du champ sur lequel baser l'ordonnancement
order: char (asc|desc)
Sens de l'ordonnancement
Returns
-------
json
{
'total': Nombre total de résultat,
'total_filtered': Nombre total de résultat après filtration,
'page': Numéro de la page retournée,
'limit': Nombre de résultats,
'items': données au format Json ou GeoJson
}
order by : @TODO
'''
parameters = request.args
limit = int(parameters.get('limit')) if parameters.get('limit') else 100
page = int(parameters.get('offset')) if parameters.get('offset') else 0
# Construction de la vue
# @TODO créer un système de mise en cache des vues mappées
geom = parameters.get('geometry_field', None)
results = GenericQuery(DB.session, view_name, view_schema, geom,
parameters, limit, page).return_query()
return results