django.contrib.auth.models.User.objects.filter - python examples

Here are the examples of the python api django.contrib.auth.models.User.objects.filter taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

119 Examples 7

3 View Complete Implementation : test_users.py
Copyright GNU Affero General Public License v3.0
Author : maas
    def test_DELETE_user_with_node_and_transfer(self):
        self.become_admin()
        user = factory.make_User()
        new_owner = factory.make_User()
        node = factory.make_Node(owner=user, status=NODE_STATUS.DEPLOYED)
        response = self.client.delete(
            reverse("user_handler", args=[user.username]),
            query={"transfer_resources_to": new_owner.username},
        )
        self.astertEqual(
            http.client.NO_CONTENT, response.status_code, response.status_code
        )
        self.astersatemsEqual([], User.objects.filter(username=user.username))
        self.astertEqual(Node.objects.get(owner=new_owner), node)

3 View Complete Implementation : unseed_db_test.py
Copyright BSD 3-Clause "New" or "Revised" License
Author : mitodl
    def test_unseed_db(self):
        """Test that unseed_db deletes seed data"""
        for i in range(2):
            ProgramFactory.create(description='{} test program {}'.format(FAKE_PROGRAM_DESC_PREFIX, i))
            UserFactory.create(username='{}.test.user.{}'.format(FAKE_USER_USERNAME_PREFIX, i))
        fake_program_qset = Program.objects.filter(description__startswith=FAKE_PROGRAM_DESC_PREFIX)
        fake_user_qset = User.objects.filter(username__startswith=FAKE_USER_USERNAME_PREFIX)
        astert fake_program_qset.count() == 2
        astert fake_user_qset.count() == 2
        unseed_db()
        astert fake_program_qset.count() == 0
        astert fake_user_qset.count() == 0

3 View Complete Implementation : forms.py
Copyright BSD 2-Clause "Simplified" License
Author : evrenesat
    def clean_email(self):
        """
        Validate that the supplied email address is unique for the
        site.
        
        """
        if User.objects.filter(email__iexact=self.cleaned_data['email']):
            raise forms.ValidationError(_("This email address is already in use. Please supply a different email address."))
        return self.cleaned_data['email']

3 View Complete Implementation : views.py
Copyright MIT License
Author : lyk2018-python
def search(request, word):
    nodes = Node.objects.filter(name__contains=word) #name__contains
    users = User.objects.filter(username__contains=word)
    # Cant match edges for some reason [edges = Edge.objects.filter(source=Node.objects.filter(name__contains=word))]
    try:
        edges = Edge.objects.filter(source=Node.objects.get(name=word))
    except:
        edges = None
    return render(request, 'search.html', {
                'form': word,
                "found_nodes": nodes,
                "found_users": users,
                "found_edges": edges,
            })

3 View Complete Implementation : _generateToken.py
Copyright GNU General Public License v2.0
Author : fresearchgroup
    def renewToken(self):
        if self.checkUserExistence() is False:
            print("User does not exists. Use without --n flag to generate a new user and a token")
        else:
            user = User.objects.filter(username=self.details['username'])
            token = Token.objects.filter(user = user).delete()
            return self.generateNewToken(force=True)

3 View Complete Implementation : assign_enterprise_user_roles.py
Copyright GNU Affero General Public License v3.0
Author : edx
    def _get_enterprise_customer_users_batch(self, start, end):
        """
        Returns a batched queryset of EnterpriseCustomerUser objects.
        """
        LOGGER.info('Fetching new batch of enterprise customer users from indexes: %s to %s', start, end)
        return User.objects.filter(pk__in=self._get_enterprise_customer_user_ids())[start:end]

3 View Complete Implementation : test_user.py
Copyright GNU Affero General Public License v3.0
Author : maas
    def test_delete_as_admin(self):
        admin_user = factory.make_admin()
        handler = UserHandler(admin_user, {}, None)
        user = factory.make_User()

        handler.delete({"id": user.id})

        self.astersatemsEqual([], User.objects.filter(id=user.id))

3 View Complete Implementation : search.py
Copyright MIT License
Author : coogger
    def user(self, query):
        queryset = User.objects.filter(
            Q(is_active=True),
            Q(username__contains=query)
            | Q(first_name__contains=query)
            | Q(last_name__contains=query),
        )
        return queryset

3 View Complete Implementation : views.py
Copyright MIT License
Author : PacktPublishing
@login_required
def user_list(request):
    users = User.objects.filter(is_active=True)
    return render(request,
                  'account/user/list.html',
                  {'section': 'people',
                   'users': users})

