def create():
"""Create an entityset.
---
post:
summary: Create an entityset
requestBody:
content:
application/json:
schema:
$ref: '#/components/schemas/EntitySetCreate'
responses:
'200':
content:
application/json:
schema:
$ref: '#/components/schemas/EntitySet'
description: OK
tags:
- EntitySet
"""
data = parse_request("EntitySetCreate")
collection = get_nested_collection(data, request.authz.WRITE)
entityset = create_entityset(collection, data, request.authz)
db.session.commit()
return EntitySetSerializer.jsonify(entityset)
def update(entityset_id):
"""Update the entityset with id `entityset_id`.
---
post:
summary: Update an entityset
parameters:
- description: The entityset id.
in: path
name: entityset_id
required: true
schema:
type: string
example: 3a0d91ece2dce88ad3259594c7b642485235a048
requestBody:
content:
application/json:
schema:
$ref: '#/components/schemas/EntitySetUpdate'
responses:
'200':
content:
application/json:
schema:
$ref: '#/components/schemas/EntitySet'
description: OK
tags:
- EntitySet
"""
entityset = get_entityset(entityset_id, request.authz.WRITE)
data = parse_request("EntitySetUpdate")
entityset.update(data)
db.session.commit()
return EntitySetSerializer.jsonify(entityset)
def update(id):
collection = get_db_collection(id, request.authz.WRITE)
data = parse_request(CollectionSchema)
collection.update(data)
db.session.commit()
update_collection(collection)
return serialize_data(collection, CollectionSchema)
def create():
require(request.authz.logged_in)
data = parse_request(CollectionSchema)
role = Role.by_id(request.authz.id)
collection = create_collection(data, role=role)
refresh_index(collections_index())
return view(collection.id)
def create():
"""Creates an alert for a given query string.
---
post:
summary: Create an alert
requestBody:
content:
application/json:
schema:
$ref: '#/components/schemas/AlertCreate'
responses:
'200':
content:
application/json:
schema:
$ref: '#/components/schemas/Alert'
description: OK
tags:
- Alert
"""
require(request.authz.session_write)
data = parse_request("AlertCreate")
alert = Alert.create(data, request.authz.id)
db.session.commit()
tag_request(alert_id=alert.id)
return AlertSerializer.jsonify(alert)
def update(id):
collection = get_collection(id, request.authz.WRITE)
data = parse_request(schema=CollectionSchema)
collection.update(data)
db.session.commit()
update_collection(collection)
return view(id)
def create():
require(not request.authz.in_maintenance, settings.PASSWORD_LOGIN)
data = parse_request(RoleCreateSchema)
try:
email = Role.SIGNATURE.loads(data.get('code'),
max_age=Role.SIGNATURE_MAX_AGE)
except BadSignature:
return jsonify({
'status': 'error',
'message': gettext('Invalid code')
}, status=400)
role = Role.by_email(email)
if role is not None:
return jsonify({
'status': 'error',
'message': gettext('Email is already registered')
}, status=409)
role = Role.load_or_create(
foreign_id='password:{}'.format(email),
type=Role.USER,
name=data.get('name') or email,
email=email
)
role.set_password(data.get('password'))
db.session.add(role)
db.session.commit()
update_role(role)
# Let the serializer return more info about this user
request.authz.id = role.id
tag_request(role_id=role.id)
return RoleSerializer.jsonify(role, status=201)
def create_code():
data = parse_request(RoleCodeCreateSchema)
challenge_role(data)
return jsonify({
'status': 'ok',
'message': gettext('To proceed, please check your email.')
})
def create():
require(request.authz.session_write)
data = parse_request(AlertSchema)
alert = Alert.create(data, request.authz.id)
db.session.commit()
tag_request(alert_id=alert.id)
return AlertSerializer.jsonify(alert)
def create_code():
data = parse_request(RoleCodeCreateSchema)
challenge_role(data)
return jsonify({
'status': 'ok',
'message': gettext('To proceed, please check your email.')
})
def create():
require(not request.authz.in_maintenance, settings.PASSWORD_LOGIN)
data = parse_request(schema=RoleCreateSchema)
try:
email = Role.SIGNATURE.loads(data.get('code'),
max_age=Role.SIGNATURE_MAX_AGE)
except BadSignature:
return jsonify({
'status': 'error',
'message': 'Invalid code'
},
status=400)
role = Role.by_email(email).first()
if role is not None:
return jsonify(
{
'status': 'error',
'message': 'Email is already registered'
},
status=409)
role = Role.load_or_create(foreign_id='password:{}'.format(email),
type=Role.USER,
name=data.get('name') or email,
email=email)
role.set_password(data.get('password'))
db.session.add(role)
db.session.commit()
# Let the serializer return more info about this user
request.authz.id = role.id
return jsonify(role, schema=RoleSchema, status=201)
def create():
require(request.authz.logged_in)
data = parse_request(CollectionCreateSchema)
role = Role.by_id(request.authz.id)
sync = get_flag('sync')
collection = create_collection(data, role=role, sync=sync)
return CollectionSerializer.jsonify(collection)
def create():
require(not request.authz.in_maintenance,
get_config('PASSWORD_REGISTRATION'))
data = parse_request(schema=RoleCreateSchema)
try:
code = data.get('code')
email = Role.SIGNATURE.loads(code, max_age=Role.SIGNATURE_MAX_AGE)
assert email == data.get('email')
except Exception:
raise BadRequest("Invalid signature")
role = Role.by_email(email).first()
status = 200
if role is None:
status = 201
role = Role.load_or_create(
foreign_id='password:{}'.format(email),
type=Role.USER,
name=data.get('name') or email,
email=email
)
role.set_password(data.get('password'))
db.session.add(role)
db.session.commit()
request.authz.id = role.id
return jsonify(role, schema=RoleSchema, status=status)
def create():
"""Create a diagram.
---
post:
summary: Create a diagram
requestBody:
content:
application/json:
schema:
$ref: '#/components/schemas/DiagramCreate'
responses:
'200':
content:
application/json:
schema:
$ref: '#/components/schemas/Diagram'
description: OK
tags:
- Diagram
"""
data = parse_request('DiagramCreate')
collection = get_nested_collection(data, request.authz.WRITE)
old_to_new_id_map = {}
entity_ids = []
for entity in data.pop('entities', []):
old_id = entity.get('id')
new_id = upsert_entity(entity, collection, sync=True)
old_to_new_id_map[old_id] = new_id
entity_ids.append(new_id)
data['entities'] = entity_ids
layout = data.get('layout', {})
data['layout'] = replace_layout_ids(layout, old_to_new_id_map)
diagram = Diagram.create(data, collection, request.authz.id)
db.session.commit()
return DiagramSerializer.jsonify(diagram)
def create():
"""
---
post:
summary: Create an entity in a collection
description: >-
Create an entity in a collection with a given schema and a set of given
properties in the database. This is not the API you want to be using to
load bulk data, but only for interactive entity manipulation in the UI.
Always use the `bulk` API or for loading source datasets, no
exceptions.
requestBody:
content:
application/json:
schema:
$ref: '#/components/schemas/EntityCreate'
responses:
'200':
description: Resturns the created entity
content:
application/json:
schema:
$ref: '#/components/schemas/Entity'
tags:
- Entity
"""
data = parse_request('EntityCreate')
collection = get_nested_collection(data, request.authz.WRITE)
data.pop('id', None)
validate = get_flag('validate', default=False)
entity_id = upsert_entity(data, collection, sync=True, validate=validate)
tag_request(entity_id=entity_id, collection_id=str(collection.id))
entity = get_index_entity(entity_id, request.authz.READ)
return EntitySerializer.jsonify(entity)
def update(id):
collection = get_db_collection(id, request.authz.WRITE)
data = parse_request(CollectionSchema)
collection.update(data)
db.session.commit()
data = update_collection(collection)
return jsonify(data, schema=CollectionSchema)
def create_code():
"""Send a account creation token to an email address.
---
post:
summary: Begin account registration
description: >
Begin validating a user email by sending a token to the address
which can then be used to create an account.
requestBody:
content:
application/json:
schema:
$ref: '#/components/schemas/RoleCodeCreate'
responses:
'200':
description: OK
content:
application/json:
schema:
type: object
properties:
status:
type: string
token:
type: string
tags:
- Role
"""
require(request.authz.can_register())
data = parse_request("RoleCodeCreate")
challenge_role(data)
return jsonify({
"status": "ok",
"message": gettext("To proceed, please check your email.")
})
def create():
"""
---
post:
summary: Create a collection
description: Create a collection with the given metadata
requestBody:
content:
application/json:
schema:
$ref: '#/components/schemas/CollectionCreate'
tags:
- Collection
responses:
'200':
description: OK
content:
application/json:
schema:
$ref: '#/components/schemas/Collection'
"""
require(request.authz.logged_in)
data = parse_request('CollectionCreate')
sync = get_flag('sync')
collection = create_collection(data, request.authz, sync=sync)
return CollectionSerializer.jsonify(collection)
def update(document_id):
document = get_db_document(document_id, request.authz.WRITE)
data = parse_request(DocumentUpdateSchema)
document.update(data)
db.session.commit()
update_document(document, shallow=True, sync=get_flag('sync', True))
return view(document_id)
def create():
require(request.authz.logged_in)
data = parse_request(CollectionSchema)
role = Role.by_id(request.authz.id)
sync = get_flag('sync')
collection = create_collection(data, role=role, sync=sync)
return serialize_data(collection, CollectionSchema)
def generate(collection_id):
data = parse_request(XrefSchema)
collection = get_db_collection(collection_id, request.authz.WRITE)
against = ensure_list(data.get("against_collection_ids"))
payload = {'against_collection_ids': against}
queue_task(collection, OP_XREF, payload=payload)
return jsonify({'status': 'accepted'}, status=202)
def create():
"""
---
post:
summary: Create a collection
description: Create a collection with the given metadata
requestBody:
content:
application/json:
schema:
$ref: '#/components/schemas/CollectionCreate'
tags:
- Collection
responses:
'200':
description: OK
content:
application/json:
schema:
$ref: '#/components/schemas/Collection'
"""
require(request.authz.logged_in)
data = parse_request("CollectionCreate")
sync = get_flag("sync", True)
collection = create_collection(data, request.authz, sync=sync)
return view(collection.get("id"))
def update(document_id):
document = get_document(document_id, request.authz.WRITE)
data = parse_request(schema=DocumentSchema)
document.update(data)
db.session.commit()
update_document(document)
return view(document_id)
def create():
require(request.authz.logged_in)
data = parse_request(CollectionSchema)
collection = Collection.create(data, request.authz.role)
db.session.commit()
update_collection(collection)
return view(collection.id)
def create():
data = parse_request(EntityCreateSchema)
collection = get_db_collection(data['collection_id'], request.authz.WRITE)
entity_id = create_entity(data, collection, sync=True)
tag_request(entity_id=entity_id, collection_id=str(collection.id))
entity = get_index_entity(entity_id, request.authz.READ)
return EntitySerializer.jsonify(entity)
def update(entity_id):
"""
---
post:
summary: Update an entity
description: >
Update the entity with id `entity_id`. This only applies to
entities which are backed by a database row, i.e. not any
entities resulting from a mapping or bulk load.
parameters:
- in: path
name: entity_id
required: true
schema:
type: string
format: entity_id
- in: query
name: sign
description: Sign entity IDs referenced in nested properties.
required: false
schema:
type: boolean
requestBody:
content:
application/json:
schema:
$ref: '#/components/schemas/EntityUpdate'
responses:
'200':
description: OK
content:
application/json:
schema:
$ref: '#/components/schemas/Entity'
tags:
- Entity
"""
data = parse_request("EntityUpdate")
try:
entity = get_index_entity(entity_id, request.authz.WRITE)
require(check_write_entity(entity, request.authz))
collection = get_db_collection(entity.get("collection_id"),
request.authz.WRITE)
except NotFound:
collection = get_nested_collection(data, request.authz.WRITE)
tag_request(collection_id=collection.id)
data["id"] = entity_id
if get_flag("validate", default=False):
validate_entity(data)
entity_id = upsert_entity(
data,
collection,
authz=request.authz,
sync=get_flag("sync", default=True),
sign=get_flag("sign", default=False),
job_id=get_session_id(),
)
db.session.commit()
return view(entity_id)
def generate(collection_id):
data = parse_request(XrefSchema)
collection = get_db_collection(collection_id, request.authz.WRITE)
args = {
"against_collection_ids": data.get("against_collection_ids")
}
xref_collection.apply_async([collection.id], kwargs=args, priority=5)
return jsonify({'status': 'accepted'}, status=202)
def create():
data = parse_request(schema=EntityCreateSchema)
collection = get_db_collection(data['collection_id'], request.authz.WRITE)
entity = Entity.create(data, collection)
db.session.commit()
update_entity(entity)
update_collection(collection)
return view(entity.id)
def update(collection_id):
collection = get_db_collection(collection_id, request.authz.WRITE)
data = parse_request(CollectionUpdateSchema)
sync = get_flag('sync')
collection.update(data)
db.session.commit()
data = update_collection(collection, sync=sync)
return CollectionSerializer.jsonify(data)
def update(collection_id):
collection = get_db_collection(collection_id, request.authz.WRITE)
data = parse_request(CollectionUpdateSchema)
sync = get_flag('sync')
collection.update(data, request.authz)
db.session.commit()
data = update_collection(collection, sync=sync)
return CollectionSerializer.jsonify(data)
def match():
entity = parse_request(EntityUpdateSchema)
record_audit(Audit.ACT_MATCH, entity=entity)
entity = model.get_proxy(entity)
collection_ids = request.args.getlist('collection_ids')
result = MatchQuery.handle(request, entity=entity,
collection_ids=collection_ids)
return EntitySerializer.jsonify_result(result)
def update(id):
collection = get_db_collection(id, request.authz.WRITE)
data = parse_request(CollectionSchema)
sync = get_flag('sync')
collection.update(data)
db.session.commit()
data = update_collection(collection, sync=sync)
return serialize_data(data, CollectionSchema)
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(document_id):
document = get_db_document(document_id, request.authz.WRITE)
data = parse_request(DocumentUpdateSchema)
document.update(data)
db.session.commit()
update_document(document)
update_collection(document.collection)
return view(document_id)
def match():
entity = parse_request(EntityUpdateSchema)
entity = model.get_proxy(entity)
tag_request(schema=entity.schema.name, caption=entity.caption)
collection_ids = request.args.getlist('collection_ids')
result = MatchQuery.handle(request, entity=entity,
collection_ids=collection_ids)
return EntitySerializer.jsonify_result(result)
def generate(id):
data = parse_request(XrefSchema)
collection = get_db_collection(id, request.authz.WRITE)
against_ids = data.get("against_collection_ids")
xref_collection.apply_async([collection.id],
kwargs={"against_collection_ids": against_ids},
priority=5)
return jsonify({'status': 'accepted'}, status=202)
def match():
entity = parse_request(EntityUpdateSchema)
record_audit(Audit.ACT_MATCH, entity=entity)
entity = model.get_proxy(entity)
tag_request(schema=entity.schema.name, caption=entity.caption)
collection_ids = request.args.getlist('collection_ids')
result = MatchQuery.handle(request, entity=entity,
collection_ids=collection_ids)
return EntitySerializer.jsonify_result(result)
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 update(entity_id):
entity = get_db_entity(entity_id, request.authz.WRITE)
tag_request(collection_id=entity.collection_id)
data = parse_request(EntityUpdateSchema)
if get_flag('merge'):
props = merge_data(data.get('properties'), entity.data)
data['properties'] = props
entity.update(data)
db.session.commit()
data = update_entity(entity, sync=get_flag('sync', True))
return EntitySerializer.jsonify(data)
def update(id):
collection = get_db_collection(id, request.authz.WRITE)
for permission in parse_request(PermissionSchema, many=True):
role_id = permission.get('role_id')
role = Role.by_id(role_id)
if not check_visible(role, request.authz):
continue
if role.is_public:
permission['write'] = False
if collection.casefile and role.is_public:
permission['read'] = False
update_permission(role,
collection,
permission['read'],
permission['write'],
editor_id=request.authz.id)
update_collection(collection)
return index(id)
def password_login():
"""Provides email and password authentication."""
data = parse_request(LoginSchema)
role = Role.by_email(data.get('email'))
if role is None or not role.has_password:
return Unauthorized("Authentication has failed.")
if not role.check_password(data.get('password')):
return Unauthorized("Authentication has failed.")
db.session.commit()
update_role(role)
authz = Authz.from_role(role)
request.authz = authz
record_audit(Audit.ACT_LOGIN)
return jsonify({
'status': 'ok',
'token': authz.to_token(role=role)
})
def create():
data = parse_request(EntityCreateSchema)
collection = get_db_collection(data['collection_id'], request.authz.WRITE)
data = create_entity(data, collection, sync=get_flag('sync', True))
tag_request(entity_id=data.get('id'), collection_id=str(collection.id))
return EntitySerializer.jsonify(data)
