Importer: manage many values in one field

1 files changed, 48 insertions, 24 deletions

diff --git a/ishtar_common/data_importer.py b/ishtar_common/data_importer.py
index 6848c3130..0ce61ba01 100644
--- a/ishtar_common/data_importer.py
+++ b/ishtar_common/data_importer.py
@@ -179,7 +179,7 @@ class IntegerFormater(Formater):
 
 class StrChoiceFormater(Formater):
     def __init__(self, choices, strict=False, equiv_dict={}, model=None,
-                 cli=False):
+                 cli=False, many_split=''):
         self.choices = list(choices)
         self.strict = strict
         self.equiv_dict = copy.deepcopy(equiv_dict)
@@ -187,6 +187,7 @@ class StrChoiceFormater(Formater):
         self.model = model
         self.create = False
         self.missings = set()
+        self.many_split = many_split
         for key, value in self.choices:
             value = unicode(value)
             if not self.strict:
@@ -213,6 +214,12 @@ class StrChoiceFormater(Formater):
                     + u"\n"
             idx += 1
         msgstr += unicode(_(u"%d. None of the above - skip")) % idx + u"\n"
+        if self.many_split:
+            new_values = []
+            r = re.compile(func.many_split)
+            for value in values:
+                new_values += r.split(value)
+            values = new_values
         for value in values:
             base_value = copy(value)
             value = self.prepare(value)
@@ -255,9 +262,10 @@ class StrChoiceFormater(Formater):
             return self.equiv_dict[value]
 
 class TypeFormater(StrChoiceFormater):
-    def __init__(self, model, cli=False, defaults={}):
+    def __init__(self, model, cli=False, defaults={}, many_split=False):
         self.model = model
         self.defaults = defaults
+        self.many_split = many_split
         self.equiv_dict, self.choices = {}, []
         for item in model.objects.all():
             self.choices.append((item.pk, unicode(item)))
@@ -634,32 +642,44 @@ class Importer(object):
                 func = func[idx_v]
             if not callable(func) and type(func) in (unicode, str):
                 func = getattr(self, func)
-            value = None
 
-            try:
-                if formater.regexp_formater_args:
-                    args = []
-                    for idx in formater.regexp_formater_args[idx_v]:
-                        args.append(val_group[idx])
-                    value = func.format(*args)
-                else:
-                    value = func.format(v)
-            except ValueError, e:
-                if formater.required:
-                    self.c_errors = True
-                self.errors.append((idx_line+1, idx_col+1, e.message))
-                c_values.append(None)
-                return
+            values = [v]
+            many_values = getattr(func, 'many_split', None)
+            if many_values:
+                values = re.compile(func.many_split).split(values)
+
+            formated_values = []
+            for idx, v in enumerate(values):
+                value = None
+                try:
+                    if formater.regexp_formater_args:
+                        args = []
+                        for idx in formater.regexp_formater_args[idx_v]:
+                            args.append(val_group[idx])
+                        value = func.format(*args)
+                    else:
+                        value = func.format(v)
+                except ValueError, e:
+                    if formater.required:
+                        self.c_errors = True
+                    self.errors.append((idx_line+1, idx_col+1, e.message))
+                    c_values.append(None)
+                    return
+                formated_values.append(value)
 
             if self.message:
                 self.messages.append(self.message)
+
+            value = formated_values
+            if not many_values:
+                value = formated_values[0]
+
             c_values.append(value)
 
-            if value == None:
-                if formater.required:
-                    self.c_errors = True
-                    self.errors.append((idx_line+1, idx_col+1,
-                                       self.ERRORS['value_required']))
+            if value == None and  formater.required:
+                self.c_errors = True
+                self.errors.append((idx_line+1, idx_col+1,
+                                   self.ERRORS['value_required']))
                 return
 
             field_name = formater.field_name
@@ -677,7 +697,7 @@ class Importer(object):
             else:
                 for field_name in field_names:
                     self._field_name_to_data_dict(field_name,
-                                              value, data, formater.force_value)
+                              value, data, formater.force_value)
         if formater.reverse_for_test:
             c_row.append(formater.reverse_for_test(**c_values))
         else:
@@ -921,7 +941,11 @@ class Importer(object):
                     created = False
                     obj = cls.objects.filter(**create_dict).all()[0]
                 for attr, value in m2ms:
-                    getattr(obj, attr).add(value)
+                    values = [value]
+                    if type(value) in (list, tuple):
+                        values = value
+                    for v in values:
+                        getattr(obj, attr).add(v)
             except IntegrityError:
                 raise ImporterError("Erreur d'import %s, contexte : %s" \
                                 % (unicode(cls), unicode(data)))