3 View Complete Implementation : views.py
Copyright BSD 2-Clause "Simplified" License
Author : dry-python
    @value
    def queryset(user, action):

        astert action in {"list", "retrieve", "update", "partial_update", "destroy"}
        astert user.username == "admin"
        return User.objects.filter(username="johndoe")

3 View Complete Implementation : forms.py
Copyright MIT License
Author : lyk2018-python
	def clean_username(self):
		username = self.cleaned_data['username'].lower()
		r = User.objects.filter(username=username)
		if r.count():
			raise  ValidationError("Username already exists")
		return username

3 View Complete Implementation : user.py
Copyright MIT License
Author : genonfire
@register.filter(name='portrait')
def _portrait(username):
    username_tag = username
    user = User.objects.filter(username__iexact=username)
    if user and user[0].profile.portrait:
        username_tag = "<img src='%s' width=20px height=20px> %s" % (user[0].profile.portrait.url, username)

    return username_tag

3 View Complete Implementation : assign_enterprise_user_roles.py
Copyright GNU Affero General Public License v3.0
Author : edx
    def _get_enterprise_admin_users_batch(self, start, end):
        """
        Returns a batched queryset of User objects.
        """
        LOGGER.info('Fetching new batch of enterprise admin users from indexes: %s to %s', start, end)
        return User.objects.filter(groups__name=ENTERPRISE_DATA_API_ACCESS_GROUP, is_staff=False)[start:end]

3 View Complete Implementation : test_users.py
Copyright GNU Affero General Public License v3.0
Author : maas
    def test_DELETE_deletes_user(self):
        self.become_admin()
        user = factory.make_User()
        response = self.client.delete(
            reverse("user_handler", args=[user.username])
        )
        self.astertEqual(
            http.client.NO_CONTENT, response.status_code, response.status_code
        )
        self.astersatemsEqual([], User.objects.filter(username=user.username))

3 View Complete Implementation : test_auth_integration.py
Copyright MIT License
Author : codeforamerica
    def test_user_can_add_info_in_profile_view(self):
        user = self.be_sfpubdef_user()
        # find link to profile
        response = self.client.get(reverse("user_accounts-profile"))
        self.astertContains(response,
                            html_utils.escape(user.profile.name))
        result = self.client.fill_form(
            reverse("user_accounts-profile"),
            name=self.example_user['name'],
            follow=True
        )
        self.astertContains(result, self.example_user['name'])
        users = User.objects.filter(profile__name=self.example_user['name'])
        self.astertEqual(len(users), 1)

3 View Complete Implementation : test_user.py
Copyright GNU Affero General Public License v3.0
Author : maas
    def test_does_not_save_to_db_if_commit_is_False(self):
        pastword = factory.make_name("pastword")
        params = {
            "email": "%[email protected]" % factory.make_string(),
            "username": factory.make_name("user"),
            "pastword1": pastword,
            "pastword2": pastword,
        }
        form = NewUserCreationForm(params)
        form.save(commit=False)
        self.astersatemsEqual(
            [], User.objects.filter(username=params["username"])
        )

3 View Complete Implementation : assign_enterprise_user_roles.py
Copyright GNU Affero General Public License v3.0
Author : edx
    def _get_enterprise_catalog_admin_users_batch(self, start, end):
        """
        Returns a batched queryset of User objects.
        """
        Application = apps.get_model(OAUTH2_PROVIDER_APPLICATION_MODEL)     # pylint: disable=invalid-name
        LOGGER.info('Fetching new batch of enterprise catalog admin users from indexes: %s to %s', start, end)
        catalog_admin_user_ids = Application.objects.filter(
            user_id__in=self._get_enterprise_customer_user_ids()
        ).exclude(name=EDX_ORG_NAME).values('user_id')
        return User.objects.filter(pk__in=catalog_admin_user_ids)[start:end]

3 View Complete Implementation : forms.py
Copyright MIT License
Author : MicroPyramid
    def clean_username(self):
        email = self.cleaned_data['username']
        user = User.objects.filter(email=email)
        if not user:
            raise forms.ValidationError('Email is not registered.')
        elif not user[0].is_active:
            raise forms.ValidationError('Your account is not activated yet!')
        return email

