Em um método save () personalizado do modelo django, como você deve identificar um novo objeto?

Quero desencadear uma ação especial no método save () de um objeto de modelo do Django quando estou salvando um novo registro (não atualizando um registro existente).

A verificação de (self.id! = None) é necessária e suficiente para garantir que o auto registro seja novo e não esteja sendo atualizado? Algum caso especial que isso possa ignorar?

Atualizado: com o esclarecimento de que self._statenão é uma variável de instância privada, mas nomeada dessa maneira para evitar conflitos, a verificação self._state.addingagora é a maneira preferível de verificação.

self.pk is None:

retorna True dentro de um novo objeto Model, a menos que o objeto tenha um UUIDFieldcomo seu primary_key.

O caso de canto com o qual você pode se preocupar é se há restrições de exclusividade em outros campos que não o ID (por exemplo, índices exclusivos secundários em outros campos). Nesse caso, você ainda pode ter um novo registro em mãos, mas não poderá salvá-lo.

Maneira alternativa de verificar self.pk, podemos verificar self._stateo modelo

self._state.adding is True criando

self._state.adding is False atualizando

Comprei nesta página

A verificação self.idassume que essa idé a chave principal do modelo. Uma maneira mais genérica seria usar o atalho pk .

is_new = self.pk is None

A verificação nãoself.pk == None é suficiente para determinar se o objeto será inserido ou atualizado no banco de dados.

O Django O / RM apresenta um hack especialmente desagradável, que é basicamente verificar se há algo na posição PK e, se for o caso, fazer um UPDATE, caso contrário, faça um INSERT (isso é otimizado para um INSERT se o PK for Nenhum).

A razão pela qual isso deve ser feito é porque você tem permissão para definir a PK quando um objeto é criado. Embora não seja comum quando você tem uma coluna de sequência para a chave primária, isso não vale para outros tipos de campos de chave primária.

Se você realmente quer saber, precisa fazer o que o O / RM faz e procurar no banco de dados.

Claro que você tem um caso específico em seu código e, para isso, é bastante provável que self.pk == Nonevocê tudo o que você precisa saber diz, mas é não uma solução geral.

Você pode simplesmente conectar-se ao sinal post_save que envia um kwargs "criado", se verdadeiro, seu objeto foi inserido.

http://docs.djangoproject.com/en/stable/ref/signals/#post-save

Verifique self.ide a force_insertbandeira.

if not self.pk or kwargs.get('force_insert', False):
    self.created = True

# call save method.
super(self.__class__, self).save(*args, **kwargs)

#Do all your post save actions in the if block.
if getattr(self, 'created', False):
    # So something
    # Do something else

Isso é útil porque o seu objeto recém-criado (auto) tem pkvalor

Estou muito atrasado para esta conversa, mas tive um problema com o self.pk sendo preenchido quando ele tem um valor padrão associado.

A maneira como resolvi isso foi adicionar um campo date_created ao modelo

date_created = models.DateTimeField(auto_now_add=True)

Daqui você pode ir

created = self.date_created is None

Para uma solução que também funcione mesmo quando você tem uma UUIDFieldchave primária (o que, como outros observaram, não é Nonese você acabou de substituir save), você pode conectar o sinal post_save do Django . Adicione isso ao seu models.py :

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

@receiver(post_save, sender=MyModel)
def mymodel_saved(sender, instance, created, **kwargs):
    if created:
        # do extra work on your instance, e.g.
        # instance.generate_avatar()
        # instance.send_email_notification()
        pass

Esse retorno de chamada bloqueará o savemétodo, para que você possa executar ações como notificações de gatilho ou atualizar ainda mais o modelo antes que sua resposta seja enviada novamente, seja usando formulários ou a estrutura REST do Django para chamadas AJAX. Obviamente, use responsavelmente e descarregue tarefas pesadas em uma fila de tarefas, em vez de manter os usuários esperando :)

em vez disso, use pk em vez de id :

if not self.pk:
  do_something()

É a maneira comum de fazer isso.

o id será dado enquanto salvo pela primeira vez no banco de dados

Isso funcionaria para todos os cenários acima?

if self.pk is not None and <ModelName>.objects.filter(pk=self.pk).exists():
...

> def save_model(self, request, obj, form, change):
>         if form.instance._state.adding:
>             form.instance.author = request.user
>             super().save_model(request, obj, form, change)
>         else:
>             obj.updated_by = request.user.username
> 
>             super().save_model(request, obj, form, change)

Para saber se você está atualizando ou inserindo o objeto (dados), use self.instance.fieldnameem seu formulário. Defina uma função limpa no seu formulário e verifique se a entrada de valor atual é igual à anterior, caso contrário, você está atualizando.

self.instancee self.instance.fieldnamecompare com o novo valor