def _serialize(self, obj):
pk = obj.get("id")
collection_id = obj.pop("collection_id", None)
obj["collection"] = self.resolve(
Collection, collection_id, CollectionSerializer
)
proxy = model.get_proxy(obj)
properties = obj.get("properties", {})
for prop in proxy.iterprops():
if prop.type != registry.entity:
continue
values = ensure_list(properties.get(prop.name))
properties[prop.name] = []
for value in values:
entity = self.resolve(Entity, value, EntitySerializer)
properties[prop.name].append(entity or value)
links = {
"self": url_for("entities_api.view", entity_id=pk),
"references": url_for("entities_api.references", entity_id=pk),
"tags": url_for("entities_api.tags", entity_id=pk),
"ui": entity_url(pk),
}
if proxy.schema.is_a(Document.SCHEMA):
content_hash = first(properties.get("contentHash"))
if content_hash:
name = entity_filename(proxy)
mime = first(properties.get("mimeType"))
links["file"] = archive_url(
content_hash,
file_name=name,
mime_type=mime,
expire=request.authz.expire,
)
pdf_hash = first(properties.get("pdfHash"))
if pdf_hash:
name = entity_filename(proxy, extension="pdf")
links["pdf"] = archive_url(
pdf_hash,
file_name=name,
mime_type=PDF,
expire=request.authz.expire,
)
csv_hash = first(properties.get("csvHash"))
if csv_hash:
name = entity_filename(proxy, extension="csv")
links["csv"] = archive_url(
csv_hash,
file_name=name,
mime_type=CSV,
expire=request.authz.expire,
)
obj["links"] = links
obj["latinized"] = transliterate_values(proxy)
obj["writeable"] = check_write_entity(obj, request.authz)
obj["shallow"] = obj.get("shallow", True)
return obj
def _serialize(self, obj):
pk = obj.get('id')
obj['id'] = str(pk)
authz = request.authz
collection_id = obj.pop('collection_id', None)
obj['collection'] = self.resolve(Collection, collection_id,
CollectionSerializer)
schema = model.get(obj.get('schema'))
if schema is None:
return None
obj['schemata'] = schema.names
properties = obj.get('properties', {})
for prop in schema.properties.values():
if prop.type != registry.entity:
continue
values = ensure_list(properties.get(prop.name))
properties[prop.name] = []
for value in values:
entity = self.resolve(Entity, value, EntitySerializer)
properties[prop.name].append(entity)
links = {
'self': url_for('entities_api.view', entity_id=pk),
'references': url_for('entities_api.references', entity_id=pk),
'tags': url_for('entities_api.tags', entity_id=pk),
'ui': entity_url(pk)
}
if schema.is_a(Document.SCHEMA):
links['content'] = url_for('entities_api.content', entity_id=pk)
file_name = first(properties.get('fileName'))
content_hash = first(properties.get('contentHash'))
if content_hash:
mime_type = first(properties.get('mimeType'))
name = safe_filename(file_name, default=pk)
links['file'] = archive_url(request.authz.id,
content_hash,
file_name=name,
mime_type=mime_type)
pdf_hash = first(properties.get('pdfHash'))
if pdf_hash:
name = safe_filename(file_name, default=pk, extension='.pdf')
links['pdf'] = archive_url(request.authz.id,
pdf_hash,
file_name=name,
mime_type=PDF)
csv_hash = first(properties.get('csvHash'))
if csv_hash:
name = safe_filename(file_name, default=pk, extension='.csv')
links['csv'] = archive_url(request.authz.id,
csv_hash,
file_name=name,
mime_type=CSV)
obj['links'] = links
obj['writeable'] = authz.can(collection_id, authz.WRITE)
obj.pop('_index', None)
return self._clean_response(obj)
def _serialize(self, obj):
pk = obj.get('id')
collection_id = obj.pop('collection_id', None)
obj['collection'] = self.resolve(Collection, collection_id,
CollectionSerializer)
proxy = model.get_proxy(obj)
obj['schemata'] = proxy.schema.names
properties = obj.get('properties', {})
for prop in proxy.iterprops():
if prop.type != registry.entity:
continue
values = ensure_list(properties.get(prop.name))
properties[prop.name] = []
for value in values:
entity = self.resolve(Entity, value, EntitySerializer)
properties[prop.name].append(entity or value)
links = {
'self': url_for('entities_api.view', entity_id=pk),
'references': url_for('entities_api.references', entity_id=pk),
'tags': url_for('entities_api.tags', entity_id=pk),
'ui': entity_url(pk)
}
if proxy.schema.is_a(Document.SCHEMA):
links['content'] = url_for('entities_api.content', entity_id=pk)
content_hash = first(properties.get('contentHash'))
if content_hash:
name = entity_filename(proxy)
mime_type = first(properties.get('mimeType'))
links['file'] = archive_url(request.authz.id,
content_hash,
file_name=name,
mime_type=mime_type)
pdf_hash = first(properties.get('pdfHash'))
if pdf_hash:
name = entity_filename(proxy, extension='pdf')
links['pdf'] = archive_url(request.authz.id,
pdf_hash,
file_name=name,
mime_type=PDF)
csv_hash = first(properties.get('csvHash'))
if csv_hash:
name = entity_filename(proxy, extension='csv')
links['csv'] = archive_url(request.authz.id,
csv_hash,
file_name=name,
mime_type=CSV)
obj['links'] = links
write = request.authz.WRITE
obj['writeable'] = request.authz.can(collection_id, write)
return obj
def test_anon_claim(self):
authz = Authz.from_role(None)
claim_url = archive_url(authz, self.content_hash, file_name="foo")
res = self.client.get(claim_url)
assert res.status_code == 200, res.status_code
disposition = res.headers.get("Content-Disposition")
assert "foo" in disposition, disposition
def _serialize(self, obj):
if obj.get("content_hash") and not obj.get("deleted"):
url = archive_url(
obj.get("content_hash"),
file_name=obj.get("file_name"),
mime_type=obj.get("mime_type"),
)
obj["links"] = {"download": url}
return obj
def _serialize(self, obj):
obj["links"] = {
"download": archive_url(
obj.get("content_hash"),
file_name=obj.get("file_name"),
mime_type=obj.get("mime_type"),
expire=request.authz.expire,
)
}
return obj
def render_notification(stub, notification):
"""Generate a text version of the notification, suitable for use
in an email or text message."""
from aleph.logic import resolver
notification = unpack_result(notification)
event = Events.get(notification.get("event"))
if event is None:
return
for name, clazz, value in _iter_params(notification, event):
resolver.queue(stub, clazz, value)
resolver.resolve(stub)
plain = str(event.template)
html = str(event.template)
for name, clazz, value in _iter_params(notification, event):
data = resolver.get(stub, clazz, value)
if data is None:
return
link, title = None, None
if clazz == Role:
title = data.get("label")
elif clazz == Alert:
title = data.get("query")
elif clazz == Collection:
title = data.get("label")
link = collection_url(value)
elif clazz == Entity:
proxy = model.get_proxy(data)
title = proxy.caption
link = entity_url(value)
elif clazz == EntitySet:
title = data.label
link = entityset_url(data.id)
elif clazz == Export:
title = data.get("label")
link = archive_url(
data.get("content_hash"),
file_name=data.get("file_name"),
mime_type=data.get("file_name"),
)
link = url_for("exports_api.download", export_id=data.get("id"))
template = "{{%s}}" % name
html = html.replace(template, html_link(title, link))
plain = plain.replace(template, "'%s'" % title)
if name == event.link_to:
plain = "%s (%s)" % (plain, link)
return {"plain": plain, "html": html}
def send_export_notification(export):
download_url = archive_url(
export.content_hash,
file_name=export.file_name,
mime_type=export.mime_type,
expire=export.expires_at,
)
params = dict(
role=export.creator,
export_label=export.label,
download_url=download_url,
expiration_date=export.expires_at.strftime("%Y-%m-%d"),
exports_url=ui_url("exports"),
ui_url=settings.APP_UI_URL,
app_title=settings.APP_TITLE,
)
plain = render_template("email/export.txt", **params)
html = render_template("email/export.html", **params)
log.info("Notification: %s", plain)
subject = "Export ready for download"
email_role(export.creator, subject, html=html, plain=plain)
def test_with_token(self):
claim_url = archive_url(self.content_hash, file_name="foo")
res = self.client.get(claim_url)
assert res.status_code == 200, res.status_code
disposition = res.headers.get("Content-Disposition")
assert "foo" in disposition, disposition
def _serialize(self, obj):
pk = obj.get("id")
proxy = model.get_proxy(obj)
properties = {}
for prop, value in proxy.itervalues():
properties.setdefault(prop.name, [])
if prop.type == registry.entity:
entity = self.resolve(Entity, value, EntitySerializer)
value = entity or value
if value is not None:
properties[prop.name].append(value)
obj["properties"] = properties
links = {
"self": url_for("entities_api.view", entity_id=pk),
"expand": url_for("entities_api.expand", entity_id=pk),
"tags": url_for("entities_api.tags", entity_id=pk),
"ui": entity_url(pk),
}
if proxy.schema.is_a(Document.SCHEMA):
content_hash = proxy.first("contentHash", quiet=True)
if content_hash:
name = entity_filename(proxy)
mime = proxy.first("mimeType", quiet=True)
links["file"] = archive_url(content_hash,
file_name=name,
mime_type=mime)
pdf_hash = proxy.first("pdfHash", quiet=True)
if pdf_hash:
name = entity_filename(proxy, extension="pdf")
links["pdf"] = archive_url(pdf_hash,
file_name=name,
mime_type=PDF)
csv_hash = proxy.first("csvHash", quiet=True)
if csv_hash:
name = entity_filename(proxy, extension="csv")
links["csv"] = archive_url(csv_hash,
file_name=name,
mime_type=CSV)
collection = obj.get("collection") or {}
coll_id = obj.pop("collection_id", collection.get("id"))
# This is a last resort catcher for entities nested in other
# entities that get resolved without regard for authz.
if not request.authz.can(coll_id, request.authz.READ):
return None
obj["collection"] = self.resolve(Collection, coll_id,
CollectionSerializer)
role_id = obj.pop("role_id", None)
obj["role"] = self.resolve(Role, role_id, RoleSerializer)
obj["links"] = links
obj["latinized"] = transliterate_values(proxy)
obj["writeable"] = check_write_entity(obj, request.authz)
obj["shallow"] = obj.get("shallow", True)
# Phasing out multi-values here (2021-01):
obj["created_at"] = min(ensure_list(obj.get("created_at")),
default=None)
obj["updated_at"] = max(ensure_list(obj.get("updated_at")),
default=None)
return obj
def test_anon_claim(self):
claim_url = archive_url(None, self.content_hash, file_name='foo')
res = self.client.get(claim_url)
assert res.status_code == 200, res.status_code
disposition = res.headers.get('Content-Disposition')
assert 'foo' in disposition, disposition
def test_anon_claim(self):
claim_url = archive_url(None, self.content_hash, file_name='foo')
res = self.client.get(claim_url)
assert res.status_code == 200, res.status_code
disposition = res.headers.get('Content-Disposition')
assert 'foo' in disposition, disposition
