Refactoring: renaming Area to Map

1 files changed, 73 insertions, 63 deletions

diff --git a/chimere/models.py b/chimere/models.py
index 7db530a..60e4cd1 100644
--- a/chimere/models.py
+++ b/chimere/models.py
@@ -105,7 +105,7 @@ class News(models.Model):
     date = models.DateField(_(u"Date"), auto_now_add=True)
     content = models.TextField()
     url = models.URLField(_(u"Url"), max_length=200, blank=True, null=True)
-    areas = SelectMultipleField('Area', verbose_name=_(u"Associated areas"),
+    maps = SelectMultipleField('Map', verbose_name=_(u"Associated maps"),
                                 blank=True, null=True)
     def __unicode__(self):
         ordering = ["-date"]
@@ -239,7 +239,7 @@ class SubCategory(models.Model):
         verbose_name_plural = _(u"Sub-categories")
 
     @classmethod
-    def getAvailable(cls, item_types=None, area_name=None, public=False):
+    def getAvailable(cls, item_types=None, map_name=None, public=False):
         '''Get list of tuples with first the category and second the associated
         subcategories
         '''
@@ -252,14 +252,14 @@ class SubCategory(models.Model):
         if public:
             subcategories = subcategories.filter(submission=True)
         selected_cats = []
-        if area_name:
-            area = Area.objects.get(urn=area_name)
+        if map_name:
+            map = Map.objects.get(urn=map_name)
             # if there some restrictions with categories limit them
-            if area.subcategories.count():
-                sub_ids = [sub.id for sub in area.subcategories.all()]
+            if map.subcategories.count():
+                sub_ids = [sub.id for sub in map.subcategories.all()]
                 subcategories = subcategories.filter(id__in=sub_ids)
             selected_cats = [subcat.pk
-                             for subcat in area.default_subcategories.all()]
+                             for subcat in map.default_subcategories.all()]
         for sub_category in subcategories.order_by('order'):
             if sub_category.category not in sub_categories:
                 sub_categories[sub_category.category] = []
@@ -275,9 +275,9 @@ class SubCategory(models.Model):
         return subcategories
 
     @classmethod
-    def getAvailableTuples(cls, area_name=None):
+    def getAvailableTuples(cls, map_name=None):
         cats = []
-        for cat, subcats in cls.getAvailable(area_name=area_name):
+        for cat, subcats in cls.getAvailable(map_name=map_name):
             cats.append((unicode(cat),
                         [(subcat.pk, subcat.name) for subcat in subcats]))
         return cats
@@ -679,20 +679,20 @@ class Marker(GeographicItem):
         if cats.count():
             return cats.all()[0]
 
-    def get_absolute_url(self, area_name=''):
+    def get_absolute_url(self, map_name=''):
         parameters = 'current_feature=%d' % self.id
         if self.default_category:
             parameters += '&checked_categories=%s' % self.default_category.pk
         urn = TinyUrl.getUrnByParameters(parameters)
-        area_name = area_name + '/' if area_name else ''
-        url = reverse('chimere:tiny', args=[area_name, urn])
+        map_name = map_name + '/' if map_name else ''
+        url = reverse('chimere:tiny', args=[map_name, urn])
         return url
 
 
 PRE_ATTRS = {
     'Marker':('name', 'geometry', 'import_version', 'modified_since_import'),
     'Route':('name', 'geometry', 'import_version', 'modified_since_import'),
-    'Area':('urn', 'name'),
+    'Map':('urn', 'name'),
     }
 def geometry_pre_save(cls, pre_save_geom_values):
     def geom_pre_save(sender, **kwargs):
@@ -1278,14 +1278,14 @@ class SimpleArea:
             return True
         return False
 
-    def getCategories(self, status='A', filter_available=True, area_name=None):
+    def getCategories(self, status='A', filter_available=True, map_name=None):
         """
-        Get categories for this area
+        Get categories for this map
         """
         wheres = []
