def test_newtask_with_task_filter_4(self):
"""Test newtask returns task that matches filter"""
user_info = dict(metadata={"profile": json.dumps({"english": 0.8})})
owner = UserFactory.create(id=500, info=user_info)
user_repo.save(owner)
project = ProjectFactory.create(owner=owner)
project.info['sched'] = Schedulers.user_pref
project_repo.save(project)
task_1_info = {'question': 'answer_1'}
task_1_filter = {'english': [0.5, ">="], 'spanish': [0.6, ">"]}
task_2_info = {'question': 'answer_2'}
task_2_filter = {}
TaskFactory.create(project=project,
info=task_1_info,
priority_0=1.0,
worker_filter=task_1_filter)
TaskFactory.create(project=project,
info=task_2_info,
priority_0=0,
worker_filter=task_2_filter)
api_key = project.owner.api_key
# as a real user, no password
url = '/api/project/%s/newtask?api_key=%s' % (project.id, api_key)
res = self.app.get(url)
assert res.status_code == 200, (res, res.data)
task = json.loads(res.data)
assert task.get('info', {}).get(
'question') == 'answer_2', "task_1 requires spanish skill >= 0.5"
def test_newtask_with_task_filter_invalid_ooperator(self):
"""Test newtask returns task that matches filter and raise exception for error"""
user_info = dict(metadata={"profile": json.dumps({"english": 0.8})})
owner = UserFactory.create(id=500, info=user_info)
user_repo.save(owner)
project = ProjectFactory.create(owner=owner)
project.info['sched'] = Schedulers.user_pref
project_repo.save(project)
task_1_info = {'question': 'answer_1'}
task_1_filter = {'english': [0.4, "%"]}
task_2_info = {'question': 'answer_2'}
task_2_filter = {}
TaskFactory.create(project=project,
info=task_1_info,
priority_0=1.0,
worker_filter=task_1_filter)
TaskFactory.create(project=project,
info=task_2_info,
priority_0=0,
worker_filter=task_2_filter)
api_key = project.owner.api_key
url = '/api/project/%s/newtask?api_key=%s' % (project.id, api_key)
res = self.app.get(url)
assert res.status_code == 200, (res, res.data)
task = json.loads(res.data)
assert task.get(
'info',
{}).get('question') == 'answer_2', "task_1 has invalid filter"
def test_newtask_with_task_preference_scores_invalid_value(self):
"""Test newtask returns task with best matching score"""
user_info = dict(metadata={"profile": json.dumps({"english": "A"})})
owner = UserFactory.create(id=500, info=user_info)
user_repo.save(owner)
project = ProjectFactory.create(owner=owner)
project.info['sched'] = Schedulers.user_pref
project_repo.save(project)
task_1_info = {'question': 'answer_1'}
task_1_pref = {'english': 1.0}
task_2_info = {'question': 'answer_2'}
task_2_pref = {'spanish': 1.0}
TaskFactory.create(project=project,
info=task_1_info,
priority_0=0,
worker_pref=task_1_pref)
TaskFactory.create(project=project,
info=task_2_info,
priority_0=1.0,
worker_pref=task_2_pref)
api_key = project.owner.api_key
# as a real user, no password
url = '/api/project/%s/newtask?api_key=%s' % (project.id, api_key)
res = self.app.get(url)
assert res.status_code == 200, (res, res.data)
task = json.loads(res.data)
assert task.get('info', {}).get('question') == 'answer_2'
def manage_user(access_token, user_data):
"""Manage the user after signin"""
# Twitter API does not provide a way
# to get the e-mail so we will ask for it
# only the first time
info = dict(twitter_token=access_token)
user = user_repo.get_by(twitter_user_id=user_data['user_id'])
if user is not None:
user.info['twitter_token'] = access_token
user_repo.save(user)
return user
user = user_repo.get_by_name(user_data['screen_name'])
if user is not None:
return None
user = User(fullname=user_data['screen_name'],
name=user_data['screen_name'],
email_addr=user_data['screen_name'],
twitter_user_id=user_data['user_id'],
info=info)
user_repo.save(user)
return user
def test_webhook_handler_owner_pro(self):
"""Test WEBHOOK view works for pro owner."""
# Admin/owner
self.register()
self.signin()
self.signout()
# User
self.register(name="Iser")
self.signin(email="*****@*****.**", password="******")
owner = user_repo.get_by(name="Iser")
owner.pro = True
user_repo.save(owner)
project = ProjectFactory.create(owner=owner)
url = "/project/%s/webhook" % project.short_name
res = self.app.get(url)
assert res.status_code == 200, res.status_code
assert "Created" in res.data
assert "Payload" in res.data
url = "/project/%s/webhook?failed=true" % project.short_name
res = self.app.get(url)
assert res.status_code == 200, res.status_code
assert "Created" in res.data
assert "Payload" in res.data
url = "/project/%s/webhook?all=true" % project.short_name
res = self.app.get(url)
assert res.status_code == 200, res.status_code
assert "Created" in res.data
assert "Payload" in res.data
def manage_user(access_token, user_data):
"""Manage the user after signin"""
user = user_repo.get_by(facebook_user_id=user_data['id'])
facebook_token = dict(oauth_token=access_token)
if user is None:
info = dict(facebook_token=facebook_token)
name = username_from_full_name(user_data['name'])
user_exists = user_repo.get_by_name(name) is not None
# NOTE: Sometimes users at Facebook validate their accounts without
# registering an e-mail (see this http://stackoverflow.com/a/17809808)
email_exists = (user_data.get('email') is not None and
user_repo.get_by(email_addr=user_data['email']) is not None)
if not user_exists and not email_exists:
if not user_data.get('email'):
user_data['email'] = name
user = User(fullname=user_data['name'],
name=name,
email_addr=user_data['email'],
facebook_user_id=user_data['id'],
info=info)
user_repo.save(user)
if newsletter.is_initialized() and user.email_addr != name:
newsletter.subscribe_user(user)
return user
else:
return None
else:
user.info['facebook_token'] = facebook_token
user_repo.save(user)
return user
def create_account(user_data, project_slugs=None, ldap_disabled=True):
new_user = model.user.User(fullname=user_data['fullname'],
name=user_data['name'],
email_addr=user_data['email_addr'],
valid_email=True,
consent=user_data.get('consent', True))
if user_data.get('user_pref'):
new_user.user_pref = user_data['user_pref']
if user_data.get('metadata'):
new_user.info = dict(metadata=user_data['metadata'])
if ldap_disabled:
new_user.set_password(user_data['password'])
else:
if user_data.get('ldap'):
new_user.ldap = user_data['ldap']
copy_data_access_levels(new_user.info, user_data.get('data_access'))
user_repo.save(new_user)
if not ldap_disabled:
flash(gettext('Thanks for signing-up'), 'success')
return _sign_in_user(new_user)
user_info = dict(fullname=user_data['fullname'],
email_addr=user_data['email_addr'],
password=user_data['password'])
msg = generate_invitation_email_for_new_user(user=user_info,
project_slugs=project_slugs)
mail_queue.enqueue(send_mail, msg)
def manage_user(access_token, user_data, next_url):
"""Manage the user after signin"""
user = user_repo.get_by(facebook_user_id=user_data['id'])
if user is None:
facebook_token = dict(oauth_token=access_token)
info = dict(facebook_token=facebook_token)
user = user_repo.get_by_name(user_data['username'])
# NOTE: Sometimes users at Facebook validate their accounts without
# registering an e-mail (see this http://stackoverflow.com/a/17809808)
email = None
if user_data.get('email'):
email = user_repo.get_by(email_addr=user_data['email'])
if user is None and email is None:
if not user_data.get('email'):
user_data['email'] = "None"
user = User(fullname=user_data['name'],
name=user_data['username'],
email_addr=user_data['email'],
facebook_user_id=user_data['id'],
info=info)
user_repo.save(user)
return user
else:
return None
else:
return user
def manage_user(access_token, user_data, next_url):
"""Manage the user after signin"""
user = user_repo.get_by(facebook_user_id=user_data['id'])
if user is None:
facebook_token = dict(oauth_token=access_token)
info = dict(facebook_token=facebook_token)
user = user_repo.get_by_name(user_data['username'])
# NOTE: Sometimes users at Facebook validate their accounts without
# registering an e-mail (see this http://stackoverflow.com/a/17809808)
email = None
if user_data.get('email'):
email = user_repo.get_by(email_addr=user_data['email'])
if user is None and email is None:
if not user_data.get('email'):
user_data['email'] = "None"
user = User(fullname=user_data['name'],
name=user_data['username'],
email_addr=user_data['email'],
facebook_user_id=user_data['id'],
info=info)
user_repo.save(user)
if newsletter.app and user.email_addr != "None":
newsletter.subscribe_user(user)
return user
else:
return None
else:
return user
def manage_user(access_token, user_data):
"""Manage the user after signin"""
# Twitter API does not provide a way
# to get the e-mail so we will ask for it
# only the first time
twitter_token = dict(oauth_token=access_token["oauth_token"], oauth_token_secret=access_token["oauth_token_secret"])
info = dict(twitter_token=twitter_token)
user = user_repo.get_by(twitter_user_id=user_data["user_id"])
if user is not None:
user.info["twitter_token"] = twitter_token
user_repo.save(user)
return user
user = user_repo.get_by_name(user_data["screen_name"])
if user is not None:
return None
user = User(
fullname=user_data["screen_name"],
name=user_data["screen_name"],
email_addr=user_data["screen_name"],
twitter_user_id=user_data["user_id"],
info=info,
)
user_repo.save(user)
return user
def confirm_account():
key = request.args.get('key')
if key is None:
abort(403)
try:
userdict = signer.loads(key, max_age=3600, salt='account-validation')
except BadData:
abort(403)
# First check if the user exists
users = user_repo.filter_by(name=userdict['name'])
if len(users) == 1 and users[0].name == userdict['name']:
u = users[0]
u.valid_email = True
u.confirmation_email_sent = False
u.email_addr = userdict['email_addr']
user_repo.update(u)
flash(gettext('Your email has been validated.'))
if newsletter.app:
return redirect(url_for('account.newsletter_subscribe'))
else:
return redirect(url_for('home.home'))
account = model.user.User(fullname=userdict['fullname'],
name=userdict['name'],
email_addr=userdict['email_addr'],
valid_email=True)
account.set_password(userdict['password'])
user_repo.save(account)
login_user(account, remember=True)
flash(gettext('Thanks for signing-up'), 'success')
if newsletter.app:
return redirect(url_for('account.newsletter_subscribe'))
else:
return redirect(url_for('home.home'))
def manage_user(access_token, user_data, next_url):
"""Manage the user after signin"""
# We have to store the oauth_token in the session to get the USER fields
user = user_repo.get_by(google_user_id=user_data['id'])
# user never signed on
if user is None:
google_token = dict(oauth_token=access_token)
info = dict(google_token=google_token)
name = user_data['name'].encode('ascii', 'ignore').lower().replace(" ", "")
user = user_repo.get_by_name(name)
email = user_repo.get_by(email_addr=user_data['email'])
if ((user is None) and (email is None)):
user = User(fullname=user_data['name'],
name=user_data['name'].encode('ascii', 'ignore')
.lower().replace(" ", ""),
email_addr=user_data['email'],
google_user_id=user_data['id'],
info=info)
user_repo.save(user)
return user
else:
return None
else:
# Update the name to fit with new paradigm to avoid UTF8 problems
if type(user.name) == unicode or ' ' in user.name:
user.name = user.name.encode('ascii', 'ignore').lower().replace(" ", "")
user_repo.update(user)
return user
def manage_user(access_token, user_data):
"""Manage the user after signin"""
# Twitter API does not provide a way
# to get the e-mail so we will ask for it
# only the first time
info = dict(twitter_token=access_token)
user = user_repo.get_by(twitter_user_id=user_data['user_id'])
if user is not None:
user.info['twitter_token'] = access_token
user_repo.save(user)
return user
user = user_repo.get_by_name(user_data['screen_name'])
if user is not None:
return None
user = User(fullname=user_data['screen_name'],
name=user_data['screen_name'],
email_addr=user_data['screen_name'],
twitter_user_id=user_data['user_id'],
info=info)
user_repo.save(user)
return user
def test_webhook_handler_owner_pro(self):
"""Test WEBHOOK view works for pro owner."""
# Admin/owner
self.register()
self.signout()
# User
self.register(name="Iser")
owner = user_repo.get_by(name="Iser")
owner.pro = True
user_repo.save(owner)
project = ProjectFactory.create(owner=owner)
url = "/project/%s/webhook" % project.short_name
res = self.app.get(url)
assert res.status_code == 200, res.status_code
assert "Created" in res.data
assert "Payload" in res.data
url = "/project/%s/webhook?failed=true" % project.short_name
res = self.app.get(url)
assert res.status_code == 200, res.status_code
assert "Created" in res.data
assert "Payload" in res.data
url = "/project/%s/webhook?all=true" % project.short_name
res = self.app.get(url)
assert res.status_code == 200, res.status_code
assert "Created" in res.data
assert "Payload" in res.data
def manage_user(access_token, user_data):
"""Manage the user after signin"""
user = user_repo.get_by(facebook_user_id=user_data['id'])
if user is None:
facebook_token = dict(oauth_token=access_token)
info = dict(facebook_token=facebook_token)
name = username_from_full_name(user_data['name'])
user_exists = user_repo.get_by_name(name) is not None
# NOTE: Sometimes users at Facebook validate their accounts without
# registering an e-mail (see this http://stackoverflow.com/a/17809808)
email_exists = (user_data.get('email') is not None and
user_repo.get_by(email_addr=user_data['email']) is not None)
if not user_exists and not email_exists:
if not user_data.get('email'):
user_data['email'] = name
user = User(fullname=user_data['name'],
name=name,
email_addr=user_data['email'],
facebook_user_id=user_data['id'],
info=info)
user_repo.save(user)
if newsletter.is_initialized() and user.email_addr != name:
newsletter.subscribe_user(user)
return user
else:
return None
else:
return user
def manage_user(access_token, user_data):
"""Manage the user after signin"""
# We have to store the oauth_token in the session to get the USER fields
user = user_repo.get_by(google_user_id=user_data['id'])
google_token = dict(oauth_token=access_token)
# user never signed on
if user is None:
info = dict(google_token=google_token)
name = username_from_full_name(user_data['name'])
user = user_repo.get_by_name(name)
email = user_repo.get_by(email_addr=user_data['email'])
if ((user is None) and (email is None)):
user = User(fullname=user_data['name'],
name=name,
email_addr=user_data['email'],
google_user_id=user_data['id'],
info=info)
user_repo.save(user)
if newsletter.is_initialized():
newsletter.subscribe_user(user)
return user
else:
return None
else:
user.info['google_token'] = google_token
# Update the name to fit with new paradigm to avoid UTF8 problems
if type(user.name) == unicode or ' ' in user.name:
user.name = username_from_full_name(user.name)
user_repo.save(user)
return user
def _create_account_Auth(user_data):
new_user = model.user.User(fullname=user_data['fullname'],
name=user_data['name'],
email_addr=user_data['email_addr'],
valid_email=True,
auth_user_id=user_data['auth_user_id'],
admin=False)
password = GenPasswd2(8, string.digits) + GenPasswd2(
15, string.ascii_letters)
new_user.set_password(password)
userxemail = user_repo.get_by(email_addr=user_data['email_addr'])
if userxemail:
if userxemail.auth_user_id is None:
new_user = userxemail
new_user.auth_user_id = user_data['auth_user_id']
user_repo.update(new_user)
flash(gettext(u'Bienvenido') + " " + new_user.fullname, 'success')
return _sign_in_user(new_user)
else:
flash(
gettext(
u'El email ya está registrado en nuestro sistema bajo otra cuenta con otras credenciales. No ha sido posible iniciar sesión. Inicie sesión utilizando la cuenta original que uso para registrarse por primera vez con esta dirección de correo.'
), 'error')
return redirect_content_type(url_for("home.home"))
else:
userduplicatename = user_repo.get_by_name(name=new_user.name)
if userduplicatename:
new_user.name = new_user.name + GenRandomString(
6, string.ascii_lowercase)
user_repo.save(new_user)
flash(gettext(u'Gracias por registrarte.'), 'success')
return _sign_in_user(new_user)
def test_task_5(self):
from pybossa import data_access
owner = UserFactory.create(id=500)
user = UserFactory.create(id=501, info=dict(data_access=["L1"]))
patch_data_access_levels = dict(
valid_access_levels=["L1", "L2", "L3", "L4"],
valid_user_levels_for_project_level=dict(L1=[], L2=["L1"]),
valid_project_levels_for_user_level=dict(L1=["L2", "L3", "L4"],
L2=["L3", "L4"]),
)
user_repo.save(owner)
project = ProjectFactory.create(owner=owner,
info=dict(project_users=[owner.id]))
project.info['sched'] = Schedulers.user_pref
tasks = TaskFactory.create_batch(3,
project=project,
n_answers=2,
info=dict(data_access=["L1"]))
tasks[0].info['data_access'] = ["L1"]
task_repo.save(tasks[0])
tasks[1].info['data_access'] = ["L1"]
task_repo.save(tasks[1])
tasks[2].info['data_access'] = ["L2"]
task_repo.save(tasks[2])
with patch.object(data_access, 'data_access_levels',
patch_data_access_levels):
assert n_available_tasks_for_user(project, 501) == 3
def manage_user(access_token, user_data):
"""Manage the user after signin"""
# We have to store the oauth_token in the session to get the USER fields
user = user_repo.get_by(google_user_id=user_data['id'])
# user never signed on
if user is None:
google_token = dict(oauth_token=access_token)
info = dict(google_token=google_token)
name = username_from_full_name(user_data['name'])
user = user_repo.get_by_name(name)
email = user_repo.get_by(email_addr=user_data['email'])
if ((user is None) and (email is None)):
user = User(fullname=user_data['name'],
name=name,
email_addr=user_data['email'],
google_user_id=user_data['id'],
info=info)
user_repo.save(user)
if newsletter.is_initialized():
newsletter.subscribe_user(user)
return user
else:
return None
else:
# Update the name to fit with new paradigm to avoid UTF8 problems
if type(user.name) == unicode or ' ' in user.name:
user.name = username_from_full_name(user.name)
user_repo.update(user)
return user
def manage_user(user_data):
"""Manage the user after signin"""
# We have to store the oauth_token in the session to get the USER fields
user = user_repo.get_by(mykaarma_user_id=user_data['id'])
# user never signed on
if user is None:
user_by_email = user_repo.get_by(email_addr=user_data['email'])
if (user_by_email is None):
"""Generate 4 digit alphanumeric string with digits and lowercase characters"""
name = get_mykaarma_username_from_full_name(user_data['name'])
"""check if already a user present with the same name, if yes, generate another random string"""
user = user_repo.get_by_name(name)
while (user is not None):
name = get_mykaarma_username_from_full_name(user_data['name'])
user = user_repo.get_by_name(name)
"""add user"""
user = User(fullname=user_data['name'],
name=name,
email_addr=user_data['email'],
mykaarma_user_id=user_data['id'])
user_repo.save(user)
if newsletter.is_initialized():
newsletter.subscribe_user(user)
return user
else:
return add_through_email(user_by_email, user_data)
else:
return user
def _create_account(user_data):
new_user = model.user.User(fullname=user_data['fullname'],
name=user_data['name'],
email_addr=user_data['email_addr'],
valid_email=True)
new_user.set_password(user_data['password'])
user_repo.save(new_user)
flash(gettext(u'Gracias por registrarte.'), 'success')
return _sign_in_user(new_user)
def _create_account(user_data):
new_user = model.user.User(fullname=user_data['fullname'],
name=user_data['name'],
email_addr=user_data['email_addr'],
valid_email=True)
new_user.set_password(user_data['password'])
user_repo.save(new_user)
flash(gettext('Created user succesfully!'), 'success')
return redirect(url_for("home.home"))
def _create_account(user_data):
new_user = model.user.User(fullname=user_data['fullname'],
name=user_data['name'],
email_addr=user_data['email_addr'],
valid_email=True)
new_user.set_password(user_data['password'])
user_repo.save(new_user)
flash(gettext('Thanks for signing-up'), 'success')
return _sign_in_user(new_user)
def _create_account(user_data):
new_user = model.user.User(fullname=user_data['fullname'],
name=user_data['name'],
email_addr=user_data['email_addr'],
valid_email=True)
new_user.set_password(user_data['password'])
user_repo.save(new_user)
flash(gettext('Thanks for signing-up'), 'success')
return _sign_in_user(new_user)
def test_task_2(self):
owner = UserFactory.create(id=500)
owner.user_pref = {'languages': ['de', 'en']}
user_repo.save(owner)
project = ProjectFactory.create(owner=owner)
project.info['sched'] = Schedulers.user_pref
task = TaskFactory.create_batch(1, project=project, n_answers=10)[0]
task.user_pref = {'languages': ['en', 'zh']}
task_repo.save(task)
assert n_available_tasks_for_user(project, 500) == 1
def create_account(user_data, project_slugs=None):
new_user = model.user.User(fullname=user_data['fullname'],
name=user_data['name'],
email_addr=user_data['email_addr'],
valid_email=True)
new_user.set_password(user_data['password'])
user_repo.save(new_user)
user_info = dict(fullname=user_data['fullname'], email_addr=user_data['email_addr'], password=user_data['password'])
msg = generate_invitation_email_for_new_user(user=user_info, project_slugs=project_slugs)
mail_queue.enqueue(send_mail, msg)
def test_task_no_pref(self):
"""
User has preferences set, task doesn't
"""
owner = UserFactory.create(id=500)
owner.user_pref = {'languages': ['en']}
user_repo.save(owner)
project = ProjectFactory.create(owner=owner)
TaskFactory.create_batch(1, project=project, n_answers=10)
tasks = get_user_pref_task(1, 500)
assert tasks
def add_through_email(user_by_email, user_data):
if (user_by_email.name == username_from_full_name(
user_data['name']).decode('utf-8')):
name = get_mykaarma_username_from_full_name(user_data['name'])
user = user_repo.get_by_name(name)
while (user is not None):
name = get_mykaarma_username_from_full_name(user_data['name'])
user = user_repo.get_by_name(name)
user_by_email.name = name
user_by_email.mykaarma_user_id = user_data['id']
user_repo.save(user_by_email)
return user_by_email
def test_no_user_pref(self):
"""
Task has preferences set, user doesn't
"""
owner = UserFactory.create(id=500)
user_repo.save(owner)
project = ProjectFactory.create(owner=owner)
task = TaskFactory.create_batch(1, project=project, n_answers=10)[0]
task.user_pref = {'languages': ['en', 'de']}
task_repo.save(task)
tasks = get_user_pref_task(1, 500)
assert not tasks
def test_project_report_with_task_details(self):
"""Test project report works with project details"""
admin = UserFactory.create(admin=True)
admin.set_password('1234')
user_repo.save(admin)
owner = UserFactory.create(pro=False)
project = ProjectFactory.create(owner=owner)
task = TaskFactory.create(project=project)
TaskRunFactory.create(task=task)
url = '/project/%s/projectreport/export?type=project&format=csv' % project.short_name
res = self.app_get_json(url, follow_redirects=True)
print res
def test_project_report_with_task_details(self):
"""Test project report works with project details"""
admin = UserFactory.create(admin=True)
admin.set_password('1234')
user_repo.save(admin)
owner = UserFactory.create(pro=False)
project = ProjectFactory.create(owner=owner)
task = TaskFactory.create(project=project)
TaskRunFactory.create(task=task)
url = '/project/%s/projectreport/export?type=project&format=csv' % project.short_name
res = self.app_get_json(url, follow_redirects=True)
print res
def test_task_2(self):
"""
Task has multiple preferences, user has multiple preferences; match
"""
owner = UserFactory.create(id=500)
owner.user_pref = {'languages': ['en', 'de']}
user_repo.save(owner)
project = ProjectFactory.create(owner=owner)
task = TaskFactory.create_batch(1, project=project, n_answers=10)[0]
task.user_pref = {'languages': ['en', 'es']}
task_repo.save(task)
tasks = get_user_pref_task(1, 500)
assert tasks
def test_task_1(self):
'''
Default user scheduler doesn't check user preference
'''
owner = UserFactory.create(id=500)
owner.user_pref = {'languages': ['de']}
user_repo.save(owner)
project = ProjectFactory.create(owner=owner)
project.info['sched'] = Schedulers.locked
task = TaskFactory.create_batch(1, project=project, n_answers=10)[0]
task.user_pref = {'languages': ['en', 'zh']}
task_repo.save(task)
assert n_available_tasks_for_user(project, 500) == 1
def test_task_7(self):
"""
Invalid user preference
"""
owner = UserFactory.create(id=500)
owner.user_pref = {'languages': 'invalid_user_pref'}
user_repo.save(owner)
project = ProjectFactory.create(owner=owner)
task = TaskFactory.create_batch(1, project=project, n_answers=10)[0]
task.user_pref = {'languages': ['en', 'zh']}
task_repo.save(task)
tasks = get_user_pref_task(1, 500)
assert not tasks
def _create_account(user_data, ldap_disabled=True):
new_user = model.user.User(fullname=user_data['fullname'],
name=user_data['name'],
email_addr=user_data['email_addr'],
valid_email=True,
consent=user_data['consent'])
if ldap_disabled:
new_user.set_password(user_data['password'])
else:
if user_data.get('ldap'):
new_user.ldap = user_data['ldap']
user_repo.save(new_user)
flash(gettext('Thanks for signing-up'), 'success')
return _sign_in_user(new_user)
def _create_account(user_data, ldap_disabled=True):
new_user = model.user.User(fullname=user_data['fullname'],
name=user_data['name'],
email_addr=user_data['email_addr'],
valid_email=True,
consent=user_data['consent'])
if ldap_disabled:
new_user.set_password(user_data['password'])
else:
if user_data.get('ldap'):
new_user.ldap = user_data['ldap']
user_repo.save(new_user)
flash(gettext('Thanks for signing-up'), 'success')
return _sign_in_user(new_user)
def test_task_6(self):
"""
User has multiple preferences of different kinds,
task has multiple preferences of different kinds, no match
"""
owner = UserFactory.create(id=500)
owner.user_pref = {'languages': ['de'], 'locations': ['us']}
user_repo.save(owner)
project = ProjectFactory.create(owner=owner)
task = TaskFactory.create_batch(1, project=project, n_answers=10)[0]
task.user_pref = {'languages': ['en', 'zh'], 'locations': ['es']}
task_repo.save(task)
tasks = get_user_pref_task(1, 500)
assert not tasks
def test_task_4(self):
'''
Tasks match user profile
'''
owner = UserFactory.create(id=500)
owner.user_pref = {'languages': ['de', 'en']}
user_repo.save(owner)
project = ProjectFactory.create(owner=owner)
project.info['sched'] = Schedulers.user_pref
tasks = TaskFactory.create_batch(2, project=project, n_answers=10)
tasks[0].user_pref = {'languages': ['en', 'zh']}
task_repo.save(tasks[0])
tasks[1].user_pref = {'languages': ['de']}
task_repo.save(tasks[1])
assert n_available_tasks_for_user(project, 500) == 2
def test_task_routing_3(self):
'''
User has empty profile set, only tasks that have empty filter can be assigned to user
'''
user_info = dict(metadata={"profile": json.dumps({})})
owner = UserFactory.create(id=500, info=user_info)
user_repo.save(owner)
project = ProjectFactory.create(owner=owner)
project.info['sched'] = Schedulers.user_pref
tasks = TaskFactory.create_batch(3, project=project, n_answers=10)
tasks[0].worker_filter = {'finance': [0.8, '>=']}
task_repo.save(tasks[0])
tasks[1].worker_filter = {'geography': [0.5, '>=']}
task_repo.save(tasks[1])
assert n_available_tasks_for_user(project, 500) == 1
def test_recent_contributor_with_multiple_user_pref_notified(self):
"""
User with multiple user pref to be notified when one of his/her
user pref matches any new task user pref
"""
owner = UserFactory.create(id=500)
owner.user_pref = {'languages': ['en']} # owner is english user
user_repo.save(owner)
sp_fr_user = UserFactory.create(id=501)
sp_fr_user.user_pref = {
'languages': ['sp', 'fr']
} # spanish french language user
user_repo.save(sp_fr_user)
# Stage 1 :
# Create 3 tasks - 1 english, 1 spanish, 1 french.
project = ProjectFactory.create(owner=owner)
project.info['sched'] = Schedulers.user_pref
tasks = TaskFactory.create_batch(6, project=project, n_answers=1)
tasks[0].user_pref = {'languages': ['en']}
task_repo.save(tasks[0])
tasks[1].user_pref = {'languages': ['sp']}
task_repo.save(tasks[1])
tasks[2].user_pref = {'languages': ['fr']}
task_repo.save(tasks[2])
# Submit 1 english and spanish tasks. this will complete
# such tasks and assoicated users to be notified about new task imported
taskrun1 = TaskRunFactory.create(task=tasks[0], user=owner)
taskrun2 = TaskRunFactory.create(task=tasks[1], user=sp_fr_user)
# Stage 2 :
# create 1 spanish task
# at this stage, record current time.
# there is french ongoing task, but since spanish task is complete
# sp_fr_user will be notified
now = datetime.datetime.utcnow().isoformat()
tasks = TaskFactory.create_batch(1, project=project, n_answers=1)
tasks[0].user_pref = {'languages': ['sp']}
task_repo.save(tasks[0])
recent_contributors = user_repo.get_user_pref_recent_contributor_emails(
project.id, now)
# with one spanish task completed, user2 will be notified about new spanish task imported
err_msg = 'There should be 1 contributors'
assert len(recent_contributors) == 1, err_msg
err_msg = 'user1 and user3 with english and chinese language preference should be notified'
assert '*****@*****.**' in recent_contributors, err_msg
def confirm_account():
key = request.args.get('key')
if key is None:
abort(403)
try:
userdict = signer.loads(key, max_age=3600, salt='account-validation')
except BadData:
abort(403)
account = model.user.User(fullname=userdict['fullname'],
name=userdict['name'],
email_addr=userdict['email_addr'])
account.set_password(userdict['password'])
user_repo.save(account)
login_user(account, remember=True)
flash(gettext('Thanks for signing-up'), 'success')
return redirect(url_for('home.home'))
def manage_user(access_token, user_data):
"""Manage the user after signin"""
# Weibo API does not provide a way
# to get the e-mail so we will ask for it
# only the first time
weibo_token=dict(oauth_token=access_token)
info = dict(weibo_token=access_token,
avatar_url=user_data['profile_image_url'])
# alreay exist
user = user_repo.get_by(weibo_user_id=user_data['id'])
if user is not None:
user.info['weibo_token'] = info
user_repo.save(user)
return user
user = User(fullname=user_data['screen_name'],
name=user_data['screen_name'],
email_addr=user_data['screen_name'],
weibo_user_id=user_data['id'],
info=info)
user_repo.save(user)
return user
def manage_user_no_login(access_token, next_url):
if current_user.is_authenticated:
user = user_repo.get(current_user.id)
user.info['twitter_token'] = access_token
user_repo.save(user)
return redirect(next_url)
