def semantic_dsw(): """ Fonction qui expose un export RDF basé sur le vocabulaire Darwin-SW sous forme d'api Le requetage des données se base sur la classe GenericQuery qui permet de filter les données de façon dynamique en respectant des conventions de nommage Parameters ---------- limit : nombre limite de résultats à retourner offset : numéro de page FILTRES : nom_col=val: Si nom_col fait partie des colonnes de la vue alors filtre nom_col=val Returns ------- turle """ conf = current_app.config.get('EXPORTS') export_dsw_dir = conf.get('export_dsw_dir') export_dsw_fullpath = str(Path( conf.get('export_dsw_dir'), conf.get('export_dsw_filename') )) os.makedirs(export_dsw_dir, exist_ok=True) if not export_dsw_fullpath: return to_json_resp( {'api_error': 'dws_disabled', 'message': 'Darwin-SW export is disabled'}, status=501) from .rdf import generate_store_dws limit = request.args.get('limit', default=1000, type=int) offset = request.args.get('offset', default=0, type=int) args = request.args.to_dict() if "limit" in args: args.pop("limit") if "offset" in args: args.pop("offset") filters = {f: args.get(f) for f in args} store = generate_store_dws(limit, offset, filters) try: with open(export_dsw_fullpath, 'w+b') as xp: store.save(store_uri=xp) except FileNotFoundError: response = Response( response="FileNotFoundError : {}".format( export_dsw_fullpath ), status=500, mimetype='application/json' ) return response return send_from_directory( os.path.dirname(export_dsw_fullpath), os.path.basename(export_dsw_fullpath) )
def export_all_habitats( info_role, export_format="csv", ): """ Download all stations The route is in post to avoid a too large query string .. :quickref: Occhab; """ data = request.get_json() export_view = GenericTableGeo( tableName="v_export_sinp", schemaName="pr_occhab", engine=DB.engine, geometry_field="geom_local", srid=current_app.config["LOCAL_SRID"], ) file_name = datetime.datetime.now().strftime("%Y_%m_%d_%Hh%Mm%S") file_name = filemanager.removeDisallowedFilenameChars(file_name) db_cols_for_shape = [] columns_to_serialize = [] for db_col in export_view.db_cols: if db_col.key in blueprint.config["EXPORT_COLUMS"]: if db_col.key != "geometry": db_cols_for_shape.append(db_col) columns_to_serialize.append(db_col.key) results = ( DB.session.query(export_view.tableDef) .filter(export_view.tableDef.columns.id_station.in_(data["idsStation"])) .limit(blueprint.config["NB_MAX_EXPORT"]) ) if export_format == "csv": formated_data = [export_view.as_dict(d, fields=[]) for d in results] return to_csv_resp( file_name, formated_data, separator=";", columns=columns_to_serialize ) elif export_format == "geojson": features = [] for r in results: features.append( Feature( geometry=json.loads(r.geojson), properties=export_view.as_dict(r, fields=columns_to_serialize), ) ) return to_json_resp( FeatureCollection(features), as_file=True, filename=file_name, indent=4 ) else: try: dir_name, file_name = export_as_geo_file( export_format=export_format, export_view=export_view, db_cols=db_cols_for_shape, geojson_col=None, data=results, file_name=file_name, ) return send_from_directory(dir_name, file_name, as_attachment=True) except GeonatureApiError as e: message = str(e) return render_template( "error.html", error=message, redirect=current_app.config["URL_APPLICATION"] + "/#/" + blueprint.config["MODULE_URL"], )
def getOneExportThread(id_export, export_format, info_role): """ Run export with thread """ # Test if export exists if ( id_export < 1 or export_format not in current_app.config['EXPORTS']['export_format_map'] ): return to_json_resp( { 'api_error': 'invalid_export', 'message': 'Invalid export or export not found' }, status=404 ) filters = {f: request.args.get(f) for f in request.args} data = dict(request.get_json()) # Alternative email in payload email_to = None if 'email' in data: email_to = data['email'] try: @copy_current_request_context def get_data(id_export, export_format, info_role, filters, email_to): thread_export_data( id_export, export_format, info_role, filters, email_to ) exp = ExportRepository(id_export) # Test if export is allowed try: exp.get_export_is_allowed(info_role) except Exception as e: return to_json_resp( {'message': "Not Allowed"}, status=403 ) # Test if user have an email try: user = ( DB.session.query(User) .filter(User.id_role == info_role.id_role) .one() ) if not user.email and not email_to: # TODO add more test return to_json_resp( {'api_error': 'no_email', 'message': "User doesn't have email"}, # noqa 501 status=500 ) except NoResultFound: return to_json_resp( {'api_error': 'no_user', 'message': "User doesn't exist"}, status=404 ) # Run export a = threading.Thread( name="export_data", target=get_data, kwargs={ "id_export": id_export, "export_format": export_format, "info_role": info_role, "filters": filters, "email_to": [email_to] if (email_to) else [user.email] } ) a.start() return to_json_resp( { 'api_success': 'in_progress', 'message': 'The Process is in progress ! You will receive an email shortly' # noqa 501 }, status=200 ) except Exception as e: LOGGER.critical('%s', e) if current_app.config['DEBUG']: raise return to_json_resp({'api_error': 'logged_error'}, status=400)
def export_observations_web(info_role): """Optimized route for observations web export. .. :quickref: Synthese; This view is customisable by the administrator Some columns are mandatory: id_synthese, geojson and geojson_local to generate the exported files POST parameters: Use a list of id_synthese (in POST parameters) to filter the v_synthese_for_export_view :query str export_format: str<'csv', 'geojson', 'shapefiles'> """ params = request.args # set default to csv export_format = "csv" export_view = GenericTableGeo( tableName="v_synthese_for_export", schemaName="gn_synthese", engine=DB.engine, geometry_field=None, srid=current_app.config["LOCAL_SRID"], ) if "export_format" in params: export_format = params["export_format"] # get list of id synthese from POST id_list = request.get_json() db_cols_for_shape = [] columns_to_serialize = [] # loop over synthese config to get the columns for export for db_col in export_view.db_cols: if db_col.key in current_app.config["SYNTHESE"]["EXPORT_COLUMNS"]: db_cols_for_shape.append(db_col) columns_to_serialize.append(db_col.key) q = DB.session.query(export_view.tableDef).filter( export_view.tableDef.columns[ current_app.config["SYNTHESE"]["EXPORT_ID_SYNTHESE_COL"] ].in_(id_list) ) # check R and E CRUVED to know if we filter with cruved cruved = cruved_scope_for_user_in_module(info_role.id_role, module_code="SYNTHESE")[ 0 ] if cruved["R"] > cruved["E"]: # filter on cruved specifying the column # id_dataset, id_synthese, id_digitiser and observer in the v_synthese_for_export_view q = synthese_query.filter_query_with_cruved( export_view.tableDef, q, info_role, id_synthese_column=current_app.config["SYNTHESE"]["EXPORT_ID_SYNTHESE_COL"], id_dataset_column=current_app.config["SYNTHESE"]["EXPORT_ID_DATASET_COL"], observers_column=current_app.config["SYNTHESE"]["EXPORT_OBSERVERS_COL"], id_digitiser_column=current_app.config["SYNTHESE"][ "EXPORT_ID_DIGITISER_COL" ], with_generic_table=True, ) results = q.limit(current_app.config["SYNTHESE"]["NB_MAX_OBS_EXPORT"]) file_name = datetime.datetime.now().strftime("%Y_%m_%d_%Hh%Mm%S") file_name = filemanager.removeDisallowedFilenameChars(file_name) # columns = [db_col.key for db_col in export_view.db_cols] if export_format == "csv": formated_data = [ export_view.as_dict(d, columns=columns_to_serialize) for d in results ] return to_csv_resp( file_name, formated_data, separator=";", columns=columns_to_serialize ) elif export_format == "geojson": features = [] for r in results: geometry = ast.literal_eval( getattr( r, current_app.config["SYNTHESE"]["EXPORT_GEOJSON_4326_COL"]) ) feature = Feature( geometry=geometry, properties=export_view.as_dict( r, columns=columns_to_serialize), ) features.append(feature) results = FeatureCollection(features) return to_json_resp(results, as_file=True, filename=file_name, indent=4) else: try: filemanager.delete_recursively( str(ROOT_DIR / "backend/static/shapefiles"), excluded_files=[".gitkeep"] ) dir_path = str(ROOT_DIR / "backend/static/shapefiles") export_view.as_shape( db_cols=db_cols_for_shape, data=results, geojson_col=current_app.config["SYNTHESE"]["EXPORT_GEOJSON_LOCAL_COL"], dir_path=dir_path, file_name=file_name, ) return send_from_directory(dir_path, file_name + ".zip", as_attachment=True) except GeonatureApiError as e: message = str(e) return render_template( "error.html", error=message, redirect=current_app.config["URL_APPLICATION"] + "/#/synthese", )
def export(info_role): """Export data from pr_occtax.v_export_occtax view (parameter) .. :quickref: Occtax; Export data from pr_occtax.v_export_occtax :query str format: format of the export ('csv', 'geojson', 'shapefile') """ export_view_name = blueprint.config["export_view_name"] export_geom_column = blueprint.config["export_geom_columns_name"] export_columns = blueprint.config["export_columns"] export_srid = blueprint.config["export_srid"] export_view = GenericTableGeo( tableName=export_view_name, schemaName="pr_occtax", engine=DB.engine, geometry_field=export_geom_column, srid=export_srid, ) releve_repository = ReleveRepository(export_view) q = releve_repository.get_filtered_query(info_role, from_generic_table=True) q = get_query_occtax_filters( request.args, export_view, q, from_generic_table=True, obs_txt_column=blueprint.config["export_observer_txt_column"], ) data = q.all() file_name = datetime.datetime.now().strftime("%Y_%m_%d_%Hh%Mm%S") file_name = filemanager.removeDisallowedFilenameChars(file_name) export_format = request.args["format"] if "format" in request.args else "geojson" if export_format == "csv": columns = ( export_columns if len(export_columns) > 0 else [db_col.key for db_col in export_view.db_cols] ) return to_csv_resp( file_name, [export_view.as_dict(d) for d in data], columns, ";" ) elif export_format == "geojson": results = FeatureCollection( [export_view.as_geofeature(d, columns=export_columns) for d in data] ) return to_json_resp( results, as_file=True, filename=file_name, indent=4, extension="geojson" ) else: try: db_cols = [ db_col for db_col in export_view.db_cols if db_col.key in export_columns ] dir_name, file_name = export_as_geo_file( export_format=export_format, export_view=export_view, db_cols=db_cols, geojson_col=None, data=data, file_name=file_name, ) return send_from_directory(dir_name, file_name, as_attachment=True) except GeonatureApiError as e: message = str(e) return render_template( "error.html", error=message, redirect=current_app.config["URL_APPLICATION"] + "/#/occtax", )
def export(info_role): """Export data from pr_occtax.v_export_occtax view (parameter) .. :quickref: Occtax; Export data from pr_occtax.v_export_occtax :query str format: format of the export ('csv', 'geojson', 'shapefile', 'gpkg') """ export_view_name = blueprint.config["export_view_name"] export_geom_column = blueprint.config["export_geom_columns_name"] export_columns = blueprint.config["export_columns"] export_srid = blueprint.config["export_srid"] export_format = request.args[ "format"] if "format" in request.args else "geojson" export_col_name_additional_data = blueprint.config[ "export_col_name_additional_data"] export_view = GenericTableGeo( tableName=export_view_name, schemaName="pr_occtax", engine=DB.engine, geometry_field=export_geom_column, srid=export_srid, ) columns = (export_columns if len(export_columns) > 0 else [db_col.key for db_col in export_view.db_cols]) releve_repository = ReleveRepository(export_view) q = releve_repository.get_filtered_query(info_role, from_generic_table=True) q = get_query_occtax_filters( request.args, export_view, q, from_generic_table=True, obs_txt_column=blueprint.config["export_observer_txt_column"], ) if current_app.config["OCCTAX"]["ADD_MEDIA_IN_EXPORT"]: q, columns = releve_repository.add_media_in_export(q, columns) data = q.all() file_name = datetime.datetime.now().strftime("%Y_%m_%d_%Hh%Mm%S") file_name = filemanager.removeDisallowedFilenameChars(file_name) #Ajout des colonnes additionnels additional_col_names = [] query_add_fields = DB.session.query(TAdditionalFields).filter( TAdditionalFields.modules.any(module_code="OCCTAX")).filter( TAdditionalFields.exportable == True) global_add_fields = query_add_fields.filter( ~TAdditionalFields.datasets.any()).all() if "id_dataset" in request.args: dataset_add_fields = query_add_fields.filter( TAdditionalFields.datasets.any( id_dataset=request.args['id_dataset'])).all() global_add_fields = [*global_add_fields, *dataset_add_fields] additional_col_names = [field.field_name for field in global_add_fields] if export_format == "csv": # set additional data col at the end (remove it and inset it ...) columns.remove(export_col_name_additional_data) columns = columns + additional_col_names columns.append(export_col_name_additional_data) if additional_col_names: serialize_result = [ as_dict_with_add_cols(export_view, row, export_col_name_additional_data, additional_col_names) for row in data ] else: serialize_result = [export_view.as_dict(row) for row in data] return to_csv_resp(file_name, serialize_result, columns, ";") elif export_format == "geojson": if additional_col_names: features = [] for row in data: properties = as_dict_with_add_cols( export_view, row, export_col_name_additional_data, additional_col_names) feature = Feature(properties=properties, geometry=to_shape( getattr(row, export_geom_column))) features.append(feature) serialize_result = FeatureCollection(features) else: serialize_result = FeatureCollection([ export_view.as_geofeature(d, fields=export_columns) for d in data ]) return to_json_resp(serialize_result, as_file=True, filename=file_name, indent=4, extension="geojson") else: try: db_cols = [ db_col for db_col in export_view.db_cols if db_col.key in export_columns ] dir_name, file_name = export_as_geo_file( export_format=export_format, export_view=export_view, db_cols=db_cols, geojson_col=None, data=data, file_name=file_name, ) db_cols = [ db_col for db_col in export_view.db_cols if db_col.key in export_columns ] return send_from_directory(dir_name, file_name, as_attachment=True) except GeonatureApiError as e: message = str(e) return render_template( "error.html", error=message, redirect=current_app.config["URL_APPLICATION"] + "/#/occtax", )
def export(info_role): """Export data from pr_occtax.export_occtax_sinp view (parameter) .. :quickref: Occtax; Export data from pr_occtax.export_occtax_sinp :query str format: format of the export ('csv', 'geojson', 'shapefile') """ export_view_name = blueprint.config["export_view_name"] export_geom_column = blueprint.config["export_geom_columns_name"] export_id_column_name = blueprint.config["export_id_column_name"] export_columns = blueprint.config["export_columns"] export_srid = blueprint.config["export_srid"] export_view = GenericTable(export_view_name, "pr_occtax", export_geom_column, export_srid) releve_repository = ReleveRepository(export_view) q = releve_repository.get_filtered_query(info_role, from_generic_table=True) q = get_query_occtax_filters( request.args, export_view, q, from_generic_table=True, obs_txt_column=blueprint.config['export_observer_txt_column']) data = q.all() file_name = datetime.datetime.now().strftime("%Y_%m_%d_%Hh%Mm%S") file_name = filemanager.removeDisallowedFilenameChars(file_name) export_format = request.args[ "format"] if "format" in request.args else "geojson" if export_format == "csv": columns = (export_columns if len(export_columns) > 0 else [db_col.key for db_col in export_view.db_cols]) return to_csv_resp(file_name, [export_view.as_dict(d) for d in data], columns, ";") elif export_format == "geojson": results = FeatureCollection([ export_view.as_geofeature(d, columns=export_columns) for d in data ]) return to_json_resp(results, as_file=True, filename=file_name, indent=4, extension="geojson") else: try: filemanager.delete_recursively(str(ROOT_DIR / "backend/static/shapefiles"), excluded_files=[".gitkeep"]) db_cols = [ db_col for db_col in export_view.db_cols if db_col.key in export_columns ] dir_path = str(ROOT_DIR / "backend/static/shapefiles") export_view.as_shape(db_cols=db_cols, data=data, dir_path=dir_path, file_name=file_name) return send_from_directory(dir_path, file_name + ".zip", as_attachment=True) except GeonatureApiError as e: message = str(e) return render_template( "error.html", error=message, redirect=current_app.config["URL_APPLICATION"] + "/#/occtax", )
def export(info_role): """Export data from pr_occtax.export_occtax_sinp view (parameter) .. :quickref: Occtax; Export data from pr_occtax.export_occtax_sinp :query str format: format of the export ('csv', 'geojson', 'shapefile', 'medias') """ export_view_name = blueprint.config["export_view_name"] export_geom_column = blueprint.config["export_geom_columns_name"] export_columns = blueprint.config["export_columns"] export_srid = blueprint.config["export_srid"] export_view = GenericTableGeo( tableName=export_view_name, schemaName="pr_occtax", engine=DB.engine, geometry_field=export_geom_column, srid=export_srid, ) releve_repository = ReleveRepository(export_view) q = releve_repository.get_filtered_query(info_role, from_generic_table=True) q = get_query_occtax_filters( request.args, export_view, q, from_generic_table=True, obs_txt_column=blueprint.config["export_observer_txt_column"], ) data = q.all() file_name = datetime.datetime.now().strftime("%Y_%m_%d_%Hh%Mm%S") file_name = filemanager.removeDisallowedFilenameChars(file_name) export_format = request.args[ "format"] if "format" in request.args else "geojson" if export_format == "csv": columns = (export_columns if len(export_columns) > 0 else [db_col.key for db_col in export_view.db_cols]) return to_csv_resp(file_name, [export_view.as_dict(d) for d in data], columns, ";") elif export_format == "geojson": results = FeatureCollection([ export_view.as_geofeature(d, columns=export_columns) for d in data ]) return to_json_resp(results, as_file=True, filename=file_name, indent=4, extension="geojson") #MET 21/10/2020 Ajout d'un export medias elif export_format == "medias": try: releve_repository_for_media = ReleveRepository(TRelevesOccurrence) q = releve_repository_for_media.get_filtered_query(info_role) parameters = request.args # Filters q = get_query_occtax_filters(parameters, TRelevesOccurrence, q) data = q.all() user = info_role user_cruved = get_or_fetch_user_cruved(session=session, id_role=info_role.id_role, module_code="OCCTAX") #on crée le dossier s'il n'existe pas dir_path = str(ROOT_DIR / "backend/static/medias/exports") if not os.path.exists(dir_path): os.makedirs(dir_path) #on le clean filemanager.delete_recursively(dir_path) featureCollection = [] zip_path = dir_path + "/" + file_name + ".zip" zp_file = zipfile.ZipFile(zip_path, mode="w") for n in data: releve_cruved = n.get_releve_cruved(user, user_cruved) feature = n.get_geofeature( relationships=('t_occurrences_occtax', 'cor_counting_occtax', 'medias')) if 'properties' in feature: if 't_occurrences_occtax' in feature['properties']: for occurence in feature['properties'][ 't_occurrences_occtax']: for counting in occurence['cor_counting_occtax']: if 'medias' in counting: for media in counting['medias']: if media['media_path'] is not None: file_path = str( ROOT_DIR / "backend/" ) + "/" + media['media_path'] if os.path.exists(file_path): zp_file.write( file_path, os.path.basename( file_path)) #copyfile( file_path, dir_path + "/" + os.path.basename(file_path)) #featureCollection.append(file_path) zp_file.close() return send_from_directory(dir_path, file_name + ".zip", as_attachment=True) except GeonatureApiError as e: message = str(e) else: try: filemanager.delete_recursively(str(ROOT_DIR / "backend/static/shapefiles"), excluded_files=[".gitkeep"]) db_cols = [ db_col for db_col in export_view.db_cols if db_col.key in export_columns ] dir_path = str(ROOT_DIR / "backend/static/shapefiles") export_view.as_shape(db_cols=db_cols, data=data, dir_path=dir_path, file_name=file_name) return send_from_directory(dir_path, file_name + ".zip", as_attachment=True) except GeonatureApiError as e: message = str(e) return render_template( "error.html", error=message, redirect=current_app.config["URL_APPLICATION"] + "/#/occtax", )
def export_all_habitats(info_role, export_format='csv',): """ Download all stations The route is in post to avoid a too large query string .. :quickref: Occhab; """ data = request.get_json() export_view = GenericTable( tableName="v_export_sinp", schemaName="pr_occhab", geometry_field=None, srid=current_app.config["LOCAL_SRID"], ) file_name = datetime.datetime.now().strftime("%Y_%m_%d_%Hh%Mm%S") file_name = filemanager.removeDisallowedFilenameChars(file_name) db_cols_for_shape = [] columns_to_serialize = [] for db_col in export_view.db_cols: if db_col.key in blueprint.config['EXPORT_COLUMS']: if db_col.key != 'geometry': db_cols_for_shape.append(db_col) columns_to_serialize.append(db_col.key) results = DB.session.query(export_view.tableDef).filter( export_view.tableDef.columns.id_station.in_(data['idsStation']) ).limit( blueprint.config['NB_MAX_EXPORT'] ) if export_format == 'csv': formated_data = [ export_view.as_dict(d, columns=[]) for d in results ] return to_csv_resp( file_name, formated_data, separator=";", columns=columns_to_serialize ) elif export_format == 'geojson': features = [] for r in results: features.append( Feature( geometry=json.loads(r.geojson), properties=export_view.as_dict( r, columns=columns_to_serialize) ) ) return to_json_resp( FeatureCollection(features), as_file=True, filename=file_name, indent=4 ) else: try: filemanager.delete_recursively( str(ROOT_DIR / "backend/static/shapefiles"), excluded_files=[".gitkeep"] ) dir_path = str(ROOT_DIR / "backend/static/shapefiles") export_view.as_shape( db_cols=db_cols_for_shape, data=results, geojson_col="geojson", dir_path=dir_path, file_name=file_name, ) return send_from_directory(dir_path, file_name + ".zip", as_attachment=True) except GeonatureApiError as e: message = str(e) return render_template( "error.html", error=message, redirect=current_app.config["URL_APPLICATION"] + "/#/" + blueprint.config['MODULE_URL'], )
def export_observations_web(info_role): """Optimized route for observations web export. .. :quickref: Synthese; This view is customisable by the administrator Some columns are mandatory: id_synthese, geojson and geojson_local to generate the exported files POST parameters: Use a list of id_synthese (in POST parameters) to filter the v_synthese_for_export_view :query str export_format: str<'csv', 'geojson', 'shapefiles', 'gpkg'> """ params = request.args export_format = params.get("export_format", "csv") # Test export_format if not export_format in current_app.config["SYNTHESE"]["EXPORT_FORMAT"]: raise BadRequest("Unsupported format") # set default to csv export_view = GenericTableGeo( tableName="v_synthese_for_export", schemaName="gn_synthese", engine=DB.engine, geometry_field=None, srid=current_app.config["LOCAL_SRID"], ) # get list of id synthese from POST id_list = request.get_json() db_cols_for_shape = [] columns_to_serialize = [] # loop over synthese config to get the columns for export for db_col in export_view.db_cols: if db_col.key in current_app.config["SYNTHESE"]["EXPORT_COLUMNS"]: db_cols_for_shape.append(db_col) columns_to_serialize.append(db_col.key) query = select([export_view.tableDef]).where(export_view.tableDef.columns[ current_app.config["SYNTHESE"]["EXPORT_ID_SYNTHESE_COL"]].in_(id_list)) synthese_query_class = SyntheseQuery( export_view.tableDef, query, {}, id_synthese_column=current_app.config["SYNTHESE"] ["EXPORT_ID_SYNTHESE_COL"], id_dataset_column=current_app.config["SYNTHESE"] ["EXPORT_ID_DATASET_COL"], observers_column=current_app.config["SYNTHESE"] ["EXPORT_OBSERVERS_COL"], id_digitiser_column=current_app.config["SYNTHESE"] ["EXPORT_ID_DIGITISER_COL"], with_generic_table=True, ) # check R and E CRUVED to know if we filter with cruved cruved = cruved_scope_for_user_in_module(info_role.id_role, module_code="SYNTHESE")[0] if cruved["R"] > cruved["E"]: synthese_query_class.filter_query_with_cruved(info_role) results = DB.session.execute( synthese_query_class.query.limit( current_app.config["SYNTHESE"]["NB_MAX_OBS_EXPORT"])) file_name = datetime.datetime.now().strftime("%Y_%m_%d_%Hh%Mm%S") file_name = filemanager.removeDisallowedFilenameChars(file_name) if export_format == "csv": formated_data = [ export_view.as_dict(d, columns=columns_to_serialize) for d in results ] return to_csv_resp(file_name, formated_data, separator=";", columns=columns_to_serialize) elif export_format == "geojson": features = [] for r in results: geometry = json.loads( getattr( r, current_app.config["SYNTHESE"]["EXPORT_GEOJSON_4326_COL"])) feature = Feature( geometry=geometry, properties=export_view.as_dict(r, columns=columns_to_serialize), ) features.append(feature) results = FeatureCollection(features) return to_json_resp(results, as_file=True, filename=file_name, indent=4) else: try: dir_name, file_name = export_as_geo_file( export_format=export_format, export_view=export_view, db_cols=db_cols_for_shape, geojson_col=current_app.config["SYNTHESE"] ["EXPORT_GEOJSON_LOCAL_COL"], data=results, file_name=file_name, ) return send_from_directory(dir_name, file_name, as_attachment=True) except GeonatureApiError as e: message = str(e) return render_template( "error.html", error=message, redirect=current_app.config["URL_APPLICATION"] + "/#/synthese", )