Dominando QuerySets do Django: Estendendo a Funcionalidade com Gerenciadores Personalizados

            # models.py

from django.db import models
from django.utils import timezone

class Product(models.Model):
    name = models.CharField(max_length=255)
    description = models.TextField()
    price = models.DecimalField(max_digits=10, decimal_places=2)
    is_available = models.BooleanField(default=True)
    discontinued_date = models.DateTimeField(null=True, blank=True)
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)

    def __str__(self):
        return self.name

            

              
                Copy
              
            
          

            # querysets.py (Você pode colocar isso em um arquivo separado para melhor organização, ou dentro de models.py)

from django.db import models
from django.utils import timezone

class ProductQuerySet(models.QuerySet):
    def available(self):
        """Retorna apenas produtos que estão atualmente disponíveis e não descontinuados."""
        now = timezone.now()
        return self.filter(
            is_available=True,
            discontinued_date__isnull=True  # Nenhuma data de descontinuação definida
            # Alternativamente, se discontinued_date representa uma data futura:
            # discontinued_date__gt=now 
        )

    def by_price_range(self, min_price, max_price):
        """Filtra produtos dentro de uma faixa de preço especificada."""
        return self.filter(price__gte=min_price, price__lte=max_price)

    def recently_added(self, days=7):
        """Retorna produtos adicionados nos últimos 'days' dias."""
        cutoff_date = timezone.now() - timezone.timedelta(days=days)
        return self.filter(created_at__gte=cutoff_date)

            

              
                Copy
              
            
          

            # managers.py (Novamente, para organização, ou dentro de models.py)

from django.db import models
from .querysets import ProductQuerySet  # Assumindo que querysets.py existe

class ProductManager(models.Manager):
    def get_queryset(self):
        return ProductQuerySet(self.model, using=self._db)

    # Você também pode adicionar métodos diretamente ao gerenciador que podem não precisar
    # ser métodos de QuerySet, ou que servem como pontos de entrada para métodos de QuerySet.
    # Por exemplo, um atalho para o método 'available':
    def all_available(self):
        return self.get_queryset().available()

    def with_price_range(self, min_price, max_price):
        return self.get_queryset().by_price_range(min_price, max_price)

    def new_items(self, days=7):
        return self.get_queryset().recently_added(days)

            

              
                Copy
              
            
          

            # models.py

from django.db import models
from django.utils import timezone

# Assumindo que managers.py e querysets.py estão no mesmo diretório de app
from .managers import ProductManager
# from .querysets import ProductQuerySet # Não é diretamente necessário aqui se o gerenciador o manipula

class Product(models.Model):
    name = models.CharField(max_length=255)
    description = models.TextField()
    price = models.DecimalField(max_digits=10, decimal_places=2)
    is_available = models.BooleanField(default=True)
    discontinued_date = models.DateTimeField(null=True, blank=True)
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)

    # Use o gerenciador personalizado
    objects = ProductManager()

    def __str__(self):
        return self.name

            

              
                Copy
              
            
          

            # Em seu views.py, shell, ou qualquer outro código Python:

from .models import Product

# Usando os atalhos do gerenciador personalizado:

# Obter todos os produtos disponíveis globalmente
available_products_global = Product.objects.all_available()

# Obter produtos dentro de uma faixa de preço específica (por exemplo, entre $50 e $200 em equivalente a USD)
# Nota: Para um verdadeiro tratamento de moeda internacional, você precisaria de uma lógica mais complexa.
# Aqui, assumimos uma moeda base consistente ou preços equivalentes.
featured_products = Product.objects.with_price_range(50.00, 200.00)

# Obter produtos adicionados nos últimos 3 dias
new_arrivals = Product.objects.new_items(days=3)

# Você também pode encadear métodos de QuerySet:

# Obter produtos disponíveis dentro de uma faixa de preço, ordenados pela data de criação
sorted_products = Product.objects.all_available().by_price_range(10.00, 100.00).order_by('-created_at')

# Obter todos os produtos, mas depois usar os métodos do QuerySet personalizado:
# Isso é menos comum se o seu gerenciador fornecer acesso direto a esses métodos.
# Você normalmente usaria Product.objects.available() em vez de:
# Product.objects.get_queryset().available()

            

              
                Copy
              
            
          

            # querysets.py

from django.db import models
from django.utils import timezone

