def view(id):
"""Retrieve role details.
---
post:
summary: Retrieve role details
description: >
Fetch detailed information about a role that the user is
entitled to access, e.g. their own role, or a group they
are part of.
parameters:
- in: path
name: id
required: true
description: role ID
schema:
type: integer
responses:
'200':
description: OK
content:
application/json:
schema:
$ref: '#/components/schemas/Role'
tags:
- Role
"""
role = obj_or_404(Role.by_id(id))
require(request.authz.can_read_role(role.id))
return RoleSerializer.jsonify(role)
def view(diagram_id):
"""Return the diagram with id `diagram_id`.
---
get:
summary: Fetch a diagram
parameters:
- description: The diagram id.
in: path
name: diagram_id
required: true
schema:
minimum: 1
type: integer
example: 2
responses:
'200':
content:
application/json:
schema:
$ref: '#/components/schemas/Diagram'
description: OK
tags:
- Diagram
"""
diagram = obj_or_404(Diagram.by_id(diagram_id))
get_db_collection(diagram.collection_id, request.authz.READ)
return DiagramSerializer.jsonify(diagram)
def delete(collection_id, mapping_id):
"""Delete a mapping.
---
delete:
summary: Delete a mapping
parameters:
- description: The collection id.
in: path
name: collection_id
required: true
schema:
minimum: 1
type: integer
example: 2
- description: The mapping id.
in: path
name: mapping_id
required: true
schema:
minimum: 1
type: integer
example: 2
responses:
'204':
description: No Content
tags:
- Collection
- Mapping
"""
get_db_collection(collection_id, request.authz.WRITE)
mapping = obj_or_404(Mapping.by_id(mapping_id))
mapping.delete()
db.session.commit()
return ("", 204)
def ingest_upload(id):
collection = obj_or_404(Collection.by_id(id))
require(request.authz.can_write(collection.id))
try:
meta = json.loads(request.form.get('meta', '{}'))
except Exception as ex:
raise BadRequest(unicode(ex))
validate_data(meta, DocumentSchema)
documents = []
for storage in request.files.values():
sec_fn = os.path.join(upload_folder, secure_filename(storage.filename))
storage.save(sec_fn)
content_hash = checksum(sec_fn)
document = Document.by_keys(collection=collection,
content_hash=content_hash)
document.mime_type = storage.mimetype
document.file_name = storage.filename
document.update(meta)
ingest_document(document, sec_fn, role_id=request.authz.id)
os.unlink(sec_fn)
documents.append(document)
return jsonify({
'status':
'ok',
'documents': [DocumentSchema().dump(d).data for d in documents]
})
def delete(diagram_id):
"""Delete a diagram.
---
delete:
summary: Delete a diagram
parameters:
- description: The diagram id.
in: path
name: diagram_id
required: true
schema:
minimum: 1
type: integer
example: 2
responses:
'204':
description: No Content
tags:
- Diagram
"""
diagram = obj_or_404(Diagram.by_id(diagram_id))
collection = get_db_collection(diagram.collection_id, request.authz.WRITE)
diagram.delete()
collection.touch()
db.session.commit()
return ('', 204)
def matches(id, other_id):
collection = obj_or_404(Collection.by_id(id))
require(request.authz.can_read(collection.id))
require(request.authz.can_read(other_id))
parser = QueryParser(request.args, request.authz, limit=10)
q = Match.find_by_collection(collection.id, other_id)
result = MatchQueryResult(request, q, parser=parser, schema=MatchSchema)
return jsonify(result)
def update(id):
role = obj_or_404(Role.by_id(id))
require(request.authz.session_write, role.id == request.authz.id)
data = parse_request(schema=RoleSchema)
role.update(data)
db.session.add(role)
db.session.commit()
return view(role.id)
def update(id):
role = obj_or_404(Role.by_id(id))
require(request.authz.can_write_role(role.id))
data = parse_request(RoleSchema)
role.update(data)
db.session.add(role)
db.session.commit()
update_role(role)
return RoleSerializer.jsonify(role)
def update(id):
role = obj_or_404(Role.by_id(id))
require(request.authz.session_write)
require(check_editable(role, request.authz))
data = parse_request(RoleSchema)
role.update(data)
db.session.add(role)
db.session.commit()
return view(role.id)
def update(id):
role = obj_or_404(Role.by_id(id))
require(request.authz.session_write)
require(check_editable(role, request.authz))
data = parse_request(RoleSchema)
role.update(data)
db.session.add(role)
db.session.commit()
update_role(role)
return RoleSerializer.jsonify(role)
def summary(id):
collection = obj_or_404(Collection.by_id(id))
require(request.authz.can_read(collection.id))
parser = QueryParser(request.args, request.authz, limit=10)
q = Match.group_by_collection(collection.id, authz=request.authz)
result = DatabaseQueryResult(request,
q,
parser=parser,
schema=MatchCollectionsSchema)
return jsonify(result)
def similar(profile_id):
"""
---
get:
summary: Get similar entities
description: >
Get a list of similar entities to the profile with id `profile_id`
parameters:
- in: path
name: profile_id
required: true
schema:
type: string
- in: query
name: 'filter:schema'
schema:
items:
type: string
type: array
- in: query
name: 'filter:schemata'
schema:
items:
type: string
type: array
responses:
'200':
description: Returns a list of entities
content:
application/json:
schema:
$ref: '#/components/schemas/EntitiesResponse'
tags:
- Profile
"""
# enable_cache()
profile = obj_or_404(get_profile(profile_id, authz=request.authz))
require(request.authz.can(profile.get("collection_id"),
request.authz.READ))
tag_request(collection_id=profile.get("collection_id"))
exclude = [item["entity_id"] for item in profile["items"]]
result = MatchQuery.handle(request,
entity=profile["merged"],
exclude=exclude)
entities = list(result.results)
result.results = []
for obj in entities:
item = {
"score": compare(model, profile["merged"], obj),
"judgement": Judgement.NO_JUDGEMENT,
"collection_id": profile.get("collection_id"),
"entity": obj,
}
result.results.append(item)
return SimilarSerializer.jsonify_result(result)
def trigger(collection_id, mapping_id):
"""Load entities by running the mapping with id `mapping_id`. Flushes
previously loaded entities before loading new entities.
---
post:
summary: Load entities from a mapping
parameters:
- description: The collection id.
in: path
name: collection_id
required: true
schema:
minimum: 1
type: integer
example: 2
- description: The mapping id.
in: path
name: mapping_id
required: true
schema:
minimum: 1
type: integer
example: 2
responses:
'202':
description: No Content
tags:
- Collection
- Mapping
"""
collection = get_db_collection(collection_id, request.authz.WRITE)
mapping = obj_or_404(Mapping.by_id(mapping_id))
mapping.disabled = False
mapping.set_status(Status.PENDING)
db.session.commit()
job_id = get_session_id()
queue_task(collection,
OP_LOAD_MAPPING,
job_id=job_id,
mapping_id=mapping.id)
mapping = obj_or_404(Mapping.by_id(mapping_id))
return MappingSerializer.jsonify(mapping, status=202)
def report(collection_id):
collection = obj_or_404(Collection.by_id(collection_id))
require(request.authz.can_read(collection.id))
output = generate_excel(collection,
request.authz,
links=as_bool(request.args.get('links')),
one_sheet=as_bool(request.args.get('merge')))
outputfile = "%s Cross-referenced.xlsx" % collection.label
return send_file(output,
as_attachment=True,
attachment_filename=outputfile)
def decide(collection_id, xref_id):
"""
---
post:
summary: Give feedback about the veracity of an xref match.
description: >
This lets a user decide if they think a given xref match is a true or
false match, and what group of users (context) should be privy to this
insight.
parameters:
- in: path
name: collection_id
required: true
schema:
type: integer
- in: path
name: xref_id
required: true
schema:
type: string
requestBody:
content:
application/json:
schema:
$ref: '#/components/schemas/XrefDecide'
responses:
'202':
content:
application/json:
schema:
properties:
status:
description: accepted
type: string
type: object
description: Accepted
tags:
- Xref
- Profiles
- EntitySet
"""
data = parse_request("XrefDecide")
xref = obj_or_404(get_xref(xref_id, collection_id=collection_id))
require(request.authz.can(collection_id, request.authz.WRITE))
entity = get_index_entity(xref.get("entity_id"))
match = get_index_entity(xref.get("match_id"))
if entity is None and match is None:
# This will raise a InvalidData error if the two types are not compatible
model.common_schema(entity.get("schema"), match.get("schema"))
decide_xref(xref, judgement=data.get("decision"), authz=request.authz)
return jsonify({"status": "ok"}, status=204)
def download(export_id):
"""Downloads the exported file from the archive.
---
get:
summary: Download an export from the archive
parameters:
- description: export id
in: path
name: export_id
required: true
schema:
type: string
- description: Authorization token for an export
in: query
name: claim
required: false
schema:
type: string
description: A signed JWT with the object hash.
responses:
'200':
description: OK
content:
'*/*': {}
'404':
description: Object does not exist.
tags:
- Export
"""
require(request.authz.logged_in)
export = obj_or_404(Export.by_id(export_id, role_id=request.authz.id))
expires_after = export.expires_at - datetime.utcnow()
url = archive.generate_publication_url(
export.namespace,
export.content_hash,
mime_type=export.mime_type,
expire=expires_after.total_seconds(),
attachment_name=export.file_name,
)
if url is not None:
return redirect(url)
local_path = archive.load_publication(export.namespace,
export.content_hash)
if local_path is None:
raise NotFound()
return send_file(
str(local_path),
as_attachment=True,
conditional=True,
attachment_filename=export.file_name,
mimetype=export.mime_type,
)
def decide(collection_id, xref_id):
"""
---
post:
summary: Give feedback about the veracity of an xref match.
description: >
This lets a user decide if they think a given xref match is a true or
false match, and what group of users (context) should be privy to this
insight.
parameters:
- in: path
name: collection_id
required: true
schema:
type: integer
- in: path
name: xref_id
required: true
schema:
type: string
requestBody:
content:
application/json:
schema:
$ref: '#/components/schemas/XrefDecide'
responses:
'202':
content:
application/json:
schema:
properties:
status:
description: accepted
type: string
type: object
description: Accepted
tags:
- Xref
- Linkage
"""
data = parse_request('XrefDecide')
xref = obj_or_404(get_xref(xref_id, collection_id=collection_id))
context_id = int(data.get('context_id', request.authz.id))
require(request.authz.can_write_role(context_id))
decide_xref(xref,
decision=data.get('decision'),
context_id=context_id,
decider_id=request.authz.id)
return jsonify({'status': 'ok'}, status=204)
def ingest_upload(id):
collection = obj_or_404(Collection.by_id(id))
require(request.authz.can_write(collection.id))
meta, foreign_id = _load_metadata()
parent_id = _load_parent(collection, meta)
upload_dir = mkdtemp()
try:
documents = []
for storage in request.files.values():
path = safe_filename(storage.filename)
path = os.path.join(upload_dir, path)
storage.save(path)
content_hash = checksum(path)
document = Document.by_keys(collection=collection,
parent_id=parent_id,
foreign_id=foreign_id,
content_hash=content_hash)
document.mime_type = storage.mimetype
if storage.filename:
document.file_name = os.path.basename(storage.filename)
document.update(meta)
ingest_document(document, path,
role_id=request.authz.id)
documents.append(document)
if not len(request.files):
# If there is no files uploaded, try to create an empty
# directory instead. Maybe this should be more explicit,
# but it seemed like the most simple way of fitting it
# into the API.
document = Document.by_keys(collection=collection,
parent_id=parent_id,
foreign_id=foreign_id)
document.update(meta)
ingest_document(document, upload_dir,
role_id=request.authz.id)
documents.append(document)
finally:
shutil.rmtree(upload_dir)
# Update child counts in index.
if parent_id is not None:
index_document_id.delay(parent_id)
return jsonify({
'status': 'ok',
'documents': [DocumentSchema().dump(d).data for d in documents]
})
def update(collection_id, mapping_id):
"""Update the mapping with id `mapping_id`.
---
post:
summary: Update a mapping
parameters:
- description: The collection id.
in: path
name: collection_id
required: true
schema:
minimum: 1
type: integer
example: 2
- description: The mapping id.
in: path
name: mapping_id
required: true
schema:
minimum: 1
type: integer
example: 2
requestBody:
content:
application/json:
schema:
$ref: '#/components/schemas/MappingCreate'
responses:
'200':
content:
application/json:
schema:
$ref: '#/components/schemas/Mapping'
description: OK
tags:
- Collection
- Mapping
"""
get_db_collection(collection_id, request.authz.WRITE)
mapping = obj_or_404(Mapping.by_id(mapping_id))
data = parse_request("MappingCreate")
mapping.update(
query=load_query(),
table_id=get_table_id(data),
entityset_id=get_entityset_id(data),
)
db.session.commit()
return MappingSerializer.jsonify(mapping)
def update(id):
"""Change user settings.
---
post:
summary: Change user settings
description: >
Update a role to change its display name, or to define a
new login password. Users can only update roles they have
write access to, i.e. their own.
parameters:
- in: path
name: id
required: true
description: role ID
schema:
type: integer
requestBody:
content:
application/json:
schema:
$ref: '#/components/schemas/RoleUpdate'
responses:
'200':
description: OK
content:
application/json:
schema:
$ref: '#/components/schemas/Role'
tags:
- Role
"""
role = obj_or_404(Role.by_id(id))
require(request.authz.can_write_role(role.id))
data = parse_request("RoleUpdate")
# When changing passwords, check the old password first.
# cf. https://github.com/alephdata/aleph/issues/718
if data.get("password"):
current_password = data.get("current_password")
if not role.check_password(current_password):
raise BadRequest(gettext("Incorrect password."))
role.update(data)
db.session.add(role)
db.session.commit()
update_role(role)
return RoleSerializer.jsonify(role)
def update(id):
role = obj_or_404(Role.by_id(id))
require(request.authz.can_write_role(role.id))
data = parse_request(RoleSchema)
# When changing passwords, check the old password first.
# cf. https://github.com/alephdata/aleph/issues/718
if data.get('password'):
current_password = data.get('current_password')
if not role.check_password(current_password):
raise BadRequest(gettext('Incorrect password.'))
role.update(data)
db.session.add(role)
db.session.commit()
update_role(role)
return RoleSerializer.jsonify(role)
def update(collection_id, mapping_id):
"""Update the mapping with id `mapping_id`.
---
post:
summary: Update a mapping
parameters:
- description: The collection id.
in: path
name: collection_id
required: true
schema:
minimum: 1
type: integer
example: 2
- description: The mapping id.
in: path
name: mapping_id
required: true
schema:
minimum: 1
type: integer
example: 2
requestBody:
content:
application/json:
schema:
$ref: '#/components/schemas/MappingCreate'
responses:
'200':
content:
application/json:
schema:
$ref: '#/components/schemas/Mapping'
description: OK
tags:
- Collection
"""
get_db_collection(collection_id, request.authz.WRITE)
mapping = obj_or_404(Mapping.by_id(mapping_id))
data = parse_request('MappingCreate')
entity_id = data.get('table_id')
query = load_query()
entity = get_index_entity(entity_id, request.authz.READ)
mapping.update(query=query, table_id=entity.get('id'))
return MappingSerializer.jsonify(mapping)
def flush(collection_id, mapping_id):
"""Flush all entities loaded by mapping with id `mapping_id`.
---
post:
summary: Flush entities loaded by a mapping
parameters:
- description: The collection id.
in: path
name: collection_id
required: true
schema:
minimum: 1
type: integer
example: 2
- description: The mapping id.
in: path
name: mapping_id
required: true
schema:
minimum: 1
type: integer
example: 2
responses:
'202':
description: No Content
tags:
- Collection
- Mapping
"""
collection = get_db_collection(collection_id, request.authz.WRITE)
mapping = obj_or_404(Mapping.by_id(mapping_id))
mapping.disabled = True
mapping.last_run_status = None
mapping.last_run_err_msg = None
db.session.add(mapping)
db.session.commit()
queue_task(
collection,
OP_FLUSH_MAPPING,
job_id=get_session_id(),
mapping_id=mapping_id,
)
return ("", 202)
def view(profile_id):
"""
---
get:
summary: Retrieve a profile
description: >-
Get a profile with constituent items and the merged pseudo entity.
responses:
'200':
description: OK
content:
application/json:
schema:
$ref: '#/components/schemas/Profile'
tags:
- Profile
"""
profile = obj_or_404(get_profile(profile_id, authz=request.authz))
require(request.authz.can(profile.get("collection_id"),
request.authz.READ))
return ProfileSerializer.jsonify(profile)
def trigger(collection_id, mapping_id):
"""Load entities by running the mapping with id `mapping_id`. Flushes
previously loaded entities before loading new entities.
---
post:
summary: Load entities from a mapping
parameters:
- description: The collection id.
in: path
name: collection_id
required: true
schema:
minimum: 1
type: integer
example: 2
- description: The mapping id.
in: path
name: mapping_id
required: true
schema:
minimum: 1
type: integer
example: 2
responses:
'202':
description: No Content
tags:
- Collection
- Mapping
"""
collection = get_db_collection(collection_id, request.authz.WRITE)
mapping = obj_or_404(Mapping.by_id(mapping_id))
job_id = get_session_id()
payload = {'mapping_id': mapping.id}
queue_task(collection, OP_LOAD_MAPPING, job_id=job_id, payload=payload)
collection.touch()
db.session.commit()
return ('', 202)
def flush(collection_id, mapping_id):
"""Flush all entities loaded by mapping with id `mapping_id`.
---
post:
summary: Flush entities loaded by a mapping
parameters:
- description: The collection id.
in: path
name: collection_id
required: true
schema:
minimum: 1
type: integer
example: 2
- description: The mapping id.
in: path
name: mapping_id
required: true
schema:
minimum: 1
type: integer
example: 2
responses:
'202':
description: No Content
tags:
- Collection
- Mapping
"""
collection = get_db_collection(collection_id, request.authz.WRITE)
mapping = obj_or_404(Mapping.by_id(mapping_id))
queue_task(collection,
OP_FLUSH_MAPPING,
job_id=get_session_id(),
payload={'mapping_id': mapping.id})
return ('', 202)
def update(diagram_id):
"""Update the diagram with id `diagram_id`.
---
post:
summary: Update a diagram
parameters:
- description: The diagram id.
in: path
name: diagram_id
required: true
schema:
minimum: 1
type: integer
example: 2
requestBody:
content:
application/json:
schema:
$ref: '#/components/schemas/DiagramUpdate'
responses:
'200':
content:
application/json:
schema:
$ref: '#/components/schemas/Diagram'
description: OK
tags:
- Diagram
"""
diagram = obj_or_404(Diagram.by_id(diagram_id))
collection = get_db_collection(diagram.collection_id, request.authz.WRITE)
data = parse_request('DiagramUpdate')
diagram.update(data, collection)
collection.touch()
db.session.commit()
return DiagramSerializer.jsonify(diagram)
def tags(profile_id):
"""
---
get:
summary: Get profile tags
description: >-
Get tags for the profile with id `profile_id`.
parameters:
- in: path
name: profile_id
required: true
schema:
type: string
responses:
'200':
description: OK
content:
application/json:
schema:
type: object
allOf:
- $ref: '#/components/schemas/QueryResponse'
properties:
results:
type: array
items:
$ref: '#/components/schemas/EntityTag'
tags:
- Profile
"""
profile = obj_or_404(get_profile(profile_id, authz=request.authz))
require(request.authz.can(profile.get("collection_id"),
request.authz.READ))
tag_request(collection_id=profile.get("collection_id"))
results = entity_tags(profile["merged"], request.authz)
return jsonify({"status": "ok", "total": len(results), "results": results})
def view(collection_id, mapping_id):
"""Return the mapping with id `mapping_id`.
---
get:
summary: Fetch a mapping
parameters:
- description: The collection id.
in: path
name: collection_id
required: true
schema:
minimum: 1
type: integer
example: 2
- description: The mapping id.
in: path
name: mapping_id
required: true
schema:
minimum: 1
type: integer
example: 2
responses:
'200':
content:
application/json:
schema:
$ref: '#/components/schemas/Mapping'
description: OK
tags:
- Collection
- Mapping
"""
get_db_collection(collection_id, request.authz.WRITE)
mapping = obj_or_404(Mapping.by_id(mapping_id))
return MappingSerializer.jsonify(mapping)
def delete(id):
require(request.authz.session_write)
alert = obj_or_404(Alert.by_id(id, role=request.authz.role))
alert.delete()
db.session.commit()
return jsonify({'status': 'ok'})
def view(id):
require(request.authz.logged_in)
alert = obj_or_404(Alert.by_id(id, role=request.authz.role))
return jsonify(alert, schema=AlertSchema)
def view(alert_id):
require(request.authz.logged_in)
alert = obj_or_404(Alert.by_id(alert_id, role_id=request.authz.id))
return AlertSerializer.jsonify(alert)
def delete(alert_id):
require(request.authz.session_write)
alert = obj_or_404(Alert.by_id(alert_id, role_id=request.authz.id))
alert.delete()
db.session.commit()
return ('', 204)
def view(id):
role = obj_or_404(Role.by_id(id))
require(check_editable(role, request.authz))
return RoleSerializer.jsonify(role)
