暂时禁用 auto_now / auto_now_add

Question

我有一个这样的模型：

class FooBar(models.Model):
    createtime = models.DateTimeField(auto_now_add=True)
    lastupdatetime = models.DateTimeField(auto_now=True)

我想覆盖某些模型实例的两个日期字段（在迁移数据时使用）。当前的解决方案如下所示：

for field in new_entry._meta.local_fields:
    if field.name == "lastupdatetime":
        field.auto_now = False
    elif field.name == "createtime":
        field.auto_now_add = False

new_entry.createtime = date
new_entry.lastupdatetime = date
new_entry.save()

for field in new_entry._meta.local_fields:
    if field.name == "lastupdatetime":
        field.auto_now = True
    elif field.name == "createtime":
        field.auto_now_add = True

有没有更好的解决方案？

Answer 1

来自 django docs

DateField.auto_now_add

在首次创建对象时自动将字段设置为现在。用于创建时间戳。请注意，始终使用当前日期； 它不仅仅是一个可以覆盖的默认值。因此，即使您在创建对象时为此字段设置了值，它也会被忽略。 如果您希望能够修改此字段，请设置以下内容而不是 auto_now_add=True：

对于 DateField：default=date.today - 来自 datetime.date.today()

对于 DateTimeField：default=timezone.now - 来自 django.utils.timezone.now()

Answer 2

来自https://stackoverflow.com/a/35943149/1731460 的更简洁的上下文管理器版本

from contextlib import contextmanager

@contextmanager
def suppress_auto_now(model, field_names):
    """
    idea taken here https://stackoverflow.com/a/35943149/1731460
    """
    fields_state = {}
    for field_name in field_names:
        field = model._meta.get_field(field_name)
        fields_state[field] = {'auto_now': field.auto_now, 'auto_now_add': field.auto_now_add}

    for field in fields_state:
        field.auto_now = False
        field.auto_now_add = False
    try:
        yield
    finally:
        for field, state in fields_state.items():
            field.auto_now = state['auto_now']
            field.auto_now_add = state['auto_now_add']

您甚至可以在工厂（工厂男孩）中使用它

        with suppress_autotime(Click, ['created']):
            ClickFactory.bulk_create(post=obj.post, link=obj.link, created__iter=created)

Answer 3

您还可以使用save() 的update_fields 参数并传递您的auto_now 字段。这是一个例子：

# Date you want to force
new_created_date = date(year=2019, month=1, day=1)
# The `created` field is `auto_now` in your model
instance.created = new_created_date
instance.save(update_fields=['created'])

以下是 Django 文档中的解释：https://docs.djangoproject.com/en/stable/ref/models/instances/#specifying-which-fields-to-save

Answer 4

您无需特殊代码即可覆盖auto_now_add。

我在尝试创建具有特定日期的对象时遇到了这个问题：

Post.objects.create(publication_date=date, ...)

publication_date = models.DateField(auto_now_add=True).

这就是我所做的：

post = Post.objects.create(...)
post.publication_date = date
post.save()

这已成功覆盖auto_now_add。

作为更长期的解决方案，覆盖save 方法是要走的路：https://code.djangoproject.com/ticket/16583

Answer 5

我需要适用于update_or_create 的解决方案，我是根据@andreaspelme 代码找到这个解决方案的。

唯一的变化是您可以通过将修改字段设置为 skip 来设置跳过，而不仅仅是通过实际将 kwarg skip_modified_update 传递给 save() 方法。

只需yourmodelobject.modified='skip' 即可跳过更新！

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


class TimeTrackableAbstractModel(models.Model):
    created = models.DateTimeField(default=timezone.now, db_index=True)
    modified = models.DateTimeField(default=timezone.now, db_index=True)

    class Meta:
        abstract = True

    def save(self, *args, **kwargs):
        skip_modified_update = kwargs.pop('skip_modified_update', False)
        if skip_modified_update or self.modified == 'skip':
            self.modified = models.F('modified')
        else:
            self.modified = timezone.now()
        super(TimeTrackableAbstractModel, self).save(*args, **kwargs)

Answer 6

Django - Models.DateTimeField - Changing dynamically auto_now_add value的副本

嗯，我花了今天下午才发现，第一个问题是如何获取模型对象以及在代码中的位置。我在 serializer.py 的 restframework 中，例如在序列化器的__init__ 中它还没有模型。现在在 to_internal_value 中，您可以获取模型类，在获取字段并修改字段属性后，如下例所示：

class ProblemSerializer(serializers.ModelSerializer):

    def to_internal_value(self, data): 
        ModelClass = self.Meta.model
        dfil = ModelClass._meta.get_field('date_update')
        dfil.auto_now = False
        dfil.editable = True

Answer 7

为了可重用性，我采用了上下文管理器。

