Hopiu/wagtail
1
0
Fork 0
mirror of https://github.com/Hopiu/wagtail.git synced 2026-05-11 16:53:10 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Renamed scheduled publishing fields

Browse source
This commit is contained in:
Karl Hobley 2014-06-03 10:21:21 +01:00
parent 8dfd0c623f
commit 3fa98ef82e
5 changed files with 116 additions and 116 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

120
wagtail/wagtailadmin/tests.py
View file

@ -78,14 +78,14 @@ class TestPageCreation(TestCase):
self.assertFalse(page.live)
def test_create_simplepage_scheduled(self):
go_live_datetime = timezone.now() + timedelta(days=1)
expiry_datetime = timezone.now() + timedelta(days=2)
go_live_at = timezone.now() + timedelta(days=1)
expire_at = timezone.now() + timedelta(days=2)
post_data = {
'title': "New page!",
'content': "Some content",
'slug': 'hello-world',
'go_live_datetime': str(go_live_datetime).split('.')[0],
'expiry_datetime': str(expiry_datetime).split('.')[0],
'go_live_at': str(go_live_at).split('.')[0],
'expire_at': str(expire_at).split('.')[0],
}
response = self.client.post(reverse('wagtailadmin_pages_create', args=('tests', 'simplepage', self.root_page.id)), post_data)
@ -94,21 +94,21 @@ class TestPageCreation(TestCase):
# Find the page and check the scheduled times
page = Page.objects.get(path__startswith=self.root_page.path, slug='hello-world').specific
self.assertEquals(page.go_live_datetime.date(), go_live_datetime.date())
self.assertEquals(page.expiry_datetime.date(), expiry_datetime.date())
self.assertEquals(page.go_live_at.date(), go_live_at.date())
self.assertEquals(page.expire_at.date(), expire_at.date())
self.assertEquals(page.expired, False)
self.assertTrue(page.status_string, "draft")
# No revisions with approved_go_live_datetime
self.assertFalse(PageRevision.objects.filter(page=page).exclude(approved_go_live_datetime__isnull=True).exists())
# No revisions with approved_go_live_at
self.assertFalse(PageRevision.objects.filter(page=page).exclude(approved_go_live_at__isnull=True).exists())
def test_create_simplepage_scheduled_go_live_before_expiry(self):
post_data = {
'title': "New page!",
'content': "Some content",
'slug': 'hello-world',
'go_live_datetime': str(timezone.now() + timedelta(days=2)).split('.')[0],
'expiry_datetime': str(timezone.now() + timedelta(days=1)).split('.')[0],
'go_live_at': str(timezone.now() + timedelta(days=2)).split('.')[0],
'expire_at': str(timezone.now() + timedelta(days=1)).split('.')[0],
}
response = self.client.post(reverse('wagtailadmin_pages_create', args=('tests', 'simplepage', self.root_page.id)), post_data)
@ -121,7 +121,7 @@ class TestPageCreation(TestCase):
'title': "New page!",
'content': "Some content",
'slug': 'hello-world',
'expiry_datetime': str(timezone.now() + timedelta(days=-1)).split('.')[0],
'expire_at': str(timezone.now() + timedelta(days=-1)).split('.')[0],
}
response = self.client.post(reverse('wagtailadmin_pages_create', args=('tests', 'simplepage', self.root_page.id)), post_data)
@ -148,15 +148,15 @@ class TestPageCreation(TestCase):
self.assertTrue(page.live)
def test_create_simplepage_post_publish_scheduled(self):
go_live_datetime = timezone.now() + timedelta(days=1)
expiry_datetime = timezone.now() + timedelta(days=2)
go_live_at = timezone.now() + timedelta(days=1)
expire_at = timezone.now() + timedelta(days=2)
post_data = {
'title': "New page!",
'content': "Some content",
'slug': 'hello-world',
'action-publish': "Publish",
'go_live_datetime': str(go_live_datetime).split('.')[0],
'expiry_datetime': str(expiry_datetime).split('.')[0],
'go_live_at': str(go_live_at).split('.')[0],
'expire_at': str(expire_at).split('.')[0],
}
response = self.client.post(reverse('wagtailadmin_pages_create', args=('tests', 'simplepage', self.root_page.id)), post_data)
@ -165,12 +165,12 @@ class TestPageCreation(TestCase):
# Find the page and check it
page = Page.objects.get(path__startswith=self.root_page.path, slug='hello-world').specific
self.assertEquals(page.go_live_datetime.date(), go_live_datetime.date())
self.assertEquals(page.expiry_datetime.date(), expiry_datetime.date())
self.assertEquals(page.go_live_at.date(), go_live_at.date())
self.assertEquals(page.expire_at.date(), expire_at.date())
self.assertEquals(page.expired, False)
# A revision with approved_go_live_datetime should exist now
self.assertTrue(PageRevision.objects.filter(page=page).exclude(approved_go_live_datetime__isnull=True).exists())
# A revision with approved_go_live_at should exist now
self.assertTrue(PageRevision.objects.filter(page=page).exclude(approved_go_live_at__isnull=True).exists())
# But Page won't be live
self.assertFalse(page.live)
self.assertTrue(page.status_string, "scheduled")
@ -250,14 +250,14 @@ class TestPageEdit(TestCase):
self.assertTrue(child_page_new.has_unpublished_changes)
def test_edit_post_scheduled(self):
go_live_datetime = timezone.now() + timedelta(days=1)
expiry_datetime = timezone.now() + timedelta(days=2)
go_live_at = timezone.now() + timedelta(days=1)
expire_at = timezone.now() + timedelta(days=2)
post_data = {
'title': "I've been edited!",
'content': "Some content",
'slug': 'hello-world',
'go_live_datetime': str(go_live_datetime).split('.')[0],
'expiry_datetime': str(expiry_datetime).split('.')[0],
'go_live_at': str(go_live_at).split('.')[0],
'expire_at': str(expire_at).split('.')[0],
}
response = self.client.post(reverse('wagtailadmin_pages_edit', args=(self.child_page.id, )), post_data)
@ -268,11 +268,11 @@ class TestPageEdit(TestCase):
# The page will still be live
self.assertTrue(child_page_new.live)
# A revision with approved_go_live_datetime should not exist
self.assertFalse(PageRevision.objects.filter(page=child_page_new).exclude(approved_go_live_datetime__isnull=True).exists())
# But a revision with go_live_datetime and expiry_datetime in their content json *should* exist
self.assertTrue(PageRevision.objects.filter(page=child_page_new, content_json__contains=str(go_live_datetime.date())).exists())
self.assertTrue(PageRevision.objects.filter(page=child_page_new, content_json__contains=str(expiry_datetime.date())).exists())
# A revision with approved_go_live_at should not exist
self.assertFalse(PageRevision.objects.filter(page=child_page_new).exclude(approved_go_live_at__isnull=True).exists())
# But a revision with go_live_at and expire_at in their content json *should* exist
self.assertTrue(PageRevision.objects.filter(page=child_page_new, content_json__contains=str(go_live_at.date())).exists())
self.assertTrue(PageRevision.objects.filter(page=child_page_new, content_json__contains=str(expire_at.date())).exists())
def test_edit_post_publish(self):
# Tests publish from edit page
@ -295,15 +295,15 @@ class TestPageEdit(TestCase):
self.assertFalse(child_page_new.has_unpublished_changes)
def test_edit_post_publish_scheduled(self):
go_live_datetime = timezone.now() + timedelta(days=1)
expiry_datetime = timezone.now() + timedelta(days=2)
go_live_at = timezone.now() + timedelta(days=1)
expire_at = timezone.now() + timedelta(days=2)
post_data = {
'title': "I've been edited!",
'content': "Some content",
'slug': 'hello-world',
'action-publish': "Publish",
'go_live_datetime': str(go_live_datetime).split('.')[0],
'expiry_datetime': str(expiry_datetime).split('.')[0],
'go_live_at': str(go_live_at).split('.')[0],
'expire_at': str(expire_at).split('.')[0],
}
response = self.client.post(reverse('wagtailadmin_pages_edit', args=(self.child_page.id, )), post_data)
@ -313,20 +313,20 @@ class TestPageEdit(TestCase):
child_page_new = SimplePage.objects.get(id=self.child_page.id)
# The page should not be live anymore
self.assertFalse(child_page_new.live)
# Instead a revision with approved_go_live_datetime should now exist
self.assertTrue(PageRevision.objects.filter(page=child_page_new).exclude(approved_go_live_datetime__isnull=True).exists())
# Instead a revision with approved_go_live_at should now exist
self.assertTrue(PageRevision.objects.filter(page=child_page_new).exclude(approved_go_live_at__isnull=True).exists())
def test_edit_post_publish_now_an_already_scheduled(self):
# First let's publish a page with a go_live_datetime in the future
go_live_datetime = timezone.now() + timedelta(days=1)
expiry_datetime = timezone.now() + timedelta(days=2)
# First let's publish a page with a go_live_at in the future
go_live_at = timezone.now() + timedelta(days=1)
expire_at = timezone.now() + timedelta(days=2)
post_data = {
'title': "I've been edited!",
'content': "Some content",
'slug': 'hello-world',
'action-publish': "Publish",
'go_live_datetime': str(go_live_datetime).split('.')[0],
'expiry_datetime': str(expiry_datetime).split('.')[0],
'go_live_at': str(go_live_at).split('.')[0],
'expire_at': str(expire_at).split('.')[0],
}
response = self.client.post(reverse('wagtailadmin_pages_edit', args=(self.child_page.id, )), post_data)
@ -336,17 +336,17 @@ class TestPageEdit(TestCase):
child_page_new = SimplePage.objects.get(id=self.child_page.id)
# The page should not be live anymore
self.assertFalse(child_page_new.live)
# Instead a revision with approved_go_live_datetime should now exist
self.assertTrue(PageRevision.objects.filter(page=child_page_new).exclude(approved_go_live_datetime__isnull=True).exists())
# Instead a revision with approved_go_live_at should now exist
self.assertTrue(PageRevision.objects.filter(page=child_page_new).exclude(approved_go_live_at__isnull=True).exists())
# Now, let's edit it and publish it right now
go_live_datetime = timezone.now()
go_live_at = timezone.now()
post_data = {
'title': "I've been edited!",
'content': "Some content",
'slug': 'hello-world',
'action-publish': "Publish",
'go_live_datetime': "",
'go_live_at': "",
}
response = self.client.post(reverse('wagtailadmin_pages_edit', args=(self.child_page.id, )), post_data)
@ -356,8 +356,8 @@ class TestPageEdit(TestCase):
child_page_new = SimplePage.objects.get(id=self.child_page.id)
# The page should be live now
self.assertTrue(child_page_new.live)
# And a revision with approved_go_live_datetime should not exist
self.assertFalse(PageRevision.objects.filter(page=child_page_new).exclude(approved_go_live_datetime__isnull=True).exists())
# And a revision with approved_go_live_at should not exist
self.assertFalse(PageRevision.objects.filter(page=child_page_new).exclude(approved_go_live_at__isnull=True).exists())
class TestPageDelete(TestCase):
def setUp(self):
@ -483,60 +483,60 @@ class TestPublishScheduledPages(TestCase):
page.title = "Hello world!"
page.slug = "hello-world"
page.live = False
page.go_live_datetime = timezone.now() - timedelta(days=1)
page.go_live_at = timezone.now() - timedelta(days=1)
self.root_page.add_child(instance=page)
page.save_revision(
approved_go_live_datetime = timezone.now() - timedelta(days=1)
approved_go_live_at = timezone.now() - timedelta(days=1)
)
p = Page.objects.get(slug='hello-world')
self.assertFalse(p.live)
self.assertTrue(PageRevision.objects.filter(page=p).exclude(approved_go_live_datetime__isnull=True).exists())
self.assertTrue(PageRevision.objects.filter(page=p).exclude(approved_go_live_at__isnull=True).exists())
management.call_command('publish_scheduled_pages', verbosity=3, interactive=False)
#management.call_command('publish_scheduled_pages', dryrun=True, verbosity=3, interactive=False)
p = Page.objects.get(slug='hello-world')
self.assertTrue(p.live)
self.assertFalse(PageRevision.objects.filter(page=p).exclude(approved_go_live_datetime__isnull=True).exists())
self.assertFalse(PageRevision.objects.filter(page=p).exclude(approved_go_live_at__isnull=True).exists())
def test_go_live_page_will_be_published(self):
page = SimplePage()
page.title = "Hello world!"
page.slug = "hello-world"
page.live = False
page.go_live_datetime = timezone.now() - timedelta(days=1)
page.go_live_at = timezone.now() - timedelta(days=1)
self.root_page.add_child(instance=page)
page.save_revision(approved_go_live_datetime = timezone.now() - timedelta(days=1))
page.save_revision(approved_go_live_at = timezone.now() - timedelta(days=1))
p = Page.objects.get(slug='hello-world')
self.assertFalse(p.live)
self.assertTrue(PageRevision.objects.filter(page=p).exclude(approved_go_live_datetime__isnull=True).exists())
self.assertTrue(PageRevision.objects.filter(page=p).exclude(approved_go_live_at__isnull=True).exists())
management.call_command('publish_scheduled_pages', )
p = Page.objects.get(slug='hello-world')
self.assertTrue(p.live)
self.assertFalse(PageRevision.objects.filter(page=p).exclude(approved_go_live_datetime__isnull=True).exists())
self.assertFalse(PageRevision.objects.filter(page=p).exclude(approved_go_live_at__isnull=True).exists())
def test_future_go_live_page_will_not_be_published(self):
page = SimplePage()
page.title = "Hello world!"
page.slug = "hello-world"
page.live = False
page.go_live_datetime = timezone.now() + timedelta(days=1)
page.go_live_at = timezone.now() + timedelta(days=1)
self.root_page.add_child(instance=page)
page.save_revision(approved_go_live_datetime = timezone.now() - timedelta(days=1))
page.save_revision(approved_go_live_at = timezone.now() - timedelta(days=1))
p = Page.objects.get(slug='hello-world')
self.assertFalse(p.live)
self.assertTrue(PageRevision.objects.filter(page=p).exclude(approved_go_live_datetime__isnull=True).exists())
self.assertTrue(PageRevision.objects.filter(page=p).exclude(approved_go_live_at__isnull=True).exists())
management.call_command('publish_scheduled_pages', )
p = Page.objects.get(slug='hello-world')
self.assertFalse(p.live)
self.assertTrue(PageRevision.objects.filter(page=p).exclude(approved_go_live_datetime__isnull=True).exists())
self.assertTrue(PageRevision.objects.filter(page=p).exclude(approved_go_live_at__isnull=True).exists())
def test_expired_page_will_be_unpublished(self):
page = SimplePage()
page.title = "Hello world!"
page.slug = "hello-world"
page.live = True
page.expiry_datetime = timezone.now() - timedelta(days=1)
page.expire_at = timezone.now() - timedelta(days=1)
self.root_page.add_child(instance=page)
p = Page.objects.get(slug='hello-world')
self.assertTrue(p.live)
@ -550,7 +550,7 @@ class TestPublishScheduledPages(TestCase):
page.title = "Hello world!"
page.slug = "hello-world"
page.live = True
page.expiry_datetime = timezone.now() + timedelta(days=1)
page.expire_at = timezone.now() + timedelta(days=1)
self.root_page.add_child(instance=page)
p = Page.objects.get(slug='hello-world')
self.assertTrue(p.live)
@ -564,7 +564,7 @@ class TestPublishScheduledPages(TestCase):
page.title = "Hello world!"
page.slug = "hello-world"
page.live = False
page.expiry_datetime = timezone.now() - timedelta(days=1)
page.expire_at = timezone.now() - timedelta(days=1)
self.root_page.add_child(instance=page)
page.save_revision(submitted_for_moderation = True)
p = Page.objects.get(slug='hello-world')

