def test_to_json(self):
fe1 = FieldError("field", "not filled in", True)
fe2 = FieldError("email", "obviously wrong", False)
ve = ValidationError([fe1, fe2])
ref = [{
"name": "field",
"error": "not filled in",
"warning": True
}, {
"name": "email",
"error": "obviously wrong",
"warning": False
}]
self.assertEqual(ve.to_json(), ref)
def change_password(self, user: InternalUser, old_password: str, new_password: str,
check_password: bool) -> ValidationError:
if check_password:
# Check the credentials
status = bcrypt.checkpw(old_password.encode("utf8"), user.password)
if not status:
return ValidationError([FieldError("password", "must match original", False)])
new_hash = bcrypt.hashpw(new_password.encode("utf8"), bcrypt.gensalt())
user.password = new_hash
user.password_reset_needed = not check_password
self.storage.commit()
t = TokenController(self.storage)
t.remove_tokens_for_user(user)
def on_patch(self, req, resp, arg1, arg2):
key = None
if req.user.role != UserKind.ADMINISTRATOR.value \
and req.user.role != UserKind.STAFF.value:
key = req.user.random_seed
database_id = req.recover_int64_field(arg1, key)
assignment_controller = AssignmentController(req.session)
decoded_assigment = AssignmentResponse.from_json(req.body)
if arg2 not in ["submit", "approve", "reject"]:
resp.obj = ValidationError(FieldError("action", "must be [submit, approve, reject]"))
raise falcon.HTTPNotAcceptable()
assignment_controller.update_assignment(database_id, decoded_assigment, req.user, arg2)
resp.status = falcon.HTTP_ACCEPTED
def create_assigment(self, new_assignment:Assignment, c:InternalCorpus) -> (SuccessfulInsert, ValidationError):
"""
Checks an Assignment for issues, then logs it into the database.
:param new_assignment:
:return: (SuccessfulInsert, None) on Success.
"""
new_assignment.assigned_annotator_id = recover_int64_field(new_assignment.assigned_annotator_id)
if new_assignment.assigned_reviewer_id:
new_assignment.assigned_reviewer_id = recover_int64_field(new_assignment.assigned_reviewer_id)
new_assignment.assigned_user_id = recover_int64_field(new_assignment.assigned_user_id)
for i, a in enumerate(new_assignment.assets):
new_assignment.assets[i] = recover_int64_field(a)
resolved_xrefs = []
asset_controller = AssetController(self.storage)
for id in new_assignment.assets:
asset = asset_controller.get_asset_with_id(id)
if asset is None:
return None, ValidationError([FieldError("assets", "Could not resolve one or more Assets", False)])
xref = InternalAssignmentAssetXRef(asset=asset)
resolved_xrefs.append(xref)
self.storage.add(xref)
an = InternalAssignment(
summary_code=new_assignment.question.summary_code,
assigned_user_id=new_assignment.assigned_annotator_id,
annotator_id=new_assignment.assigned_annotator_id,
question=new_assignment.question.to_json(),
response=None,
reviewer_id=new_assignment.assigned_reviewer_id,
created=datetime.utcnow(),
corpus=c,
state="created"
)
self.storage.begin_nested()
self.storage.add(an)
self.storage.commit()
for x in resolved_xrefs:
x.assignment = an
self.storage.commit()
return SuccessfulInsert(id=obfuscate_int64_field(an.id)), None
def create_initial_user(self, rq) -> ValidationError:
if self.initial_user_created():
return ValidationError([FieldError("_state", "initial user already created", False)])
rq.role = UserKind.ADMINISTRATOR
return self._create_user(rq, reset_needed=False)
def create_user(self, new_user: NewUserRequest, requesting_user: InternalUser):
if requesting_user.role != UserKind.ADMINISTRATOR.value:
return ValidationError([FieldError("_meta", "requesting user is not administrator", False)])
return self._create_user(new_user, reset_needed=True)
def update_assignment(self, non_obfuscated_id:int, user_provided_assignment:AssignmentResponse,
current_user: InternalUser, action: str) -> ValidationError:
db_assignment = self.retrieve_assignment(non_obfuscated_id)
user_provided_response_json = None
if user_provided_assignment.response:
user_provided_response_json = user_provided_assignment.response.to_json()
if action == AssignmentAction.APPROVE:
# If the reviewer approves the annotation, place into the "approved" state
reviewer = db_assignment.assigned_reviewer
if reviewer != current_user:
return ValidationError([FieldError("_user", "Not responsible for approving this Annotation")])
ah = InternalAssignmentHistory(assignment_id=db_assignment.id, state="Approved",
notes=user_provided_assignment.notes,
response=user_provided_response_json,
updating_user_id=current_user.id)
db_assignment.state = "approved"
db_assignment.completed = datetime.utcnow()
db_assignment.updated = datetime.utcnow()
if user_provided_assignment.response:
db_assignment.response = user_provided_assignment.response.to_json()
db_assignment.assigned_user_id = None
self.storage.add(ah)
self.storage.commit()
elif action == AssignmentAction.REJECT:
# If rejected, assign back to the annotator.
reviewer = db_assignment.assigned_reviewer
if reviewer != current_user:
return ValidationError([FieldError("_user", "Not responsible for approving this Annotation")])
ah = InternalAssignmentHistory(assignment_id=db_assignment.id, state="Rejected",
notes=user_provided_assignment.notes,
response=user_provided_assignment.response,
updating_user_id=current_user.id)
db_assignment.state = "created"
db_assignment.completed = None
db_assignment.updated = datetime.utcnow()
if user_provided_assignment.response:
db_assignment.response = user_provided_assignment.response.to_json()
db_assignment.assigned_user_id = db_assignment.annotator_id
self.storage.add(ah)
self.storage.commit()
elif action == AssignmentAction.SUBMIT_FOR_REVIEW:
annotator = db_assignment.assigned_user
if current_user != annotator:
if annotator != current_user:
return ValidationError([FieldError("_user", "Not responsible for this Assignment")])
ah = InternalAssignmentHistory(assignment_id=db_assignment.id, state="Submitted",
notes=user_provided_assignment.notes,
response=user_provided_response_json,
updating_user_id=current_user.id)
if not db_assignment.reviewer_id:
# If there's no reviewer, then automatically place the annotation into the approved state.
db_assignment.state = "approved"
db_assignment.completed = datetime.utcnow()
if user_provided_assignment.response:
db_assignment.response = user_provided_assignment.response.to_json()
db_assignment.assigned_user_id = None
else:
# Otherwise, assign it to the reviewer
db_assignment.state = "pending"
db_assignment.completed = None
db_assignment.updated = datetime.utcnow()
if user_provided_assignment.response:
db_assignment.response = user_provided_response_json
db_assignment.assigned_user_id = db_assignment.reviewer_id
self.storage.add(ah)
self.storage.commit()
else:
raise ValueError((action, "Shouldn't reach here"))
def test_to_json(self):
fe = FieldError("field", "not filled in", True)
ref = {"name": "field", "error": "not filled in", "warning": True}
self.assertDictEqual(fe.to_json(), ref)
def test_from_json(self):
ref = {"name": "field", "error": "not filled in", "warning": True}
fe = FieldError.from_json(ref)
self.assertEqual(fe.name, "field")
self.assertEqual(fe.error, "not filled in")
self.assertTrue(fe.warning)