Python functions.Lower方法代码示例

# 需要导入模块: from django.db.models import functions [as 别名]
# 或者: from django.db.models.functions import Lower [as 别名]
def team_listing(request):
    """Return a listing of teams visible to the user."""
    team_list = Team.objects.user_visible(request.user).order_by(Lower('name'))
    desc = _('List of teams on {name} and summary information').format(name=get_current_site(request).name)  # nopep8

    user_teams = set()
    user_invites = set()
    user_pending = set()
    user_owns = set()

    if request.user.is_authenticated:
        user_invites = set(TeamRequest.objects.filter(invitee=request.user, inviter__isnull=False).values_list('team', flat=True))
        user_pending = set(TeamRequest.objects.filter(invitee=request.user, inviter__isnull=True).values_list('team', flat=True))
        user_teams = set(request.user.team_set.values_list('id', flat=True))
        user_owns = set(Team.objects.filter(owner=request.user).values_list('id', flat=True))

    return render(request, 'teams/teams.html', {
        'teams': make_paginator(request, team_list),
        'meta_description': desc,
        'user_teams': user_teams,
        'user_invites': user_invites,
        'user_pending': user_pending,
        'user_owns': user_owns,
    }) 

# 需要导入模块: from django.db.models import functions [as 别名]
# 或者: from django.db.models.functions import Lower [as 别名]
def clean_domain_name(field_name):
    """
    Returns a Django query expression that replaces all underscores with a
    hyphen, removes leading and trailing hyphens, and converts the field to
    lower case.
    """
    remove_underscores = Func(
        F(field_name),
        Value('_'),
        Value('-'),
        function='replace'
    )
    trim_hyphens = Func(
        remove_underscores,
        Value('-'),
        function='btrim',
    )
    remove_trailing_hyphens = Func(
        trim_hyphens,
        Value(r'[-]+\.'),
        Value('.'),
        Value('g'),
        function='regexp_replace'
    )
    return Lower(remove_trailing_hyphens) 

# 需要导入模块: from django.db.models import functions [as 别名]
# 或者: from django.db.models.functions import Lower [as 别名]
def alphabetize(order, fields):
    """Returns the correct sort order

    :param order: The list of ordering
    :type order: list
    :param fields: The list of fields to alphabetize
    :type fields: list
    """

    ordering = []
    for o in order:
        if o in fields:
            # Check for descending first (prepended with a -)
            if o[0] == '-':
                ordering.append(Lower(o[1:]).desc())
            else:
                ordering.append(Lower(o))
        else:
            ordering.append(o)

    return ordering 

# 需要导入模块: from django.db.models import functions [as 别名]
# 或者: from django.db.models.functions import Lower [as 别名]
def get_queryset(self):
        event = Event.objects.get(slug=self.kwargs.get('slug'))
        queryset = Ticket.objects.filter(type__event=event).order_by(Lower('last_name'), Lower('first_name'))

        search = self.request.GET.get('search')
        if search:
            queryset = queryset.filter(
                Q(first_name__icontains=search) |
                Q(last_name__icontains=search) |
                Q(email__icontains=search)
            )

        registered_only = self.request.GET.get('registered_only')
        if registered_only:
            queryset = queryset.filter(status=Ticket.REGISTERED)

        return queryset 

# 需要导入模块: from django.db.models import functions [as 别名]
# 或者: from django.db.models.functions import Lower [as 别名]
def get_ordering(self, request, queryset):
        ordering = super().get_ordering(request, queryset)
        for i in range(len(ordering)):
            desc = False
            fieldname = ordering[i]
            if fieldname.startswith("-"):
                fieldname = fieldname[1:]
                desc = True

            try:
                field = queryset.model()._meta.get_field(
                    "id" if fieldname == "pk" else fieldname
                )
            except FieldDoesNotExist:
                continue

            f_type = field.db_type(connection)
            if f_type != "text":
                continue

            if desc:
                ordering[i] = Lower(fieldname).desc()
            else:
                ordering[i] = Lower(fieldname)
        return ordering 

# 需要导入模块: from django.db.models import functions [as 别名]
# 或者: from django.db.models.functions import Lower [as 别名]
def test_basic(self):
        Author.objects.create(name='John Smith', alias='smithj')
        Author.objects.create(name='Rhonda')
        authors = Author.objects.annotate(name_part=Substr('name', 5, 3))
        self.assertQuerysetEqual(
            authors.order_by('name'), [' Sm', 'da'],
            lambda a: a.name_part
        )
        authors = Author.objects.annotate(name_part=Substr('name', 2))
        self.assertQuerysetEqual(
            authors.order_by('name'), ['ohn Smith', 'honda'],
            lambda a: a.name_part
        )
        # If alias is null, set to first 5 lower characters of the name.
        Author.objects.filter(alias__isnull=True).update(
            alias=Lower(Substr('name', 1, 5)),
        )
        self.assertQuerysetEqual(
            authors.order_by('name'), ['smithj', 'rhond'],
            lambda a: a.alias
        ) 

# 需要导入模块: from django.db.models import functions [as 别名]
# 或者: from django.db.models.functions import Lower [as 别名]
def test_basic(self):
        Author.objects.create(name='John Smith', alias='smithj')
        Author.objects.create(name='Rhonda')
        authors = Author.objects.annotate(lower_name=Lower('name'))
        self.assertQuerysetEqual(
            authors.order_by('name'), ['john smith', 'rhonda'],
            lambda a: a.lower_name
        )
        Author.objects.update(name=Lower('name'))
        self.assertQuerysetEqual(
            authors.order_by('name'), [
                ('john smith', 'john smith'),
                ('rhonda', 'rhonda'),
            ],
            lambda a: (a.lower_name, a.name)
        ) 

