Modernize code

.dockerignore

@@ -0,0 +1,3 @@
+*.pyc
+django_flatpages_tinymce.egg-info/
+

.gitignore

@@ -1 +1,3 @@
 *.pyc
+django_flatpages_tinymce.egg-info/
+build_and_test.sh

.travis.yml

@@ -0,0 +1,5 @@
+services:
+  - docker
+
+script:
+  - ./build_and_test.sh

Dockerfile

@@ -0,0 +1,9 @@
+ARG PYTHON_VERSION=3
+ARG DJANGO_VERSION=1.11
+
+FROM python:${PYTHON_VERSION}-alpine
+RUN pip install "django${DJANGO_VERSION}" django-tinymce
+ADD . /src
+WORKDIR /src
+RUN pip install .
+CMD ["python","manage.py","test","-v2"]

README.rst

@@ -1,3 +1,6 @@
+.. image:: https://travis-ci.com/ad-m/django-flatpages-tinymce.svg?branch=master
+    :target: https://travis-ci.com/ad-m/django-flatpages-tinymce
+
 -----
 About
 -----

build_and_test.sh

@@ -0,0 +1,15 @@
+#!/bin/sh
+set -eux
+for DJANGO_VERSION in '<2.3' '<2' '<2.1' '<2.2' '<2.3' '<2.4'; do
+	for PYTHON_VERSION in 3.7 2.7 3.6 3.7; do
+		image_name=$(echo "test:${DJANGO_VERSION}-${PYTHON_VERSION}" | tr '<' '_' )
+
+		docker build \
+			--build-arg DJANGO_VERSION="$DJANGO_VERSION" \
+			--build-arg PYTHON_VERSION="$PYTHON_VERSION" \
+			-t "$image_name" \
+			.
+		docker run "$image_name" python manage.py check
+		docker run "$image_name"
+	done;
+done;

flatpages_tinymce/admin.py

@@ -1,6 +1,5 @@
 from django.db import transaction
 from django.utils.translation import ugettext_lazy as _
-from django.core.urlresolvers import reverse
 from django import forms
 from django.contrib import admin
 from django.contrib.auth.decorators import permission_required
@@ -10,63 +9,91 @@
 from flatpages_tinymce import settings
 from django.shortcuts import get_object_or_404
 from django.http import HttpResponse, Http404
-from django.conf.urls.defaults import patterns, url
+
+try:
+    from django.urls import reverse
+    # Django 2.0 removes the django.core.urlresolvers module,
+    # which was moved to django.urls in version 1.10.
+except ImportError:
+    from django.core.urlresolvers import reverse
+
+from django.conf.urls import url
 from django.views.decorators.csrf import csrf_protect
 
 
 class FlatPageAdmin(flatpages_admin.FlatPageAdmin):
-    # @csrf_protect
     def __init__(self, *args, **kwargs):
         super(FlatPageAdmin, self).__init__(*args, **kwargs)
 
-        # Once Django 1.4 is commonplace, add raise_exception=True to permission_required.
-        self.ajax_save = csrf_protect(permission_required('flatpages.change_flatpage')(self._ajax_save))
+        self.ajax_save = csrf_protect(
+            permission_required('flatpages.change_flatpage')(self._ajax_save)
+        )
 
-    @transaction.commit_on_success
+    @transaction.atomic
     def _ajax_save(self, request):
         try:
-            page_id = int(request.REQUEST.get("id", 0))
+            page_id = int(request.POST.get("id", 0))
         except ValueError:
             page_id = 0
 
         page = get_object_or_404(FlatPage, id=page_id)
-        page_content = request.REQUEST.get("content", "").strip()
+        page_content = request.POST.get("content", "").strip()
         if not page_content:
             raise Http404()
         page.content = page_content
         page.save()
-        # raise Exception(page.content)
         return HttpResponse(page.content)
 
     def get_urls(self):
         urls = super(FlatPageAdmin, self).get_urls()
-        my_urls = patterns('',
-            url(r'^ajax-save/$', self.admin_site.admin_view(self.ajax_save), name='flatpages_ajax_save'),
-        )
+        my_urls = [
+            url(
+                '^ajax-save/$',
+                self.admin_site.admin_view(self.ajax_save),
+                name='flatpages_ajax_save'
+            ),
+        ]
         return my_urls + urls
 
     def formfield_for_dbfield(self, db_field, **kwargs):
         if db_field.name == 'content':
             if settings.USE_ADMIN_AREA_TINYMCE:
-                return db_field.formfield(widget=TinyMCE(
-                attrs={'cols': 80, 'rows': 30},
-                    mce_attrs={'external_link_list_url': reverse('tinymce.views.flatpages_link_list')},
-                    ))
+                return db_field.formfield(
+                    widget=TinyMCE(
+                        attrs={'cols': 80, 'rows': 30},
+                        mce_attrs={
+                            'external_link_list_url':
+                                reverse('tinymce-linklist')
+                        },
+                    )
+                )
         elif db_field.name == "template_name" and settings.USE_TEMPLATE_DROPDOWN:
-            prev_field = super(FlatPageAdmin, self).formfield_for_dbfield(db_field, **kwargs)
-            return forms.FilePathField(label=prev_field.label,
-                                       path=settings.TEMPLATE_DIR,
-                                       required=False,
-                                       recursive=False,
-                                       match=settings.TEMPLATE_FILES_REGEXP,
-                                       )
-        return super(FlatPageAdmin, self).formfield_for_dbfield(db_field, **kwargs)
+            prev_field = super(FlatPageAdmin, self).formfield_for_dbfield(
+                db_field, **kwargs
+            )
+            return forms.FilePathField(
+                label=prev_field.label,
+                path=settings.TEMPLATE_DIR,
+                required=False,
+                recursive=False,
+                match=settings.TEMPLATE_FILES_REGEXP,
+            )
+        return super(FlatPageAdmin, self).formfield_for_dbfield(
+            db_field,
+            **kwargs
+        )
+
     # redefining
     fieldsets = (
         (None, {'fields': ('url', 'title', 'content', 'sites')}),
-        (_('Advanced options'), {'classes': ('collapse',), 'fields': ('enable_comments',
-                                                    'registration_required', 'template_name')}),
+        (_('Advanced options'), {
+            'classes': ('collapse',),
+            'fields': ('enable_comments',
+                       'registration_required',
+                       'template_name')
+        }),
     )
 
+
 admin.site.unregister(FlatPage)
 admin.site.register(FlatPage, FlatPageAdmin)

flatpages_tinymce/settings.py

@@ -5,7 +5,7 @@
 USE_FRONTED_TINYMCE = getattr(settings, "FLATPAGES_TINYMCE_FRONTEND", True)
 
 USE_TEMPLATE_DROPDOWN = getattr(settings, "FLATPAGES_USE_TEMPLATE_DROPDOWN", True)
-TEMPLATE_DIR = getattr(settings, "FLATPAGES_TEMPLATE_DIR", os.path.join(settings.TEMPLATE_DIRS[0], 'flatpages'))
+TEMPLATE_DIR = getattr(settings, "FLATPAGES_TEMPLATE_DIR", os.path.join(settings.TEMPLATES[0]['DIRS'][0], 'flatpages'))
 TEMPLATE_FILES_REGEXP = getattr(settings, 'FLATPAGES_ADMIN_REGEXP', r'.*\.d?html?')
 
 DIV_PREFIX = getattr(settings, 'FLATPAGES_DIV_PREFIX', "django_staticpages_edit")

flatpages_tinymce/templatetags/flatpage_admin.py

@@ -1,15 +1,22 @@
 import os
-import simplejson
-
+import json
 # Settings
+
 from django.conf import settings
 import tinymce.settings
 from flatpages_tinymce import settings as local_settings
 
 from django import template
-from django.core.urlresolvers import reverse
 from django.utils.safestring import mark_safe
 from django.utils.translation import ugettext as _
+from django.utils.encoding import force_text
+
+try:
+    from django.urls import reverse
+    # Django 2.0 removes the django.core.urlresolvers module,
+    # which was moved to django.urls in version 1.10.
+except ImportError:
+    from django.core.urlresolvers import reverse
 
 register = template.Library()
 
@@ -59,9 +66,9 @@ def flatpage_media(context):
         'prefix': local_settings.DIV_PREFIX,
         'url': reverse('admin:flatpages_ajax_save'),
         'error_message': _(u'Error while saving. Please try again.'),
-        'csrf_token': unicode(context['csrf_token']),
+        'csrf_token': force_text(context['csrf_token']),
         }
-    output_chunks.append('<script type="text/javascript">$_STATICPAGES_INIT(%s)</script>' % simplejson.dumps(params))
+    output_chunks.append('<script type="text/javascript">$_STATICPAGES_INIT(%s)</script>' % json.dumps(params))
 
     context.render_context["flatpage_media_loaded"] = 1
     return mark_safe("\n".join(output_chunks))

flatpages_tinymce/testapp/__init__.py

@@ -0,0 +1 @@
+from __future__ import unicode_literals