class PostQuerySet(models.QuerySet):
    def published(self):
        """Retorna apenas posts publicados e disponíveis agora."""
        return self.filter(is_published=True, published_date__lte=timezone.now())

    def for_locale(self, language_code='en', region_slug=None):
        """Filtra posts para um idioma específico e região opcional."""
        qs = self.published().filter(language_code=language_code)
        if region_slug:
            qs = qs.filter(target_regions__slug=region_slug)
        return qs

    def most_recent_for_locale(self, language_code='en', region_slug=None):
        """Obtém o post mais recente publicado para uma localidade."""
        return self.for_locale(language_code, region_slug).order_by('-published_date').first()

            

              
                Copy
              
            
          

            # views.py

from django.shortcuts import render
from .models import Post

def international_post_view(request):
    # Obter idioma/região preferencial do usuário (simplificado)
    user_lang = request.GET.get('lang', 'en')
    user_region = request.GET.get('region', None)

    # Obter o post mais recente para sua localidade
    latest_post = Post.objects.most_recent_for_locale(language_code=user_lang, region_slug=user_region)

    # Obter uma lista de todos os posts disponíveis em sua localidade
    all_posts_in_locale = Post.objects.for_locale(language_code=user_lang, region_slug=user_region)

    context = {
        'latest_post': latest_post,
        'all_posts': all_posts_in_locale,
    }
    return render(request, 'posts/international_list.html', context)

            

              
                Copy
              
            
          

            # querysets.py

from django.db import models
from django.utils import timezone

class TaskQuerySet(models.QuerySet):
    def blocked(self):
        """Retorna tarefas que estão atualmente bloqueadas."""
        return self.filter(status='Blocked')

    def completed_by(self, user):
        """Retorna tarefas concluídas por um usuário específico."""
        return self.filter(status='Completed', completed_by=user)

    def due_soon(self, days=3):
        """Retorna tarefas com vencimento nos próximos 'days' dias, excluindo as concluídas."""
        cutoff_date = timezone.now() + timezone.timedelta(days=days)
        return self.exclude(status='Completed').filter(due_date__lte=cutoff_date)

    def active_projects_tasks(self, project):
        """Retorna tarefas de projetos que estão atualmente ativos."""
        return self.filter(project=project, project__is_active=True)

            

              
                Copy
              
            
          

            # views.py

from django.shortcuts import get_object_or_404
from .models import Task, User, Project

def project_dashboard(request, project_id):
    project = get_object_or_404(Project, pk=project_id)

    # Obter tarefas para este projeto que são de projetos ativos (redundante se o objeto do projeto já foi buscado)
    # Mas imagine se fosse uma lista de tarefas global relacionada a projetos ativos.
    # Aqui, focamos nas tarefas pertencentes ao projeto específico:
    
    # Obter tarefas para o projeto especificado
    project_tasks = Task.objects.filter(project=project)

    # Usar métodos de QuerySet personalizados nessas tarefas
    due_tasks = project_tasks.due_soon()
    blocked_tasks = project_tasks.blocked()

    context = {
        'project': project,
        'due_tasks': due_tasks,
        'blocked_tasks': blocked_tasks,
    }
    return render(request, 'project/dashboard.html', context)

            

              
                Copy
              
            
          

            # querysets.py

from django.db import models
from django.utils import timezone
import pytz # Precisa instalar o pytz: pip install pytz