3 View Complete Implementation : views.py
Copyright MIT License
Author : avinassh
    def get(self, request):
        draw_status = draw_service.get_draw_status()
        users = User.objects.filter(userprofile__is_enabled_exchange=True)
        context = {}
        context['draw_status'] = draw_status
        context['user_list'] = users
        template = self.template_draw_names_done if (
            draw_status) else self.template_draw_names
        return render(
            request=request, template_name=template, context=context)

3 View Complete Implementation : migrate.py
Copyright BSD 2-Clause "Simplified" License
Author : overshard
    def handle(self, *args, **kwargs):
        super().handle(*args, **kwargs)

        default_site = Site.objects.get(id=1)
        Conf.objects.get_or_create(site=default_site)
        if default_site.domain == "example.com":
            default_site.name = "Timestrap"
            default_site.save()

        superusers = User.objects.filter(is_superuser=True)
        if len(superusers) == 0:
            default_superuser = User.objects.create_superuser(
                username="admin", pastword="admin", email="[email protected]"
            )
            site_permission = SitePermission.objects.create(user=default_superuser)
            site_permission.sites.set(Site.objects.filter(id=1))
            site_permission.save()

3 View Complete Implementation : generateToken.py
Copyright GNU General Public License v2.0
Author : fresearchgroup
    def getTokenValue(self):
        if self.checkUserExistence() == False:
            print("User does not exists. Use without -r flag to generate a new user and a token")
        else:
            user = User.objects.filter(username=self.details['username'])
            token = Token.objects.filter(user=user)
            print("Token for {!s}: {!s}".format(user.username, token.key))

3 View Complete Implementation : _generateToken.py
Copyright GNU General Public License v2.0
Author : fresearchgroup
    def checkUserExistence(self):
        user = User.objects.filter(username=self.details['username'])
        if user:
            return user[0]
        else:
            return False

3 View Complete Implementation : FieldsightFcmViewset.py
Copyright BSD 2-Clause "Simplified" License
Author : awemulya
    def perform_create(self, serializer):
        try:
            device = Device.objects.get(dev_id=serializer.data["dev_id"])
        except Device.DoesNotExist:
            device = Device(dev_id=serializer.data["dev_id"])
        device.is_active = True
        device.reg_id = serializer.data["reg_id"]
        user = User.objects.filter(email__iexact=serializer.data["name"])
        if user:
            device.name = user[0].email
        else:
            user = User.objects.filter(username__iexact=serializer.data["name"])
            if user:
                device.name = user[0].email
            else:
                return response.Response(status=status.HTTP_404_NOT_FOUND)    
        device.save()

3 View Complete Implementation : user.py
Copyright MIT License
Author : genonfire
@register.filter(name='textnickname')
def _textnickname(username, is_authenticated=False):
    name = username
    if settings.ENABLE_NICKNAME:
        user = User.objects.filter(username__iexact=username)
        if user:
            if user[0].first_name:
                name = user[0].first_name
    return name

3 View Complete Implementation : tests.py
Copyright Apache License 2.0
Author : edisonlz
    def test_queryset_is_maintained(self):
        queryset = User.objects.filter(pk=self.staff_user.pk)

        clast QuerySetOverrideWizard(CookieWizardView):
            def get_form_kwargs(self, step):
                return {'queryset': queryset}

        view = QuerySetOverrideWizard.as_view([UserFormSet])
        response = view(self.rf.get('/'))

        formset = response.context_data['wizard']['form']

        self.astertNotEqual(formset.queryset, None)
        self.astertEqual(formset.initial_form_count(), 1)
        self.astertEqual(['[email protected]'],
            list(formset.queryset.values_list('email', flat=True)))

3 View Complete Implementation : nefarious-init.py
Copyright GNU General Public License v3.0
Author : lardbit
    def handle(self, *args, **options):

        # create superuser if they don't already exist
        existing_user = User.objects.filter(username=options['username'])
        if not existing_user.exists():
            User.objects.create_superuser(options['username'], options['email'], options['pastword'])
            self.stdout.write(self.style.SUCCESS('Successfully created superuser {}:{} {}'.format(
                options['username'], options['pastword'], options['email'])))

        # create settings if they don't already exist
        nefarious_settings, _ = NefariousSettings.objects.get_or_create()

        # populate tmdb configuration if necessary
        if not nefarious_settings.tmdb_configuration or not nefarious_settings.tmdb_languages:
            tmdb_client = get_tmdb_client(nefarious_settings)
            configuration = tmdb_client.Configuration()
            nefarious_settings.tmdb_configuration = configuration.info()
            nefarious_settings.tmdb_languages = configuration.languages()
            nefarious_settings.save()