34
wagtail/wagtailadmin/views/pages.py
View file

@ -133,18 +133,18 @@ def create(request, content_type_app_name, content_type_model_name, parent_page_
is_publishing = bool(request.POST.get('action-publish')) and parent_page_perms.can_publish_subpage()
is_submitting = bool(request.POST.get('action-submit'))
go_live_datetime = form.cleaned_data.get('go_live_datetime')
future_go_live = go_live_datetime and go_live_datetime > timezone.now()
approved_go_live_datetime = None
go_live_at = form.cleaned_data.get('go_live_at')
future_go_live = go_live_at and go_live_at > timezone.now()
approved_go_live_at = None
if is_publishing:
page.has_unpublished_changes = False
page.expired = False
if future_go_live:
page.live = False
# Set approved_go_live_datetime only if is publishing
# Set approved_go_live_at only if is publishing
# and the future_go_live is actually in future
approved_go_live_datetime = go_live_datetime
approved_go_live_at = go_live_at
else:
page.live = True
else:
@ -153,11 +153,11 @@ def create(request, content_type_app_name, content_type_model_name, parent_page_
parent_page.add_child(instance=page) # assign tree parameters - will cause page to be saved
# Pass approved_go_live_datetime to save_revision
# Pass approved_go_live_at to save_revision
page.save_revision(
user=request.user,
submitted_for_moderation=is_submitting,
approved_go_live_datetime = approved_go_live_datetime
approved_go_live_at = approved_go_live_at
)
if is_publishing:
@ -222,24 +222,24 @@ def edit(request, page_id):
if form.is_valid():
is_publishing = bool(request.POST.get('action-publish')) and page_perms.can_publish()
is_submitting = bool(request.POST.get('action-submit'))
go_live_datetime = form.cleaned_data.get('go_live_datetime')
future_go_live = go_live_datetime and go_live_datetime > timezone.now()
approved_go_live_datetime = None
go_live_at = form.cleaned_data.get('go_live_at')
future_go_live = go_live_at and go_live_at > timezone.now()
approved_go_live_at = None
if is_publishing:
page.has_unpublished_changes = False
page.expired = False
if future_go_live:
page.live = False
# Set approved_go_live_datetime only if publishing
approved_go_live_datetime = go_live_datetime
# Set approved_go_live_at only if publishing
approved_go_live_at = go_live_at
else:
page.live = True
form.save()
# Clear approved_go_live_datetime for older revisions
# Clear approved_go_live_at for older revisions
page.revisions.update(
submitted_for_moderation=False,
approved_go_live_datetime=None,
approved_go_live_at=None,
)
else:
# not publishing the page
@ -255,7 +255,7 @@ def edit(request, page_id):
page.save_revision(
user=request.user,
submitted_for_moderation=is_submitting,
approved_go_live_datetime = approved_go_live_datetime
approved_go_live_at = approved_go_live_at
)
if is_publishing:
@ -455,8 +455,8 @@ def unpublish(request, page_id):
parent_id = page.get_parent().id
page.live = False
page.save()
# Since page is unpublished clear the approved_go_live_datetime of all revisions
page.revisions.update(approved_go_live_datetime=None)
# Since page is unpublished clear the approved_go_live_at of all revisions
page.revisions.update(approved_go_live_at=None)
messages.success(request, _("Page '{0}' unpublished.").format(page.title))
return redirect('wagtailadmin_explore', parent_id)

16
wagtail/wagtailcore/management/commands/publish_scheduled_pages.py
View file

@ -8,11 +8,11 @@ from wagtail.wagtailcore.models import Page, PageRevision
def revision_date_expired(r):
expiry_str = json.loads(r.content_json).get('expiry_datetime')
expiry_str = json.loads(r.content_json).get('expire_at')
if not expiry_str:
return False
expiry_datetime = dateparse.parse_datetime(expiry_str)
if expiry_datetime < timezone.now():
expire_at = dateparse.parse_datetime(expiry_str)
if expire_at < timezone.now():
return True
else:
return False
@ -37,7 +37,7 @@ class Command(BaseCommand):
# 1. get all expired pages with live = True
expired_pages = Page.objects.filter(
live=True,
expiry_datetime__lt=timezone.now()
expire_at__lt=timezone.now()
)
if dryrun:
if expired_pages:
@ -46,7 +46,7 @@ class Command(BaseCommand):
print "---------------\t\t----\t\t----"
for ep in expired_pages:
print "{0}\t{1}\t{2}".format(
ep.expiry_datetime.strftime("%Y-%m-%d %H:%M"),
ep.expire_at.strftime("%Y-%m-%d %H:%M"),
ep.slug,
ep.title
)
@ -71,7 +71,7 @@ class Command(BaseCommand):
rev_data = json.loads(er.content_json)
print "{0}\t{1}\t{2}".format(
dateparse.parse_datetime(
rev_data.get('expiry_datetime')
rev_data.get('expire_at')
).strftime("%Y-%m-%d %H:%M"),
rev_data.get('slug'),
rev_data.get('title')
@ -85,7 +85,7 @@ class Command(BaseCommand):
# 3. get all revisions that need to be published
revs_for_publishing = PageRevision.objects.filter(
approved_go_live_datetime__lt=timezone.now()
approved_go_live_at__lt=timezone.now()
)
if dryrun:
print "---------------------------------"
@ -96,7 +96,7 @@ class Command(BaseCommand):
for rp in revs_for_publishing:
rev_data = json.loads(rp.content_json)
print "{0}\t\t{1}\t{2}".format(
rp.approved_go_live_datetime.strftime("%Y-%m-%d %H:%M"),
rp.approved_go_live_at.strftime("%Y-%m-%d %H:%M"),
rev_data.get('slug'),
rev_data.get('title')
)

30
wagtail/wagtailcore/migrations/0003_fields_for_scheduled_publishing.py
View file

@ -8,18 +8,18 @@ from django.db import models
class Migration(SchemaMigration):
def forwards(self, orm):
# Adding field 'PageRevision.approved_go_live_datetime'
db.add_column(u'wagtailcore_pagerevision', 'approved_go_live_datetime',
# Adding field 'PageRevision.approved_go_live_at'
db.add_column(u'wagtailcore_pagerevision', 'approved_go_live_at',
self.gf('django.db.models.fields.DateTimeField')(null=True, blank=True),
keep_default=False)
# Adding field 'Page.go_live_datetime'
db.add_column(u'wagtailcore_page', 'go_live_datetime',
# Adding field 'Page.go_live_at'
db.add_column(u'wagtailcore_page', 'go_live_at',
self.gf('django.db.models.fields.DateTimeField')(null=True, blank=True),
keep_default=False)
# Adding field 'Page.expiry_datetime'
db.add_column(u'wagtailcore_page', 'expiry_datetime',
# Adding field 'Page.expire_at'
db.add_column(u'wagtailcore_page', 'expire_at',
self.gf('django.db.models.fields.DateTimeField')(null=True, blank=True),
keep_default=False)
@ -30,14 +30,14 @@ class Migration(SchemaMigration):
def backwards(self, orm):
# Deleting field 'PageRevision.approved_go_live_datetime'
db.delete_column(u'wagtailcore_pagerevision', 'approved_go_live_datetime')
# Deleting field 'PageRevision.approved_go_live_at'
db.delete_column(u'wagtailcore_pagerevision', 'approved_go_live_at')
# Deleting field 'Page.go_live_datetime'
db.delete_column(u'wagtailcore_page', 'go_live_datetime')
# Deleting field 'Page.go_live_at'
db.delete_column(u'wagtailcore_page', 'go_live_at')
# Deleting field 'Page.expiry_datetime'
db.delete_column(u'wagtailcore_page', 'expiry_datetime')
# Deleting field 'Page.expire_at'
db.delete_column(u'wagtailcore_page', 'expire_at')
# Deleting field 'Page.expired'
db.delete_column(u'wagtailcore_page', 'expired')
@ -92,8 +92,8 @@ class Migration(SchemaMigration):
'content_type': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'pages'", 'to': u"orm['contenttypes.ContentType']"}),
'depth': ('django.db.models.fields.PositiveIntegerField', [], {}),
'expired': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'expiry_datetime': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'blank': 'True'}),
'go_live_datetime': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'blank': 'True'}),
'expire_at': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'blank': 'True'}),
'go_live_at': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'blank': 'True'}),
'has_unpublished_changes': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'live': ('django.db.models.fields.BooleanField', [], {'default': 'True'}),
@ -109,7 +109,7 @@ class Migration(SchemaMigration):
},
u'wagtailcore.pagerevision': {
'Meta': {'object_name': 'PageRevision'},
'approved_go_live_datetime': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'blank': 'True'}),
'approved_go_live_at': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'blank': 'True'}),
'content_json': ('django.db.models.fields.TextField', [], {}),
'created_at': ('django.db.models.fields.DateTimeField', [], {'auto_now_add': 'True', 'blank': 'True'}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),