flatpages_tinymce/testapp/tests/__init__.py

@@ -0,0 +1 @@
+from __future__ import unicode_literals

flatpages_tinymce/testapp/tests/conf.py

@@ -0,0 +1,78 @@
+from __future__ import unicode_literals
+import unittest
+from guardian.conf import settings as guardian_settings
+from django.conf import settings
+from django.conf import UserSettingsHolder
+from django.utils.functional import wraps
+
+
+def skipUnlessTestApp(obj):
+    app = 'guardian.testapp'
+    return unittest.skipUnless(app in settings.INSTALLED_APPS,
+                               'app %r must be installed to run this test' % app)(obj)
+
+
+class TestDataMixin(object):
+
+    def setUp(self):
+        super(TestDataMixin, self).setUp()
+        from django.contrib.auth.models import Group
+        from django.contrib.auth import get_user_model
+        User = get_user_model()
+        Group.objects.create(pk=1, name='admins')
+        jack_group = Group.objects.create(pk=2, name='jackGroup')
+        User.objects.get_or_create(username=guardian_settings.ANONYMOUS_USER_NAME)
+        jack = User.objects.create(username='jack', is_active=True,
+                                   is_superuser=False, is_staff=False)
+        jack.groups.add(jack_group)
+
+
+class override_settings(object):
+    """
+    Acts as either a decorator, or a context manager. If it's a decorator it
+    takes a function and returns a wrapped function. If it's a contextmanager
+    it's used with the ``with`` statement. In either event entering/exiting
+    are called before and after, respectively, the function/block is executed.
+    """
+
+    def __init__(self, **kwargs):
+        self.options = kwargs
+        self.wrapped = settings._wrapped
+
+    def __enter__(self):
+        self.enable()
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        self.disable()
+
+    def __call__(self, test_func):
+        from django.test import TransactionTestCase
+        if isinstance(test_func, type) and issubclass(test_func, TransactionTestCase):
+            original_pre_setup = test_func._pre_setup
+            original_post_teardown = test_func._post_teardown
+
+            def _pre_setup(innerself):
+                self.enable()
+                original_pre_setup(innerself)
+
+            def _post_teardown(innerself):
+                original_post_teardown(innerself)
+                self.disable()
+            test_func._pre_setup = _pre_setup
+            test_func._post_teardown = _post_teardown
+            return test_func
+        else:
+            @wraps(test_func)
+            def inner(*args, **kwargs):
+                with self:
+                    return test_func(*args, **kwargs)
+        return inner
+
+    def enable(self):
+        override = UserSettingsHolder(settings._wrapped)
+        for key, new_value in self.options.items():
+            setattr(override, key, new_value)
+        settings._wrapped = override
+
+    def disable(self):
+        settings._wrapped = self.wrapped

flatpages_tinymce/testapp/tests/test_admin.py

@@ -0,0 +1,43 @@
+from __future__ import unicode_literals
+
+from django.contrib.auth import get_user_model
+from django.contrib.auth.models import Group
+from django.test import TestCase
+from django.test.client import Client
+from django.urls import reverse
+from django.contrib.flatpages.models import FlatPage
+
+User = get_user_model()
+
+class AdminTests(TestCase):
+
+    def setUp(self):
+        self.admin = User.objects.create_superuser(
+            'admin', 'admin@example.com', 'admin'
+        )
+        self.user = User.objects.create_user('joe', 'joe@example.com', 'joe')
+        self.group = Group.objects.create(name='group')
+        self.flatpage = FlatPage.objects.create(
+            title='x',
+            content='before_update'
+        )
+        self.client = Client()
+
+    def tearDown(self):
+        self.client.logout()
+
+    def _login_superuser(self):
+        self.client.login(username='admin', password='admin')
+
+    def test_view_manage_negative_user_form(self):
+        self._login_superuser()
+
+        url = reverse('admin:flatpages_ajax_save')
+        data = {
+            'id': self.flatpage.id,
+                'title': 'y',
+                'content': 'after_update'
+        }
+        response = self.client.post(url, data, follow=True)
+        self.assertEqual(len(response.redirect_chain), 0)
+        self.assertEqual(response.status_code, 200)

flatpages_tinymce/testapp/tests/urls.py

@@ -0,0 +1,12 @@
+from __future__ import unicode_literals
+from django.conf.urls import include, url
+from django.contrib import admin
+import django
+
+if django.VERSION[0] < 2:
+    admin.autodiscover()
+
+urlpatterns = [
+    url(r'^admin/', admin.site.urls),
+    url(r'^tinymce/', include('tinymce.urls')),
+]