def metadata():
enable_cache(server_side=False)
schemata = {}
for schema_id, schema in resolver.store.items():
if not schema_id.endswith('#'):
schema_id = schema_id + '#'
schemata[schema_id] = {
'id': schema_id,
'title': schema.get('title'),
'faIcon': schema.get('faIcon'),
'plural': schema.get('plural', schema.get('title')),
'description': schema.get('description'),
'inline': schema.get('inline', False)
}
return jsonify({
'status': 'ok',
'app': {
'title': get_app_title(),
'url': get_app_url(),
'samples': get_config('SAMPLE_SEARCHES')
},
'fields': Metadata.facets(),
'categories': Collection.CATEGORIES,
'countries': COUNTRY_NAMES,
'languages': LANGUAGE_NAMES,
'schemata': schemata
})
def statistics():
collections = authz.collections(authz.READ)
enable_cache(vary=collections)
query = documents_query(MultiDict())
query["size"] = 0
result = execute_documents_query(MultiDict(), query)
# collections = Collection.category_statistics(collections)
return jsonify({"document_count": result["total"], "collection_count": len(collections)})
def metadata():
from aleph.views.cache import enable_cache
enable_cache(server_side=False)
return jsonify({
'status': 'ok',
'fields': CORE_FACETS,
'source_categories': SOURCE_CATEGORIES,
'countries': COUNTRY_NAMES,
'languages': LANGUAGE_NAMES
})
def query():
enable_cache(vary_user=True,
vary=authz.collections(authz.READ))
query = documents_query(request.args)
query['size'] = get_limit(default=100)
query['from'] = get_offset()
result = execute_documents_query(request.args, query)
params = next_params(request.args, result)
if params is not None:
result['next'] = url_for('search_api.query', **params)
return jsonify(result)
def file(document_id):
document = get_document(document_id)
enable_cache(server_side=True)
url = get_archive().generate_url(document.meta)
if url is not None:
return redirect(url)
local_path = get_archive().load_file(document.meta)
fh = open(local_path, 'rb')
return send_file(fh, as_attachment=True,
attachment_filename=document.meta.file_name,
mimetype=document.meta.mime_type)
def records(document_id):
document = get_document(document_id)
enable_cache(vary_user=True)
query = records_query(document.id, request.args)
if query is None:
return jsonify({"status": "ok", "message": "no query"})
query["size"] = get_limit(default=30)
query["from"] = get_offset()
result = execute_records_query(query)
params = next_params(request.args, result)
if params is not None:
result["next"] = url_for("search_api.record", document_id=document_id, **params)
return jsonify(result)
def pdf(document_id):
document = get_document(document_id)
enable_cache(server_side=True)
if document.type != Document.TYPE_TEXT:
raise BadRequest("PDF is only available for text documents")
pdf = document.meta.pdf
url = get_archive().generate_url(pdf)
if url is not None:
return redirect(url)
local_path = get_archive().load_file(pdf)
fh = open(local_path, 'rb')
return send_file(fh, mimetype=pdf.mime_type)
def query():
enable_cache(vary_user=True, vary=authz.collections(authz.READ))
query = documents_query(request.args)
query["size"] = get_limit(default=100)
query["from"] = get_offset()
# import json
# print json.dumps(query, indent=2)
result = execute_documents_query(request.args, query)
params = next_params(request.args, result)
log_event(request)
if params is not None:
result["next"] = url_for("search_api.query", **params)
return jsonify(result)
def status():
enable_cache(vary_user=True)
return jsonify({
'logged_in': authz.logged_in(),
'api_key': request.auth_role.api_key if authz.logged_in() else None,
'role': request.auth_role,
'roles': list(request.auth_roles),
'permissions': {
'read': authz.collections(authz.READ),
'write': authz.collections(authz.WRITE)
},
'logout': url_for('.logout')
})
def query():
creds = authz.collections(authz.READ), authz.sources(authz.READ)
enable_cache(vary_user=True, vary=creds)
query = documents_query(request.args)
query['size'] = get_limit(default=100)
query['from'] = get_offset()
result = execute_documents_query(request.args, query)
result['alert'] = None
if authz.logged_in():
result['alert'] = Alert.exists(request.args, request.auth_role)
params = next_params(request.args, result)
if params is not None:
result['next'] = url_for('search_api.query', **params)
return jsonify(result)
def pdf(document_id):
document = get_document(document_id)
enable_cache(server_side=True)
log_event(request, document_id=document.id)
if document.type != Document.TYPE_TEXT:
raise BadRequest("PDF is only available for text documents")
pdf = document.meta.pdf
url = get_archive().generate_url(pdf)
if url is not None:
return redirect(url)
try:
local_path = get_archive().load_file(pdf)
fh = open(local_path, 'rb')
except Exception as ex:
raise NotFound("Missing PDF file: %r" % ex)
return send_file(fh, mimetype=pdf.mime_type)
def records(document_id):
document = get_document(document_id)
enable_cache(vary_user=True)
query = records_query(document.id, request.args)
if query is None:
return jsonify({
'status': 'ok',
'message': 'no query'
})
query['size'] = get_limit(default=30)
query['from'] = get_offset()
result = execute_records_query(query)
params = next_params(request.args, result)
if params is not None:
result['next'] = url_for('search_api.record', document_id=document_id,
**params)
return jsonify(result)
def view(document_id):
doc = get_document(document_id)
enable_cache()
data = doc.to_dict()
data['data_url'] = get_archive().generate_url(doc.meta)
if data['data_url'] is None:
data['data_url'] = url_for('documents_api.file',
document_id=document_id)
if doc.meta.is_pdf:
data['pdf_url'] = data['data_url']
else:
data['pdf_url'] = get_archive().generate_url(doc.meta.pdf)
if data['pdf_url'] is None:
data['pdf_url'] = url_for('documents_api.pdf',
document_id=document_id)
data['source'] = doc.source
return jsonify(data)
def view(document_id):
doc = get_document(document_id)
enable_cache()
data = doc.to_dict()
data['data_url'] = get_archive().generate_url(doc.meta)
if data['data_url'] is None:
data['data_url'] = url_for('documents_api.file',
document_id=document_id)
if doc.meta.is_pdf:
data['pdf_url'] = data['data_url']
else:
try:
data['pdf_url'] = get_archive().generate_url(doc.meta.pdf)
except Exception as ex:
log.info('Could not generate PDF url: %r', ex)
if data.get('pdf_url') is None:
data['pdf_url'] = url_for('documents_api.pdf',
document_id=document_id)
data['source'] = doc.source
return jsonify(data)
def metadata():
enable_cache(server_side=False)
schemata = {}
for schema_id, schema in resolver.store.items():
if not schema_id.endswith('#'):
schema_id = schema_id + '#'
schemata[schema_id] = {
'id': schema_id,
'title': schema.get('title'),
'faIcon': schema.get('faIcon'),
'plural': schema.get('plural', schema.get('title')),
'description': schema.get('description'),
'inline': schema.get('inline', False)
}
return jsonify({
'status': 'ok',
'fields': CORE_FACETS,
'source_categories': SOURCE_CATEGORIES,
'countries': COUNTRY_NAMES,
'languages': LANGUAGE_NAMES,
'schemata': schemata
})
def ui(**kwargs):
enable_cache(server_side=True)
return render_template("layout.html", templates=angular_templates())
def view(id):
enable_cache(vary_user=True)
authz.require(authz.logged_in())
alert = obj_or_404(Alert.by_id(id, role=request.auth_role))
return jsonify(alert)
def index():
collections = authz.collections(authz.READ)
enable_cache(vary_user=True, vary=collections)
q = Collection.all_by_ids(collections)
q = q.order_by(Collection.label.asc())
return jsonify(Pager(q))
def view(id):
enable_cache()
entity = get_index_entity(id, request.authz.READ)
record_audit(Audit.ACT_ENTITY, id=id)
return serialize_data(entity, CombinedSchema)
def index():
enable_cache()
result = DocumentsQuery.handle(request, schema=CombinedSchema)
return jsonify(result)
def page(document_id, number):
document, page = get_page(document_id, number)
enable_cache(server_side=True)
return jsonify(page)
def page(document_id, number):
document, page = get_page(document_id, number)
enable_cache(server_side=True)
return jsonify(page)
def suggest():
collections = authz.collections(authz.READ)
enable_cache(vary=collections, server_side=False)
prefix = request.args.get('prefix')
min_count = int(request.args.get('min_count', 0))
return jsonify(suggest_entities(prefix, min_count))
def suggest():
collections = authz.collections(authz.READ)
enable_cache(vary=collections, server_side=False)
return jsonify(suggest_entities(request.args))
def view(document_id):
enable_cache()
document = get_index_document(document_id)
return jsonify(document, schema=DocumentSchema)
def view(id):
enable_cache(vary_user=True)
authz.require(authz.logged_in())
alert = obj_or_404(Alert.by_id(id, role=request.auth_role))
return jsonify(alert)
def statistics():
enable_cache(vary_user=True)
return jsonify(get_instance_stats(request.authz))
def suggest():
enable_cache()
result = SuggestEntitiesQuery.handle(request, schema=CombinedSchema)
return jsonify(result)
def index():
result = DocumentsQuery.handle(request, schema=CombinedSchema)
enable_cache(vary_user=True, vary=result.cache_key)
return jsonify(result)
def view(document_id):
doc = get_document(document_id)
enable_cache()
data = doc.to_dict()
data['source'] = doc.source
return jsonify(data)
def match():
enable_cache()
entity = parse_request(EntityUpdateSchema)
entity = model.get_proxy(entity)
result = MatchQuery.handle(request, entity=entity, schema=CombinedSchema)
return jsonify(result)
def index():
result = CollectionsQuery.handle(request, schema=CollectionSchema)
enable_cache(vary_user=True, vary=result.cache_key)
return jsonify(result)
def suggest():
collections = authz.collections(authz.READ)
enable_cache(vary=collections, server_side=False)
prefix = request.args.get('prefix')
results = Entity.suggest_prefix(prefix, collections)
return jsonify({'results': results})
def table(document_id, table_id):
document, tabular = get_tabular(document_id, table_id)
enable_cache(vary_user=True)
return jsonify(tabular)
def peek():
enable_cache(vary_user=True, vary=authz.collections(authz.READ))
response = peek_query(request.args)
if not authz.logged_in():
response.pop('roles', None)
return jsonify(response)
def index():
enable_cache(vary_user=True)
results = [d for d in datasets if request.authz.check_roles(d.roles)]
state = QueryState(
{
'filter:dataset': [d.name for d in results],
'facet': 'dataset',
'limit': 0
}, request.authz)
res = entities_query(state)
values = res.get('facets', {}).get('dataset', {}).get('values', [])
counts = {v.get('id'): v.get('count') for v in values}
countries_facet = defaultdict(int)
category_facet = defaultdict(int)
countries_filter = set(request.args.getlist('filter:countries'))
category_filter = set(request.args.getlist('filter:category'))
filtered = []
for dataset in results:
dataset.entities_count = counts.get(dataset.name)
if len(category_filter) and dataset.category not in category_filter:
continue
if len(countries_filter) and \
not len(countries_filter.intersection(dataset.countries)):
continue
for country in dataset.countries:
countries_facet[country] += 1
category_facet[dataset.category] += 1
filtered.append(dataset)
filtered = sorted(filtered, key=lambda d: d.entities_count, reverse=True)
facets = {'countries': {'values': []}, 'category': {'values': []}}
categories = get_config('COLLECTION_CATEGORIES', {})
countries_facet = sorted(countries_facet.items(), key=lambda (k, c): c)
for key, count in countries_facet[::-1]:
facets['countries']['values'].append({
'id':
key,
'count':
count,
'label':
COUNTRY_NAMES.get(key, key)
})
category_facet = sorted(category_facet.items(), key=lambda (k, c): c)
for key, count in category_facet[::-1]:
if key is None:
continue
facets['category']['values'].append({
'id': key,
'count': count,
'label': categories.get(key, key)
})
return jsonify({
'results': filtered,
'facets': facets,
'total': len(filtered),
'total_entities_count': res.get('total')
})
def peek():
enable_cache(vary_user=True, vary=authz.collections(authz.READ))
response = peek_query(request.args)
if not authz.logged_in():
response.pop("roles", None)
return jsonify(response)
def search():
enable_cache()
result = CombinedQuery.handle_request(request, schema=SearchResultSchema)
# TODO do we want to include alerting info ("is the user subscribed to
# the results of this query?")
return jsonify(result)
def ui(**kwargs):
from aleph.views.cache import enable_cache
enable_cache(server_side=True)
return render_template("layout.html", templates=angular_templates())
def statistics():
enable_cache()
return jsonify(get_instance_stats(request.authz))
def ui(**kwargs):
enable_cache(server_side=True)
return render_template("layout.html", templates=angular_templates())
def suggest():
collections = authz.collections(authz.READ)
enable_cache(vary=collections, server_side=False)
return jsonify(suggest_entities(request.args))
def index():
require(request.authz.logged_in)
query = Alert.by_role_id(request.authz.id)
result = DatabaseQueryResult(request, query, schema=AlertSchema)
enable_cache(vary_user=True, vary=result.cache_key)
return jsonify(result)
def table(document_id, table_id):
document, tabular = get_tabular(document_id, table_id)
enable_cache(vary_user=True)
return jsonify(tabular)
def index():
enable_cache()
result = EntitiesQuery.handle_request(request, schema=EntitySchema)
return jsonify(result)
def ui(**kwargs):
from aleph.views.cache import enable_cache
enable_cache(server_side=True)
return render_template("layout.html", templates=angular_templates())
def view(entity_id):
enable_cache()
entity = get_index_entity(entity_id, request.authz.READ)
record_audit(Audit.ACT_ENTITY, id=entity_id)
return EntitySerializer.jsonify(entity)
def index():
collections = authz.collections(authz.READ)
enable_cache(vary_user=True, vary=collections)
q = Collection.all_by_ids(collections)
q = q.order_by(Collection.label.asc())
return jsonify(Pager(q))
def suggest():
collections = authz.collections(authz.READ)
enable_cache(vary=collections, server_side=False)
prefix = request.args.get('prefix')
min_count = int(request.args.get('min_count', 0))
return jsonify(suggest_entities(prefix, min_count))
