Django - Sovrascrivi il metodo Model.create ()?

La documentazione di Django elenca solo esempi per sovrascrivere save()e delete(). Tuttavia, vorrei definire alcune elaborazioni extra per i miei modelli solo quando vengono creati . Per chiunque abbia familiarità con Rails, sarebbe l'equivalente di creare un :before_createfiltro. È possibile?

L'override __init__()provocherebbe l'esecuzione del codice ogni volta che viene istanziata la rappresentazione python dell'oggetto. Non conosco rails, ma un :before_createdfiltro mi suona come se fosse un codice da eseguire quando l'oggetto viene creato nel database. Se vuoi eseguire codice quando viene creato un nuovo oggetto nel database, devi sovrascriverlo save(), controllando se l'oggetto ha un pkattributo o meno. Il codice sarebbe simile a questo:

def save(self, *args, **kwargs):
    if not self.pk:
        # This code only happens if the objects is
        # not in the database yet. Otherwise it would
        # have pk
    super(MyModel, self).save(*args, **kwargs)

Questo è vecchio, ha una risposta accettata che funziona (quella di Zach) e anche una più idiomatica (quella di Michael Bylstra), ma poiché è ancora il primo risultato su Google che la maggior parte delle persone vede, penso che abbiamo bisogno di un django moderno più best practice risposta di stile qui :

from django.db.models.signals import post_save

class MyModel(models.Model):
    # ...
    @classmethod
    def post_create(cls, sender, instance, created, *args, **kwargs):
        if not created:
            return
        # ...what needs to happen on create

post_save.connect(MyModel.post_create, sender=MyModel)

Il punto è questo:

1. usa i segnali (leggi di più qui nella documentazione ufficiale )
2. usa un metodo per una buona spaziatura dei nomi (se ha senso) ... e l'ho contrassegnato come @classmethodinvece di @staticmethodperché molto probabilmente finirai per aver bisogno di fare riferimento ai membri della classe statica nel codice

Ancora più pulito sarebbe se il core Django avesse un post_createsegnale effettivo . (Imho se devi passare un argomento booleano per cambiare il comportamento di un metodo, dovrebbero essere 2 metodi.)

un esempio di come creare un segnale post_save (da http://djangosnippets.org/snippets/500/ )

from django.db.models.signals import post_save
from django.dispatch import receiver

@receiver(post_save, sender=User)
def create_profile(sender, instance, created, **kwargs):
    """Create a matching profile whenever a user object is created."""
    if created: 
        profile, new = UserProfile.objects.get_or_create(user=instance)

ecco una discussione ponderata sull'opportunità di utilizzare segnali o metodi di salvataggio personalizzati https://web.archive.org/web/20120815022107/http://www.martin-geber.com/ Thought/ 2007/10/29/ django-signal-vs-custom-save-method /

Secondo me l'utilizzo di segnali per questo compito è più robusto, più facile da leggere ma più lungo.

Per rispondere letteralmente alla domanda, il createmetodo nel gestore di un modello è un modo standard per creare nuovi oggetti in Django. Per ignorare, fai qualcosa di simile

from django.db import models

class MyModelManager(models.Manager):
    def create(self, **obj_data):
        # Do some extra stuff here on the submitted data before saving...
        # For example...
        obj_data['my_field'] = my_computed_value(obj_data['my_other_field'])

        # Now call the super method which does the actual creation
        return super().create(**obj_data) # Python 3 syntax!!

class MyModel(models.model):
    # An example model
    my_field = models.CharField(max_length=250)
    my_other_field = models.CharField(max_length=250)

    objects = MyModelManager()

In questo esempio, sovrascrivo il metodo di Manager create per eseguire un'elaborazione aggiuntiva prima che l'istanza venga effettivamente creata.

NOTA: codice simile

my_new_instance = MyModel.objects.create(my_field='my_field value')

eseguirà questo createmetodo modificato , ma un codice simile

my_new_unsaved_instance = MyModel(my_field='my_field value')

non lo farò.

L'override __init__()ti consentirà di eseguire il codice quando viene creata un'istanza del modello. Non dimenticare di chiamare i genitori __init__().

È possibile sostituire il metodo create con un gestore personalizzato o aggiungere un metodo di classe sulla classe del modello. https://docs.djangoproject.com/en/1.11/ref/models/instances/#creating-objects

La risposta preferita è corretta ma il test per stabilire se l'oggetto viene creato non funziona se il modello deriva da UUIDModel. Il campo pk avrà già un valore.

In questo caso, puoi farlo:

already_created = MyModel.objects.filter(pk=self.pk).exists()