Fix fatal bug with Django => 1.11.2 for non-GIS databases (makinacorpus#196)

* Amend exception handling and add fallback OGRGeomType class

Update exception handling (https://code.djangoproject.com/ticket/28178). The OGRGeomType had to be added to this codebase, since Django does not allow using GIS classes anymore without such a service installed (https://code.djangoproject.com/ticket/28160).

* Fix version issue with the BaseGeometryWidget class

BaseGeometryWidget is now based off Django 1.11.3's version and includes the deprecated render function with a version check.

* Update requirements.txt for example

* Fix newline

* Fixed style errors and faulty exceptions

Author: deSagaz

example/requirements.txt

@@ -1,6 +1,6 @@
-Django==1.10.2
-django-geojson==2.9.1
-django-leaflet==0.19.0
-jsonfield==1.0.3
-Pillow==3.4.1
-six==1.10.0
+Django==1.11.3
+django-geojson==2.10.0
+django-leaflet==0.22.0
+jsonfield==2.0.2
+Pillow==4.2.1
+six==1.10.0

leaflet/forms/backport.py

@@ -33,8 +33,10 @@
 import warnings
 import json
 
+from distutils.version import LooseVersion
+from django import get_version
 from django.conf import settings
-from django.contrib.gis import gdal
+from django.core.exceptions import ImproperlyConfigured
 from django.forms.widgets import Widget
 from django.template import loader
 from django.utils import six
@@ -45,21 +47,127 @@
 
 try:
     from django.contrib.gis.geos import GEOSGeometry
-except ImportError:
+except (ImportError, ImproperlyConfigured):
     from .nogeos import GEOSGeometry
 
 try:
     from django.contrib.gis.geos import GEOSException
-except ImportError:
+except (ImportError, ImproperlyConfigured):
     from .nogeos import GEOSException
 
+try:
+    from django.contrib.gis.gdal import OGRException
+except (ImportError, ImproperlyConfigured):
+    from .nogeos import OGRException
+
+try:
+    from django.contrib.gis.gdal import OGRGeomType
+except (ImportError, ImproperlyConfigured):
+    class OGRGeomType:
+        """
+        Encapsulate OGR Geometry Types.
+        Taken from Django GitHub repository:
+        https://github.com/django/django/commit/5411821e3b8d1427ee63a5914aed1088c04cc1ed
+        """
+
+        wkb25bit = -2147483648
+
+        # Dictionary of acceptable OGRwkbGeometryType s and their string names.
+        _types = {0: 'Unknown',
+                  1: 'Point',
+                  2: 'LineString',
+                  3: 'Polygon',
+                  4: 'MultiPoint',
+                  5: 'MultiLineString',
+                  6: 'MultiPolygon',
+                  7: 'GeometryCollection',
+                  100: 'None',
+                  101: 'LinearRing',
+                  102: 'PointZ',
+                  1 + wkb25bit: 'Point25D',
+                  2 + wkb25bit: 'LineString25D',
+                  3 + wkb25bit: 'Polygon25D',
+                  4 + wkb25bit: 'MultiPoint25D',
+                  5 + wkb25bit: 'MultiLineString25D',
+                  6 + wkb25bit: 'MultiPolygon25D',
+                  7 + wkb25bit: 'GeometryCollection25D',
+                  }
+        # Reverse type dictionary, keyed by lower-case of the name.
+        _str_types = {v.lower(): k for k, v in _types.items()}
+
+        def __init__(self, type_input):
+            "Figure out the correct OGR Type based upon the input."
+            if isinstance(type_input, OGRGeomType):
+                num = type_input.num
+            elif isinstance(type_input, str):
+                type_input = type_input.lower()
+                if type_input == 'geometry':
+                    type_input = 'unknown'
+                num = self._str_types.get(type_input)
+                if num is None:
+                    raise GEOSException('Invalid OGR String Type "%s"' % type_input)
+            elif isinstance(type_input, int):
+                if type_input not in self._types:
+                    raise GEOSException('Invalid OGR Integer Type: %d' % type_input)
+                num = type_input
+            else:
+                raise TypeError('Invalid OGR input type given.')
+
+                # Setting the OGR geometry type number.
+            self.num = num
+
+        def __str__(self):
+            "Return the value of the name property."
+            return self.name
+
+        def __eq__(self, other):
+            """
+            Do an equivalence test on the OGR type with the given
+            other OGRGeomType, the short-hand string, or the integer.
+            """
+            if isinstance(other, OGRGeomType):
+                return self.num == other.num
+            elif isinstance(other, str):
+                return self.name.lower() == other.lower()
+            elif isinstance(other, int):
+                return self.num == other
+            else:
+                return False
+
+        @property
+        def name(self):
+            "Return a short-hand string form of the OGR Geometry type."
+            return self._types[self.num]
+
+        @property
+        def django(self):
+            "Return the Django GeometryField for this OGR Type."
+            s = self.name.replace('25D', '')
+            if s in ('LinearRing', 'None'):
+                return None
+            elif s == 'Unknown':
+                s = 'Geometry'
+            elif s == 'PointZ':
+                s = 'Point'
+            return s + 'Field'
+
+        def to_multi(self):
+            """
+            Transform Point, LineString, Polygon, and their 25D equivalents
+            to their Multi... counterpart.
+            """
+            if self.name.startswith(('Point', 'LineString', 'Polygon')):
+                self.num += 3
+
 logger = logging.getLogger('django.contrib.gis')
 
 
 class BaseGeometryWidget(Widget):
     """
     The base class for rich geometry widgets.
-    Renders a map using the WKT of the geometry.
+    Render a map using the WKT of the geometry.
+    Adapted from:
+    https://github.com/django/django/commit/a7975260b50282b934c78c8e51846d103636ba04
     """
     geom_type = 'GEOMETRY'
     map_srid = 4326
@@ -82,45 +190,81 @@ def serialize(self, value):
 
     def deserialize(self, value):
         try:
+            # To allow older versions of django-leaflet to work,
+            # self.map_srid is also returned (unlike the imported Django class)
             return GEOSGeometry(value, self.map_srid)
         except (GEOSException, ValueError) as err:
-            logger.error(
-                "Error creating geometry from value '%s' (%s)" % (value, err)
-            )
+            logger.error("Error creating geometry from value '%s' (%s)", value, err)
         return None
 
-    def render(self, name, value, attrs=None):
-        # If a string reaches here (via a validation error on another
-        # field) then just reconstruct the Geometry.
-        if isinstance(value, six.string_types):
-            value = self.deserialize(value)
-
-        if isinstance(value, dict):
-            value = GEOSGeometry(json.dumps(value), srid=self.map_srid)
-
-        if value:
-            # Check that srid of value and map match
-            if value.srid != self.map_srid:
-                try:
-                    ogr = value.ogr
-                    ogr.transform(self.map_srid)
-                    value = ogr
-                except gdal.OGRException as err:
-                    logger.error(
-                        "Error transforming geometry from srid '%s' to srid "
-                        "'%s' (%s)" % (value.srid, self.map_srid, err)
-                    )
-
-        context = self.build_attrs(
-            attrs,
-            name=name,
-            module='geodjango_%s' % name.replace('-', '_'),  # JS-safe
-            serialized=self.serialize(value),
-            geom_type=gdal.OGRGeomType(self.attrs['geom_type']),
-            STATIC_URL=settings.STATIC_URL,
-            LANGUAGE_BIDI=translation.get_language_bidi(),
-        )
-        return loader.render_to_string(self.template_name, context)
+    if LooseVersion(get_version()) >= LooseVersion('1.11'):
+        def get_context(self, name, value, attrs):
+            context = super().get_context(name, value, attrs)
+            # If a string reaches here (via a validation error on another
+            # field) then just reconstruct the Geometry.
+            if value and isinstance(value, str):
+                value = self.deserialize(value)
+
+            if value:
+                # Check that srid of value and map match
+                if value.srid and value.srid != self.map_srid:
+                    try:
+                        ogr = value.ogr
+                        ogr.transform(self.map_srid)
+                        value = ogr
+                    except OGRException as err:
+                        logger.error(
+                            "Error transforming geometry from srid '%s' to srid '%s' (%s)",
+                            value.srid, self.map_srid, err
+                        )
+
+            if attrs is None:
+                attrs = {}
+
+            build_attrs_kwargs = {
+                'name': name,
+                'module': 'geodjango_%s' % name.replace('-', '_'),  # JS-safe
+                'serialized': self.serialize(value),
+                'geom_type': OGRGeomType(self.attrs['geom_type']),
+                'STATIC_URL': settings.STATIC_URL,
+                'LANGUAGE_BIDI': translation.get_language_bidi(),
+            }
+            build_attrs_kwargs.update(attrs)
+            context.update(self.build_attrs(self.attrs, build_attrs_kwargs))
+            return context
+    else:
+        def render(self, name, value, attrs=None):
+            # If a string reaches here (via a validation error on another
+            # field) then just reconstruct the Geometry.
+            if isinstance(value, six.string_types):
+                value = self.deserialize(value)
+
+            if isinstance(value, dict):
+                value = GEOSGeometry(json.dumps(value), srid=self.map_srid)
+
+            if value:
+                # Check that srid of value and map match
+                if value.srid != self.map_srid:
+                    try:
+                        ogr = value.ogr
+                        ogr.transform(self.map_srid)
+                        value = ogr
+                    except OGRException as err:
+                        logger.error(
+                            "Error transforming geometry from srid '%s' to srid "
+                            "'%s' (%s)" % (value.srid, self.map_srid, err)
+                        )
+
+            context = self.build_attrs(
+                attrs,
+                name=name,
+                module='geodjango_%s' % name.replace('-', '_'),  # JS-safe
+                serialized=self.serialize(value),
+                geom_type=OGRGeomType(self.attrs['geom_type']),
+                STATIC_URL=settings.STATIC_URL,
+                LANGUAGE_BIDI=translation.get_language_bidi(),
+            )
+            return loader.render_to_string(self.template_name, context)
 
 
 class GeometryField(forms.Field):

leaflet/forms/nogeos.py

@@ -14,3 +14,7 @@ def __init__(self, geo_input, srid=None):
 
 class GEOSException(Exception):
     pass
+
+
+class OGRException(Exception):
+    pass

leaflet/forms/widgets.py

@@ -5,10 +5,11 @@
 from django import get_version
 from django import forms
 from django.core import validators
+from django.core.exceptions import ImproperlyConfigured
 from django.template.defaultfilters import slugify
 try:
     from django.contrib.gis.forms.widgets import BaseGeometryWidget
-except ImportError:
+except (ImportError, ImproperlyConfigured):
     from .backport import BaseGeometryWidget
 
 from leaflet import app_settings, PLUGINS, PLUGIN_FORMS