Merge branch 'new-save-flow'

Author: Rocky Meza

setup.py

@@ -13,7 +13,7 @@ def read(fname):
 
 
 install_requires = [
-    'mezzanine >= 1.3.0',
+    'mezzanine >= 3.1.10',
     'django-treebeard',
     'django-filer>=0.9.6',
     'South',

tests/test_sqlite.py

@@ -47,3 +47,15 @@
     'django.contrib.staticfiles.finders.AppDirectoriesFinder',
     'compressor.finders.CompressorFinder',
 )
+
+TEMPLATE_CONTEXT_PROCESSORS = (
+    "django.contrib.auth.context_processors.auth",
+    "django.contrib.messages.context_processors.messages",
+    "django.core.context_processors.debug",
+    "django.core.context_processors.i18n",
+    "django.core.context_processors.static",
+    "django.core.context_processors.media",
+    "django.core.context_processors.request",
+    "mezzanine.conf.context_processors.settings",
+    "mezzanine.pages.context_processors.page",
+)

tests/urls.py

@@ -1,4 +1,5 @@
 from django.conf.urls import patterns, include, url
+from django.conf import settings
 
 from django.contrib import admin
 admin.autodiscover()
@@ -11,7 +12,12 @@ def dummy_view(*args, **kwargs):
 urlpatterns = patterns('',
     url('^core_tests/', include('modeltests.core_tests.urls')),
     url("^admin/", include(admin.site.urls)),
-    url('^widgy-mezzanine/', include('widgy.contrib.widgy_mezzanine.urls')),
     # mezzanine.pages.views.page reverses the 'home' url.
     url('^$', dummy_view, name='home'),
 )
+
+if 'widgy.contrib.widgy_mezzanine' in settings.INSTALLED_APPS:
+    urlpatterns += [
+        url('^widgy-mezzanine/', include('widgy.contrib.widgy_mezzanine.urls')),
+        url('^mezzanine/', include('mezzanine.urls')),
+    ]

widgy/contrib/page_builder/templates/widgy/page_builder/widgypage_change_form.html

@@ -23,6 +23,10 @@ def unapproved(self):
             return self.filter(approved_at__isnull=True,
                                approved_by__isnull=True)
 
+        def approved(self):
+            return self.exclude(approved_at__isnull=True,
+                                approved_by__isnull=True)
+
     objects = ReviewedVersionCommitQuerySet.as_manager()
 
     @property
@@ -61,11 +65,8 @@ def published(self):
 
     objects = ReviewedVersionTrackerQuerySet.as_manager()
 
-    def get_published_node(self, request):
-        for commit in self.get_history():
-            if commit.is_published and commit.reviewedversioncommit.is_approved:
-                return commit.root_node
-        return None
+    def commit_is_ready(self, commit):
+        return commit.is_published and commit.reviewedversioncommit.is_approved
 
     @property
     def commits(self):

widgy/contrib/review_queue/models.py

@@ -124,6 +124,5 @@ def get_context_data(self, **kwargs):
         interesting = True
         for commit in kwargs['commits']:
             commit.is_interesting_to_approve_or_unapprove = interesting
-            if commit.reviewedversioncommit.is_approved:
-                interesting = False
+            interesting &= not self.object.commit_is_ready(commit)
         return kwargs

widgy/contrib/review_queue/views.py

@@ -6,7 +6,11 @@
 from django import forms
 from django.core.urlresolvers import reverse
 from django.contrib.admin.util import quote
-from django.utils.translation import ugettext_lazy as _, ugettext
+from django.utils.translation import ugettext_lazy as _, ugettext, ungettext
+from django.utils import timezone
+from django.contrib import messages
+from django.db.models.signals import post_save
+from django.db.models import Min, Q
 
 from mezzanine.pages.admin import PageAdmin
 try:
@@ -17,18 +21,26 @@
 from mezzanine.core.models import (CONTENT_STATUS_PUBLISHED,
                                    CONTENT_STATUS_DRAFT)
 
