Manage natural keys for types and import related models

1 files changed, 106 insertions, 3 deletions

diff --git a/ishtar_common/models.py b/ishtar_common/models.py
index 803a2367c..25270e633 100644
--- a/ishtar_common/models.py
+++ b/ishtar_common/models.py
@@ -415,6 +415,11 @@ def post_save_cache(sender, **kwargs):
     sender.refresh_cache()
 
 
+class TypeManager(models.Manager):
+    def get_by_natural_key(self, txt_idx):
+        return self.get(txt_idx=txt_idx)
+
+
 class GeneralType(Cached, models.Model):
     """
     Abstract class for "types"
@@ -430,14 +435,17 @@ class GeneralType(Cached, models.Model):
     comment = models.TextField(_(u"Comment"), blank=True, null=True)
     available = models.BooleanField(_(u"Available"), default=True)
     HELP_TEXT = u""
+    objects = TypeManager()
 
     class Meta:
         abstract = True
-        unique_together = (('txt_idx', 'available'),)
 
     def __unicode__(self):
         return self.label
 
+    def natural_key(self):
+        return (self.txt_idx, )
+
     @classmethod
     def create_default_for_test(cls):
         return [cls.objects.create(label='Test %d' % i) for i in range(5)]
@@ -1894,9 +1902,15 @@ def import_class(full_path_classname):
     return getattr(module, mods[-1])
 
 
+class ImportModelManager(models.Manager):
+    def get_by_natural_key(self, klass):
+        return self.get(klass=klass)
+
+
 class ImporterModel(models.Model):
     name = models.CharField(_(u"Name"), max_length=200)
-    klass = models.CharField(_(u"Class name"), max_length=200)
+    klass = models.CharField(_(u"Class name"), max_length=200, unique=True)
+    objects = ImportModelManager()
 
     class Meta:
         verbose_name = _(u"Importer - Model")
@@ -1906,6 +1920,14 @@ class ImporterModel(models.Model):
     def __unicode__(self):
         return self.name
 
+    def natural_key(self):
+        return (self.klass, )
+
+
+class ImporterTypeManager(models.Manager):
+    def get_by_natural_key(self, slug):
+        return self.get(slug=slug)
+
 
 class ImporterType(models.Model):
     """
@@ -1929,12 +1951,16 @@ class ImporterType(models.Model):
     is_template = models.BooleanField(_(u"Is template"), default=False)
     unicity_keys = models.CharField(_(u"Unicity keys (separator \";\")"),
                                     blank=True, null=True, max_length=500)
+    objects = ImporterTypeManager()
 
     class Meta:
         verbose_name = _(u"Importer - Type")
         verbose_name_plural = _(u"Importer - Types")
         ordering = ('name',)
 
+    def natural_key(self):
+        return (self.slug, )
+
     def __unicode__(self):
         return self.name
 
@@ -2023,6 +2049,11 @@ def get_associated_model(parent_model, keys):
     return model
 
 
+class ImporterDefaultManager(models.Manager):
+    def get_by_natural_key(self, importer_type, target):
+        return self.get(importer_type__slug=importer_type, target=target)
+
+
 class ImporterDefault(models.Model):
     """
     Targets of default values in an import
@@ -2033,10 +2064,15 @@ class ImporterDefault(models.Model):
     class Meta:
         verbose_name = _(u"Importer - Default")
         verbose_name_plural = _(u"Importer - Defaults")
+        unique_together = ('importer_type', 'target')
+    objects = ImporterDefaultManager()
 
     def __unicode__(self):
         return u"{} - {}".format(self.importer_type, self.target)
 
+    def natural_key(self):
+        return self.importer_type.slug, self.target
+
     @property
     def keys(self):
         return tuple(self.target.split('__'))
@@ -2054,6 +2090,13 @@ class ImporterDefault(models.Model):
         return values
 
 
+class ImporterDefaultValuesManager(models.Manager):
+    def get_by_natural_key(self, def_target_type, def_target, target):
+        return self.get(default_target__importer_type__slug=def_target_type,
+                        default_target__target=def_target,
+                        target=target)
+
+
 class ImporterDefaultValues(models.Model):
     """
     Default values in an import
@@ -2062,6 +2105,7 @@ class ImporterDefaultValues(models.Model):
                                        related_name='default_values')
     target = models.CharField(u"Target", max_length=500)
     value = models.CharField(u"Value", max_length=500)
+    objects = ImporterDefaultValuesManager()
 
     def __unicode__(self):
         return u"{} - {}".format(self.default_target, self.target, self.value)
@@ -2070,6 +2114,11 @@ class ImporterDefaultValues(models.Model):
         verbose_name = _(u"Importer - Default value")
         verbose_name_plural = _(u"Importer - Default values")
 
+    def natural_key(self):
+        return (self.default_target.importer_type.slug,
+                self.default_target.target,
+                self.target)
+
     def get_value(self):
         parent_model = self.default_target.associated_model
         if not parent_model:
