def post(self, request, *args, **kwargs): """Handles logic and Returns response for `POST` requests to `/login`""" username = request.POST.get('username') password = request.POST.get('password') if not request.POST.get('remember_me', None): request.session.set_expiry(0) if '@' in username: kwargs = {'email': username} else: kwargs = {'username': username} try: user = User.objects.get(**kwargs) if user.check_password(password): user_backend = authenticate( username=user.username, password=password, ) if not user_backend: raise User.DoesNotExist() login(request, user_backend) return redirect(reverse('app.dashboard')) else: raise User.DoesNotExist() except (User.DoesNotExist, User.MultipleObjectsReturned): messages.error(request, 'Wrong username or password.') return redirect(reverse('app.index'))
def _remove_django_user(username): # Get the user associated with the username, delete their apps, and # then delete the user try: user = User.objects.get(username=username) apps = App.objects.filter(user=user) for app in apps: app_id = app.app_id DataHubManager.remove_app(app_id=app_id) Collaborator.objects.filter(user=user).delete() user.delete() except User.DoesNotExist: user = None # Do the same thing for legacy users try: legacy_user = DataHubLegacyUser.objects.get(username=username) apps = App.objects.filter(legacy_user=legacy_user) for app in apps: app_id = app.app_id DataHubManager.remove_app(app_id=app_id) legacy_user.delete() except DataHubLegacyUser.DoesNotExist: legacy_user = None # Raise a not found exception if this didn't result in any deletions if not user and not legacy_user: raise User.DoesNotExist()
def signupView(request) : if request.method == 'POST' : try : # checking if the user already exists username = request.POST.get('username') email = request.POST.get('email') password = request.POST.get('password') if not is_valid_email(email) or not is_valid_username(username) : messages.error(request, 'Invalid username or email address') return redirect('/account/signup/') if User.objects.filter(username=username).exists() or User.objects.filter(email=email).exists() : messages.error(request,'User already exists with those credentials') return redirect('/account/signup/') else : raise User.DoesNotExist() except User.DoesNotExist : # when the user doesnot exist we create a new user user = User.objects.create_user(username=username, email=email, password=password) profile = UserProfile( user=user, username=username, profile_pic = request.FILES.get('profile_pic', 'default.png'), bio = request.POST.get('bio') ) profile.save() user.save() messages.success(request, 'Account succesfully created. Please login to continue.') return redirect('/account/login/') else : # request method is GET return render(request, 'account/signup.html')
def submit_group_completion(self, block_key, completion, users=None, user_ids=None): """ Submit a completion for a group of users. Arguments: block_key (opaque_key.edx.keys.UsageKey): The block to submit completions for. completion (float): A value in the range [0.0, 1.0] users ([django.contrib.auth.models.User]): An optional iterable of Users that completed the block. user_ids ([int]): An optional iterable of ids of Users that completed the block. Returns a list of (BlockCompletion, bool) where the boolean indicates whether the given BlockCompletion was newly created. """ if users is None: users = [] if user_ids is None: user_ids = [] more_users = User.objects.filter(id__in=user_ids) if len(more_users) < len(user_ids): found_ids = {u.id for u in more_users} not_found_ids = [pk for pk in user_ids if pk not in found_ids] raise User.DoesNotExist("User not found with id(s): {}".format(not_found_ids)) users.extend(more_users) submitted = [] for user in users: submitted.append(BlockCompletion.objects.submit_completion( user=user, block_key=block_key, completion=completion )) return submitted
def testAcceptFromRealEndpoint(self): username = '******' request = RequestFactory().post('/login', { 'username': username, 'password': '******' }) server = self.TestWebServer(self.Always200Handler) server.start() auth = HttpBasicEndpointAuth(endpoint=server.getUrl()) # Stub out user object retrieval & creation mockUserDao = flexmock(User.objects) mockUserDao.should_receive('get').and_raise(User.DoesNotExist()) mockUserDao.should_call('create_user').with_args(username, '')\ .at_least.once # Ditto for group object retrieval group = Group.objects.create(name='test-group') group.save() mockGroupDao = flexmock(Group.objects) mockGroupDao.should_receive('get').with_args(name='test-group')\ .and_return(group).at_least.once mockGroupDao.should_receive('get').with_args(name='unknown-group')\ .and_raise(Group.DoesNotExist) result = auth.authenticate(request) server.stop() self._checkResult(result, username)
def get_user_from_irc_nick(self, irc_nick): irc_nick = irc_nick.lstrip(":").lower() users = get_or_create_bugzilla_users(self.query_users(":" + irc_nick)) for user in users: if user.username.lower() == irc_nick: return user raise User.DoesNotExist()
def join(request, username, groupname): """Add user to a group specified by name. :param str username: user name. :param str groupname: group name to add given user name. :raise PermissionDenied: if the request has no permission to add a user to a group. :raise Object.DoesNotExist: if user name or group name does not exist. Example:: >>> User.join('username', 'groupname') """ try: user = User.objects.get(username=username) except User.DoesNotExist: raise User.DoesNotExist('User "%s" does not exist' % username) else: try: group = Group.objects.get(name=groupname) except Group.DoesNotExist: raise Group.DoesNotExist('Group "%s" does not exist' % groupname) else: user.groups.add(group)
def authenticate(self, request, username=None, password=None): try: user = User.objects.get(email=username) if user.check_password(password): return user return None except User.DoesNotExist(): return None
def get_user_from_auth(request): try: user_id = request.auth.user_id except ValueError: raise ValueError("Invalid authentication token!") try: return User.objects.get(pk=user_id) except User.DoesNotExist: raise User.DoesNotExist("User for given id does not exists!")
def fromUser(**kwargs): user = User.objects.get(**kwargs) if hasattr(user, 'trosnothuser'): result = user.trosnothuser elif user.username == 'autoadmin': # Special case: autoadmin is not allowed to actually play raise User.DoesNotExist('autoadmin is not allowed to play') else: result = TrosnothUser(user=user, nick=user.username) result.save() return result
def send_password_reset_email(email, request=None): form = PasswordResetForm({'email': email}) if not form.is_valid(): raise User.DoesNotExist(email) request = request or create_request_for_email() template_base = 'wagtailadmin/account/password_reset/' form.save(request=request, subject_template_name=template_base + 'email_subject.txt', email_template_name=template_base + 'email.txt', use_https=request.is_secure())
def default_django_user(self): login_id = "" # first choice: web user login if self.web_account.login_id: login_id = self.web_account.login_id # second choice: latest registered commcare account elif self.commcare_accounts: login_id = _get_default(self.commcare_accounts).login_id else: raise User.DoesNotExist( "This couch user doesn't have a linked django login!") return django_user_from_couch_id(login_id)
def testAllowOnSuccess(self): username = '******' request = RequestFactory().post('/login', { 'username': username, 'password': '******'}) # A "successful" mock OpenerDirector result = tempfile.TemporaryFile(mode='r') mockOpener = flexmock(urllib2.OpenerDirector(), open = result) # Stub out user object retrieval & creation mockUserDao = flexmock(User.objects) mockUserDao.should_receive('get').and_raise(User.DoesNotExist()) mockUserDao.should_call('create_user').with_args(username, '')\ .at_least.once auth = HttpBasicEndpointAuth(mockOpener,endpoint=self.mock_endpoint) self._checkResult(auth.authenticate(request),username)
def test_backend_profile_exceptions(self, p_mock): # We have a legitimate profile, but for some reason the user_id is # phony. s = SessionBackend() session = Session.objects.get(pk='17f051c99f083244bf653d5798111216') p_mock.side_effect = User.DoesNotExist() eq_(None, s.authenticate(session)) p_mock.side_effect = IntegrityError() eq_(None, s.authenticate(session)) p_mock.side_effect = Exception() eq_(None, s.authenticate(session))
def authenticate(self, request): username = request.GET.get('username') if username is None: return None try: user = User.objects.get(username=username) except User.DoesNotExist(): raise AuthenticationFailed("username does't match") return (user, None) #on web #http://127.0.0.1:8000/studentapi/?username=piyush
def join(request, username, groupname): """ Description: Add user to a group specified by name. Returns: None Raises: PermissionDenied Object.DoesNotExist Example: >>> User.join('username', 'groupname') """ try: user = User.objects.get(username=username) except User.DoesNotExist, e: raise User.DoesNotExist('User "%s" does not exist' % username)
def GET_USER_BY_USERNAME(username): from django.contrib.auth.models import User # from django_auth_ldap.backend import LDAPBackend for domain in ('@clemson.edu', '@g.clemson.edu', '@exchange.clemson.edu'): if username.lower().endswith(domain): username = username[:-len(domain)] break try: return User.objects.get(username=username) except User.DoesNotExist: # backend = LDAPBackend() user = backend.populate_user(username) if user is None: raise User.DoesNotExist('%s not in LDAP or database' % username) return user
def activate(request, uidb64, token): try: uid = force_text(urlsafe_base64_decode(uidb64)) user = User.objects.get(pk=uid) except (TypeError, ValueError, OverflowError, User.DoesNotExist()): user = None if user is not None and account_activation_token.check_token(user, token): user.is_active = True user.save() # profile.save() # registered = True login(request, user) return HttpResponse( 'Thank you for your email confirmation. Now you can login your account.' ) # return redirect('home') else: return HttpResponse('Activation link is invalid or Expired!')
def fse_username_validator(username): flag = True try: _ = User.objects.get(username=username) except User.DoesNotExist(): flag = False if flag: raise ValidationError( '%(value)s is already registered. Double registration is not allowed.', params={'value': username} ) try: data = get_account(username, type='2') except RuntimeError as err: raise ValidationError('{}'.format(err)) try: value = data['accounts'][0]['label'] except (KeyError, IndexError): raise ValidationError('%(value)s is not a valid FSEconomy account', params={'value': username}) if value != username: raise ValidationError('%(value)s is not a valid FSEconomy account', params={'value': username})
def update_from_data(pool_id, pool_member_data): """ Adds a new member whose username is in `pool_data`. Args: pool_id: The pool id of an existing pool pool_data: Expected to be in the format: {"username": <username of new member>} Raises: User.DoesNotExist: If the user within `pool_data` doesn't exist. Pool.DoesNotExist: If the pool doesn't exist. TooManyMembersException: If we attempt to add more users than the pool can handle. """ # 0. Validate the `pool_data` and `pool_id`. assert pool_id.isdigit() assert "username" in pool_member_data member_username = pool_member_data["username"] pool_id = long(pool_id) # 1. Validate that a user exists with `member_username` user = User.objects.get(username=member_username) if not user: raise User.DoesNotExist() # 2. Attempt to fetch the Pool. pool = Pool.objects.get(id=pool_id) if not pool: raise Pool.DoesNotExist() logger.info('pool: %s' % pool) # 3. Add the new member to the pool. pool.add_member(user) logger.info('pool after adding member: %s' % pool.members.all()) return pool.members.all()
def get_user(email, **kwargs): try: name = hash_email(email) except UnicodeEncodeError: raise User.DoesNotExist() return User.objects.get(username=name, **kwargs)
def validate_username(self, value): if not User.objects.filter(username=value).exists(): raise User.DoesNotExist("Cannot find username matching '{}'".format(value)) return value
def get_user(self,user_id): try: return User.objects.get(pk=user_id) except User.DoesNotExist(): return None
def view_user_doesnotexist(request): # pylint: disable=W0613 "A dummy view that raises a User.DoesNotExist exception" raise User.DoesNotExist()
def user_does_not_exist_side_effect(username="******"): raise User.DoesNotExist()