-        if area_name:
+        if map_name:
             subcategory_pks = []
-            for cat, subcats in SubCategory.getAvailable(area_name=area_name):
+            for cat, subcats in SubCategory.getAvailable(map_name=map_name):
                 for subcat in subcats:
                     subcategory_pks.append(unicode(subcat.pk))
             if filter_available:
@@ -1349,11 +1349,11 @@ class Layer(models.Model):
     class Meta:
         verbose_name = _("Layer")
 
-class Area(models.Model, SimpleArea):
-    """Rectangular area of the map
+class Map(models.Model, SimpleArea):
+    """A map
     """
     name = models.CharField(_(u"Name"), max_length=150)
-    urn = models.SlugField(_(u"Area urn"), max_length=50, blank=True,
+    urn = models.SlugField(_(u"Map urn"), max_length=50, blank=True,
                            unique=True)
     welcome_message = models.TextField(_(u"Welcome message"), blank=True,
                                        null=True)
@@ -1363,18 +1363,18 @@ class Area(models.Model, SimpleArea):
             default='POINT(0 0)', srid=settings.CHIMERE_EPSG_DISPLAY_PROJECTION)
     lower_right_corner = models.PointField(_(u"Lower right corner"),
             default='POINT(0 0)', srid=settings.CHIMERE_EPSG_DISPLAY_PROJECTION)
-    default = models.NullBooleanField(_(u"Default area"),
-                    help_text=_(u"Only one area is set by default"))
-    layers = SelectMultipleField(Layer, related_name='areas',
-                                 through='AreaLayers', blank=True)
+    default = models.NullBooleanField(_(u"Default map"),
+                    help_text=_(u"Only one map is set by default"))
+    layers = SelectMultipleField(Layer, related_name='maps',
+                                 through='MapLayers', blank=True)
     default_subcategories = SelectMultipleField(SubCategory, blank=True,
                            verbose_name=_(u"Sub-categories checked by default"))
     dynamic_categories = models.NullBooleanField(
         _(u"Sub-categories dynamicaly displayed"),
         help_text=_(u"If checked, categories are only displayed in the menu if "
                     u"they are available on the current extent."))
-    subcategories = SelectMultipleField(SubCategory, related_name='areas',
-       blank=True, db_table='chimere_subcategory_areas',
+    subcategories = SelectMultipleField(SubCategory, related_name='maps',
+       blank=True, db_table='chimere_subcategory_maps',
        verbose_name=_(u"Restricted to theses sub-categories"),
        help_text=_(u"If no sub-category is set all sub-categories are "
                    u"available"))
@@ -1389,11 +1389,11 @@ class Area(models.Model, SimpleArea):
 
     class Meta:
         ordering = ('order', 'name')
-        verbose_name = _("Area")
+        verbose_name = _("Map")
 
     @classmethod
     def getAvailable(cls):
-        '''Get available areas
+        '''Get available maps
         '''
         return cls.objects.filter(available=True)
 
@@ -1419,54 +1419,64 @@ class Area(models.Model, SimpleArea):
         """
         return Q(route__contained=self.getWkt())
 
-pre_save_area_values = {}
-def area_pre_save(sender, **kwargs):
+pre_save_map_values = {}
+def map_pre_save(sender, **kwargs):
     if not kwargs['instance']:
         return
-    geometry_pre_save(Area, pre_save_area_values)(sender, **kwargs)
-pre_save.connect(area_pre_save, sender=Area)
+    geometry_pre_save(Map, pre_save_map_values)(sender, **kwargs)
+pre_save.connect(map_pre_save, sender=Map)
 
-def area_post_save(sender, **kwargs):
+def map_post_save(sender, **kwargs):
     if not kwargs['instance']:
         return
-    area = kwargs['instance']
-    if area.default:
-        defaults = Area.objects.filter(default=True).exclude(pk=area.pk)
+    map = kwargs['instance']
+    if map.default:
+        defaults = Map.objects.filter(default=True).exclude(pk=map.pk)
         for default in defaults:
             default.default = False
             default.save()
     # manage permissions