32
wagtail/wagtailcore/models.py
View file

@ -235,8 +235,8 @@ class Page(MP_Node, ClusterableModel, Indexed):
show_in_menus = models.BooleanField(default=False, help_text=_("Whether a link to this page will appear in automatically generated menus"))
search_description = models.TextField(blank=True)
go_live_datetime = models.DateTimeField(verbose_name=_("Go live date/time"), help_text=_("Please add a date-time in the form YYYY-MM-DD hh:mm."), blank=True, null=True)
expiry_datetime = models.DateTimeField(verbose_name=_("Expiry date/time"), help_text=_("Please add a date-time in the form YYYY-MM-DD hh:mm."), blank=True, null=True)
go_live_at = models.DateTimeField(verbose_name=_("Go live date/time"), help_text=_("Please add a date-time in the form YYYY-MM-DD hh:mm."), blank=True, null=True)
expire_at = models.DateTimeField(verbose_name=_("Expiry date/time"), help_text=_("Please add a date-time in the form YYYY-MM-DD hh:mm."), blank=True, null=True)
expired = models.BooleanField(default=False, editable=False)
indexed_fields = {
@ -382,12 +382,12 @@ class Page(MP_Node, ClusterableModel, Indexed):
else:
raise Http404
def save_revision(self, user=None, submitted_for_moderation=False, approved_go_live_datetime=None):
def save_revision(self, user=None, submitted_for_moderation=False, approved_go_live_at=None):
self.revisions.create(
content_json=self.to_json(),
user=user,
submitted_for_moderation=submitted_for_moderation,
approved_go_live_datetime=approved_go_live_datetime,
approved_go_live_at=approved_go_live_at,
)
def get_latest_revision(self):
@ -472,11 +472,11 @@ class Page(MP_Node, ClusterableModel, Indexed):
def clean(self):
super(Page, self).clean()
if self.go_live_datetime and self.expiry_datetime:
if self.go_live_datetime > self.expiry_datetime:
if self.go_live_at and self.expire_at:
if self.go_live_at > self.expire_at:
raise ValidationError(ugettext('Go live date/time should be before expiry datetime.'))
if self.expiry_datetime and self.expiry_datetime < timezone.now():
if self.expire_at and self.expire_at < timezone.now():
raise ValidationError(ugettext('Expiry date/time should be in the future'))
@classmethod
@ -567,7 +567,7 @@ class Page(MP_Node, ClusterableModel, Indexed):
@property
def approved_schedule(self):
return self.revisions.exclude(approved_go_live_datetime__isnull=True).exists()
return self.revisions.exclude(approved_go_live_at__isnull=True).exists()
def has_unpublished_subtree(self):
"""
@ -742,7 +742,7 @@ class PageRevision(models.Model):
created_at = models.DateTimeField(auto_now_add=True)
user = models.ForeignKey(settings.AUTH_USER_MODEL, null=True, blank=True)
content_json = models.TextField()
approved_go_live_datetime = models.DateTimeField(null=True, blank=True)
approved_go_live_at = models.DateTimeField(null=True, blank=True)
objects = models.Manager()
submitted_revisions = SubmittedRevisionsManager()
@ -776,18 +776,18 @@ class PageRevision(models.Model):
def publish(self):
page = self.as_page_object()
if page.go_live_datetime and page.go_live_datetime > timezone.now():
if page.go_live_at and page.go_live_at > timezone.now():
# if we have a go_live in the future don't make the page live
page.live = False
# Instead set the approved_go_live_datetime of this revision
self.approved_go_live_datetime = page.go_live_datetime
# Instead set the approved_go_live_at of this revision
self.approved_go_live_at = page.go_live_at
self.save()
# And clear the the approved_go_live_datetime of any other revisions
page.revisions.exclude(id=self.id).update(approved_go_live_datetime=None)
# And clear the the approved_go_live_at of any other revisions
page.revisions.exclude(id=self.id).update(approved_go_live_at=None)
else:
page.live = True
# If page goes live clear the approved_go_live_datetime of all revisions
page.revisions.update(approved_go_live_datetime=None)
# If page goes live clear the approved_go_live_at of all revisions
page.revisions.update(approved_go_live_at=None)
page.expired = False # When a page is published it can't be expired
page.save()
self.submitted_for_moderation = False