@contextlib.contextmanager
def suppress_autotime(model, fields):
    _original_values = {}
    for field in model._meta.local_fields:
        if field.name in fields:
            _original_values[field.name] = {
                'auto_now': field.auto_now,
                'auto_now_add': field.auto_now_add,
            }
            field.auto_now = False
            field.auto_now_add = False
    try:
        yield
    finally:
        for field in model._meta.local_fields:
            if field.name in fields:
                field.auto_now = _original_values[field.name]['auto_now']
                field.auto_now_add = _original_values[field.name]['auto_now_add']

这样使用：

with suppress_autotime(my_object, ['updated']):
    my_object.some_field = some_value
    my_object.save()

轰隆隆。

Answer 8

对于那些在编写测试时看到这一点的人，有一个名为 freezegun 的 python 库可以让你伪造时间 - 所以当 auto_now_add 代码运行时，它会得到你真正想要的时间。所以：

from datetime import datetime, timedelta
from freezegun import freeze_time

with freeze_time('2016-10-10'):
    new_entry = FooBar.objects.create(...)
with freeze_time('2016-10-17'):
    # use new_entry as you wish, as though it was created 7 days ago

它也可以用作装饰器 - 有关基本文档，请参阅上面的链接。

Answer 9

我使用了提问者的建议，并创建了一些功能。这是用例：

turn_off_auto_now(FooBar, "lastupdatetime")
turn_off_auto_now_add(FooBar, "createtime")

new_entry.createtime = date
new_entry.lastupdatetime = date
new_entry.save()

下面是实现：

def turn_off_auto_now(ModelClass, field_name):
    def auto_now_off(field):
        field.auto_now = False
    do_to_model(ModelClass, field_name, auto_now_off)

def turn_off_auto_now_add(ModelClass, field_name):
    def auto_now_add_off(field):
        field.auto_now_add = False
    do_to_model(ModelClass, field_name, auto_now_add_off)

def do_to_model(ModelClass, field_name, func):
    field = ModelClass._meta.get_field_by_name(field_name)[0]
    func(field)

可以创建类似的功能来重新打开它们。

Answer 10

我迟到了，但与其他几个答案类似，这是我在数据库迁移期间使用的解决方案。与其他答案的不同之处在于，这会禁用模型的 all auto_now 字段，假设确实没有理由拥有多个此类字段。

def disable_auto_now_fields(*models):
    """Turns off the auto_now and auto_now_add attributes on a Model's fields,
    so that an instance of the Model can be saved with a custom value.
    """
    for model in models:
        for field in model._meta.local_fields:
            if hasattr(field, 'auto_now'):
                field.auto_now = False
            if hasattr(field, 'auto_now_add'):
                field.auto_now_add = False

然后要使用它，你可以简单地这样做：

disable_auto_now_fields(Document, Event, ...)

它将遍历并删除您传入的所有模型类的所有 auto_now 和 auto_now_add 字段。

Answer 11

我需要在迁移期间为 DateTime 字段禁用 auto_now，并且能够做到这一点。

events = Events.objects.all()
for event in events:
    for field in event._meta.fields:
        if field.name == 'created_date':
            field.auto_now = False
    event.save()

Answer 12

我最近在测试我的应用程序时遇到了这种情况。我需要“强制”一个过期的时间戳。就我而言，我通过使用查询集更新来做到这一点。像这样：

# my model
class FooBar(models.Model):
    title = models.CharField(max_length=255)
    updated_at = models.DateTimeField(auto_now=True, auto_now_add=True)



# my tests
foo = FooBar.objects.get(pk=1)

# force a timestamp
lastweek = datetime.datetime.now() - datetime.timedelta(days=7)
FooBar.objects.filter(pk=foo.pk).update(updated_at=lastweek)

# do the testing.

Answer 13

您无法以其他方式真正禁用 auto_now/auto_now_add。如果您需要灵活地更改这些值，auto_now/auto_now_add 不是最佳选择。在保存对象之前使用default 和/或覆盖save() 方法进行操作通常更灵活。

使用default 和覆盖的save() 方法，解决您的问题的一种方法是这样定义您的模型：

class FooBar(models.Model):
    createtime = models.DateTimeField(default=datetime.datetime.now)
    lastupdatetime = models.DateTimeField()

    def save(self, *args, **kwargs):
        if not kwargs.pop('skip_lastupdatetime', False):
            self.lastupdatetime = datetime.datetime.now()

        super(FooBar, self).save(*args, **kwargs)

在您想要跳过自动 lastupdatetime 更改的代码中，只需使用

new_entry.save(skip_lastupdatetime=True)

如果您的对象保存在管理界面或其他地方，将在没有 skip_lastupdatetime 参数的情况下调用 save()，它的行为与之前使用 auto_now 时一样。