class EventQuerySet(models.QuerySet):
    def happening_now(self, current_time=None):
        """Filtra eventos que estão ocorrendo agora, considerando seu fuso horário local."""
        if current_time is None:
            current_time = timezone.now() # Isto é UTC

        # Obter todos os eventos que podem estar ativos com base no intervalo de tempo UTC
        potential_events = self.filter(
            start_time__lte=current_time,
            end_time__gte=current_time
        )

        # Refinar ainda mais verificando o fuso horário local
        # Isso é complicado, pois o ORM do Django não suporta diretamente conversões de fuso horário em filtros facilmente.
        # Frequentemente, você faria essa conversão em Python após buscar os eventos potenciais.
        # Para demonstração, vamos assumir uma abordagem simplificada onde buscamos horários UTC relevantes
        # e depois filtramos em Python.
        return potential_events # O refinamento adicional ocorreria geralmente no código Python

    def happening_today_in_timezone(self, target_timezone_name):
        """Filtra eventos que acontecem hoje em um fuso horário alvo específico."""
        try:
            target_timezone = pytz.timezone(target_timezone_name)
        except pytz.UnknownTimeZoneError:
            return self.none() # Ou levante um erro

        now_utc = timezone.now()
        today_start_utc = now_utc.replace(hour=0, minute=0, second=0, microsecond=0)
        today_end_utc = today_start_utc + timezone.timedelta(days=1)

        # Converter o início e o fim de hoje para o fuso horário alvo
        today_start_local = target_timezone.localize(today_start_utc.replace(tzinfo=None))
        today_end_local = target_timezone.localize(today_end_utc.replace(tzinfo=None))

        # Precisamos converter os horários de início/fim do evento para o fuso horário alvo para comparação.
        # Isso é melhor feito em Python para clareza e correção.
        # Para eficiência do banco de dados, você pode armazenar início/fim em UTC e o nome do fuso horário separadamente.
        # Então, você buscaria eventos cujo início/fim em UTC pudessem sobrepor o equivalente UTC do dia alvo.

        # Uma abordagem comum e amigável ao ORM é filtrar com base na representação UTC do dia alvo.
        # Encontrar eventos cujo início UTC é antes do fim do dia alvo, e o fim UTC é depois do início do dia alvo.
        # Isso inclui eventos que podem abranger a meia-noite em UTC.
        # Então, a verificação específica do fuso horário é feita em Python.
        
        # Abordagem simplificada: Buscar eventos que começam ou terminam dentro da janela UTC do dia alvo.
        # Isso precisa de refinamento se os eventos durarem vários dias e você só quiser *hoje* nessa zona.
        # Uma abordagem mais robusta envolve converter os horários de cada evento para o fuso horário alvo para comparação.

        # Vamos ilustrar uma abordagem de filtragem do lado do Python:
        qs = self.filter(
            # Verificação básica de sobreposição em UTC
            start_time__lt=today_end_utc, 
            end_time__gt=today_start_utc
        )
        
        # Agora, vamos filtrar isso em Python com base no fuso horário alvo
        relevant_events = []
        for event in qs:
            event_start_local = event.start_time.astimezone(target_timezone)
            event_end_local = event.end_time.astimezone(target_timezone)
            
            # Verificar se alguma parte do evento cai no dia alvo no fuso horário local
            if event_start_local.date() == today_start_local.date() or 
               event_end_local.date() == today_start_local.date() or 
               (event_start_local.date() < today_start_local.date() and event_end_local.date() > today_start_local.date()):
                relevant_events.append(event)
        
        # Retornar um objeto tipo QuerySet ou uma lista.
        # Para melhor integração, você pode retornar uma lista e envolvê-la, ou usar um método de Manager personalizado
        # para lidar com isso de forma mais eficiente, se possível.
        return relevant_events # Isso retorna uma lista, não um QuerySet. Isso é um compromisso.


# Vamos reconsiderar o modelo para tornar o tratamento de fuso horário mais claro

class Event(models.Model):
    name = models.CharField(max_length=255)
    start_time = models.DateTimeField()
    end_time = models.DateTimeField()
    timezone_name = models.CharField(max_length=100, default='UTC') # Armazenar o nome real do fuso horário

    objects = EventManager() # Assumir que EventManager usa EventQuerySet

    def get_local_start_time(self):
        return self.start_time.astimezone(pytz.timezone(self.timezone_name))

    def get_local_end_time(self):
        return self.end_time.astimezone(pytz.timezone(self.timezone_name))

    def is_happening_now(self):
        now_utc = timezone.now()
        return self.start_time <= now_utc and self.end_time >= now_utc

    def is_happening_today(self):
        now_utc = timezone.now()
        local_tz = pytz.timezone(self.timezone_name)
        
        event_start_local = self.start_time.astimezone(local_tz)
        event_end_local = self.end_time.astimezone(local_tz)
        
        today_local_date = now_utc.astimezone(local_tz).date()
        
        # Verificar se a duração local do evento se sobrepõe à data local de hoje
        if event_start_local.date() == today_local_date or 
           event_end_local.date() == today_local_date or 
           (event_start_local.date() < today_local_date and event_end_local.date() > today_local_date):
            return True
        return False