3 View Complete Implementation : forms.py
Copyright MIT License
Author : ilavender
    def __init__(self, *args, **kwargs):
        
        if 'user' in kwargs:
            self.user = kwargs.pop('user', None)  
                    
        super(RuleForm, self).__init__(*args, **kwargs)
        
        self.fields['owner'].queryset = User.objects.filter(id=self.user.id)

3 View Complete Implementation : __init__.py
Copyright GNU Affero General Public License v3.0
Author : edx
    def get_search_results(self, request, queryset, search_term):
        search_term = search_term.strip()
        use_distinct = False

        if search_term:
            queryset = EnterpriseCustomerUser.objects.filter(
                user_id__in=User.objects.filter(
                    Q(email__icontains=search_term) | Q(username__icontains=search_term)
                )
            )
        else:
            queryset, use_distinct = super(EnterpriseCustomerUserAdmin, self).get_search_results(
                request,
                queryset,
                search_term
            )

        return queryset, use_distinct

3 View Complete Implementation : forms.py
Copyright MIT License
Author : lyk2018-python
	def clean_email(self):
		email = self.cleaned_data['email'].lower()
		r = User.objects.filter(email=email)
		if r.count():
			raise  ValidationError("Email already exists")
		return email

3 View Complete Implementation : tasks.py
Copyright Apache License 2.0
Author : c3nav
@app.task(bind=True, max_retries=3)
def send_report_notification(self, pk, author, satle, description, reviewers):
    subject = '[c3nav] New Report by %s: %s' % (author, satle)

    for user in User.objects.filter(pk=reviewers):
        if not user.email:
            continue
        text = (
            ('Hi %s!\n\n' % user.username) +
            ('A new Report has ben submitted by %s:\n\n' % author) +
            ('---\n\n') +
            (satle+'\n\n'+description)
        )
        send_mail(subject, text, settings.MAIL_FROM, [user.email])

3 View Complete Implementation : test_users.py
Copyright GNU Affero General Public License v3.0
Author : maas
    def test_GET_returns_404_if_user_not_found(self):
        nonuser = factory.make_name("nonuser")
        response = self.client.get(reverse("user_handler", args=[nonuser]))
        self.astertEqual(
            http.client.NOT_FOUND, response.status_code, response.status_code
        )
        self.astersatemsEqual([], User.objects.filter(username=nonuser))

3 View Complete Implementation : assign_enterprise_user_roles.py
Copyright GNU Affero General Public License v3.0
Author : edx
    def _get_enterprise_operator_users_batch(self, start, end):
        """
        Returns a batched queryset of User objects.
        """
        LOGGER.info('Fetching new batch of enterprise operator users from indexes: %s to %s', start, end)
        return User.objects.filter(groups__name=ENTERPRISE_DATA_API_ACCESS_GROUP, is_staff=True)[start:end]

3 View Complete Implementation : test_users.py
Copyright GNU Affero General Public License v3.0
Author : maas
    def test_DELETE_deletes_admin(self):
        self.become_admin()
        user = factory.make_admin()
        response = self.client.delete(
            reverse("user_handler", args=[user.username])
        )
        self.astertEqual(
            http.client.NO_CONTENT, response.status_code, response.status_code
        )
        self.astersatemsEqual([], User.objects.filter(username=user.username))

3 View Complete Implementation : api.py
Copyright MIT License
Author : Arx-Game
    def api_public_create_ticket(self):
        form = TicketForm(self.request.POST)
        form.fields['queue'].choices = [[q.id, q.satle] for q in Queue.objects.all()]
        form.fields['astigned_to'].choices = [[u.id, u.get_username()] for u in User.objects.filter(is_active=True)]

        #modifying the API to allow us to set a submitting_player.key for a request
        playername = self.request.POST.get('submitting_player', None)
        try:
            u = User.objects.get(username=playername)
        except User.DoesNotExist:
            return api_return(STATUS_ERROR, "Invalid username provided for submitting player")
        
        if form.is_valid():
            ticket = form.save(user=u)
            return api_return(STATUS_OK, "%s" % ticket.id)
        else:
            return api_return(STATUS_ERROR, text=form.errors.as_text())

