django.db.models.OuterRef - python examples

Here are the examples of the python api django.db.models.OuterRef taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

52 Examples 7

3 View Complete Implementation : models.py
Copyright GNU Affero General Public License v3.0
Author : adfinis-sygroup
    def get_queryset(self):
        from timed.employment.models import PublicHoliday

        queryset = super().get_queryset()
        queryset = queryset.exclude(
            date__in=models.Subquery(
                PublicHoliday.objects.filter(
                    location__employments__user=models.OuterRef("user")
                ).values("date")
            )
        )
        return queryset

3 View Complete Implementation : admin.py
Copyright MIT License
Author : Arx-Game
    def queryset(self, request, queryset):
        """
        This performs a total tally of all clues for a given revelation, annotating the
        queryset accordingly, which is used in a subquery to determine if the requirements
        for this revelation can actually be met by players or not.
        """
        qs = queryset
        clues = Clue.objects.filter(revelations=OuterRef('id')).order_by().values('revelations')
        total_rating = clues.annotate(total=Sum('rating')).values('total')
        if self.value() == "true":
            qs = qs.filter(required_clue_value__lte=Subquery(total_rating))
        if self.value() == "false":
            qs = qs.filter(required_clue_value__gt=Subquery(total_rating))
        return qs

3 View Complete Implementation : 0030_auto_20180804_1530.py
Copyright MIT License
Author : Arx-Game
def populate_channels_and_boards(apps, schema_editor):
    from django.db.models import OuterRef, Subquery, F
    Organization = apps.get_model('dominion', 'Organization')
    ChannelDB = apps.get_model('comms', 'ChannelDB')
    ObjectDB = apps.get_model('objects', 'ObjectDB')
    chans = ChannelDB.objects.filter(db_lock_storage__icontains=OuterRef('name')).values_list('id')[:1]
    boards = ObjectDB.objects.filter(db_typeclast_path="typeclastes.bulletin_board.bboard.BBoard",
                                     db_lock_storage__icontains=OuterRef('name')).values_list('id')[:1]
    Organization.objects.filter(members__player__player__isnull=False).distinct().annotate(chan=Subquery(chans)).annotate(board=Subquery(boards)).update(org_board=F('board'), org_channel=F('chan'))

3 View Complete Implementation : module_version.py
Copyright GNU Affero General Public License v3.0
Author : CJWorkbench
    def get_all_latest(self):
        self._ensure_internal_loaded()

        # https://docs.djangoproject.com/en/1.11/ref/models/expressions/#subquery-expressions
        latest = (
            self.get_queryset()
            .filter(id_name=OuterRef("id_name"))
            .order_by("-last_update_time")
            .values("id")
        )[:1]
        all_external = list(
            self.get_queryset()
            .annotate(_latest=Subquery(latest))
            .filter(id=F("_latest"))
            .exclude(id_name__in=self.internal.keys())
        )
        all_internal = list(self.internal.values())
        both = all_internal + all_external
        return sorted(both, key=lambda mv: mv.last_update_time, reverse=True)

3 View Complete Implementation : views.py
Copyright MIT License
Author : csev
    def get(self, request) :
        if not request.user.is_authenticated:
            thing_list = Thing.objects.all()
        else:
            thing_list = Thing.objects.annotate(
                FAV_USER_ID=Exists(Fav.objects.filter(user=self.request.user,thing_id=OuterRef('id')))
                ).all()
        ctx = {'thing_list' : thing_list}
        return render(request, self.template_name, ctx)

3 View Complete Implementation : models.py
Copyright GNU Affero General Public License v3.0
Author : Fleeg
    @staticmethod
    def feeds(username):
        follower_ids = Relationship.objects.filter(
            owner__user__username=username).values_list('follow_id', flat=True).distinct()
        qs_reacted = Reaction.objects.filter(post=models.OuterRef('pk'),
                                             owner__user__username=username)
        qs_added = Post.objects.filter(origin=models.OuterRef('pk'),
                                       owner__user__username=username)

        return Post.objects.filter(
            models.Q(owner_id__in=follower_ids) |
            models.Q(owner__user__username=username)).annotate(
            is_reacted=models.Exists(queryset=qs_reacted)).annotate(
            is_added=models.Exists(queryset=qs_added)).order_by('-created_at')

3 View Complete Implementation : models.py
Copyright GNU Affero General Public License v3.0
Author : Fleeg
    @staticmethod
    def links_by_user(username, user=None):
        qs_reactions = Reaction.objects.filter(post=models.OuterRef('pk'), owner=user)
        qs_added = Post.objects.filter(origin=models.OuterRef('pk'), owner=user)

        return Post.objects.filter(owner__user__username=username).annotate(
                    is_reacted=models.Exists(queryset=qs_reactions)).annotate(
                    is_added=models.Exists(queryset=qs_added)).order_by('-created_at')

3 View Complete Implementation : managers.py
Copyright MIT License
Author : imbokov
    def with_invites_count(self, request):
        from .models import Invite

        return self.annotate(
            invites_count=models.Subquery(
                Invite.objects.filter(party=models.OuterRef("pk"))
                .order_by()
                .values("party")
                .annotate(count=models.Count("pk"))
                .values("count")
            )
        )

3 View Complete Implementation : managers.py
Copyright MIT License
Author : imbokov
    def with_has_answer(self, request):
        from .models import Answer

        return self.annotate(
            has_answer=models.Exists(
                Answer.objects.filter(invite=models.OuterRef("pk"))
            )
        )

3 View Complete Implementation : managers.py
Copyright MIT License
Author : imbokov
    def with_all_details_reviewed(self, request):
        from .models import Details

        return self.annotate(
            all_details_reviewed=~models.Exists(
                Details.objects.filter(answer=models.OuterRef("pk"), reviewed=False)
            )
        )