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
3
View Complete Implementation : test_users.py
Copyright GNU Affero General Public License v3.0
Author : maas
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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