POO Django

class Funcionario:
    salario_minimo = 1_412.00  # atributo de classe

    def __init__(self, nome, salario):
        self.nome = nome
        self.salario = salario

    # Factory method: cria um Funcionario com salário mínimo
    @classmethod
    def criar_com_salario_minimo(cls, nome):
        return cls(nome, cls.salario_minimo)

    # Método utilitário: não precisa de instância nem da classe
    @staticmethod
    def validar_cpf(cpf):
        cpf_limpo = cpf.replace(".", "").replace("-", "")
        return len(cpf_limpo) == 11 and cpf_limpo.isdigit()

    def __str__(self):
        return f"{self.nome} — R$ {self.salario:,.2f}"

# Criação via factory method (sem precisar saber o salário mínimo)
estagiario = Funcionario.criar_com_salario_minimo("Carlos")
print(estagiario)

# Validação sem precisar de uma instância
print(Funcionario.validar_cpf("123.456.789-09"))
print(Funcionario.validar_cpf("123"))

class ContaBancaria:
    def __init__(self, titular, saldo_inicial):
        self.titular = titular           # público
        self._saldo = saldo_inicial      # protegido (convenção)
        self.__historico = []            # privado (name mangling)

    def depositar(self, valor):
        if valor > 0:
            self._saldo += valor
            self.__historico.append(f"Depósito: +R$ {valor:.2f}")

    def sacar(self, valor):
        if 0 < valor <= self._saldo:
            self._saldo -= valor
            self.__historico.append(f"Saque: -R$ {valor:.2f}")
        else:
            print("Saldo insuficiente.")

    @property
    def saldo(self):
        return self._saldo

    @property
    def historico(self):
        return list(self.__historico)  # retorna cópia, não a lista original

    def __str__(self):
        return f"Conta de {self.titular} — Saldo: R$ {self._saldo:.2f}"

conta = ContaBancaria("Maria", 1000)
conta.depositar(500)
conta.sacar(200)

print(conta)
print(conta.saldo)
print(conta.historico)

# Tentando acessar o atributo "privado" diretamente
try:
    print(conta.__historico)
except AttributeError as e:
    print(f"Erro: {e}")

# O name mangling renomeia para _ContaBancaria__historico
print(conta._ContaBancaria__historico)  # funciona, mas é má prática

import json

class JsonMixin:
    """Adiciona capacidade de serializar o objeto para JSON."""
    def to_json(self):
        return json.dumps(self.__dict__, ensure_ascii=False)

class LogMixin:
    """Adiciona capacidade de registrar criação do objeto."""
    def log(self):
        print(f"[LOG] Objeto '{self.__class__.__name__}' criado: {self}")

class ValidacaoMixin:
    """Adiciona validação básica de dados."""
    def validar(self):
        for attr, valor in self.__dict__.items():
            if valor is None:
                raise ValueError(f"Atributo '{attr}' não pode ser None")
        return True


# Pedido combina múltiplos mixins
class Pedido(LogMixin, JsonMixin, ValidacaoMixin):
    def __init__(self, id_pedido, produto, total):
        self.id_pedido = id_pedido
        self.produto = produto
        self.total = total

    def __str__(self):
        return f"Pedido #{self.id_pedido} — {self.produto} — R$ {self.total:.2f}"


p = Pedido(42, "Notebook", 3500.00)
p.log()
print(p.to_json())
print(p.validar())

# A ordem dos mixins importa! Python usa MRO (Method Resolution Order)
# Para ver a ordem de resolução:
print(Pedido.__mro__)

# ============================================================
# O que você aprendeu em POO puro:
# ============================================================

class Cachorro:
    # Atributo de classe
    especie = "Canis familiaris"

    def __init__(self, nome, idade, raca):
        # Atributos de instância
        self.nome = nome
        self.idade = idade
        self.raca = raca

    # Método mágico: representação amigável
    def __str__(self):
        return f"{self.nome} ({self.raca})"

    # Método mágico: representação para desenvolvedor
    def __repr__(self):
        return f"Cachorro(nome={self.nome!r}, idade={self.idade!r})"

    # Atributo calculado
    @property
    def eh_filhote(self):
        return self.idade < 1

    # Factory method
    @classmethod
    def criar_filhote(cls, nome, raca):
        return cls(nome, 0, raca)


rex = Cachorro("Rex", 3, "Labrador")
print(rex)
print(repr(rex))
print(rex.eh_filhote)

bolt = Cachorro.criar_filhote("Bolt", "Dálmata")
print(bolt)
print(bolt.eh_filhote)

# ============================================================
# Como fica no Django (não executa aqui — apenas para estudo):
# ============================================================

django_model_exemplo = """
from django.db import models

class Cachorro(models.Model):           # herda de models.Model (classe pai do Django)

    # Atributos de classe especiais — definem as colunas do banco de dados
    nome  = models.CharField(max_length=100)
    idade = models.IntegerField()
    raca  = models.CharField(max_length=100)

    def __str__(self):                  # mesmo método mágico que você aprendeu!
        return f\"{self.nome} ({self.raca})\"

    def __repr__(self):
        return f\"Cachorro(nome={self.nome!r}, idade={self.idade!r})\"

    @property
    def eh_filhote(self):               # @property funciona igual
        return self.idade < 1

    @classmethod
    def criar_filhote(cls, nome, raca): # @classmethod funciona igual
        return cls.objects.create(nome=nome, idade=0, raca=raca)

    class Meta:                         # inner class especial do Django
        ordering = ['nome']             # ordena resultados por nome por padrão
        verbose_name = 'Cachorro'
        verbose_name_plural = 'Cachorros'
"""

print(django_model_exemplo)