Como determinar se um registro acabou de ser criado ou atualizado em after_save

O #new_record? função determina se um registro foi salvo. Mas é sempre falso no after_savegancho. Existe uma maneira de determinar se o registro é um registro recém-criado ou antigo da atualização?

Espero não usar outro retorno de chamada, como before_createdefinir um sinalizador no modelo ou exigir outra consulta no banco de dados.

Qualquer conselho é apreciado.

Editar: preciso determiná-lo no after_savegancho e, para meu caso de uso específico, não há nenhum carimbo de data updated_at/ updated_onhora

Eu estava tentando usar isso para um after_saveretorno de chamada.

Uma solução mais simples é usar id_changed?(uma vez que não muda update) ou mesmo created_at_changed?se as colunas de carimbo de data / hora estiverem presentes.

Atualizar: como @mitsy aponta, se esta verificação for necessária fora dos retornos de chamada, use id_previously_changed?. Veja a documentação .

Não há mágica de trilhos aqui que eu conheça, você terá que fazer isso sozinho. Você pode limpar isso usando um atributo virtual ...

Em sua classe de modelo:

def before_save
  @was_a_new_record = new_record?
  return true
end

def after_save
  if @was_a_new_record
    ...
  end
end

Outra opção, para aqueles que fazem tem um updated_atcarimbo do tempo:

if created_at == updated_at
  # it's a newly created record
end

Existe um after_createcallback que só é acionado se o registro for um novo registro, após ser salvo . Também há um after_updateretorno de chamada para uso se este for um registro existente que foi alterado e salvo. O after_saveretorno de chamada é chamado em ambos os casos, após after_createouafter_update é chamado.

Usar after_create se precisar que algo aconteça uma vez depois que um novo registro for salvo.

Mais informações aqui: http://api.rubyonrails.org/classes/ActiveRecord/Callbacks.html

Uma vez que o objeto já foi salvo, você precisa verificar as alterações anteriores. O ID só deve mudar após a criação.

# true if this is a new record
@object.previous_changes[:id].any?

Também existe uma variável de instância @new_record_before_save. Você pode acessá-lo fazendo o seguinte:

# true if this is a new record
@object.instance_variable_get(:@new_record_before_save)

Ambos são muito feios, mas permitem que você saiba se o objeto foi criado recentemente. Espero que ajude!

Via Rails 5.1+:

user = User.new
user.save!
user.saved_change_to_attribute?(:id) # => true

Para Rails 4 (verificado em 4.2.11.1), os resultados de changese os previous_changesmétodos são hashes vazios {}na criação de objetos internos after_save. Portanto, attribute_changed?métodos comoid_changed? não funcionarão conforme o esperado.

Mas você pode aproveitar este conhecimento e - sabendo que pelo menos 1 atributo deve estar em changesatualização - verifique se changesestá vazio. Depois de confirmar que está vazio, você deve estar durante a criação do objeto:

after_save do
  if changes.empty?
    # code appropriate for object creation goes here ...
  end
end

Gosto de ser específico mesmo sabendo que :idnão deve mudar no normal, mas

(byebug) id_change.first.nil?
true

É sempre mais barato ser específico em vez de encontrar um bug inesperado muito estranho.

Da mesma forma, se eu esperar truesinalização de argumento não confiável

def foo?(flag)
  flag == true
end

Isso economiza muitas horas para não ficar sentado em cima de insetos estranhos.