Translation verbose_name and help_text of models to French

coin/billing/models.py

@@ -44,7 +44,7 @@ class Invoice(models.Model):
     status = models.CharField(max_length=50, choices=INVOICES_STATUS_CHOICES,
                               default='open',
                               verbose_name='statut')
-    date = models.DateField(default=datetime.date.today, null=True)
+    date = models.DateField(default=datetime.date.today, null=True, verbose_name='date')
     date_due = models.DateField(
         default=end_of_month,
         null=True,

coin/configuration/models.py

@@ -64,6 +64,9 @@ class Configuration(PolymorphicModel):
         else:
             return self.model_name().lower()
 
+    class Meta:
+        verbose_name = 'configuration'
+
 
 @receiver(post_save, sender=IPSubnet)
 def subnet_save_event(sender, **kwargs):

coin/members/models.py

@@ -35,9 +35,9 @@ class Member(CoinLdapSyncMixin, AbstractUser):
     )
 
     status = models.CharField(max_length=50, choices=MEMBER_STATUS_CHOICES,
-                              default='pending')
+                              default='pending', verbose_name='statut')
     type = models.CharField(max_length=20, choices=MEMBER_TYPE_CHOICES,
-                            default='natural_person')
+                            default='natural_person', verbose_name='type')
 
     organization_name = models.CharField(max_length=200, blank=True,
                                          verbose_name="nom de l'organisme",
@@ -48,7 +48,7 @@ class Member(CoinLdapSyncMixin, AbstractUser):
                                            verbose_name='téléphone mobile')
     # TODO: use a django module that provides an address model? (would
     # support more countries and address types)
-    address = models.TextField(verbose_name='adresse', blank=True, null=True)
+    address = models.TextField(verbose_name='adresse postale', blank=True, null=True)
     postal_code = models.CharField(max_length=5, blank=True, null=True,
                                    validators=[RegexValidator(regex=r'^\d{5}$',
                                                message='Code postal non valide.')],
@@ -237,7 +237,8 @@ class CryptoKey(models.Model):
 
     KEY_TYPE_CHOICES = (('RSA', 'RSA'), ('GPG', 'GPG'))
 
-    type = models.CharField(max_length=3, choices=KEY_TYPE_CHOICES)
+    type = models.CharField(max_length=3, choices=KEY_TYPE_CHOICES,
+                            verbose_name='type')
     key = models.TextField(verbose_name='clé')
     member = models.ForeignKey('Member', verbose_name='membre')
 

coin/offers/models.py

@@ -30,7 +30,8 @@ class Offer(models.Model):
     configuration_type = models.CharField(max_length=50,
                             null=True,
                             choices = (('',''),),
-                            help_text="Type of configuration to use with this offer")
+                            verbose_name='type de configuration',
+                            help_text="Type de configuration à utiliser avec cette offre")
     billing_period = models.IntegerField(blank=False, null=False, default=1,
                                          verbose_name='période de facturation',
                                          help_text='en mois')

coin/resources/models.py

@@ -21,13 +21,15 @@ def validate_subnet(cidr):
 class IPPool(models.Model):
     """Pool of IP addresses (either v4 or v6)."""
     name = models.CharField(max_length=255, blank=False, null=False,
-                            help_text='Name of the IP pool')
+                            verbose_name='nom',
+                            help_text="Nom du pool d'IP")
     default_subnetsize = models.PositiveSmallIntegerField(blank=False,
-                                                          verbose_name='default subnet size',
-                                                          help_text='Default subnet size to allocate to subscribers in this pool',
+                                                          verbose_name='taille de sous-réseau par défaut',
+                                                          help_text='Taille par défaut du sous-réseau à allouer aux abonnés dans ce pool',
                                                           validators=[MaxValueValidator(64)])
     inet = CidrAddressField(validators=[validate_subnet],
-                            help_text="Address space to use")
+                            verbose_name='réseau',
+                            help_text="Bloc d'adresses IP du pool")
     objects = NetManager()
 
     def clean(self):
@@ -47,6 +49,10 @@ class IPPool(models.Model):
     def __unicode__(self):
         return self.name
 
+    class Meta:
+        verbose_name = "pool d'IP"
+        verbose_name_plural = "pools d'IP"
+
 
 class IPSubnet(models.Model):
     # TODO: find some way to signal to Subscriptions objects when a subnet
@@ -55,16 +61,20 @@ class IPSubnet(models.Model):
     # Actually, a better idea would be to build a custom relation and update
     # LDAP in the relation itself.
     inet = CidrAddressField(blank=True, validators=[validate_subnet],
-                            verbose_name="subnet",
-                            help_text="Leave empty for automatic allocation")
+                            verbose_name="sous-réseau",
+                            help_text="Laisser vide pour allouer automatiquement")
     objects = NetManager()
