DataHandler names unification + test_em modifications

lodel/leapi/datahandlers/data_fields/bool.py

 from ..data_field import DataField
 
 
-class EmDataField(DataField):
+class DataHandler(DataField):
 
     help = 'A basic boolean field'
     ftype = 'bool'

lodel/leapi/datahandlers/data_fields/datetime.py

 from ..data_field import DataField
 
 
-class EmDataField(DataField):
+class DataHandler(DataField):
 
     help = 'A datetime field. Take two boolean options now_on_update and now_on_create'
 

lodel/leapi/datahandlers/data_fields/file.py

 from ..data_field import DataField
 
 
-class EmDataField(DataField):
+class DataHandler(DataField):
 
     ## @brief a file field
     # @param upload_path str : None by default

lodel/leapi/datahandlers/data_fields/format.py

 from .varchar import EmDataField as VarcharDataField
 
 
-class EmDataField(VarcharDataField):
+class DataHandler(VarcharDataField):
 
     help = 'Automatic string field, designed to use the str % operator to build its content'
 

lodel/leapi/datahandlers/data_fields/integer.py

 from ..data_field import DataField
 
 
-class EmDataField(DataField):
+class DataHandler(DataField):
 
     help = 'Basic integer field'
     ftype = 'int'

lodel/leapi/datahandlers/data_fields/regexvarchar.py

 from .varchar import EmDataField as VarcharDataField
 
 
-class EmDataField(VarcharDataField):
+class DataHandler(VarcharDataField):
 
     help = 'String field validated with a regex. Takes two options : max_length and regex'
 

lodel/leapi/datahandlers/data_fields/text.py

 from ..data_field import DataField
 
 
-class EmDataField(DataField):
+class DataHandler(DataField):
     help = 'A text field (big string)'
     ftype = 'text'
 

lodel/leapi/datahandlers/data_fields/uid.py

 from .integer import EmDataField as IntegerDataField
 
 
-class EmDataField(IntegerDataField):
+class DataHandler(IntegerDataField):
 
     help = 'Fieldtype designed to handle editorial model UID'
 

lodel/leapi/datahandlers/data_fields/varchar.py

 from ..data_field import DataField
 
 
-class EmDataField(DataField):
+class DataHandler(DataField):
     help = 'Basic string (varchar) field. Default size is 64 characters'
 
     ## @brief A string field

lodel/leapi/datahandlers/field_data_handler.py

     # @param fieldtype_name str : A field type name
     # @return DataField child class
     @staticmethod
-    def from_name(fieldtype_name):
-        mod = importlib.import_module(FieldDataHandler.module_name(fieldtype_name))
-        return mod.EmDataField
+    def from_name(data_handler_name):
+        data_handler_name = data_handler_name.lower()
+        mod = None
+        for mname in FieldDataHandler.modules_name(data_handler_name):
+            try:
+                mod = importlib.import_module(mname)
+            except ImportError:
+                pass
+        if mod is None:
+            raise NameError("Unknown data_handler name : '%s'" % data_handler_name)
+        return mod.DataHandler
 
     ## @brief get a module name given a fieldtype name
     # @param fieldtype_name str : a field type name
     # @return a string representing a python module name
     @staticmethod
-    def module_name(fieldtype_name):
-        return 'lodel.leapi.datahandlers.data_fields.%s' % fieldtype_name
+    def modules_name(fieldtype_name):
+        return (
+                'lodel.leapi.datahandlers.data_fields.%s' % fieldtype_name,
+                'lodel.leapi.datahandlers.references.%s' % fieldtype_name
+        )
 
     ## @brief __hash__ implementation for fieldtypes
     def __hash__(self):

lodel/leapi/datahandlers/reference.py

 class Reference(FieldDataHandler):
 
     ## @brief Instanciation
-    # @param allowed list
+    # @param allowed_classes list | None : list of allowed em classes if None no restriction
     # @param internal bool : if False, the field is not internal
     # @param **kwargs : other arguments
-    def __init__(self, allowed=[], internal=False, **kwargs):
-        self.allowed = allowed
-        self.internal = internal
-        super().__init__(internal=self.internal, **kwargs)
+    def __init__(self, allowed_classes = None, internal=False, **kwargs):
+        self.allowed_classes = None if allowed_classes is None else set(allowed_classes)
+        super().__init__(internal=internal, **kwargs)
 
     ## @brief gets the target of the reference
     def get_relateds(self):

