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)