# 需要导入模块: from django.db.models import functions [as 别名]
# 或者: from django.db.models.functions import Lower [as 别名]
def team_members(request, team_id):
    """Return a listing of members for the given team."""
    team = get_object_or_404(Team, pk=team_id)

    is_member, pending_invitation = member_status(request.user, team)

    if not is_member and not team.public and not pending_invitation:
        raise PermissionDenied()

    return render(request, 'teams/members.html', {
        'team': team,
        'members': make_paginator(request, team.members.order_by(Lower('username'))),
        'is_owner': team.owner == request.user,
    }) 

# 需要导入模块: from django.db.models import functions [as 别名]
# 或者: from django.db.models.functions import Lower [as 别名]
def __init__(self, *args, user=None, **kwargs):
        super().__init__(*args, **kwargs)

        # NOTE: a user who doesn't have access to a team can see the team name here if it's already a collaborator
        # on the board. In the future, might want to hide those team names here
        team_ids = set(Team.objects.user_visible(user=user).values_list('id', flat=True)) | set(kwargs['instance'].teams.values_list('id', flat=True))
        self.fields['teams'].queryset = Team.objects.filter(id__in=team_ids).order_by(Lower('name'))
        self.fields['collaborators'].queryset = User.objects.all().order_by(Lower('username'))
        self.fields['collaborators'].label = _('User Collaborators')
        self.fields['teams'].label = _('Team Collaborators') 

# 需要导入模块: from django.db.models import functions [as 别名]
# 或者: from django.db.models.functions import Lower [as 别名]
def clean_email(self):
        """
        Ensure that the email address provided is unique (in a case-insensitive manner).
        """
        email_value = self.cleaned_data['email']
        if not email_value:
            raise ValidationError(_("Enter a valid email address."))
        invalid_email = '{}{}'.format(settings.INVALID_PREFIX, email_value)
        emails_lookup = Q(email_lc=email_value.lower()) | Q(email_lc=invalid_email.lower())
        if email_value and email_value.lower() != self.previous_email.lower() \
                and User.objects.annotate(email_lc=Lower('email')).filter(emails_lookup).exists():
            raise ValidationError(_("User address already in use."))
        return email_value 

# 需要导入模块: from django.db.models import functions [as 别名]
# 或者: from django.db.models.functions import Lower [as 别名]
def init_from_get_params(self, get_params: QueryDict) -> bool:
        tags = {tag.lower() for tag in get_params.getlist(self.GET_TAG_SEARCH)}
        self.tags = Tag.objects.annotate(name_lower=Lower('name')).filter(name_lower__in=tags)
        return bool(self.tags) 

# 需要导入模块: from django.db.models import functions [as 别名]
# 或者: from django.db.models.functions import Lower [as 别名]
def test_list(self):
        """ Verify the endpoint returns a list of all courses. """
        url = reverse('api:v1:course-list')

        with self.assertNumQueries(25):
            response = self.client.get(url)
        self.assertEqual(response.status_code, 200)
        self.assertListEqual(
            response.data['results'],
            self.serialize_course(Course.objects.all().order_by(Lower('key')), many=True)
        ) 

# 需要导入模块: from django.db.models import functions [as 别名]
# 或者: from django.db.models.functions import Lower [as 别名]
def test_list(self):
        """ Verify the endpoint returns a list of all course runs. """
        url = reverse('api:v1:course_run-list')

        with self.assertNumQueries(13):
            response = self.client.get(url)

        assert response.status_code == 200
        self.assertListEqual(
            response.data['results'],
            self.serialize_course_run(CourseRun.objects.all().order_by(Lower('key')), many=True)
        ) 

# 需要导入模块: from django.db.models import functions [as 别名]
# 或者: from django.db.models.functions import Lower [as 别名]
def get_queryset(self):
        return super(SiteManager, self).get_queryset().order_by(Lower("hostname")) 

# 需要导入模块: from django.db.models import functions [as 别名]
# 或者: from django.db.models.functions import Lower [as 别名]
def make_usernames_lower(apps, schema_editor):
    from django.db.models.functions import Lower
    from django.db.models import Count
    from ...core.conf import settings
    User = apps.get_model(settings.AUTH_USER_MODEL)

    if settings.ST_CASE_INSENSITIVE_USERNAMES:
        try:
            with transaction.atomic():
                User.objects.all().update(
                    username=Lower('username'))
        except IntegrityError:
            # Show all duplicated usernames
            users_lower = (
                User.objects
                .annotate(username_lower=Lower('username'))
                .values('username_lower')
                .annotate(cnt=Count(Lower('username')))
                .values('username_lower', 'cnt')
                .filter(cnt__gt=1)
                .order_by('username_lower', 'cnt'))
            users = [
                u.username
                for u in (
                    User.objects
                    .annotate(username_lower=Lower('username'))
                    .filter(username_lower__in=[
                        u['username_lower'] for u in users_lower]))]
            raise IntegrityError(
                'There are two or more users with '
                'similar name but different casing, for example: '
                'someUser and SomeUser, either remove one of them '
                'or set the `ST_CASE_INSENSITIVE_USERNAMES` setting '
                'to False. Then run the upgrade/migration again. '
                'Any change was reverted. Duplicate users are {}'.format(users))