def get(self, project_id):
user_id = g.current_user.id
# Gets a document not contributed
# :: Looks for not completed documents in projects assigned to user
subquery = db.session.query(AnnotationSet.document_id, func.count(AnnotationSet.user_id).label('frequency')) \
.group_by(AnnotationSet.document_id) \
.subquery()
document = Document.query \
.filter_by(project_id=project_id) \
.join(Project, Project.id == Document.project_id) \
.outerjoin(subquery, Document.id == subquery.c.document_id) \
.filter(or_(subquery.c.frequency.is_(None), Project.redundancy > subquery.c.frequency)) \
.join(UserRole, UserRole.project_id == Project.id) \
.filter(UserRole.user_id == user_id) \
.outerjoin(AnnotationSet, and_(AnnotationSet.document_id == Document.id,
AnnotationSet.user_id == UserRole.user_id), ) \
.filter(and_(or_(AnnotationSet.completed.is_(None), AnnotationSet.completed.is_(False)),
or_(AnnotationSet.skipped.is_(None), AnnotationSet.skipped.is_(False)))) \
.first()
if document is not None:
document_data = DocumentSchema().dump(document)
document_data['project'] = ProjectSchema().dump(document.project)
document_data['project']['tasks'] = TaskSchema().dump(
document.project.tasks, many=True)
annotation_set = op.get_annotation_set(user_id, document.id)
annotation_set_data = AnnotationSetSchema().dump(annotation_set)
return js.success({
'document': document_data,
'annotation_set': annotation_set_data
})
return js.success()
def get(self):
check = bool(request.args.get('check', False))
if check:
return js.success()
token = generate_token(g.current_user)
user_schema = UserSchema()
current_user = user_schema.dump(g.current_user)
return js.success({
'token': token.decode('ascii'),
'user': current_user
})
def post(self, project_id):
# authenticate
project = get_project(project_id)
# Validate
assert project is not None, {
'data': {
'_root': 'Invalid project. Please try with a valid project ID.'
}
}
data = request.get_json()
data.update({'project_id': project_id})
labels = utils.iferror(lambda: data['labels'], [])
schema = TaskSchema()
data = schema.load(data, unknown=EXCLUDE)
task = Task(**data)
task.labels[:] = []
for label_data in labels:
label = None
if 'id' in label_data:
label_id = label_data['id']
label = Label.query.get(label_id)
if label is None: # create if label not found
label_schema = LabelSchema()
label_data = label_schema.load(label_data)
label = Label(**label_data)
task.labels.append(label)
op.create_object(task)
data = schema.dump(task)
return js.success(data)
def delete(self, project_id, document_id):
# Authenticate and get
document = get_document(document_id)
# delete document
op.delete_object(document)
# return success
return js.success()
def post(self, project_id):
# Authenticate & get
project = get_project(project_id)
# Validate
assert project is not None, {
'data': {
'_root': 'Invalid project. Please try with a valid project ID.'
}
}
payload = request.get_json()
# get user id
assert 'username' in payload, {
'username': ['Required field \'username\' not found.']
}
username = payload['username']
user = User.query.filter_by(username=username).one_or_none()
assert user is not None, {'_root': ['No such user in the system.']}
payload.update({'user_id': user.id, 'project_id': project_id})
# create object
schema = UserRoleSchema()
data = schema.load(payload, unknown=EXCLUDE)
role_assignment = UserRole(**data)
op.create_object(role_assignment)
data = schema.dump(role_assignment)
return js.success(data)
def delete(self, project_id):
# get payload
payload = request.get_json()
# validate params
assert 'username' in payload, {
'username': ['Required field \'username\' not found.']
}
# authenticate
project = get_project(project_id)
# validate
assert project is not None, {
'data': {
'_root': ['Invalid project. Please enter a valid project ID.']
}
}
user = User.query.filter_by(username=payload['username']).one_or_none()
assert user is not None, {'_root': ['No such user in the system.']}
role = UserRole.query.filter_by(project_id=project_id,
user_id=user.id).one_or_none()
assert role is not None, {
'data': {
'_root': ['Role not assigned to provided user.']
}
}
op.delete_object(role)
return js.success()
def flag_document(self, data):
user_id, document_id = data['user_id'], data['document_id']
annotation_set = op.get_annotation_set(user_id, document_id)
op.update_object(annotation_set,
{'flagged': not annotation_set.flagged})
data = AnnotationSetSchema().dump(annotation_set)
return js.success(data)
def put(self, project_id, task_id):
# authenticate
task = get_task(task_id)
# validate input
data = request.get_json()
data.update({'project_id': project_id})
schema = TaskSchema()
data_labels = data['labels']
data = schema.load(data, unknown=EXCLUDE)
# update object
task.labels[:] = []
for data_label in data_labels:
label = None
if 'id' in data_label:
label_id = data_label['id']
label = Label.query.get(label_id)
if label is None: # create if label not found
label_schema = LabelSchema()
data_label = label_schema.load(data_label)
label = Label(**data_label)
else:
op.update_object(label, data_label, commit=False)
task.labels.append(label)
op.update_object(task, data)
# return status
data = schema.dump(task)
return js.success(data)
def delete(self, user_id):
# Assert project authorization for authenticated user
assert g.current_user.id == user_id, {
'_root': ['You are not authorized to delete another account.']
}
user = User.query.get(user_id)
op.delete_object(user)
return js.success()
def put(self, project_id):
data = request.get_json()
schema = ProjectSchema()
schema.load(data, partial=True, unknown=EXCLUDE)
project = get_project(project_id)
op.update_object(project, data)
data = schema.dump(project)
return js.success(data)
def put(self, project_id, document_id):
# get params
data = request.get_json()
# Authenticate and get
document = get_document(document_id)
# update object
op.update_object(document, data)
# return updated
data = DocumentSchema().dump(document)
return js.success(data)
def get(self):
search = None
if 'q' in request.args:
search = request.args.get('q')
query = User.query
if search is not None:
query = query.filter(User.username.contains(search))
users = query.all()
data = UserSchema().dump(users, many=True)
return js.success(data)
def post(self):
data = request.get_json()
# add user details as owner
data['owner_id'] = g.current_user.id
schema = ProjectSchema()
data = schema.load(data, unknown=EXCLUDE)
project = Project(**data)
# Create project (do not commit)
op.create_object(project)
data = schema.dump(project)
return js.success(data)
def get(self, project_id):
# Assert project authorization for authenticated user
user_id = g.current_user.id
tasks = Task.query \
.join(Project, Project.id == Task.project_id) \
.join(UserRole, UserRole.project_id == Project.id, isouter=True) \
.filter(or_(and_(UserRole.user_id == user_id, UserRole.role == 'admin'),
Project.owner_id == user_id)) \
.filter_by(project_id=project_id) \
.all()
data = TaskSchema().dump(tasks, many=True)
return js.success(data)
def get(self, project_id):
user_id = g.current_user.id
try:
offset = int(request.args.get('offset', 1))
except ValueError as _:
offset = 1
try:
limit = int(request.args.get('limit', 20))
except ValueError as _:
limit = 20
query = db.session.query(Document, AnnotationSet) \
.join(AnnotationSet, AnnotationSet.document_id == Document.id, isouter=True) \
.join(Project, Project.id == Document.project_id) \
.join(UserRole, UserRole.project_id == Project.id) \
.filter(and_(or_(UserRole.user_id == user_id, Project.owner_id == user_id),
Document.project_id == project_id))
# Filter by flagged options
var = request.args.get('flagged', None)
if var != 'none':
if isinstance(var, str):
var = var == 'true'
else:
var = bool(var)
query = query.filter(AnnotationSet.flagged.is_(var))
# Filter by status options
status = request.args.get('status', None)
if status == 'completed':
query = query.filter(AnnotationSet.completed.is_(True))
elif status == 'skipped':
query = query.filter(AnnotationSet.skipped.is_(True))
elif status == 'active':
query = query.filter(
or_(AnnotationSet.id.is_(None),
AnnotationSet.completed.is_(False)))
paginate = utils.paginate(query, limit, offset)
# update structure
items = []
for doc, annotation_set in paginate.items:
data = DocumentSchema().dump(doc)
data.update(
{'annotation_set': AnnotationSetSchema().dump(annotation_set)})
items.append(data)
return js.success({
'pagination': {
'page': paginate.page,
'pages': paginate.pages,
'has_prev': paginate.has_prev,
'has_next': paginate.has_next,
'per_page': paginate.per_page,
'total': paginate.total,
'items': items,
},
})
def get(self, project_id):
# Authenticate & get
project = get_project(project_id)
# Validate
assert project is not None, {
'data': {
'_root': 'Invalid project. Please try with a valid project ID.'
}
}
# return
data = UserRoleSchema().dump(project.user_roles, many=True)
return js.success(data)
def put(self, user_id):
# Assert project authorization for authenticated user
assert g.current_user.id == user_id, {
'_root': ['You are not authorized to update another account.']
}
payload = request.get_json()
schema = UserSchema()
data = schema.load(payload, unknown=EXCLUDE)
if 'password' in data:
data['password'] = hash_password(data['password'])
user = User.query.get(user_id)
op.update_object(user, data)
data = schema.dump(user)
return js.success(data)
def get(self, project_id, document_id):
document = get_document(document_id)
assert document is not None, {'_root': ['Document not found.']}
document_data = DocumentSchema().dump(document)
document_data['project'] = ProjectSchema().dump(document.project)
document_data['project']['tasks'] = TaskSchema().dump(
document.project.tasks, many=True)
user_id = g.current_user.id
annotation_set = op.get_annotation_set(user_id, document.id)
annotation_set_data = AnnotationSetSchema().dump(annotation_set)
data = {
'document': document_data,
'annotation_set': annotation_set_data
}
return js.success(data)
def post(self):
payload = request.get_json()
schema = UserSchema()
data = schema.load(payload, unknown=EXCLUDE)
if 'password' in data:
data['password'] = hash_password(data['password'])
user = User(**data)
assert User.query.filter_by(username=user.username).count() == 0, {
'_root': [
'Username already exists in the system. Please try another username.'
]
}
op.create_object(user)
data = schema.dump(user)
return js.success(data)
def get(self):
offset = request.args.get('offset', None)
limit = request.args.get('limit', None)
user_id = g.current_user.id
query = Project.query \
.join(UserRole, UserRole.project_id == Project.id, isouter=True) \
.filter(or_(Project.owner_id == user_id, and_(UserRole.user_id == user_id, UserRole.role == 'admin')))
paginate = utils.paginate(query, limit, offset)
data = ProjectSchema().dump(paginate.items, many=True)
return js.success({
'pagination': {
'page': paginate.page,
'pages': paginate.pages,
'has_prev': paginate.has_prev,
'has_next': paginate.has_next,
'per_page': paginate.per_page,
'total': paginate.total,
'items': data,
},
})
def save_document(self, data):
user_id, document_id, annotations = data['user_id'], data[
'document_id'], data['annotations']
# Delete existing annotations
annotation_set = op.get_annotation_set(user_id, document_id)
query = Annotation.query.filter_by(annotation_set_id=annotation_set.id)
op.delete_object(query, True)
# Create new annotations
schema = AnnotationSchema()
for a in annotations:
a['annotation_set_id'] = annotation_set.id
data = schema.load(annotations, many=True)
annotations = []
for a in data:
span = None
if 'span' in a:
s = a.pop('span')
span = AnnotationSpan(**s)
a = Annotation(**a)
a.span = span
annotations.append(a)
op.create_object(annotations, many=True)
op.update_object(annotation_set, {'completed': True})
return js.success()
def post(self, project_id):
# Authorize & Validate
assert get_project(project_id) is not None, {
'data': {
'_root': 'Invalid project. Please try with a valid project ID.'
}
}
if 'file' in request.files:
file = request.files['file']
payload = self.process_file(file)
else:
payload = request.get_json()
if isinstance(payload, list):
for d in payload:
d.update({'project_id': project_id})
data = DocumentSchema().load(payload, many=True, unknown=EXCLUDE)
documents = [Document(**d) for d in data]
op.create_object(documents, many=True)
else:
payload.update({'project_id': project_id})
data = DocumentSchema().load(payload, unknown=EXCLUDE)
document = Document(**data)
op.create_object(document)
return js.success()
def skip_document(self, data):
user_id, document_id = data['user_id'], data['document_id']
annotation_set = op.get_annotation_set(user_id, document_id)
op.update_object(annotation_set, {'skipped': True})
data = AnnotationSetSchema().dump(annotation_set)
return js.success(data)
def get(self, project_id):
project = get_project(project_id)
data = ProjectSchema().dump(project)
return js.success(data)
def delete(self, project_id):
project = get_project(project_id)
op.delete_object(project)
return js.success()
def get(self, project_id, task_id):
# authorize & get
task = get_task(task_id)
data = TaskSchema().dump(task)
return js.success(data)
def delete(self, project_id, task_id):
# authenticate
task = get_task(task_id)
# delete object
op.delete_object(task)
return js.success()
