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)