-    old_urn, old_name = area.urn, area.name
-    if area.pk in pre_save_area_values:
-        old_urn, old_name = pre_save_area_values[area.pk]
+    old_urn, old_name = map.urn, map.name
+    if map.pk in pre_save_map_values:
+        old_urn, old_name = pre_save_map_values[map.pk]
     perm, old_groups, old_users = None, [], []
-    if area.urn != old_urn:
-        oldmnemo = 'change_area_' + old_urn
+
+    if map.urn != old_urn:
+        oldmnemo = 'change_map_' + old_urn
         old_perm = Permission.objects.filter(codename=oldmnemo)
         if old_perm.count():
             perm = old_perm.all()[0]
-            perm.codename = 'change_area_' + area.urn
+            perm.codename = 'change_map_' + map.urn
             perm.save()
-    if not area.urn:
-        area.urn = defaultfilters.slugify(area.name)
-        area.save()
-    mnemo = 'change_area_' + area.urn
+    if not map.urn:
+        map.urn = defaultfilters.slugify(map.name)
+        map.save()
+
+    # fix old mnemo
+    oldmnemo = 'change_area_' + old_urn
+    old_perm = Permission.objects.filter(codename=oldmnemo)
+    if old_perm.count():
+        perm = old_perm.all()[0]
+        perm.codename = 'change_map_' + map.urn
+        perm.save()
+
+    mnemo = 'change_map_' + map.urn
     perm = Permission.objects.filter(codename=mnemo)
-    lbl = "Can change " + area.name
+    lbl = "Can change " + map.name
     if not perm.count():
         content_type, created = ContentType.objects.get_or_create(
-                                        app_label="chimere", model="area")
+                                        app_label="chimere", model="map")
         perm = Permission(name=lbl, content_type_id=content_type.id,
                           codename=mnemo)
         perm.save()
     else:
         perm = perm.all()[0]
-        if old_name != area.name:
+        if old_name != map.name:
             perm.name = lbl
             perm.save()
     # manage moderation group
-    groupname = area.name + " moderation"
-    if old_name != area.name:
+    groupname = map.name + " moderation"
+    if old_name != map.name:
         old_groupname = old_name + " moderation"
         old_gp = Group.objects.filter(name=old_groupname)
         if old_gp.count():
@@ -1487,33 +1497,33 @@ def area_post_save(sender, **kwargs):
             for p in Permission.objects.filter(content_type=ct).all():
                 group.permissions.add(p)
 
-post_save.connect(area_post_save, sender=Area)
+post_save.connect(map_post_save, sender=Map)
 
-def get_areas_for_user(user):
+def get_maps_for_user(user):
     """
     Getting subcats for a specific user
     """
     perms = user.get_all_permissions()
-    areas = set()
-    prefix = 'chimere.change_area_'
+    maps = set()
+    prefix = 'chimere.change_map_'
     for perm in perms:
         if perm.startswith(prefix):
             try:
-                area = Area.objects.get(urn=perm[len(prefix):])
-                areas.add(area)
+                map = Map.objects.get(urn=perm[len(prefix):])
+                maps.add(map)
             except ObjectDoesNotExist:
                 pass
-    return areas
+    return maps
 
-def get_users_by_area(area):
-    if not area:
+def get_users_by_map(map):
+    if not map:
         return []
-    perm = 'change_area_'+area.urn
+    perm = 'change_map_'+map.urn
     return User.objects.filter(Q(groups__permissions__codename=perm)|
                                 Q(user_permissions__codename=perm)).all()
 
-class AreaLayers(models.Model):
-    area = models.ForeignKey(Area)
+class MapLayers(models.Model):
+    map = models.ForeignKey(Map)
     layer = models.ForeignKey(Layer)
     order = models.IntegerField(_(u"Order"))
     default = models.NullBooleanField(_(u"Default layer"))