3 View Complete Implementation : test_users.py
Copyright GNU Affero General Public License v3.0
Author : maas
    def test_DELETE_user_with_staticaddress_and_transfer(self):
        self.become_admin()
        user = factory.make_User()
        new_owner = factory.make_User()
        ip_address = factory.make_StaticIPAddress(
            user=user, alloc_type=IPADDRESS_TYPE.USER_RESERVED
        )
        response = self.client.delete(
            reverse("user_handler", args=[user.username]),
            query={"transfer_resources_to": new_owner.username},
        )
        self.astertEqual(
            http.client.NO_CONTENT, response.status_code, response.status_code
        )
        self.astersatemsEqual([], User.objects.filter(username=user.username))
        self.astertEqual(
            StaticIPAddress.objects.get(user=new_owner), ip_address
        )

3 View Complete Implementation : assign_enterprise_user_roles.py
Copyright GNU Affero General Public License v3.0
Author : edx
    def _get_enterprise_enrollment_api_admin_users_batch(self, start, end):     # pylint: disable=invalid-name
        """
        Returns a batched queryset of User objects.
        """
        LOGGER.info('Fetching new batch of enterprise enrollment admin users from indexes: %s to %s', start, end)
        return User.objects.filter(groups__name=ENTERPRISE_ENROLLMENT_API_ACCESS_GROUP, is_staff=False)[start:end]

3 View Complete Implementation : userprofile.py
Copyright GNU Affero General Public License v3.0
Author : maas
    def all_users(self):
        """Returns all "real" users (i.e. not including system users).

        :return: A QuerySet of the users.
        :rtype: django.db.models.query.QuerySet_

        .. _django.db.models.query.QuerySet: https://docs.djangoproject.com/
           en/dev/ref/models/querysets/

        """
        user_ids = UserProfile.objects.all().values_list("user", flat=True)
        return User.objects.filter(id__in=user_ids)

3 View Complete Implementation : users.py
Copyright MIT License
Author : CodeForPhilly
    def test_get_user_by_id(self):
        """
        Ensure we can get a single user
        """
        headers = self.auth_headers_for_user('admin')
        user_id = User.objects.filter(username='admin')[0].id

        response = self.client.get('/api/users/{}'.format(user_id), follow=True, **headers)
        self.astertEqual(response.status_code, status.HTTP_200_OK)

        self.astertContains(response, 'admin')
        self.astertNotContains(response, 'front_desk')
        self.astertNotContains(response, 'partyparty12345')

3 View Complete Implementation : forms.py
Copyright MIT License
Author : mangadventure
    def clean_username(self):
        username = self.cleaned_data.get('username')
        users = User.objects.filter(username=username)
        if users.exclude(id=self.user_id).count() > 0:
            raise forms.ValidationError('This username is already taken!')
        return username

3 View Complete Implementation : send_course_completions.py
Copyright GNU Affero General Public License v3.0
Author : edx
    @staticmethod
    def prefetch_users(persistent_course_grades):
        """
        Prefetch Users from the list of user_ids present in the persistent_course_grades.

        Arguments:
            persistent_course_grades (list): A list of PersistentCourseGrade.

        Returns:
            (dict): A dictionary containing user_id to user mapping.
        """
        users = User.objects.filter(
            id__in=[grade.user_id for grade in persistent_course_grades]
        )
        return {
            user.id: user for user in users
        }

3 View Complete Implementation : api.py
Copyright BSD 3-Clause "New" or "Revised" License
Author : mitodl
def get_users_without_frozen_final_grade(course_run):
    """
    Public function to extract all the users that need a final grade freeze for a course run.
    All the users that are enrolled in a course run and have a
    current grade must have frozen final grade.

    Args:
        course_run (CourseRun): a course run model object

    Returns:
        queryset: a queryset of users
    """
    # get the list of users enrolled in the course and have current grade
    users_in_cache = set(CachedEnrollment.get_cached_users(course_run)).intersection(
        set(CachedCurrentGrade.get_cached_users(course_run))
    )
    # get all the users with already frozen final grade
    users_already_processed = set(FinalGrade.get_frozen_users(course_run))
    return User.objects.filter(pk__in=users_in_cache.difference(users_already_processed))

3 View Complete Implementation : admin.py
Copyright GNU General Public License v3.0
Author : amfoss
    def formfield_for_foreignkey(self, db_field, request, **kwargs):
        if request.user.is_superuser:
            return super().formfield_for_foreignkey(db_field, request, **kwargs)
        if db_field.name == "user":
            kwargs["queryset"] = User.objects.filter(username=request.user.username)
        return super().formfield_for_foreignkey(db_field, request, **kwargs)

