Translate the error messages regarding IP subnets and pools

coin/resources/models.py

@@ -13,9 +13,9 @@ def validate_subnet(cidr):
     """Checks that a CIDR object is indeed a subnet, i.e. the host bits are
     all set to zero."""
     if not isinstance(cidr, IPNetwork):
-        raise ValidationError("Internal error, expected IPNetwork object")
+        raise ValidationError("Erreur, objet IPNetwork attendu.")
     if cidr.ip != cidr.network:
-        raise ValidationError("{} is not a proper subnet, you probably mean {}".format(cidr, cidr.cidr))
+        raise ValidationError("{} n'est pas un sous-réseau valide, voulez-vous dire {} ?".format(cidr, cidr.cidr))
 
 
 class IPPool(models.Model):
@@ -36,14 +36,14 @@ class IPPool(models.Model):
         if self.inet:
             max_subnetsize = 64 if self.inet.version == 6 else 32
             if not self.inet.prefixlen <= self.default_subnetsize <= max_subnetsize:
-                raise ValidationError('Invalid default subnet size')
+                raise ValidationError('Taille de sous-réseau invalide')
             # Check that related subnet are in the pool (useful when
             # modifying an existing pool that already has subnets
             # allocated in it)
             incorrect = [str(subnet) for subnet in self.ipsubnet_set.all()
                          if not subnet.inet in self.inet]
             if incorrect:
-                err = 'Some subnets allocated in this pool are outside the pool: {}'.format(incorrect)
+                err = "Des sous-réseaux se retrouveraient en-dehors du bloc d'IP: {}".format(incorrect)
                 raise ValidationError(err)
 
     def __unicode__(self):
@@ -90,24 +90,24 @@ class IPSubnet(models.Model):
         try:
             first_free = available.next()
         except StopIteration:
-            raise ValidationError('Unable to allocate an IP subnet in the specified pool: not enough space left.')
+            raise ValidationError("Impossible d'allouer un sous-réseau : bloc d'IP rempli.")
         self.inet = first_free.subnet(self.ip_pool.default_subnetsize, 1).next()
 
     def validate_inclusion(self):
         """Check that we are included in the IP pool"""
         if not self.inet in self.ip_pool.inet:
-            raise ValidationError('Subnet must be included in the IP pool.')
+            raise ValidationError("Le sous-réseau doit être inclus dans le bloc d'IP.")
         # Check that we don't conflict with existing subnets.
         conflicting = self.ip_pool.ipsubnet_set.filter(Q(inet__net_contained_or_equal=self.inet) |
                                                        Q(inet__net_contains_or_equals=self.inet)).exclude(id=self.id)
         if conflicting:
-            raise ValidationError('Subnet must not intersect with existing subnets.\nIntersected subnets: {}.'.format(conflicting))
+            raise ValidationError("Le sous-réseau est en conflit avec des sous-réseaux existants: {}.".format(conflicting))
 
     def validate_reverse_dns(self):
         """Check that reverse DNS entries, if any, are included in the subnet"""
         incorrect = [str(rev.ip) for rev in self.reversednsentry_set.all() if not rev.ip in self.inet]
         if incorrect:
-            raise ValidationError('Some reverse DNS entries are not in the subnet: {}.'.format(incorrect))
+            raise ValidationError("Des entrées DNS inverse ne sont pas dans le sous-réseau: {}.".format(incorrect))
 
     def clean(self):
         if not self.inet: