def retrieve_with_data(self, request, *args, **kwargs):
task = self.get_object()
task_worker = TaskWorker.objects.filter(worker=request.user, task=task).first()
serializer = TaskSerializer(instance=task,
fields=('id', 'template', 'project_data', 'status'),
context={'task_worker': task_worker})
requester_alias = task.project.owner.username
project = task.project.id
is_review = task.project.is_review
target = task.project.owner.id
timeout = task.project.timeout
worker_timestamp = task_worker.created_at
now = datetime.datetime.utcnow().replace(tzinfo=utc)
if timeout is not None:
time_left = int(timeout.total_seconds() - (now - worker_timestamp).total_seconds())
else:
time_left = None
auto_accept = False
user_prefs = get_model_or_none(UserPreferences, user=request.user)
if user_prefs is not None:
auto_accept = user_prefs.auto_accept
return Response({'data': serializer.data,
'requester_alias': requester_alias,
'project': project,
'is_review': is_review,
'time_left': time_left,
'auto_accept': auto_accept,
'task_worker_id': task_worker.id,
'target': target}, status.HTTP_200_OK)
def get_modules_filtered(self, obj):
"""
temporary for studies, to be removed after CHI
"""
module_objects = models.Module.objects.filter(project=obj)
userprofile = self.context['request'].user.userprofile
if hasattr(userprofile, 'worker'):
worker_exp = get_model_or_none(
experimental_models.WorkerExperiment,
worker=userprofile.worker)
if worker_exp:
module_objects = models.Module.objects.filter(
Q(module_pool__pool__isnull=True)
| Q(module_pool__pool=worker_exp.pool),
project=obj,
is_prototype=worker_exp.has_prototype)
modules = ModuleSerializer(
module_objects,
many=True,
fields=('id', 'name', 'description', 'status', 'repetition',
'module_timeout', 'price', 'template', 'total_tasks',
'file_id', 'has_data_set', 'age', 'is_micro',
'is_prototype', 'task_time', 'has_comments',
'allow_feedback', 'feedback_permissions',
'available_tasks'),
context={'request': self.context['request']})
return modules.data
def reset_password(self, request):
password = request.data.get('password', 'N')
password_reset_model = get_model_or_none(PasswordResetModel,
reset_key=request.data.get(
'reset_key', ''))
serializer = UserSerializer(context={'request': request})
data, http_status = serializer.reset_password(
reset_model=password_reset_model, password=password)
return Response(data=data, status=http_status)
def create(self, *args, **kwargs):
recipient = None
user = None
payment_data = self.build_payment()
if self.validated_data['type'] == 'self':
user = self.context['request'].user
else:
user = get_model_or_none(User, username=self.validated_data['username'])
recipient = get_model_or_none(FinancialAccount, owner=user, type='requester')
paypalbackend = PayPalBackend()
payment = paypalbackend.paypalrestsdk.Payment(payment_data)
if payment.create():
redirect_url = next((link for link in payment['links'] if link['method'] == 'REDIRECT'), '#')
if payment['payer']['payment_method'] == 'credit_card':
redirect_url = {
'href': '#'
}
flow_data = {
"redirect_url": redirect_url['href'],
"paypal_id": payment.id
}
payment_flow = PayPalFlowSerializer(data=flow_data, fields=('redirect_url', 'paypal_id',),
context={'request': self.context['request']})
if payment_flow.is_valid():
payment_flow.create(recipient=recipient)
if payment['payer']['payment_method'] == 'credit_card':
data = {
"paypal_id": payment['id'],
"payer_id": "UNKNOWN_CC"
}
execute_serializer = PayPalFlowSerializer(fields=('paypal_id', 'payer_id'), data=data,
context={"request": self.context['request']})
if execute_serializer.is_valid():
message, https_status = execute_serializer.execute()
return {"message": message}, https_status
else:
return execute_serializer.errors, status.HTTP_400_BAD_REQUEST
return payment_flow.data, status.HTTP_201_CREATED
else:
return payment_flow.errors, status.HTTP_400_BAD_REQUEST
else:
return payment.error, status.HTTP_400_BAD_REQUEST
def create(self, *args, **kwargs):
recipient = None
recipient_profile = None
payment_data = self.build_payment()
if self.validated_data['type'] == 'self':
recipient_profile = self.context['request'].user.userprofile
else:
recipient_profile = get_model_or_none(UserProfile, user__username=self.validated_data['username'])
recipient = get_model_or_none(FinancialAccount, owner=recipient_profile, type='requester')
paypalbackend = PayPalBackend()
payment = paypalbackend.paypalrestsdk.Payment(payment_data)
if payment.create():
redirect_url = next((link for link in payment['links'] if link['method'] == 'REDIRECT'), '#')
if payment['payer']['payment_method'] == 'credit_card':
redirect_url = {
'href': '#'
}
flow_data = {
"redirect_url": redirect_url['href'],
"paypal_id": payment.id
}
payment_flow = PayPalFlowSerializer(data=flow_data, fields=('redirect_url', 'paypal_id',),
context={'request': self.context['request']})
if payment_flow.is_valid():
payment_flow.create(recipient=recipient)
if payment['payer']['payment_method'] == 'credit_card':
data = {
"paypal_id": payment['id'],
"payer_id": "UNKNOWN_CC"
}
execute_serializer = PayPalFlowSerializer(fields=('paypal_id', 'payer_id'), data=data,
context={"request": self.context['request']})
if execute_serializer.is_valid():
message, https_status = execute_serializer.execute()
return {"message": message}, https_status
else:
return execute_serializer.errors, status.HTTP_400_BAD_REQUEST
return payment_flow.data, status.HTTP_201_CREATED
else:
return payment_flow.errors, status.HTTP_400_BAD_REQUEST
else:
return payment.error, status.HTTP_400_BAD_REQUEST
def get_or_create_worker(worker_id):
if worker_id is None:
return None
daemo_username = '******' + string.lower(worker_id)
user = get_model_or_none(User, username=daemo_username)
if user is None:
user_obj = User.objects.create(username=daemo_username, email=daemo_username + '@daemo.stanford.edu',
password=make_password(generate_random_id()), is_active=False)
UserProfile.objects.create(user=user_obj)
return user_obj
else:
return user
def send_forgot_password(self, **kwargs):
user = kwargs['user']
salt = hashlib.sha1(str(random.random()).encode('utf-8')).hexdigest()[:5]
username = user.username
reset_key = hashlib.sha1(str(salt + username).encode('utf-8')).hexdigest()
password_reset = get_model_or_none(models.PasswordResetModel, user_id=user.id)
if password_reset is None:
password_reset = models.PasswordResetModel()
password_reset.user = user
password_reset.reset_key = reset_key
if settings.EMAIL_ENABLED:
password_reset.save()
send_password_reset_email(email=user.email, host=self.context['request'].get_host(),
reset_key=reset_key)
def create(self, *args, **kwargs):
recipient = None
recipient_profile = None
payment_data = self.build_payment()
if self.validated_data["type"] == "self":
recipient_profile = self.context["request"].user.userprofile
else:
recipient_profile = get_model_or_none(UserProfile, user__username=self.validated_data["username"])
recipient = get_model_or_none(FinancialAccount, owner=recipient_profile, type="requester")
paypalbackend = PayPalBackend()
payment = paypalbackend.paypalrestsdk.Payment(payment_data)
if payment.create():
redirect_url = next((link for link in payment["links"] if link["method"] == "REDIRECT"), "#")
if payment["payer"]["payment_method"] == "credit_card":
redirect_url = {"href": "#"}
flow_data = {"redirect_url": redirect_url["href"], "paypal_id": payment.id}
payment_flow = PayPalFlowSerializer(
data=flow_data, fields=("redirect_url", "paypal_id"), context={"request": self.context["request"]}
)
if payment_flow.is_valid():
payment_flow.create(recipient=recipient)
if payment["payer"]["payment_method"] == "credit_card":
data = {"paypal_id": payment["id"], "payer_id": "UNKNOWN_CC"}
execute_serializer = PayPalFlowSerializer(
fields=("paypal_id", "payer_id"), data=data, context={"request": self.context["request"]}
)
if execute_serializer.is_valid():
message, https_status = execute_serializer.execute()
return {"message": message}, https_status
else:
return execute_serializer.errors, status.HTTP_400_BAD_REQUEST
return payment_flow.data, status.HTTP_201_CREATED
else:
return payment_flow.errors, status.HTTP_400_BAD_REQUEST
else:
return payment.error, status.HTTP_400_BAD_REQUEST
def reset_password(self, **kwargs):
"""
Resets the password if requested by the user.
"""
if len(kwargs['password']) < 8:
raise ValidationError("New password must be at least 8 characters long")
if not kwargs['reset_model']:
raise ValidationError("Invalid email or reset key")
user = get_model_or_none(User, id=kwargs['reset_model'].user_id, email=self.context['request'].data
.get('email', 'NO_EMAIL'))
if not user:
raise ValidationError("Invalid email or reset key")
user.set_password(kwargs['password'])
user.save()
kwargs['reset_model'].delete()
return {"message": "Password reset successfully"}, status.HTTP_200_OK
def post(self, request, *args, **kwargs):
from django.contrib.auth import authenticate as auth_authenticate, login
# self.redirect_to = request.POST.get('next', '') #to be changed, POST does not contain any data
username = request.data.get('username', '')
password = request.data.get('password', '')
email_or_username = username
# match with username if not email
if not re.match(r"[^@]+@[^@]+\.[^@]+", email_or_username):
username = email_or_username
else:
user = get_model_or_none(User, email=email_or_username)
if user is not None:
username = user.username
user = auth_authenticate(username=username, password=password)
if user is not None:
if not user.is_anonymous():
userprofile = user.profile
userprofile.last_active = timezone.now()
userprofile.save()
if user.is_active:
login(request, user)
response_data = dict()
response_data["username"] = user.username
response_data["email"] = user.email
response_data["first_name"] = user.first_name
response_data["last_name"] = user.last_name
response_data["date_joined"] = user.date_joined
response_data["last_login"] = user.last_login
response_data["is_requester"] = user.profile.is_requester
response_data["is_worker"] = user.profile.is_worker
return Response(response_data, status.HTTP_200_OK)
else:
raise AuthenticationFailed(
_(
'Account is not activated yet. Look for an email in your inbox and click the activation '
'link in it.'))
else:
raise AuthenticationFailed(_('Username or password is incorrect.'))
def authenticate(self, request):
from django.contrib.auth import authenticate as auth_authenticate
# self.redirect_to = request.POST.get('next', '') #to be changed, POST does not contain any data
username = request.data.get('username', '')
password = request.data.get('password', '')
email_or_username = username
# match with username if not email
if not re.match(r"[^@]+@[^@]+\.[^@]+", email_or_username):
username = email_or_username
else:
user = get_model_or_none(User, email=email_or_username)
if user is not None:
username = user.username
user = auth_authenticate(username=username, password=password)
if user is not None:
if user.is_active:
oauth2_utils = Oauth2Utils()
client = oauth2_utils.create_client(request, user)
response_data = dict()
response_data["client_id"] = client.client_id
response_data["client_secret"] = client.client_secret
response_data["username"] = user.username
response_data["email"] = user.email
response_data["first_name"] = user.first_name
response_data["last_name"] = user.last_name
response_data["date_joined"] = user.date_joined
response_data["last_login"] = user.last_login
response_data["is_requester"] = hasattr(
request.user.userprofile, 'requester')
response_data["is_worker"] = hasattr(request.user.userprofile,
'worker')
return response_data, status.HTTP_201_CREATED
else:
raise AuthenticationFailed(_('Account is not activated yet.'))
else:
raise AuthenticationFailed(_('Username or password is incorrect.'))
def authenticate(self, request):
from django.contrib.auth import authenticate as auth_authenticate
# self.redirect_to = request.POST.get('next', '') #to be changed, POST does not contain any data
username = request.data.get('username', '')
password = request.data.get('password', '')
email_or_username = username
# match with username if not email
if not re.match(r"[^@]+@[^@]+\.[^@]+", email_or_username):
username = email_or_username
else:
user = get_model_or_none(User, email=email_or_username)
if user is not None:
username = user.username
user = auth_authenticate(username=username, password=password)
if user is not None:
if user.is_active:
oauth2_utils = Oauth2Utils()
client = oauth2_utils.create_client(request, user)
response_data = dict()
response_data["client_id"] = client.client_id
response_data["client_secret"] = client.client_secret
response_data["username"] = user.username
response_data["email"] = user.email
response_data["first_name"] = user.first_name
response_data["last_name"] = user.last_name
response_data["date_joined"] = user.date_joined
response_data["last_login"] = user.last_login
response_data["is_requester"] = hasattr(request.user.userprofile, 'requester')
response_data["is_worker"] = hasattr(request.user.userprofile, 'worker')
return response_data, status.HTTP_201_CREATED
else:
raise AuthenticationFailed(_('Account is not activated yet.'))
else:
raise AuthenticationFailed(_('Username or password is incorrect.'))
def get_modules_filtered(self, obj):
"""
temporary for studies, to be removed after CHI
"""
module_objects = models.Module.objects.filter(project=obj)
userprofile = self.context['request'].user.userprofile
if hasattr(userprofile, 'worker'):
worker_exp = get_model_or_none(experimental_models.WorkerExperiment, worker=userprofile.worker)
if worker_exp:
module_objects = models.Module.objects.filter(
Q(module_pool__pool__isnull=True) | Q(module_pool__pool=worker_exp.pool), project=obj,
is_prototype=worker_exp.has_prototype)
modules = ModuleSerializer(module_objects, many=True,
fields=('id', 'name', 'description', 'status', 'repetition', 'module_timeout',
'price', 'template', 'total_tasks', 'file_id', 'has_data_set', 'age',
'is_micro', 'is_prototype', 'task_time', 'has_comments',
'allow_feedback', 'feedback_permissions', 'available_tasks'),
context={'request': self.context['request']})
return modules.data
def destroy(self, request, *args, **kwargs):
serializer = TaskWorkerSerializer()
obj = self.queryset.get(id=kwargs['pk'], worker=request.user)
auto_accept = False
user_prefs = get_model_or_none(UserPreferences, user=request.user)
instance, http_status = None, status.HTTP_204_NO_CONTENT
if user_prefs is not None:
auto_accept = user_prefs.auto_accept
if auto_accept:
instance, http_status = serializer.create(worker=request.user, project=obj.task.project_id)
obj.status = TaskWorker.STATUS_SKIPPED
obj.save()
refund_task.delay([{'id': obj.id}])
update_worker_cache.delay([obj.worker_id], constants.TASK_SKIPPED)
mturk_hit_update.delay({'id': obj.task.id})
serialized_data = {}
if http_status == status.HTTP_200_OK:
serialized_data = TaskWorkerSerializer(instance=instance).data
return Response(serialized_data, http_status)
def destroy(self, request, *args, **kwargs):
serializer = TaskWorkerSerializer()
obj = self.queryset.get(id=kwargs['pk'], worker=request.user)
auto_accept = False
user_prefs = get_model_or_none(UserPreferences, user=request.user)
instance, http_status = None, status.HTTP_204_NO_CONTENT
if user_prefs is not None:
auto_accept = user_prefs.auto_accept
if auto_accept:
instance, http_status = serializer.create(
worker=request.user, project=obj.task.project_id)
obj.status = TaskWorker.STATUS_SKIPPED
obj.save()
refund_task.delay([{'id': obj.id}])
update_worker_cache.delay([obj.worker_id], constants.TASK_SKIPPED)
mturk_hit_update.delay({'id': obj.task.id})
serialized_data = {}
if http_status == status.HTTP_200_OK:
serialized_data = TaskWorkerSerializer(instance=instance).data
return Response(serialized_data, http_status)
def authenticate(self, request):
from django.contrib.auth import authenticate as auth_authenticate
#self.redirect_to = request.POST.get('next', '') #to be changed, POST does not contain any data
username = request.data.get('username', '')
password = request.data.get('password', '')
email_or_username = username
if not re.match(r"[^@]+@[^@]+\.[^@]+", email_or_username):
username = email_or_username
else:
user = get_model_or_none(User,email=email_or_username)
if user is not None:
username = user.username
user = auth_authenticate(username=username, password=password)
if user is not None:
if user.is_active:
oauth2_utils = Oauth2Utils()
client = oauth2_utils.create_client(request,user)
response_data = {}
response_data["client_id"] = client.client_id
response_data["client_secret"] = client.client_secret
response_data["username"] = user.username
response_data["email"] = user.email
response_data["first_name"] = user.first_name
response_data["last_name"] = user.last_name
response_data["date_joined"] = user.date_joined
response_data["last_login"] = user.last_login
return response_data, status.HTTP_201_CREATED
#return Response(response_data,status=status.HTTP_201_CREATED)
else:
return {
'status': 'Unauthorized',
'message': 'Account is not activated yet.'
}, status.HTTP_401_UNAUTHORIZED
else:
return {
'status': 'Unauthorized',
'message': 'Username or password is incorrect.'
}, status.HTTP_401_UNAUTHORIZED
def retrieve_with_data(self, request, *args, **kwargs):
task = self.get_object()
task_worker = TaskWorker.objects.filter(worker=request.user,
task=task).first()
serializer = TaskSerializer(instance=task,
fields=('id', 'template', 'project_data',
'status'),
context={'task_worker': task_worker})
requester_alias = task.project.owner.username
project = task.project.id
is_review = task.project.is_review
target = task.project.owner.id
timeout = task.project.timeout
worker_timestamp = task_worker.created_at
now = datetime.datetime.utcnow().replace(tzinfo=utc)
if timeout is not None:
time_left = int(timeout.total_seconds() -
(now - worker_timestamp).total_seconds())
else:
time_left = None
auto_accept = False
user_prefs = get_model_or_none(UserPreferences, user=request.user)
if user_prefs is not None:
auto_accept = user_prefs.auto_accept
return Response(
{
'data': serializer.data,
'requester_alias': requester_alias,
'project': project,
'is_review': is_review,
'time_left': time_left,
'auto_accept': auto_accept,
'task_worker_id': task_worker.id,
'target': target
}, status.HTTP_200_OK)
def list(self, request, *args, **kwargs):
requester_id = -1
worker_config = {
"has_prototype": True,
"sorting_type": 1
}
if hasattr(request.user.userprofile, 'requester'):
requester_id = request.user.userprofile.requester.id
if hasattr(request.user.userprofile, 'worker'):
worker = request.user.userprofile.worker
worker_exp = get_model_or_none(experimental_models.WorkerExperiment, worker=worker)
if worker_exp:
worker_config['has_prototype'] = worker_exp.has_prototype
worker_config['sorting_type'] = worker_exp.sorting_type
try:
query = '''
SELECT p.id, p.name, p.description, Max(mod.relevant_requester_rating) FROM (
SELECT id, name, description, created_timestamp, last_updated, owner_id, project_id, imputed_rating,
CASE WHEN real_weight IS NULL AND average_requester_rating IS NOT NULL THEN average_requester_rating
WHEN real_weight IS NULL AND average_requester_rating IS NULL THEN 1.99
WHEN real_weight IS NOT NULL AND average_requester_rating IS NULL THEN real_weight
ELSE real_weight + 0.1 * average_requester_rating END relevant_requester_rating
FROM (
SELECT rnk.*, wrr.weight as real_weight, avg.average_requester_rating FROM (
--This fetches the modules according to cascading release
SELECT evr.*
FROM(
SELECT avgrat.*, CASE WHEN weight IS NULL
AND adj_average_worker_rating IS NOT NULL THEN adj_average_worker_rating
WHEN weight IS NULL AND adj_average_worker_rating IS NULL THEN 1.99
WHEN weight IS NOT NULL AND adj_average_worker_rating IS NULL THEN weight
ELSE weight + 0.1 * adj_average_worker_rating END worker_relevant_rating
FROM (
SELECT m.*, als.weight, als.adj_average_worker_rating, imputed_rating FROM crowdsourcing_module m
INNER JOIN crowdsourcing_requester r ON m.owner_id = r.id and m.is_prototype=%(has_prototype)s
INNER JOIN crowdsourcing_userprofile u ON r.profile_id = u.id
LEFT OUTER JOIN
(SELECT w.* FROM crowdsourcing_workerrequesterrating w
INNER JOIN(
SELECT origin_id, MAX(last_updated) AS max_date FROM crowdsourcing_workerrequesterrating
WHERE origin_type='requester' AND target_id = %(worker_profile)s GROUP BY origin_id) tb
ON w.origin_id = tb.origin_id AND w.last_updated = tb.max_date
AND w.origin_type='requester' AND w.target_id=%(worker_profile)s) w
ON u.id = w.origin_id
LEFT OUTER JOIN (
SELECT temp.origin_id, temp.target_id, temp.average_worker_rating, temp.count, temp.weight,
(temp.average_worker_rating * temp.count - temp.weight) /
(temp.count-1) as adj_average_worker_rating FROM
(SELECT w.*, average_worker_rating, count from crowdsourcing_workerrequesterrating w
INNER JOIN
(SELECT target_id, AVG(weight) AS average_worker_rating, COUNT(target_id) from
(SELECT wr.* FROM crowdsourcing_workerrequesterrating wr
INNER JOIN (
SELECT origin_id, target_id, MAX(last_updated) AS max_date
FROM crowdsourcing_workerrequesterrating
GROUP BY origin_id, target_id) fltr
ON fltr.origin_id=wr.origin_id AND fltr.target_id=wr.target_id AND
wr.last_updated=fltr.max_date AND wr.target_id=%(worker_profile)s AND wr.origin_type='requester') sult
GROUP BY target_id) avgreq
ON w.target_id=avgreq.target_id
INNER JOIN (
SELECT origin_id, target_id, MAX(last_updated) AS max_date
FROM crowdsourcing_workerrequesterrating
GROUP BY origin_id, target_id
) tmp ON w.origin_id = tmp.origin_id AND w.target_id = tmp.target_id AND
w.last_updated=tmp.max_date AND w.origin_type='requester') temp) als
ON owner_id=als.origin_id
INNER JOIN (
SELECT id, CASE WHEN elapsed_time > hard_deadline THEN 0
WHEN elapsed_time/hard_deadline > submitted_tasks/total_tasks THEN
min_rating * (1 - (elapsed_time/hard_deadline - submitted_tasks/total_tasks))
ELSE min_rating END imputed_rating
FROM (
SELECT m.*, COALESCE(submitted_tasks, 0) as submitted_tasks,
(num_tasks * m.repetition) AS total_tasks,
EXTRACT('EPOCH' FROM NOW() - m.created_timestamp) AS elapsed_time,
EXTRACT('EPOCH' FROM INTERVAL '1 day') AS hard_deadline
FROM crowdsourcing_module m
INNER JOIN (SELECT module_id, COUNT(id) AS
num_tasks FROM crowdsourcing_task GROUP BY module_id) tsk
ON m.id=module_id
LEFT OUTER JOIN (SELECT task_id, COUNT(task_id) AS submitted_tasks FROM
(SELECT task_worker_id, task_id FROM crowdsourcing_taskworkerresult
INNER JOIN (SELECT task_id, id FROM crowdsourcing_taskworker GROUP BY task_id, id) tw
ON tw.id = task_worker_id GROUP BY task_worker_id, task_id) tmp GROUP BY task_id) sbmt
ON sbmt.task_id = id) calc) imprat ON imprat.id = m.id) avgrat)
evr WHERE worker_relevant_rating > imputed_rating) rnk
INNER JOIN crowdsourcing_requester rq ON rnk.owner_id = rq.id
INNER JOIN crowdsourcing_userprofile up ON rq.profile_id = up.id
LEFT OUTER JOIN
(SELECT w.* FROM crowdsourcing_workerrequesterrating w
INNER JOIN(
SELECT target_id, MAX(last_updated) AS max_date FROM crowdsourcing_workerrequesterrating
WHERE origin_type='worker' AND origin_id=%(worker_profile)s GROUP BY target_id) tb
ON w.target_id = tb.target_id AND w.last_updated = tb.max_date AND w.origin_type='worker'
AND w.origin_id=%(worker_profile)s) wrr
ON up.id = wrr.target_id
LEFT OUTER JOIN (
SELECT target_id, AVG(weight) AS average_requester_rating from
(SELECT wr.* FROM crowdsourcing_workerrequesterrating wr
INNER JOIN (
SELECT origin_id, target_id, MAX(last_updated) AS max_date FROM crowdsourcing_workerrequesterrating
GROUP BY origin_id, target_id) fltr
ON fltr.origin_id=wr.origin_id AND fltr.target_id=wr.target_id AND wr.last_updated=fltr.max_date
AND wr.origin_id <> %(worker_profile)s AND wr.origin_type='worker') sult GROUP BY target_id) avg
ON avg.target_id = up.id) calc WHERE owner_id<>%(owner)s
) mod INNER JOIN crowdsourcing_project p ON p.id=mod.project_id
GROUP BY p.id, p.name, p.description, relevant_requester_rating
ORDER BY case when 1=%(sorting_type)s then relevant_requester_rating else p.id end desc,
case when 1=%(sorting_type)s then p.id end desc;
'''
projects = Project.objects.select_related('modules').\
raw(query, params={'worker_profile': request.user.userprofile.id,
'sorting_type': worker_config['sorting_type'],
'owner': requester_id, 'has_prototype': worker_config['has_prototype']})
#for project in projects:
#m = Module.objects.get(id=project.module_id)
#m.min_rating = project.imputed_rating
#m.save()
# pass
'''
TODO query above has to be rewritten and min_rating has to be updated, disabling it now because we
dont need cascading for CHI, it has to be optimized too -DM
'''
projects_serialized = ProjectSerializer(projects, fields=('id', 'name', 'description', 'modules_filtered', 'owner'),
many=True, context={'request': request})
return Response(projects_serialized.data)
except:
return Response([])
def post(self, request, *args, **kwargs):
from django.contrib.auth import authenticate as auth_authenticate, login
# self.redirect_to = request.POST.get('next', '') #to be changed, POST does not contain any data
username = request.data.get('username', '')
password = request.data.get('password', '')
email_or_username = username
# match with username if not email
if not re.match(r"[^@]+@[^@]+\.[^@]+", email_or_username):
username = email_or_username
else:
user = get_model_or_none(User, email=email_or_username)
if user is not None:
username = user.username
user = auth_authenticate(username=username, password=password)
if user is not None:
if user.is_active:
login(request, user)
response_data = dict()
response_data["username"] = user.username
response_data["email"] = user.email
response_data["first_name"] = user.first_name
response_data["last_name"] = user.last_name
response_data["date_joined"] = user.date_joined
response_data["last_login"] = user.last_login
response_data["is_requester"] = hasattr(
request.user.userprofile, 'requester')
response_data["is_worker"] = hasattr(request.user.userprofile,
'worker')
'''
For experimental phase only, to be removed later.
{begin experiment}
'''
if hasattr(request.user.userprofile, 'requester'):
experiment_model = get_model_or_none(
experimental_models.RequesterExperiment,
requester=request.user.userprofile.requester)
if experiment_model:
response_data['requester_experiment_fields'] = {
"has_prototype": experiment_model.has_prototype,
"has_boomerang": experiment_model.has_boomerang,
"pool": experiment_model.pool
}
else:
response_data['requester_experiment_fields'] = {
"has_prototype": True,
"has_boomerang": True,
"pool": -1
}
if hasattr(request.user.userprofile, 'worker'):
experiment_model = get_model_or_none(
experimental_models.WorkerExperiment,
worker=request.user.userprofile.worker)
if experiment_model:
response_data['worker_experiment_fields'] = {
"has_prototype": experiment_model.has_prototype,
"sorting_type": experiment_model.sorting_type,
"pool": experiment_model.pool,
"is_subject_to_cascade":
experiment_model.is_subject_to_cascade,
"feedback_required":
experiment_model.feedback_required
}
else:
response_data['worker_experiment_fields'] = {
"has_prototype": True,
"sorting_type": 1,
"is_subject_to_cascade": True,
"pool": -1,
"feedback_required": False
}
'''
{end experiment}
'''
return Response(response_data, status.HTTP_200_OK)
else:
raise AuthenticationFailed(_('Account is not activated yet.'))
else:
raise AuthenticationFailed(_('Username or password is incorrect.'))
def post(self, request, *args, **kwargs):
from django.contrib.auth import authenticate as auth_authenticate, login
# self.redirect_to = request.POST.get('next', '') #to be changed, POST does not contain any data
username = request.data.get("username", "")
password = request.data.get("password", "")
email_or_username = username
# match with username if not email
if not re.match(r"[^@]+@[^@]+\.[^@]+", email_or_username):
username = email_or_username
else:
user = get_model_or_none(User, email=email_or_username)
if user is not None:
username = user.username
user = auth_authenticate(username=username, password=password)
if user is not None:
if user.is_active:
login(request, user)
response_data = dict()
response_data["username"] = user.username
response_data["email"] = user.email
response_data["first_name"] = user.first_name
response_data["last_name"] = user.last_name
response_data["date_joined"] = user.date_joined
response_data["last_login"] = user.last_login
response_data["is_requester"] = hasattr(request.user.userprofile, "requester")
response_data["is_worker"] = hasattr(request.user.userprofile, "worker")
"""
For experimental phase only, to be removed later.
{begin experiment}
"""
if hasattr(request.user.userprofile, "requester"):
experiment_model = get_model_or_none(
experimental_models.RequesterExperiment, requester=request.user.userprofile.requester
)
if experiment_model:
response_data["requester_experiment_fields"] = {
"has_prototype": experiment_model.has_prototype,
"has_boomerang": experiment_model.has_boomerang,
"pool": experiment_model.pool,
}
else:
response_data["requester_experiment_fields"] = {
"has_prototype": True,
"has_boomerang": True,
"pool": -1,
}
if hasattr(request.user.userprofile, "worker"):
experiment_model = get_model_or_none(
experimental_models.WorkerExperiment, worker=request.user.userprofile.worker
)
if experiment_model:
response_data["worker_experiment_fields"] = {
"has_prototype": experiment_model.has_prototype,
"sorting_type": experiment_model.sorting_type,
"pool": experiment_model.pool,
"is_subject_to_cascade": experiment_model.is_subject_to_cascade,
"feedback_required": experiment_model.feedback_required,
}
else:
response_data["worker_experiment_fields"] = {
"has_prototype": True,
"sorting_type": 1,
"is_subject_to_cascade": True,
"pool": -1,
"feedback_required": False,
}
"""
{end experiment}
"""
return Response(response_data, status.HTTP_200_OK)
else:
raise AuthenticationFailed(_("Account is not activated yet."))
else:
raise AuthenticationFailed(_("Username or password is incorrect."))
def reset_password(self, request):
password = request.data.get('password', 'N')
password_reset_model = get_model_or_none(models.UserPasswordReset, reset_key=request.data.get('reset_key', ''))
serializer = UserSerializer(context={'request': request})
data, http_status = serializer.reset_password(reset_model=password_reset_model, password=password)
return Response(data=data, status=http_status)