@@ -2095,6 +2144,12 @@ class ImporterDefaultValues(models.Model):
         return ""
 
 
+class ImporterColumnManager(models.Manager):
+    def get_by_natural_key(self, importer_type, col_number):
+        return self.get(importer_type__slug=importer_type,
+                        col_number=col_number)
+
+
 class ImporterColumn(models.Model):
     """
     Import file column description
@@ -2111,6 +2166,7 @@ class ImporterColumn(models.Model):
         help_text=_(u"Fill this field if the field name is ambiguous for "
                     u"export. For instance: concatenated fields.")
     )
+    objects = ImporterColumnManager()
 
     class Meta:
         verbose_name = _(u"Importer - Column")
@@ -2121,6 +2177,9 @@ class ImporterColumn(models.Model):
     def __unicode__(self):
         return u"{} - {}".format(self.importer_type, self.col_number)
 
+    def natural_key(self):
+        return self.importer_type.slug, self.col_number
+
     def targets_lbl(self):
         return u', '.join([target.target for target in self.targets.all()])
 
@@ -2129,6 +2188,13 @@ class ImporterColumn(models.Model):
                            for dp in self.duplicate_fields.all()])
 
 
+class ImporterDuplicateFieldManager(models.Manager):
+    def get_by_natural_key(self, importer_type, col_number, field_name):
+        return self.get(column__importer_type__slug=importer_type,
+                        column__col_number=col_number,
+                        field_name=field_name)
+
+
 class ImporterDuplicateField(models.Model):
     """
     Direct copy of result in other fields
@@ -2142,17 +2208,28 @@ class ImporterDuplicateField(models.Model):
                                  default=False)
     concat_str = models.CharField(_(u"Concatenate character"), max_length=5,
                                   blank=True, null=True)
+    objects = ImporterDuplicateFieldManager()
 
     class Meta:
         verbose_name = _(u"Importer - Duplicate field")
         verbose_name_plural = _(u"Importer - Duplicate fields")
 
+    def natural_key(self):
+        return self.column.importer_type, self.column.col_number, \
+            self.field_name
+
+
+class NamedManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+
 
 class Regexp(models.Model):
-    name = models.CharField(_(u"Name"), max_length=100)
+    name = models.CharField(_(u"Name"), max_length=100, unique=True)
     description = models.CharField(_(u"Description"), blank=True, null=True,
                                    max_length=500)
     regexp = models.CharField(_(u"Regular expression"), max_length=500)
+    objects = NamedManager()
 
     class Meta:
         verbose_name = _(u"Importer - Regular expression")
@@ -2161,6 +2238,16 @@ class Regexp(models.Model):
     def __unicode__(self):
         return self.name
 
+    def natural_key(self):
+        return (self.name, )
+
+
+class ImportTargetManager(models.Manager):
+    def get_by_natural_key(self, importer_type, col_number, target):
+        return self.get(column__importer_type__slug=importer_type,
+                        column__col_number=col_number,
+                        target=target)
+
 
 class ImportTarget(models.Model):
     """
@@ -2177,14 +2264,20 @@ class ImportTarget(models.Model):
     concat_str = models.CharField(_(u"Concatenate character"), max_length=5,
                                   blank=True, null=True)
     comment = models.TextField(_(u"Comment"), blank=True, null=True)
+    objects = ImportTargetManager()
 
     class Meta:
         verbose_name = _(u"Importer - Target")
         verbose_name_plural = _(u"Importer - Targets")
+        unique_together = ('column', 'target')
 
     def __unicode__(self):
         return self.target[:50] if self.target else self.comment
 
+    def natural_key(self):
+        return self.column.importer_type.slug, self.column.col_number, \
+               self.target
+
     @property
     def associated_model(self):
         try:
@@ -2349,6 +2442,12 @@ IMPORTER_TYPES_CHOICES = {'TypeFormater': TARGET_MODELS,
                           'DateFormater': DATE_FORMATS}
 
 
+class FormaterTypeManager(models.Manager):
+    def get_by_natural_key(self, formater_type, options, many_split):
+        return self.get(formater_type=formater_type,
+                        options=options, many_split=many_split)
+
+
 class FormaterType(models.Model):
     formater_type = models.CharField(u"Formater type", max_length=20,
                                      choices=IMPORTER_TYPES)
@@ -2356,6 +2455,7 @@ class FormaterType(models.Model):
                                null=True)
     many_split = models.CharField(_(u"Split character(s)"), max_length=10,
                                   blank=True, null=True)
+    objects = FormaterTypeManager()
 
     class Meta:
         verbose_name = _(u"Importer - Formater type")
@@ -2363,6 +2463,9 @@ class FormaterType(models.Model):
         unique_together = ('formater_type', 'options', 'many_split')
         ordering = ('formater_type', 'options')
 
+    def natural_key(self):
+        return self.formater_type, self.options, self.many_split
+
     def __unicode__(self):
         return u" - ".join(
             [unicode(dict(IMPORTER_TYPES)[self.formater_type])