-from widgy.forms import WidgyFormMixin
+from widgy.forms import WidgyFormMixin, VersionedWidgyWidget
 from widgy.contrib.widgy_mezzanine import get_widgypage_model
-from widgy.contrib.widgy_mezzanine.views import ClonePageView
-from widgy.utils import fancy_import, format_html
+from widgy.contrib.widgy_mezzanine.views import ClonePageView, UnpublishView
+from widgy.utils import format_html
+from widgy.db.fields import get_site
 
 
 WidgyPage = get_widgypage_model()
 
 
+class PageVersionedWidgyWidget(VersionedWidgyWidget):
+    template_name = 'widgy/widgy_mezzanine/versioned_widgy_field.html'
+
+
 class WidgyPageAdminForm(WidgyFormMixin, PageAdminForm):
     class Meta:
         model = WidgyPage
+        widgets = {
+            'root_node': PageVersionedWidgyWidget,
+        }
 
     def __init__(self, *args, **kwargs):
         super(WidgyPageAdminForm, self).__init__(*args, **kwargs)
@@ -38,26 +50,133 @@ def __init__(self, *args, **kwargs):
         self.fields['expiry_date'].help_text = _(
             "If you enter a date here, the page will not be viewable after this time"
         )
-        self.fields['status'].initial = CONTENT_STATUS_DRAFT
+        if self.instance.pk is not None:
+            self.instance.status = CONTENT_STATUS_DRAFT
 
-    def clean_status(self):
-        status = self.cleaned_data.get('status')
-        if (status == CONTENT_STATUS_PUBLISHED and (not self.instance.root_node or
-                                                    not self.instance.root_node.head)):
-            raise forms.ValidationError(_('You must commit before you can publish'))
-        return status
 
+# the status of a page before it's created, on the add page
+CONTENT_STATUS_EMBRYO = 0
 
 class WidgyPageAdmin(PageAdmin):
-    change_form_template = 'widgy/page_builder/widgypage_change_form.html'
+    change_form_template = 'widgy/widgy_mezzanine/widgypage_change_form.html'
     form = WidgyPageAdminForm
+    readonly_fields = ['status']
+
+    unreviewed_buttons = {
+        CONTENT_STATUS_EMBRYO    : [('_continue', _('Save'))],
+        CONTENT_STATUS_DRAFT     : [('_continue', _('Save as Draft')),
+                                    ('_save_and_commit', _('Publish'))],
+        CONTENT_STATUS_PUBLISHED : [('_save_and_commit', _('Publish Changes'))],
+    }
+    reviewed_buttons = {
+        (CONTENT_STATUS_EMBRYO, False)    : [('_continue', _('Save'))],
+        (CONTENT_STATUS_EMBRYO, True)     : [('_continue', _('Save'))],
+        (CONTENT_STATUS_DRAFT, False)     : [('_continue', _('Save as Draft')),
+                                             ('_save_and_commit', _('Submit for Review'))],
+        (CONTENT_STATUS_DRAFT, True)      : [('_continue', _('Save as Draft')),
+                                             ('_save_and_commit', _('Submit for Review')),
+                                             ('_save_and_approve', _('Publish'))],
+        (CONTENT_STATUS_PUBLISHED, False) : [('_save_and_commit', _('Submit for Review'))],
+        (CONTENT_STATUS_PUBLISHED, True)  : [('_save_and_commit', _('Submit for Review')),
+                                             ('_save_and_approve', _('Publish Changes'))],
+    }
 
     def get_urls(self):
         clone_view = ClonePageView.as_view(has_permission=self.has_add_permission)
+        unpublish_view = UnpublishView.as_view(has_change_permission=self.has_change_permission)
         return [
             url('^(.+)/clone/$', self.admin_site.admin_view(clone_view)),
+            url('^(.+)/unpublish/$', self.admin_site.admin_view(unpublish_view)),
         ] + super(WidgyPageAdmin, self).get_urls()
 