lodel/leapi/datahandlers/references/Link.py

-# -*- coding: utf-8 -*-
-from lodel.leapi.datahandlers.reference import Reference
-from lodel.editorial_model.components import EmClass
-
-
-class Link(Reference):
-
-    ## @brief instanciates a link reference
-    # @param emclass EmClass : linked object
-    # @param allowed list
-    # @param internal bool : if False, the field is not internal
-    # @param kwargs : Other named arguments
-    def __init__(self, emclass, allowed=[], internal=False, **kwargs):
-        self._refs = emclass
-        self._refs_class = EmClass
-        super().__init__(allowed=allowed, internal=internal, **kwargs)

lodel/leapi/datahandlers/references/Dict.py → lodel/leapi/datahandlers/references/dict.py

 from lodel.editorial_model.components import EmClass
 
 
-class Dict(Reference):
+class DataHandler(Reference):
 
     ## @brief instanciates a dict reference
-    # @param emclasses dict : Dict of EmClass objects
-    # @param allowed list
+    # @param allowed_classes list | None : list of allowed em classes if None no restriction
     # @param internal bool : if False, the field is not internal
     # @param kwargs : Other named arguments
-    def __init__(self, emclasses, allowed=[], internal=False, **kwargs):
-        self._refs = set(emclasses)
-        self._refs_class = dict
-        super().__init__(allowed=allowed, internal=internal, **kwargs)
+    def __init__(self, allowed_classes = None, internal=False, **kwargs):
+        super().__init__(allowed_classes=allowed_classes, internal=internal, **kwargs)
 
     ## @brief checks if the given target is valid
     # @return bool
         if isinstance(emclass, EmClass) and isinstance(ref_name, str):
             self._refs[ref_name] = emclass
             return True
-        return False
+        return False

lodel/leapi/datahandlers/references/link.py

+# -*- coding: utf-8 -*-
+from lodel.leapi.datahandlers.reference import Reference
+from lodel.editorial_model.components import EmClass
+
+
+class DataHandler(Reference):
+
+    ## @brief instanciates a link reference
+    # @param allowed_classes list | None : list of allowed em classes if None no restriction
+    # @param internal bool : if False, the field is not internal
+    # @param kwargs : Other named arguments
+    def __init__(self, allowed_classes = None, internal=False, **kwargs):
+        super().__init__(allowed_classes=allowed_classes, internal=internal, **kwargs)

lodel/leapi/datahandlers/references/List.py → lodel/leapi/datahandlers/references/list.py

 from lodel.leapi.datahandlers.reference import Reference
 
 
-class List(Reference):
+class DataHandler(Reference):
 
     ## @brief instanciates a list reference
-    # @param emclasses list : linked emclasses objects
-    # @param allowed list
+    # @param allowed_classes list | None : list of allowed em classes if None no restriction
     # @param internal bool
     # @param kwargs
-    def __init__(self, emclasses, allowed=[], internal=False, **kwargs):
-        self._refs = emclasses
-        self._refs_class = list
-        super().__init__(self, allowed=allowed, internal=internal, **kwargs)
+    def __init__(self, allowed_classes = None, internal=False, **kwargs):
+        super().__init__(allowed_classes=allowed_classes, internal=internal, **kwargs)
 
     ## @brief adds a referenced element
     # @param emclass EmClass
         if isinstance(emclass, EmClass):
             self._refs.append(emclass)
             return True
-        return False
+        return False

lodel/leapi/datahandlers/references/Set.py → lodel/leapi/datahandlers/references/set.py

 from lodel.leapi.datahandlers.reference import Reference
 
 
-class Set(Reference):
+class DataHandler(Reference):
 
     ## @brief instanciates a set reference
-    # @param emclasses list : List of EmClass objects
-    # @param allowed list
+    # @param allowed_classes list | None : list of allowed em classes if None no restriction
     # @param internal bool : if False, the field is not internal
     # @param kwargs : Other named arguments
-    def __init__(self, emclasses, allowed=[], internal=False, **kwargs):
-        self._refs = set(emclasses)
-        self._refs_class = set
-        super().__init__(allowed=allowed, internal=internal, **kwargs)
+    def __init__(self, allowed_classes = None, internal=False, **kwargs):
+        super().__init__(allowed_classes=allowed_classes, internal=internal, **kwargs)
 
     ## @brief adds a referenced element
     # @param emclass EmClass
         if isinstance(emclass, EmClass):
             self._refs.add(emclass)
             return True