-    ip_pool = models.ForeignKey(IPPool, verbose_name="IP pool")
+    ip_pool = models.ForeignKey(IPPool, verbose_name="pool d'IP")
     configuration = models.ForeignKey('configuration.Configuration',
-                                      related_name='ip_subnet')
-    delegate_reverse_dns = models.BooleanField(default=False)
+                                      related_name='ip_subnet',
+                                      verbose_name='configuration')
+    delegate_reverse_dns = models.BooleanField(default=False,
+                                               verbose_name='déléguer le reverse DNS',
+                                               help_text='Déléguer la résolution DNS inverse de ce sous-réseau à un ou plusieurs serveurs de noms')
     name_server = models.ManyToManyField('reverse_dns.NameServer',
                                          blank=True,
-                                         help_text="Nameserver to use for the delegation of reverse DNS")
+                                         verbose_name='serveur de noms',
+                                         help_text="Serveur de noms à qui déléguer la résolution DNS inverse")
 
     def allocate(self):
         """Automatically allocate a free subnet"""
@@ -108,3 +118,7 @@ class IPSubnet(models.Model):
 
     def __unicode__(self):
         return str(self.inet)
+
+    class Meta:
+        verbose_name = "sous-réseau IP"
+        verbose_name_plural = "sous-réseaux IP"

coin/reverse_dns/models.py

@@ -18,22 +18,27 @@ class NameServer(models.Model):
     # between NameServer and IPSubnet (see Capslock), and save in LDAP
     # there.
     dns_name = models.CharField(max_length=255,
-                                help_text="Example: ns1.example.com")
+                                verbose_name="nom du serveur",
+                                help_text="Exemple : ns1.example.com")
     description = models.CharField(max_length=255, blank=True,
-                                   verbose_name="human-readable name of the nameserver",
-                                   help_text="Example: My first name server")
-    owner = models.ForeignKey("members.Member")
+                                   verbose_name="description du serveur",
+                                   help_text="Exemple : Mon serveur de noms principal")
+    owner = models.ForeignKey("members.Member", verbose_name="propriétaire")
 
     def __unicode__(self):
         return "{} ({})".format(self.description, self.dns_name) if self.description else self.dns_name
 
+    class Meta:
+        verbose_name = 'serveur de noms'
+        verbose_name_plural = 'serveurs de noms'
+
 
 class ReverseDNSEntry(models.Model):
-    ip = InetAddressField(unique=True)
-    reverse = models.CharField(max_length=255,
-                               verbose_name="hostname to associate to the IP")
+    ip = InetAddressField(unique=True, verbose_name='adresse IP')
+    reverse = models.CharField(max_length=255, verbose_name='reverse',
+                               help_text="Nom à associer à l'adresse IP")
     ttl = models.IntegerField(default=3600, verbose_name="TTL",
-                              help_text="in seconds",
+                              help_text="en secondes",
                               validators=[MinValueValidator(60)])
     ip_subnet = models.ForeignKey('resources.IPSubnet')
 
@@ -50,3 +55,7 @@ class ReverseDNSEntry(models.Model):
 
     def __unicode__(self):
         return "{} → {}".format(self.ip, self.reverse)
+
+    class Meta:
+        verbose_name = 'entrée DNS inverse'
+        verbose_name_plural = 'entrées DNS inverses'

coin/vpn/models.py

@@ -24,18 +24,19 @@ class VPNConfiguration(CoinLdapSyncMixin, Configuration):
     #     'offers.OfferSubscription',
     #     related_name=backend_name,
     #     validators=[ValidateBackendType(backend_name)])
-    activated = models.BooleanField(default=False)
+    activated = models.BooleanField(default=False, verbose_name='activé')
     login = models.CharField(max_length=50, unique=True, blank=True,
                              verbose_name="identifiant",
                              help_text="leave empty for automatic generation")
-    password = models.CharField(max_length=256, blank=True, null=True)
+    password = models.CharField(max_length=256, verbose_name="mot de passe",
+                                blank=True, null=True)
     ipv4_endpoint = InetAddressField(validators=[validation.validate_v4],
                                      verbose_name="IPv4", blank=True, null=True,
-                                     help_text="Addresse IPv4 utilisée par "
+                                     help_text="Adresse IPv4 utilisée par "
                                      "défaut sur le VPN")
     ipv6_endpoint = InetAddressField(validators=[validation.validate_v6],
                                      verbose_name="IPv6", blank=True, null=True,
-                                     help_text="Addresse IPv6 utilisée par "
+                                     help_text="Adresse IPv6 utilisée par "
                                      "défaut sur le VPN")
     comment = models.CharField(blank=True, max_length=512,
                                verbose_name="commentaire")