+    def _save_and_commit(self, request, obj):
+        site = self.get_site()
+        commit_model = site.get_version_tracker_model().commit_model
+        if not site.has_add_permission(request, commit_model):
+            messages.error(request, _("You don't have permission to commit."))
+        else:
+            if obj.root_node.has_changes():
+                obj.root_node.commit(user=request.user)
+            elif self.has_review_queue:
+                messages.warning(request, _("There was nothing to submit for review."))
+
+            if not self.has_review_queue:
+                obj.status = CONTENT_STATUS_PUBLISHED
+            # else:
+                # If we are reviewed, we'll have to wait for approval.
+                # Handled by the publish_page_on_approve signal.
+
+    def _save_and_approve(self, request, obj):
+        site = self.get_site()
+        commit_model = site.get_version_tracker_model().commit_model
+        if not site.has_add_permission(request, commit_model) or \
+                not site.has_change_permission(request, commit_model):
+            messages.error(request, _("You don't have permission to approve commits."))
+        else:
+            if obj.root_node.has_changes():
+                obj.root_node.commit(request.user)
+            # If we had changes, `head` is the same commit we just created.
+            # If we didn't need to create a commit, we want to publish the
+            # most recent one instead.
+            obj.root_node.head.reviewedversioncommit.approve(request.user)
+            obj.root_node.head.reviewedversioncommit.save()
+            obj.status = CONTENT_STATUS_PUBLISHED
+
+    def save_model(self, request, obj, form, change):
+        if '_save_and_commit' in request.POST:
+            self._save_and_commit(request, obj)
+        elif '_save_and_approve' in request.POST and self.has_review_queue:
+            self._save_and_approve(request, obj)
+        request.POST['_continue'] = True
+        super(WidgyPageAdmin, self).save_model(request, obj, form, change)
+
+    def render_change_form(self, request, context, add=False, change=False, form_url='', obj=None, *args, **kwargs):
+        if not add:
+            unapproved = 0
+            future = 0
+            for commit in obj.root_node.get_history_list():
+                if obj.root_node.commit_is_ready(commit):
+                    # got to the currently-published commit
+                    break
+                if self.has_review_queue and not commit.reviewedversioncommit.is_approved:
+                    unapproved += 1
+                if not commit.is_published:
+                    future += 1
+            if unapproved:
+                messages.warning(request, ungettext(
+                    "There is one unreviewed commit for this page.",
+                    "There are {count} unreviewed commits for this page.",
+                    unapproved
+                ).format(count=unapproved))
+            if future:
+                messages.warning(request, ungettext(
+                    "There is one future-scheduled commit.",
+                    "There are {count} future-scheduled commits.",
+                    future
+                ).format(count=future))
+
+        site = self.get_site()
+        if add:
+            status = CONTENT_STATUS_EMBRYO
+        else:
+            status = obj.status
+        if self.has_review_queue:
+            commit_model = site.get_version_tracker_model().commit_model
+            can_approve = site.has_change_permission(request, commit_model)
+            context['save_buttons'] = self.reviewed_buttons[(status, can_approve)]
+        else:
+            context['save_buttons'] = self.unreviewed_buttons[status]
+        if not add:
+            context['history_url'] =  site.reverse(site.history_view, kwargs={'pk': obj.pk})
+        return super(WidgyPageAdmin, self).render_change_form(request, context, add, change, form_url, obj, *args, **kwargs)
+
+    @property
+    def has_review_queue(self):
+        return isinstance(self.get_site(), ReviewedWidgySite)
+
+    def get_site(self):
+        return get_site(settings.WIDGY_MEZZANINE_SITE)
+
 
 class UndeleteField(forms.ModelChoiceField):
     widget = forms.RadioSelect
@@ -138,12 +257,55 @@ def __init__(self, *args, **kwargs):
 admin.site.register(WidgyPage, WidgyPageAdmin)
 admin.site.register(UndeletePage, UndeletePageAdmin)
 
+
+def publish_page_on_approve(sender, instance, created, **kwargs):
+    site = get_site(settings.WIDGY_MEZZANINE_SITE)
+
+    pages = WidgyPage.objects.filter(
+        root_node=instance.tracker,
+    )
+    if instance.is_approved:
+        pages = pages.filter(
+            Q(publish_date__gte=instance.publish_at) |
+            Q(status=CONTENT_STATUS_DRAFT)
+        ).update(
+            status=CONTENT_STATUS_PUBLISHED,
+            publish_date=instance.publish_at,
+        )
+    elif not site.get_version_tracker_model().objects.filter(pk=instance.tracker.pk).published().exists():
+        # unaproving a commit, and there are no other currently published commits
+        CommitModel = site.get_version_tracker_model().commit_model
+        beginning_of_validity = CommitModel.objects.approved().filter(
+            tracker_id=instance.tracker.pk,
+            publish_at__gt=timezone.now(),
+        ).aggregate(min=Min('publish_at'))['min']
+        if beginning_of_validity is not None:
+            # There's a scheduled commit, move publish_date of the page forward
+            # up to the publish_at of the commit.
+            pages.update(
+                publish_date=beginning_of_validity,
+                status=CONTENT_STATUS_PUBLISHED,
+            )
+        else:
+            # no other published commits at all, page needs to be unpublished
+            pages.update(
+                status=CONTENT_STATUS_DRAFT,
+            )
+
 if 'widgy.contrib.review_queue' in settings.INSTALLED_APPS:
     from widgy.contrib.review_queue.admin import VersionCommitAdminBase
     from widgy.contrib.review_queue.models import ReviewedVersionCommit
+    from widgy.contrib.review_queue.site import ReviewedWidgySite
 
     class VersionCommitAdmin(VersionCommitAdminBase):
         def get_site(self):
-            return fancy_import(settings.WIDGY_MEZZANINE_SITE)
+            return get_site(settings.WIDGY_MEZZANINE_SITE)
 
     admin.site.register(ReviewedVersionCommit, VersionCommitAdmin)
+
+    site = get_site(settings.WIDGY_MEZZANINE_SITE)
+
+    if isinstance(site, ReviewedWidgySite):
+        # In the tests, review_queue is installed but a ReviewedWidgySite might
+        # not be in use.
+        post_save.connect(publish_page_on_approve, sender=site.get_version_tracker_model().commit_model)

widgy/contrib/widgy_mezzanine/admin.py

@@ -0,0 +1,20 @@
+{% extends "widgy/popup_base.html" %}
+{% load i18n %}
+
+{% block content %}
+<h1>{% blocktrans with page_title=object.title %}Unpublishing {{ page_title }}{% endblocktrans %}</h1>
+<p>
+  {% blocktrans %}
+  Unpublishing will cause this page to disappear from the live site.  Users who
+  go to this page will get a 404 (File Not Found) error page.  Are you sure you
+  want to unpublish this page?
+  {% endblocktrans %}
+</p>
+<form method="post">
+  {% csrf_token %}
+  <div class="submit-row">
+    <p class="cancellink-box"><a href="../" class="cancellink">{% trans "Cancel" %}</a></p>
+    <input type="submit" value="{% trans "Yes, I'm sure" %}" class="default" />
+ </div>
+</form>
+{% endblock %}

widgy/contrib/widgy_mezzanine/templates/widgy/widgy_mezzanine/unpublish.html

@@ -0,0 +1,8 @@
+{% extends "widgy/versioned_widgy_field_base.html" %}
+{% load i18n %}
+{% load staticfiles %}
+
+{% block widgy_tools %}
+  <li><a class="widgy-fancybox commit" href="{{ commit_url }}">{% trans "Schedule changes" %}</a></li>
+  <li><a class="widgy-fancybox reset" href="{{ reset_url }}">{% trans "Reset" %}</a></li>
+{% endblock %}