-        return False
+        return False

test_em.py

                         parents = em_object,
 )
 
+person.new_field(   'firstname',
+                    display_name = {
+                        'eng': 'Firstname',
+                        'fre': 'Prénom',
+                    },
+                    data_handler = 'varchar',
+)
+person.new_field(   'lastname',
+                    display_name = {
+                        'eng': 'Lastname',
+                        'fre': 'Nom de famille',
+                    },
+                    data_handler = 'varchar',
+)
+person.new_field(   'fullname',
+                    display_name = {
+                        'eng': 'Fullname',
+                        'fre': 'Nom complet',
+                    },
+                    group = base_group,
+                    data_handler = 'varchar', # <-- should be concat type
+                    internal = True,
+                    immutable = True,
+)
+person.new_field(   'alias',
+                    display_name = 'alias',
+                    help_text = {
+                        'eng': 'Link to other person class instance that represent the same person',
+                        'fre': 'Lien vers un ensemble d\'instances de la classe personne représentant le même individu',
+                    },
+                    data_handler = 'set',
+                    allowed_classes = [person],
+)
+
+
 entry = em.new_class(   'entry',
                         display_name = 'Entry',
                         help_text = 'Replace olf entry classtype',
 )
 
 # Classe texte
-texte = em.new_class(   'text',
+text = em.new_class(   'text',
                         display_name = 'Text',
                         help_text = 'Abstract class that represent texts',
                         group = editorial_group,
                         abstract = True,
 )
 
-texte.new_field(    'title',
+text.new_field(    'title',
                     display_name = {'eng': 'Title', 'fre': 'Titre'},
                     group = editorial_group,
                     data_handler = 'varchar',
 )
-texte.new_field(    'subtitle',
+text.new_field(    'subtitle',
                     display_name = {
                         'eng': 'Subtitle',
                         'fre': 'Sous-titre',
                         abstract = True,
                         data_handler = 'varchar'
 )
+
+#####################
+# Persons & authors #
+#####################
+
+editorial_person_group = em.new_group(  'editorial_person',
+                                        display_name = 'Editorial person',
+                                        help_text = {
+                                            'eng': 'Introduce the concept of editorial person (authors, translator etc)',
+                                            'fre': 'Contient les classes servant à la gestion des personnes editorials (auteurs, traducteur...)',
+                                        },
+                                        depends = (editorial_group,)
+)
+text_person = em.new_class( 'text_person',
+                            display_name = {
+                                'eng': 'TextPerson',
+                                'fre': 'TextePersonne',
+                            },
+                            help_text = {
+                                'eng': 'Represent a link between someone and a text',
+                                'fre': 'Représente un lien entre une personne et un texte',
+                            },
+                            group = editorial_person_group,
+                            abstract = True,
+)
+bref_textperson_text = text_person.new_field(  'text',
+                                                display_name = {
+                                                    'eng': 'Linked text',
+                                                    'fre': 'Texte lié',
+                                                },
+                                                data_handler = 'link',
+                                                allowed_classes = [text],
+                                                group = editorial_person_group
+)
+bref_textperson_person = text_person.new_field( 'person',
+                                                display_name = {
+                                                    'eng': 'Linked person',
+                                                    'fre': 'Personne liée',
+                                                },
+                                                data_handler = 'link',
+                                                allowed_classes = [person],
+                                                group = editorial_person_group,
+)
+text_person.new_field(  'role',
+                        display_name = {
+                            'eng': 'Person role',
+                            'fre': 'Role de la personne',
+                        },
+                        data_handler = 'varchar',
+                        group = editorial_person_group
+)
+"""
+person.new_field(   'linked_texts',
+                    display_name = {
+                        'eng': 'Linked texts',
+                        'fre': 'Textes liés',
+                    },
+                    data_handler = 'relation',
+                    data_handler_kwargs = {
+                        'data_handler': 'list',
+                        'allowed_class': text_person,
+                        'backreference': bref_textperson_text,
+                    },
+                    group = editorial_person_group,
+)
+text.new_field( 'linked_persons',
+                display_name = {
+                    'eng': 'Linked persons',
+                    'fre': 'Personnes liées',
+                },
+                data_handler = 'relation',
+                data_handler_kwargs = {
+                    'data_handler': 'list',
+                    'allowed_class': text_person,
+                    'backreference': bref_textperson_person,
+
+                },
+                group = editorial_person_group,
+)
+"""
+