# QuerySet e Manager revisados para eventos cientes de fuso horário

# querysets.py
from django.db import models
from django.utils import timezone
import pytz

class EventQuerySet(models.QuerySet):
    def for_timezone(self, tz_name):
        """Retorna eventos que estão ativos ou estarão ativos hoje no fuso horário fornecido."""
        try:
            tz = pytz.timezone(tz_name)
        except pytz.UnknownTimeZoneError:
            return self.none()

        now_utc = timezone.now()
        today_start_utc = now_utc.replace(hour=0, minute=0, second=0, microsecond=0)
        today_end_utc = today_start_utc + timezone.timedelta(days=1)

        # Encontrar eventos cujo intervalo de tempo UTC se sobrepõe ao equivalente UTC do intervalo do dia alvo.
        # Esta é uma aproximação para reduzir o número de eventos buscados.
        # Estamos procurando por eventos onde:
        # (event.start_time < today_end_utc) AND (event.end_time > today_start_utc)
        # Isso garante qualquer sobreposição, mesmo que parcial, dentro do período do dia UTC.
        return self.filter(
            start_time__lt=today_end_utc,
            end_time__gt=today_start_utc
        ).order_by('start_time') # Ordenar para facilitar o processamento

# managers.py
from django.db import models
from .querysets import EventQuerySet

class EventManager(models.Manager):
    def get_queryset(self):
        return EventQuerySet(self.model, using=self._db)

    def happening_today_in_timezone(self, tz_name):
        """Encontra eventos que acontecem hoje no fuso horário especificado."""
        # Buscar eventos potencialmente relevantes usando o método do QuerySet
        potential_events_qs = self.get_queryset().for_timezone(tz_name)

        # Agora, realize a verificação precisa do fuso horário em Python
        relevant_events = []
        try:
            target_tz = pytz.timezone(tz_name)
        except pytz.UnknownTimeZoneError:
            return [] # Retorna lista vazia se o fuso horário for inválido

        # Obter a data local de hoje no fuso horário alvo
        today_local_date = timezone.now().astimezone(target_tz).date()

        for event in potential_events_qs:
            event_start_local = event.start_time.astimezone(target_tz)
            event_end_local = event.end_time.astimezone(target_tz)
            
            # Verificar a sobreposição com a data local de hoje
            if event_start_local.date() == today_local_date or 
               event_end_local.date() == today_local_date or 
               (event_start_local.date() < today_local_date and event_end_local.date() > today_local_date):
                relevant_events.append(event)
        
        return relevant_events # Esta é uma lista de objetos Event.


            

              
                Copy
              
            
          

            # models.py

from django.db import models

class Tenant(models.Model):
    name = models.CharField(max_length=100)
    # ... outros detalhes do inquilino

class TenantAwareQuerySet(models.QuerySet):
    def for_tenant(self, tenant):
        """Filtra objetos pertencentes a um inquilino específico."""
        if tenant:
            return self.filter(tenant=tenant)
        return self.none() # Ou trate apropriadamente se o inquilino for None

class TenantAwareManager(models.Manager):
    def get_queryset(self):
        return TenantAwareQuerySet(self.model, using=self._db)

    def for_tenant(self, tenant):
        return self.get_queryset().for_tenant(tenant)

    def active(self):
        """Retorna itens ativos para o inquilino atual (assumindo que o inquilino é acessível globalmente ou passado)."""
        # Isso assume um mecanismo para obter o inquilino atual, por exemplo, de middleware ou thread locals
        from .middleware import get_current_tenant 
        current_tenant = get_current_tenant()
        return self.for_tenant(current_tenant).filter(is_active=True)


class TenantModel(models.Model):
    tenant = models.ForeignKey(Tenant, on_delete=models.CASCADE)
    is_active = models.BooleanField(default=True)
    # ... outros campos

    objects = TenantAwareManager()

    class Meta:
        abstract = True # Este é um padrão semelhante a um mixin

class Customer(TenantModel):
    name = models.CharField(max_length=255)
    # ... outros campos do cliente

# Uso:
# from .models import Customer
# current_tenant = Tenant.objects.get(name='Globex Corp.')
# customers_for_globex = Customer.objects.for_tenant(current_tenant)
# active_customers_globex = Customer.objects.active() # Assume que get_current_tenant() está configurado corretamente

            

              
                Copy