def patch(self, doc_type, doc_id):
"""Update entity"""
parser = reqparse.RequestParser()
parser.add_argument('oldEntity', type=str, required=True)
parser.add_argument('newEntity', type=str, required=True)
args = parser.parse_args()
base_query = Task.query
if (doc_type == "news"):
base_query = base_query.filter(Task.news_article_id == doc_id,
Task.news_ent == args.oldEntity)
elif (doc_type == "science"):
base_query = base_query.filter(Task.sci_paper_id == doc_id,
Task.sci_ent == args.oldEntity)
else:
return {
"error": "Type of document must be 'news' or 'science"
}, 400
if doc_type == "news":
affected = base_query.update({Task.news_ent: args.newEntity})
else:
affected = base_query.update({Task.sci_ent: args.newEntity})
db_session.commit()
return {"updated_rows": affected}
def post(self, task_id):
parser = reqparse.RequestParser()
parser.add_argument('answer',
type=str,
required=True,
choices=['yes', 'no'])
args = parser.parse_args()
task = Task.query.get(task_id)
if task is None:
return {"error": f"No task with ID={task_id} exists"}, 404
ut = UserTask(task_id=task_id,
user_id=current_user.id,
answer=args.answer)
db_session.add(ut)
# there is a random chance that this will become an IAA task
if np.random.random() < float(os.getenv('IAA_RATIO',
0.05)) and (not task.is_iaa):
task.is_iaa = True
task.is_iaa_priority = True
db_session.commit()
return marshal(ut, self.ut_fields), 201
def patch(self, task_id):
parser = reqparse.RequestParser()
parser.add_argument('answer',
type=str,
required=True,
choices=['yes', 'no'])
args = parser.parse_args()
ans = UserTask.query.filter(
UserTask.task_id == task_id,
UserTask.user_id == current_user.id).one_or_none()
if ans is None:
return {
"error":
f"No answer with task={task_id} and user_id={current_user.id} exists"
}, 404
ans.answer = args.answer
ans.created_at = datetime.utcnow()
db_session.add(ans)
db_session.commit()
return marshal(ans, self.ut_fields), 200
def post(self):
ap = reqparse.RequestParser()
ap.add_argument("news_article_id", type=int, required=True)
ap.add_argument("sci_paper_id", type=int, required=True)
ap.add_argument("answers", action='append', type=dict, required=True)
args = ap.parse_args()
tasks = db_session.query(Task).filter(
Task.news_article_id == args.news_article_id,
Task.sci_paper_id == args.sci_paper_id).all()
taskmap = defaultdict(lambda: [])
for task in tasks:
taskmap[(task.news_ent, task.sci_ent)].append(task)
dbanswers = []
for answer in args.answers:
tasks = taskmap.get((answer['news_ent'], answer['sci_ent']))
existing_answer = False
if (tasks is None) or (len(tasks) < 1):
print("create new task")
t = Task(news_article_id=args.news_article_id,
sci_paper_id=args.sci_paper_id,
news_ent=answer['news_ent'],
sci_ent=answer['sci_ent'])
db_session.add(t)
else:
for t in tasks:
for ut in t.usertasks:
if ut.user_id == current_user.id:
ut.answer = answer['answer'],
existing_answer = True
print(
f"Update existing answer (news_ent={t.news_ent}, sci_ent={t.sci_ent}, answer={answer['answer']})"
)
dbanswers.append(ut)
if not existing_answer:
print(
f"create answer (news_ent={t.news_ent}, sci_ent={t.sci_ent}, answer={answer['answer']})"
)
ut = UserTask(answer=answer['answer'],
user_id=current_user.id,
task=t,
created_at=datetime.utcnow())
db_session.add(ut)
dbanswers.append(ut)
db_session.commit()
return {"answers": [marshal(ut, ut_fields) for ut in dbanswers]}
def change_password(email, password):
"""Change a user's password"""
u = db_session.query(User).filter(User.email==email).one()
u.password = hash_password(password)
db_session.add(u)
db_session.commit()
def post(self):
ap = reqparse.RequestParser()
ap.add_argument("news_article_id", type=int, required=True)
ap.add_argument("sci_paper_id", type=int, required=True)
ap.add_argument("news_ent", type=str, required=False)
ap.add_argument("sci_ent", type=str, required=False)
args = ap.parse_args()
if (args.news_ent is None):
# science singleton
tasks = db_session.query(Task).filter(
Task.sci_paper_id == args.sci_paper_id,
Task.sci_ent == args.sci_ent).all()
elif (args.sci_ent is None):
# news singleton
tasks = db_session.query(Task).filter(
Task.news_article_id == args.news_article_id,
Task.news_ent == args.news_ent).all()
else:
return {"message": "Either news_ent or sci_ent must be null"}, 400
for task in tasks:
skip_task = False
for ut in task.usertasks:
if ut.user_id == current_user.id:
skip_task = True
break
if not skip_task:
ut = UserTask(user_id=current_user.id,
task_id=task.id,
answer="no")
db_session.add(ut)
db_session.commit()
def post(self):
"""Give user the opportunity to report a task as 'bad'"""
parser = reqparse.RequestParser()
parser.add_argument('task_id', type=str, required=True)
parser.add_argument('is_bad', type=bool, required=False, default=None)
parser.add_argument('is_bad_reason', type=str, required=False)
parser.add_argument('is_difficult',
type=bool,
required=False,
default=False)
args = parser.parse_args()
t = db_session.query(Task).filter(
Task.id == args.task_id).one_or_none()
if not t:
return {"error": f"No such task with id={args.task_id}"}, 404
else:
if args.is_bad is not None:
t.is_bad = args.is_bad
if args.is_bad:
t.is_bad_reason = args.is_bad_reason
t.is_bad_user_id = current_user.id
t.is_bad_reported_at = datetime.utcnow()
if t.is_bad_reason == "bad sci ent":
# update all tasks with same sci ent
db_session.query(Task)\
.filter(Task.sci_ent==t.sci_ent, Task.sci_paper_id==t.sci_paper_id)\
.update({"is_bad":True, "is_bad_reason": t.is_bad_reason})
elif t.is_bad_reason == "bad news ent":
#update all tasks with same news ent
db_session.query(Task)\
.filter(Task.news_ent==t.news_ent, Task.news_article_id==t.news_article_id)\
.update({"is_bad":True,
"is_bad_reason": t.is_bad_reason,
"is_bad_reported_at": t.is_bad_reported_at,
"is_bad_user_id": t.is_bad_user_id })
else:
t.is_bad_reason = None
t.is_bad_user_id = None
t.is_bad_reported_at = None
if args.is_difficult is not None:
t.is_difficult = args.is_difficult
if t.is_difficult:
t.is_difficult_user_id = current_user.id
t.is_difficult_reported_at = datetime.utcnow()
else:
t.is_difficult_user_id = None
t.is_difficult_reported_at = None
db_session.add(t)
db_session.commit()
return marshal(t, self.task_fields)