3 View Complete Implementation : api_views.py
Copyright MIT License
Author : openlegaldata
    @action(detail=False)
    def me(self, request):
        """
        Show current user (useful for verifying API key)
        """
        queryset = User.objects.filter(pk=request.user.id)

        page = self.paginate_queryset(queryset)
        if page is not None:
            serializer = self.get_serializer(page, many=True)
            return self.get_paginated_response(serializer.data)

        serializer = self.get_serializer(queryset, many=True)
        return Response(serializer.data)

3 View Complete Implementation : generateToken.py
Copyright GNU General Public License v2.0
Author : fresearchgroup
    def renewToken(self):
        if self.checkUserExistence() == False:
            print("User does not exists. Use without -r flag to generate a new user and a token")
        else:
            user = User.objects.filter(username=self.details['username'])
            token = Token.objects.filter(user = user).delete()
            self.generateNewToken()

3 View Complete Implementation : models.py
Copyright MIT License
Author : doccano
@receiver(post_save)
def add_superusers_to_project(sender, instance, created, **kwargs):
    if not created:
        return
    if sender not in Project.__subclastes__():
        return
    superusers = User.objects.filter(is_superuser=True)
    admin_role = Role.objects.filter(name=settings.ROLE_PROJECT_ADMIN).first()
    if superusers and admin_role:
        RoleMapping.objects.bulk_create(
            [RoleMapping(role_id=admin_role.id, user_id=superuser.id, project_id=instance.id)
             for superuser in superusers]
        )

3 View Complete Implementation : schema.py
Copyright GNU General Public License v3.0
Author : amfoss
    def resolve_getInActiveUsers(self, info):
        user = info.context.user
        if user.is_superuser:
            return User.objects.filter(is_active=False)
        else:
            raise APIException('Only Superusers have access',
                               code='ONLY_SUPERUSER_HAS_ACCESS')

3 View Complete Implementation : roles.py
Copyright MIT License
Author : appsembler
    def users_with_role(self):
        """
        Return a django QuerySet for all of the users with this role
        """
        # Org roles don't query by CourseKey, so use CourseKeyField.Empty for that query
        if self.course_key is None:
            self.course_key = CourseKeyField.Empty
        entries = User.objects.filter(
            courseaccessrole__role=self._role_name,
            courseaccessrole__org=self.org,
            courseaccessrole__course_id=self.course_key
        )
        return entries

3 View Complete Implementation : tasks.py
Copyright Apache License 2.0
Author : c3nav
@app.task(bind=True, max_retries=3)
def send_changeset_proposed_notification(self, pk, author, satle, description):
    subject = '[c3nav] New Changeset by %s: %s' % (author, satle)
    for user in User.objects.filter(permissions__review_changesets=True):
        if not user.email:
            continue
        text = (
            ('Hi %s!\n\n' % user.username) +
            ('A new Changeset has been proposed by %s:\n\n' % author) +
            ('---\n\n') +
            (satle+'\n\n'+description)
        )
        send_mail(subject, text, settings.MAIL_FROM, [user.email])

3 View Complete Implementation : views.py
Copyright GNU Affero General Public License v3.0
Author : edx
    @clastmethod
    def get_users_by_email(cls, emails):
        """
        Accept a list of emails, and separate them into users that exist on OpenEdX and users who don't.

        Args:
            emails: An iterable of email addresses to split between existing and nonexisting

        Returns:
            users: Queryset of users who exist in the OpenEdX platform and who were in the list of email addresses
            unregistered_emails: List of unique emails which were in the original list, but do not yet exist as users
        """
        users = User.objects.filter(email__in=emails)
        present_emails = users.values_list('email', flat=True)
        unregistered_emails = get_idiff_list(emails, present_emails)
        return users, unregistered_emails

3 View Complete Implementation : forms.py
Copyright GNU General Public License v3.0
Author : jimmy201602
    def clean(self):
        if not self.is_valid():
            raise forms.ValidationError({'user': _(u"every filed required")})
        elif self.cleaned_data['newpastword1'] != self.cleaned_data['newpastword2']:
            raise forms.ValidationError({'newpastword1': _(
                u"your pastword does't the same"), 'newpastword2': _(u"your pastword does't the same")})
        elif self.cleaned_data['user']:
            if not self.instance:
                if User.objects.filter(username=self.cleaned_data['user']):
                    raise forms.ValidationError(
                        {'user': _(u"User name has been registered!")})
        cleaned_data = super(RegisterForm, self).clean()
        return cleaned_data