New picklediff datasource and "Seems to work" version of em_editor.

But really not debuged and without tests on the new datasource

DataSource/picklediff/leapidatasource.py

@@ -0,0 +1,171 @@
+#-*- coding: utf-8 -*-
+
+import os, os.path
+import pickle
+import re
+from collections import OrderedDict
+from Lodel import logger
+
+from Lodel.settings import Settings
+
+## @brief Datasource designed to stores datas and datas diff in pickle files
+# 
+# @note designed to handle editorial model storage
+#
+# Datas organisation :
+#
+# - editorial_model :
+#  - components : dict with lodel_id as key and datas dict as value
+#   - datas : dict with field name as key and field value as value
+#  - class_link : dict with leo class as key and sets of lodel_id as value
+# - states : dict with editorial_model state hash as key and modifications_datas dict as value
+#  - modifications_datas : dict with action key and arguements for actions (example : { 'action': 'insert', 'target_class': EmClass, 'datas': dict() }
+#
+class LeapiDataSource(object):
+    
+    def __init__(self, filename = None):
+        if filename is None:
+            filename = Settings.datasource['default']['filename']
+        self.__filename = filename
+        self.__content = None
+        self.__load_file()
+        
+    def select(self, target_cls, field_list, filters, rel_filters = None, order = None, group = None, limit = None, offset = 0, instanciate = True):
+        if not target_cls.is_leobject() and target_cls.__class__ != target_cls.name2class('Lerelation'):
+            if target_cls.__name__ not in self.__content['editorial_model']['class_link'] or len(self.__content['editorial_model']['class_link'][target_cls.__name__]) == 0:
+                return []
+            lodel_ids = list(self.__content['editorial_model']['class_link'][target_cls.__name__])
+        else:
+            lodel_ids = list(self.__content['editorial_model']['components'].keys())
+            
+        for field, cmp_op, value in filters:
+            if cmp_op.endswith('like '): # *like case
+                value.replace('%', '.*')
+                tmp_ids = []
+                for lodel_id in lodel_ids:
+                    match = re.match(value, self.__field_value(lodel_id, field))
+                    if (cmp_op == ' like ' and match) or (cmp_op == ' not like ' and not match):
+                        tmp_ids.append(lodel_ids)
+                    elif cmp_op == ' in ':
+                        lodel_ids = [ lid for lid in lodel_ids if self.__field_value(lodel_id, field) in value]
+                    elif cmp_op == ' not in ':
+                        lodel_ids = [ lid for lid in lodel_ids if self.__field_value(lodel_id, field) not in value]
+                    elif cmp_op == '=':
+                        lodel_ids = [ lid for lid in lodel_ids if self.__field_value(lodel_id, field) == value]
+                    elif cmp_op == '<=':
+                        lodel_ids = [ lid for lid in lodel_ids if self.__field_value(lodel_id, field) <= value]
+                    elif cmp_op == '>=':
+                        lodel_ids = [ lid for lid in lodel_ids if self.__field_value(lodel_id, field) <= value]
+                    elif cmp_op == '!=':
+                        lodel_ids = [ lid for lid in lodel_ids if self.__field_value(lodel_id, field) != value]
+                    elif cmp_op == '<':
+                        lodel_ids = [ lid for lid in lodel_ids if self.__field_value(lodel_id, field) < value]
+                    elif cmp_op == '>':
+                        lodel_ids = [ lid for lid in lodel_ids if self.__field_value(lodel_id, field) < value]
+        # Now we got filtered lodel_id list in lodel_ids
+        result = []
+        for datas in [ self.__content['editorial_model']['components'][lodel_id] for lodel_id in lodel_ids ]:
+            comp_class = target_cls.name2class(datas['__component_leapi_class__'])
+            del(datas['__component_leapi_class__'])
+
+            if instanciate:
+                # Don't care about field_list... maybe it's not a good idea ?
+                result.append(comp_class(**datas))
+            else:
+                result.append({ fname: datas[fname] for fname in field_list })
+        return result
+            
+
+    def delete(self, target_cls, leo_id):
+        if leo_id not in self.__content['editorial_model']['class_link'][target_cls.__name__]:
+            raise AttributeError("No %s with id %d" % (target_cls.__name__, leo_id))
+        self.__content['editorial_model']['class_link'][target_cls.__name__] -= set([leo_id])
+        self.__content['editorial_model']['class_link'][target_cls.leclass.__name__] -= set([leo_id])
+        del(self.__content['editorial_model']['components'][leo_id])
+        self.__register_modification('delete', {'target_cls': target_cls, 'leo_id': leo_id})
+
+    def update(self, target_cls, leo_id, **datas):
+        if leo_id not in self.__content['editorial_model']['class_link'][target_cls.__name__]:
+            raise AttributeError("No %s with id %d" % (target_cls.__name__, leo_id))
+        for key, value in datas.items():
+            self.__content['editorial_model']['components'][leo_id][key] = value #no checks, leapi should have checked before...
+        self.__register_modification('update', {'target_cls': target_cls, 'leo_id': leo_id, 'datas': datas})
+        pass
+
+    def insert(self, target_cls, **datas):
+        new_id = self.__new_id()
+        datas[self.__id_name(target_cls)] = new_id
+        # Adding target_cls to datas
+        datas['__component_leapi_class__'] = target_cls.__name__
+        # Adding the component to component list
+        self.__content['editorial_model']['components'][new_id] = datas
+        # Creating class_link type entry
+        if target_cls.__name__ not in self.__content['editorial_model']['class_link']:
+            self.__content['editorial_model']['class_link'][target_cls.__name__] = set()
+        self.__content['editorial_model']['class_link'][target_cls.__name__] |= set([new_id])
+        # Creating class_link class entry
+        if target_cls._leclass.__name__ not in self.__content['editorial_model']['class_link']:
+            self.__content['editorial_model']['class_link'][target_cls._leclass.__name__] = set()
+        self.__content['editorial_model']['class_link'][target_cls._leclass.__name__] |= set([new_id])
+
+        self.__register_modification('insert', {'target_cls': target_cls, 'datas': datas})
+        return new_id
+
+    def insert_multi(self, target_cls, datas_list):
+        pass
+
+    def update_rank(self, le_relation, new_rank):
+        pass
+
+    def __id_name(self, target_cls):
+        return 'lodel_id' if target_cls.implements_leobject() else 'relation_id'
+
+    def __new_id(self):
+        # Find a new component id avoiding 'id holes'
+        lodel_id = 1
+        while lodel_id in self.__content['editorial_model']['components'].keys():
+            lodel_id += 1
+        return lodel_id
+
+    ## @brief Save memory repr of em into pickle file
+    def __save(self):
+        with open(self.__filename, 'wb') as ffd:
+            pickle.dump(self.__content, ffd)
+    
+    ## @brief Loads self.__content from self.__filename
+    def __load_file(self):
+        if not os.path.isfile(self.__filename):
+            logger.debug("File %s not found !" % self.__filename)
+            self.__content = dict()
+        else:
+            with open(self.__filename, 'rb') as ffd:
+                self.__content = pickle.load(ffd)
+        # dict initialisation
+        if self.__content is None:
+            self.__content = dict()
+        else:
+            logger.debug("Loaded : \n %s" % self.__content)
+        if 'editorial_model' not in self.__content:
+            self.__content['editorial_model'] = OrderedDict()
+        if 'components' not in self.__content['editorial_model']:
+            self.__content['editorial_model']['components'] = OrderedDict()
+        if 'class_link' not in self.__content['editorial_model']:
+            self.__content['editorial_model']['class_link'] = OrderedDict()
+        if 'states' not in self.__content:
+            self.__content['states'] = OrderedDict()
+
+    ## @brief Method that register a EM modification
+    # @warning this method MUST be called once the modification is made in the __content dict
+    # 
+    # @param action str : name of modification (update, delete or insert)
+    # @param kwargs dict : action arguments
+    def __register_modification(self, action, kwargs):
+        logger.debug("Registered a modification : action = %s kwargs = %s" % (action, kwargs))
+        em_hash = hash(pickle.dumps(self.__content['editorial_model']))
+        self.__content['states'][em_hash] = (action, kwargs)
+        self.__save()
+
+    ## @brief Given a lodel_id and a field name return the field value
+    # @return the field value of designated LeObject
+    def __field_value(self, lodel_id, field_name):
+        return self.__content['editorial_model']['components'][lodel_id][field_name]

DataSource/picklediff/migrationhandler.py

@@ -0,0 +1,11 @@
+#-*- coding: utf-8 -*-
+
+from DataSource.dummy.migrationhandler import MigrationHandler
+
+class MigrationHandler(MigrationHandler):
+
+    def __init__(self, debug=False): pass
+
+    def register_change(self, em, uid, initial_state, new_state): pass
+
+    def register_model_state(self, em, state_hash): pass

DataSource/utils.py

@@ -0,0 +1,22 @@
+#-*- coding:utf-8 -*-
+
+import importlib
+from Lodel.settings import Settings
+
+def get_datasource_cls():
+    module = importlib.import_module("DataSource.{pkg_name}.leapidatasource".format(
+        pkg_name = Settings.ds_package,
+    ))
+    return getattr(module, 'LeapiDataSource')
+
+def get_datasource_instance():
+    return get_datasource_cls(Settings.datasource_options)
+
+def get_migrationhandler_cls():
+    module = importlib.import_module("DataSource.{pkg_name}.migrationhandler".format(
+        pkg_name = Settings.ds_package,
+    ))
+    return getattr(module, 'MigrationHandler')
+
+def get_migrationhandler_instance():
+    return get_migrationhandler_cls()(**Settings.migrationhandler_options)

EditorialModel/fieldtypes/datetime.py

@@ -2,6 +2,7 @@
 
 from .generic import SingleValueFieldType
 
+import datetime
 
 class EmFieldType(SingleValueFieldType):
 
@@ -15,3 +16,12 @@ class EmFieldType(SingleValueFieldType):
         self.now_on_update = now_on_update
         self.now_on_create = now_on_create
         super(EmFieldType, self).__init__(**kwargs)
+
+    def construct_data(self, lec, fname, datas, cur_value):
+        if self.now_on_update:
+            return datetime.datetime.now()
+        elif cur_value is None:
+            if self.now_on_create:
+                return datetime.datetime.now()
+        return super().construct_data(self, lec, fname, datas, cur_value)
+            

Lodel/utils/mlstring.py

@@ -77,6 +77,8 @@ class MlString(object):
     ## @brief Equivalent to json_dumps
     def dumps(self): return self.json_dumps()
 
+    def to_JSON(self): return self.json_dumps()
+
     ## Test if two MlString instance are equivalent
     # @param other MlString|str : Another MlString instance or a string (json formated)
     # @return True or False

em_editor/dynleapi.py

@@ -2,7 +2,7 @@
 
 import EditorialModel
 from EditorialModel import fieldtypes
-from EditorialModel.fieldtypes import naturerelation, leo, datetime, dictionary, rank, namerelation, pk, bool, i18n, char, integer, emuid
+from EditorialModel.fieldtypes import pk, dictionary, integer, leo, rank, bool, char, emuid, datetime, namerelation, naturerelation, i18n
 from Lodel.utils.mlstring import MlString
 
 import leapi
@@ -12,27 +12,23 @@ import leapi.lerelation
 from leapi.leclass import _LeClass
 from leapi.letype import _LeType
 
-import DataSource.MySQL.leapidatasource
-
-
 ## @brief _LeCrud concret class
 # @see leapi.lecrud._LeCrud
 class LeCrud(leapi.lecrud._LeCrud):
-    _datasource = DataSource.MySQL.leapidatasource.LeDataSourceSQL(**{})
     _uid_fieldtype = None
 
 ## @brief _LeObject concret class
 # @see leapi.leobject._LeObject
 class LeObject(LeCrud, leapi.leobject._LeObject):
-    _me_uid = {32: 'Emclass', 33: 'Emtype', 34: 'Emfield', 22: 'Emcomponent', 1: '_Editorialmodel', 8: '_Classtype', 15: '_Hierarchy', 29: 'Classtype', 30: 'Hierarchyoptions', 31: 'Editorialmodel'}
+    _me_uid = {1: '_Editorialmodel', 36: 'Classtype', 37: 'Hierarchyoptions', 38: 'Editorialmodel', 39: 'Emclass', 40: 'Emtype', 41: 'Emfield', 42: 'Emmodification', 15: '_Hierarchy', 8: '_Classtype', 22: 'Emcomponent', 29: '_Emmodification'}
     _me_uid_field_names = ('class_id', 'type_id')
-    _uid_fieldtype = { 'lodel_id': EditorialModel.fieldtypes.pk.EmFieldType(**{'uniq': False, 'nullable': False, 'immutable': True, 'internal': 'autosql', 'string': '{"___": "", "fre": "identifiant lodel", "eng": "lodel identifier"}'}) }
+    _uid_fieldtype = { 'lodel_id': EditorialModel.fieldtypes.pk.EmFieldType(**{'immutable': True, 'string': '{"___": "", "fre": "identifiant lodel", "eng": "lodel identifier"}', 'nullable': False, 'uniq': False, 'internal': 'autosql'}) }
     _leo_fieldtypes = {
-	'class_id': EditorialModel.fieldtypes.emuid.EmFieldType(**{'uniq': False, 'nullable': False, 'immutable': True, 'internal': 'automatic', 'string': '{"___": "", "fre": "identifiant de la classe", "eng": "class identifier"}', 'is_id_class': True}),
-	'type_id': EditorialModel.fieldtypes.emuid.EmFieldType(**{'uniq': False, 'nullable': False, 'immutable': True, 'internal': 'automatic', 'string': '{"___": "", "fre": "identifiant de la type", "eng": "type identifier"}', 'is_id_class': False}),
-	'modification_date': EditorialModel.fieldtypes.datetime.EmFieldType(**{'uniq': False, 'internal': 'autosql', 'now_on_update': True, 'immutable': True, 'nullable': False, 'now_on_create': True, 'string': '{"___": "", "fre": "Date de modification", "eng": "Modification date"}'}),
+	'class_id': EditorialModel.fieldtypes.emuid.EmFieldType(**{'immutable': True, 'is_id_class': True, 'string': '{"___": "", "fre": "identifiant de la classe", "eng": "class identifier"}', 'nullable': False, 'uniq': False, 'internal': 'automatic'}),
+	'type_id': EditorialModel.fieldtypes.emuid.EmFieldType(**{'immutable': True, 'is_id_class': False, 'string': '{"___": "", "fre": "identifiant de la type", "eng": "type identifier"}', 'nullable': False, 'uniq': False, 'internal': 'automatic'}),
 	'string': None,
-	'creation_date': EditorialModel.fieldtypes.datetime.EmFieldType(**{'uniq': False, 'internal': 'autosql', 'now_on_create': True, 'immutable': True, 'nullable': False, 'string': '{"___": "", "fre": "Date de création", "eng": "Creation date"}'})
+	'creation_date': EditorialModel.fieldtypes.datetime.EmFieldType(**{'immutable': True, 'string': '{"___": "", "fre": "Date de création", "eng": "Creation date"}', 'now_on_create': True, 'nullable': False, 'uniq': False, 'internal': 'autosql'}),
+	'modification_date': EditorialModel.fieldtypes.datetime.EmFieldType(**{'immutable': True, 'string': '{"___": "", "fre": "Date de modification", "eng": "Modification date"}', 'now_on_create': True, 'nullable': False, 'uniq': False, 'internal': 'autosql', 'now_on_update': True})
 	}
 
 ## @brief _LeRelation concret class
@@ -40,12 +36,12 @@ class LeObject(LeCrud, leapi.leobject._LeObject):
 class LeRelation(LeCrud, leapi.lerelation._LeRelation):
     _uid_fieldtype = { 'id_relation': EditorialModel.fieldtypes.pk.EmFieldType(**{'immutable': True, 'internal': 'autosql'}) }
     _rel_fieldtypes = {
-	'relation_name': EditorialModel.fieldtypes.namerelation.EmFieldType(**{'max_length': 128, 'immutable': True}),
-	'nature': EditorialModel.fieldtypes.naturerelation.EmFieldType(**{'immutable': True}),
-	'superior': EditorialModel.fieldtypes.leo.EmFieldType(**{'immutable': True, 'superior': True}),
 	'depth': EditorialModel.fieldtypes.integer.EmFieldType(**{'immutable': True, 'internal': 'automatic'}),
+	'subordinate': EditorialModel.fieldtypes.leo.EmFieldType(**{'immutable': True, 'superior': False}),
+	'superior': EditorialModel.fieldtypes.leo.EmFieldType(**{'immutable': True, 'superior': True}),
+	'relation_name': EditorialModel.fieldtypes.namerelation.EmFieldType(**{'immutable': True, 'max_length': 128}),
 	'rank': EditorialModel.fieldtypes.rank.EmFieldType(**{'immutable': True, 'internal': 'automatic'}),
-	'subordinate': EditorialModel.fieldtypes.leo.EmFieldType(**{'immutable': True, 'superior': False})
+	'nature': EditorialModel.fieldtypes.naturerelation.EmFieldType(**{'immutable': True})
 	}
     ## WARNING !!!! OBSOLETE ! DON'T USE IT
     _superior_field_name = 'superior'
@@ -92,51 +88,65 @@ class Emcomponent(LeClass, LeObject):
     ml_string = MlString('EmComponent')
 
 
+## @brief EmClass _Emmodification LeClass child class
+# @see leapi.leclass.LeClass
+class _Emmodification(LeClass, LeObject):
+    _class_id = 29
+    ml_string = MlString('_EmModification')
+
+
 ## @brief EmType Classtype LeType child class
 # @see leobject::letype::LeType
 class Classtype(LeType, _Classtype):
-    _type_id = 29
+    _type_id = 36
     ml_string = MlString('ClassType')
 
 
 ## @brief EmType Hierarchyoptions LeType child class
 # @see leobject::letype::LeType
 class Hierarchyoptions(LeType, _Hierarchy):
-    _type_id = 30
+    _type_id = 37
     ml_string = MlString('HierarchyOptions')
 
 
 ## @brief EmType Editorialmodel LeType child class
 # @see leobject::letype::LeType
 class Editorialmodel(LeType, _Editorialmodel):
-    _type_id = 31
+    _type_id = 38
     ml_string = MlString('EditorialModel')
 
 
 ## @brief EmType Emclass LeType child class
 # @see leobject::letype::LeType
 class Emclass(LeType, Emcomponent):
-    _type_id = 32
+    _type_id = 39
     ml_string = MlString('EmClass')
 
 
+## @brief EmType Emmodification LeType child class
+# @see leobject::letype::LeType
+class Emmodification(LeType, _Emmodification):
+    _type_id = 42
+    ml_string = MlString('EmModification')
+
+
 ## @brief EmType Emtype LeType child class
 # @see leobject::letype::LeType
 class Emtype(LeType, Emcomponent):
-    _type_id = 33
+    _type_id = 40
     ml_string = MlString('EmType')
 
 
 ## @brief EmType Emfield LeType child class
 # @see leobject::letype::LeType
 class Emfield(LeType, Emcomponent):
-    _type_id = 34
+    _type_id = 41
     ml_string = MlString('EmField')
 
 
 class Rel_ClasstypeHierarchyoptionsHierarchy_Specs(LeRel2Type):
     _rel_attr_fieldtypes = {
-    'nature': EditorialModel.fieldtypes.char.EmFieldType(**{'internal': False, 'max_length': 10, 'uniq': False, 'nullable': False})
+    'nature': EditorialModel.fieldtypes.char.EmFieldType(**{'uniq': False, 'nullable': False, 'max_length': 10, 'internal': False})
 }
     _superior_cls = _Classtype
     _subordinate_cls = Hierarchyoptions
@@ -177,7 +187,7 @@ class RelEmcomponentEmfieldSelected_Field(LeRel2Type):
 
 class RelEmcomponentEmtypeSuperiors(LeRel2Type):
     _rel_attr_fieldtypes = {
-    'nature': EditorialModel.fieldtypes.char.EmFieldType(**{'internal': False, 'max_length': '10', 'uniq': False, 'nullable': False})
+    'nature': EditorialModel.fieldtypes.char.EmFieldType(**{'uniq': False, 'nullable': False, 'max_length': 10, 'internal': False})
 }
     _superior_cls = Emcomponent
     _subordinate_cls = Emtype
@@ -194,19 +204,19 @@ class RelEmcomponentEmfieldRel_Field(LeRel2Type):
 
 #Initialisation of _Editorialmodel class attributes
 _Editorialmodel._fieldtypes = {
-    'description': EditorialModel.fieldtypes.char.EmFieldType(**{'internal': False, 'max_length': 4096, 'uniq': False, 'nullable': False}),
-    'string': EditorialModel.fieldtypes.char.EmFieldType(**{'internal': 'automatic', 'max_length': 128, 'immutable': False, 'uniq': False, 'nullable': True}),
-    'name': EditorialModel.fieldtypes.char.EmFieldType(**{'internal': False, 'max_length': 56, 'uniq': False, 'nullable': False})
+    'description': EditorialModel.fieldtypes.char.EmFieldType(**{'uniq': False, 'nullable': False, 'max_length': 4096, 'internal': False}),
+    'string': EditorialModel.fieldtypes.char.EmFieldType(**{'immutable': False, 'nullable': True, 'max_length': 128, 'internal': 'automatic', 'uniq': False}),
+    'name': EditorialModel.fieldtypes.char.EmFieldType(**{'uniq': False, 'nullable': False, 'max_length': 56, 'internal': False})
 }
 _Editorialmodel.ml_fields_strings = {
    'class_id': MlString({"___": "class_id", "eng": "class identifier", "fre": "identifiant de la classe"}),
    'type_id': MlString({"___": "type_id", "eng": "type identifier", "fre": "identifiant de la type"}),
-   'name': MlString({"___": "name"}),
-   'lodel_id': MlString({"___": "lodel_id", "eng": "lodel identifier", "fre": "identifiant lodel"}),
-   'modification_date': MlString({"___": "modification_date", "eng": "Modification date", "fre": "Date de modification"}),
    'string': MlString({"___": "string", "eng": "String representation", "fre": "Repr\u00e9sentation textuel"}),
    'creation_date': MlString({"___": "creation_date", "eng": "Creation date", "fre": "Date de cr\u00e9ation"}),
-   'description': MlString({"___": "description"})
+   'lodel_id': MlString({"___": "lodel_id", "eng": "lodel identifier", "fre": "identifiant lodel"}),
+   'name': MlString({"___": "name"}),
+   'description': MlString({"___": "description"}),
+   'modification_date': MlString({"___": "modification_date", "eng": "Modification date", "fre": "Date de modification"})
 }
 _Editorialmodel._linked_types = {
 }
@@ -214,19 +224,19 @@ _Editorialmodel._classtype = 'entity'
 
 #Initialisation of _Classtype class attributes
 _Classtype._fieldtypes = {
-    'string': EditorialModel.fieldtypes.char.EmFieldType(**{'internal': 'automatic', 'max_length': 128, 'immutable': False, 'uniq': False, 'nullable': True}),
-    'name': EditorialModel.fieldtypes.char.EmFieldType(**{'internal': False, 'max_length': 56, 'uniq': False, 'nullable': False})
+    'string': EditorialModel.fieldtypes.char.EmFieldType(**{'immutable': False, 'nullable': True, 'max_length': 128, 'internal': 'automatic', 'uniq': False}),
+    'name': EditorialModel.fieldtypes.char.EmFieldType(**{'uniq': False, 'nullable': False, 'max_length': 56, 'internal': False})
 }
 _Classtype.ml_fields_strings = {
    'class_id': MlString({"___": "class_id", "eng": "class identifier", "fre": "identifiant de la classe"}),
+   'hierarchy_specs': MlString({"___": "hierarchy_specs"}),
+   'nature': MlString({"___": "nature"}),
    'type_id': MlString({"___": "type_id", "eng": "type identifier", "fre": "identifiant de la type"}),
-   'name': MlString({"___": "name"}),
-   'lodel_id': MlString({"___": "lodel_id", "eng": "lodel identifier", "fre": "identifiant lodel"}),
-   'modification_date': MlString({"___": "modification_date", "eng": "Modification date", "fre": "Date de modification"}),
    'string': MlString({"___": "string", "eng": "String representation", "fre": "Repr\u00e9sentation textuel"}),
    'creation_date': MlString({"___": "creation_date", "eng": "Creation date", "fre": "Date de cr\u00e9ation"}),
-   'hierarchy_specs': MlString({"___": "hierarchy_specs"}),
-   'nature': MlString({"___": "nature"})
+   'lodel_id': MlString({"___": "lodel_id", "eng": "lodel identifier", "fre": "identifiant lodel"}),
+   'name': MlString({"___": "name"}),
+   'modification_date': MlString({"___": "modification_date", "eng": "Modification date", "fre": "Date de modification"})
 }
 _Classtype._linked_types = {
     'hierarchy_specs': Hierarchyoptions
@@ -235,23 +245,23 @@ _Classtype._classtype = 'entity'
 
 #Initialisation of _Hierarchy class attributes
 _Hierarchy._fieldtypes = {
-    'string': EditorialModel.fieldtypes.char.EmFieldType(**{'internal': 'automatic', 'max_length': 128, 'immutable': False, 'uniq': False, 'nullable': True}),
-    'attach': EditorialModel.fieldtypes.char.EmFieldType(**{'internal': False, 'max_length': 10, 'uniq': False, 'nullable': False}),
-    'maxdepth': EditorialModel.fieldtypes.integer.EmFieldType(**{'internal': False, 'uniq': False, 'nullable': False}),
-    'maxchildren': EditorialModel.fieldtypes.integer.EmFieldType(**{'internal': False, 'uniq': False, 'nullable': False}),
-    'automatic': EditorialModel.fieldtypes.bool.EmFieldType(**{'internal': False, 'uniq': False, 'nullable': False})
+    'automatic': EditorialModel.fieldtypes.bool.EmFieldType(**{'uniq': False, 'nullable': False, 'internal': False}),
+    'maxchildren': EditorialModel.fieldtypes.integer.EmFieldType(**{'uniq': False, 'nullable': False, 'internal': False}),
+    'maxdepth': EditorialModel.fieldtypes.integer.EmFieldType(**{'uniq': False, 'nullable': False, 'internal': False}),
+    'attach': EditorialModel.fieldtypes.char.EmFieldType(**{'uniq': False, 'nullable': False, 'max_length': 10, 'internal': False}),
+    'string': EditorialModel.fieldtypes.char.EmFieldType(**{'immutable': False, 'nullable': True, 'max_length': 128, 'internal': 'automatic', 'uniq': False})
 }
 _Hierarchy.ml_fields_strings = {
-   'maxchildren': MlString({"___": "maxchildren"}),
    'class_id': MlString({"___": "class_id", "eng": "class identifier", "fre": "identifiant de la classe"}),
-   'type_id': MlString({"___": "type_id", "eng": "type identifier", "fre": "identifiant de la type"}),
-   'lodel_id': MlString({"___": "lodel_id", "eng": "lodel identifier", "fre": "identifiant lodel"}),
-   'modification_date': MlString({"___": "modification_date", "eng": "Modification date", "fre": "Date de modification"}),
    'automatic': MlString({"___": "automatic"}),
+   'maxdepth': MlString({"___": "maxdepth"}),
+   'maxchildren': MlString({"___": "maxchildren"}),
+   'type_id': MlString({"___": "type_id", "eng": "type identifier", "fre": "identifiant de la type"}),
    'string': MlString({"___": "string", "eng": "String representation", "fre": "Repr\u00e9sentation textuel"}),
    'creation_date': MlString({"___": "creation_date", "eng": "Creation date", "fre": "Date de cr\u00e9ation"}),
+   'lodel_id': MlString({"___": "lodel_id", "eng": "lodel identifier", "fre": "identifiant lodel"}),
    'attach': MlString({"___": "attach"}),
-   'maxdepth': MlString({"___": "maxdepth"})
+   'modification_date': MlString({"___": "modification_date", "eng": "Modification date", "fre": "Date de modification"})
 }
 _Hierarchy._linked_types = {
 }
@@ -259,47 +269,61 @@ _Hierarchy._classtype = 'entity'
 
 #Initialisation of Emcomponent class attributes
 Emcomponent._fieldtypes = {
-    'fieldtype': EditorialModel.fieldtypes.char.EmFieldType(**{'internal': False, 'uniq': False, 'nullable': False}),
-    'name': EditorialModel.fieldtypes.char.EmFieldType(**{'internal': False, 'max_length': 56, 'uniq': False, 'nullable': False}),
-    'string': EditorialModel.fieldtypes.char.EmFieldType(**{'internal': 'automatic', 'max_length': 128, 'immutable': False, 'uniq': False, 'nullable': True}),
-    'help_text': EditorialModel.fieldtypes.i18n.EmFieldType(**{'internal': False, 'uniq': False, 'nullable': False}),
-    'fieldtype_options': EditorialModel.fieldtypes.dictionary.EmFieldType(**{'internal': False, 'uniq': False, 'nullable': False}),
-    'date_update': EditorialModel.fieldtypes.datetime.EmFieldType(**{'now_on_update': True, 'nullable': False, 'uniq': False, 'internal': False}),
-    'date_create': EditorialModel.fieldtypes.datetime.EmFieldType(**{'now_on_create': True, 'internal': False, 'uniq': False, 'nullable': False}),
-    'rank': EditorialModel.fieldtypes.integer.EmFieldType(**{'internal': False, 'uniq': False, 'nullable': False})
+    'date_update': EditorialModel.fieldtypes.datetime.EmFieldType(**{'now_on_update': True, 'nullable': False, 'uniq': False, 'internal': 'automatic'}),
+    'fieldtype': EditorialModel.fieldtypes.char.EmFieldType(**{'uniq': False, 'nullable': False, 'internal': False}),
+    'string': EditorialModel.fieldtypes.char.EmFieldType(**{'immutable': False, 'nullable': True, 'max_length': 128, 'internal': 'automatic', 'uniq': False}),
+    'name': EditorialModel.fieldtypes.char.EmFieldType(**{'uniq': False, 'nullable': False, 'max_length': 56, 'internal': False}),
+    'help_text': EditorialModel.fieldtypes.i18n.EmFieldType(**{'uniq': False, 'nullable': False, 'internal': False, 'default': {'en': 'no help'}}),
+    'fieldtype_options': EditorialModel.fieldtypes.dictionary.EmFieldType(**{'uniq': False, 'nullable': False, 'internal': False}),
+    'date_create': EditorialModel.fieldtypes.datetime.EmFieldType(**{'uniq': False, 'nullable': False, 'internal': 'automatic', 'now_on_create': True})
 }
 Emcomponent.ml_fields_strings = {
-   'superiors': MlString({"___": "superiors"}),
-   'creation_date': MlString({"___": "creation_date", "eng": "Creation date", "fre": "Date de cr\u00e9ation"}),
-   'name': MlString({"___": "name"}),
-   'lodel_id': MlString({"___": "lodel_id", "eng": "lodel identifier", "fre": "identifiant lodel"}),
-   'modification_date': MlString({"___": "modification_date", "eng": "Modification date", "fre": "Date de modification"}),
-   'parent_class': MlString({"___": "parent_class"}),
-   'fieldtype_options': MlString({"___": "fieldtype_options"}),
-   'help_text': MlString({"___": "help_text"}),
-   'rank': MlString({"___": "rank"}),
-   'sort_column': MlString({"___": "sort_column"}),
-   'fieldtype': MlString({"___": "fieldtype"}),
    'class_id': MlString({"___": "class_id", "eng": "class identifier", "fre": "identifiant de la classe"}),
-   'selected_field': MlString({"___": "selected_field"}),
+   'classtype': MlString({"___": "classtype"}),
    'rel_field': MlString({"___": "rel_field"}),
+   'superiors': MlString({"___": "superiors"}),
    'string': MlString({"___": "string", "eng": "String representation", "fre": "Repr\u00e9sentation textuel"}),
    'type_id': MlString({"___": "type_id", "eng": "type identifier", "fre": "identifiant de la type"}),
-   'classtype': MlString({"___": "classtype"}),
+   'fieldtype': MlString({"___": "fieldtype"}),
+   'creation_date': MlString({"___": "creation_date", "eng": "Creation date", "fre": "Date de cr\u00e9ation"}),
+   'selected_field': MlString({"___": "selected_field"}),
+   'fieldtype_options': MlString({"___": "fieldtype_options"}),
    'date_create': MlString({"___": "date_create"}),
-   'nature': MlString({"___": "nature"}),
-   'date_update': MlString({"___": "date_update"})
+   'date_update': MlString({"___": "date_update"}),
+   'modification_date': MlString({"___": "modification_date", "eng": "Modification date", "fre": "Date de modification"}),
+   'name': MlString({"___": "name"}),
+   'lodel_id': MlString({"___": "lodel_id", "eng": "lodel identifier", "fre": "identifiant lodel"}),
+   'sort_column': MlString({"___": "sort_column"}),
+   'help_text': MlString({"___": "help_text"}),
+   'parent_class': MlString({"___": "parent_class"}),
+   'nature': MlString({"___": "nature"})
 }
 Emcomponent._linked_types = {
+    'classtype': Classtype,
     'superiors': Emtype,
     'rel_field': Emfield,
-    'classtype': Classtype,
-    'parent_class': Emclass,
     'sort_column': Emfield,
-    'selected_field': Emfield
+    'selected_field': Emfield,
+    'parent_class': Emclass
 }
 Emcomponent._classtype = 'entity'
 
+#Initialisation of _Emmodification class attributes
+_Emmodification._fieldtypes = {
+    'string': EditorialModel.fieldtypes.char.EmFieldType(**{'immutable': False, 'nullable': True, 'max_length': 128, 'internal': 'automatic', 'uniq': False})
+}
+_Emmodification.ml_fields_strings = {
+   'class_id': MlString({"___": "class_id", "eng": "class identifier", "fre": "identifiant de la classe"}),
+   'type_id': MlString({"___": "type_id", "eng": "type identifier", "fre": "identifiant de la type"}),
+   'string': MlString({"___": "string", "eng": "String representation", "fre": "Repr\u00e9sentation textuel"}),
+   'creation_date': MlString({"___": "creation_date", "eng": "Creation date", "fre": "Date de cr\u00e9ation"}),
+   'lodel_id': MlString({"___": "lodel_id", "eng": "lodel identifier", "fre": "identifiant lodel"}),
+   'modification_date': MlString({"___": "modification_date", "eng": "Modification date", "fre": "Date de modification"})
+}
+_Emmodification._linked_types = {
+}
+_Emmodification._classtype = 'entity'
+
 #Initialisation of Classtype class attributes
 Classtype._fields = ['name']
 Classtype._superiors = {}
@@ -316,19 +340,24 @@ Editorialmodel._superiors = {}
 Editorialmodel._leclass = _Editorialmodel
 
 #Initialisation of Emclass class attributes
-Emclass._fields = ['name', 'help_text', 'date_update', 'date_create', 'rank']
+Emclass._fields = ['name', 'help_text', 'date_update', 'date_create']
 Emclass._superiors = {'parent': [Editorialmodel]}
 Emclass._leclass = Emcomponent
 
+#Initialisation of Emmodification class attributes
+Emmodification._fields = []
+Emmodification._superiors = {}
+Emmodification._leclass = _Emmodification
+
 #Initialisation of Emtype class attributes
-Emtype._fields = ['name', 'help_text', 'date_update', 'date_create', 'rank']
+Emtype._fields = ['name', 'help_text', 'date_update', 'date_create']
 Emtype._superiors = {'parent': [Emclass]}
 Emtype._leclass = Emcomponent
 
 #Initialisation of Emfield class attributes
-Emfield._fields = ['name', 'help_text', 'date_update', 'date_create', 'rank', 'fieldtype', 'fieldtype_options']
+Emfield._fields = ['name', 'help_text', 'date_update', 'date_create', 'fieldtype', 'fieldtype_options']
 Emfield._superiors = {'parent': [Emtype]}
 Emfield._leclass = Emcomponent
 
 ## @brief Dict for getting LeClass and LeType child classes given an EM uid
-LeObject._me_uid = {32: Emclass, 1: _Editorialmodel, 34: Emfield, 22: Emcomponent, 33: Emtype, 8: _Classtype, 31: Editorialmodel, 29: Classtype, 30: Hierarchyoptions, 15: _Hierarchy}
+LeObject._me_uid = {1: _Editorialmodel, 36: Classtype, 37: Hierarchyoptions, 38: Editorialmodel, 39: Emclass, 40: Emtype, 41: Emfield, 42: Emmodification, 15: _Hierarchy, 8: _Classtype, 22: Emcomponent, 29: _Emmodification}

em_editor/init_em.py

@@ -31,6 +31,8 @@ class_em = em.add_class('_EditorialModel', classtype = 'entity')
 class_ctype = em.add_class('_ClassType', classtype='entity')
 class_ctype_h = em.add_class('_Hierarchy', classtype='entity')
 class_comp = em.add_class('EmComponent', classtype='entity')
+
+class_emmod = em.add_class('_EmModification', classtype='entity')
 #       class_ftype = em.add_class('_FieldType', classtype = 'entity')
 
 #       type_ftype = em.add_type('FieldType', class_ftype)
@@ -42,10 +44,14 @@ type_class = em.add_type('EmClass', class_comp, superiors_list = {'parent': [typ
 type_type = em.add_type('EmType', class_comp, superiors_list = {'parent':[type_class.uid]})
 type_field = em.add_type('EmField', class_comp, superiors_list = {'parent':[type_type.uid]})
 
+
+type_emmod = em.add_type('EmModification', class_emmod)
 #        FieldType common fields
 #       em.add_field('name', class_ftype, fieldtype = 'char', max_length = 56)
 #       em.add_field('max_length', class_ftype, optional = True, fieldtype = 'integer')
 
+# EditorialModel modification fields
+
 # EditorialModel common fields
 em.add_field('name', class_em, fieldtype = 'char', max_length = 56)
 em.add_field('description', class_em, fieldtype = 'char', max_length = 4096)
@@ -64,10 +70,10 @@ em.add_field('nature', class_ctype, fieldtype = 'char', max_length = 10, rel_fie
 # EmComponent common fields
 em.add_field('name', class_comp, fieldtype = 'char', max_length = 56)
 # Part of default fields #em.add_field('string', class_comp, fieldtype = 'i18n')
-em.add_field('help_text', class_comp, fieldtype = 'i18n')
-em.add_field('date_update', class_comp, fieldtype = 'datetime', now_on_update = True)
-em.add_field('date_create', class_comp, fieldtype = 'datetime', now_on_create = True)
-em.add_field('rank', class_comp, fieldtype = 'integer')
+em.add_field('help_text', class_comp, fieldtype = 'i18n', default={'en':'no help'})
+em.add_field('date_update', class_comp, fieldtype = 'datetime', now_on_update = True, internal='automatic')
+em.add_field('date_create', class_comp, fieldtype = 'datetime', now_on_create = True, internal='automatic')
+#em.add_field('rank', class_comp, fieldtype = 'rank', internal='automatic')
 # EmComponent optional fields
 field_ctype = em.add_field('classtype', class_comp, optional = True, fieldtype = 'rel2type', rel_to_type_id = type_ctype.uid)
 field_sortcol = em.add_field('sort_column', class_comp, optional = True, fieldtype = 'rel2type', rel_to_type_id = type_field.uid)

em_editor/instance_settings.py

@@ -10,17 +10,10 @@ templates_base_dir = 'LODEL2_INSTANCE_TEMPLATES_BASE_DIR'
 
 debug = False
 
-em_file = 'em.json'
+em_file = 'em.pickle'
 dynamic_code_file = 'dynleapi.py'
 
-ds_package = 'MySQL'
-mh_classname = 'MysqlMigrationHandler'
-datasource = {
-    'default': {
-        'module': pymysql,
-        'host': '127.0.0.1',
-        'user': 'lodel',
-        'passwd': 'bruno',
-        'db': 'lodel2tests'
-    }
+ds_package = 'picklediff'
+datasource_options = {
+    'filename': '/tmp/em_em.json',
 }

em_editor/utils.py

@@ -9,7 +9,6 @@ def refreshdyn():
     from EditorialModel.model import Model
     from leapi.lefactory import LeFactory
     from EditorialModel.backend.json_backend import EmBackendJson
-    from DataSource.MySQL.leapidatasource import LeDataSourceSQL
     OUTPUT = Settings.dynamic_code_file
     EMJSON = Settings.em_file
     # Load editorial model
@@ -17,13 +16,14 @@ def refreshdyn():
     # Generate dynamic code
     fact = LeFactory(OUTPUT)
     # Create the python file
-    fact.create_pyfile(em, LeDataSourceSQL, {})
+    fact.create_pyfile(em)
 
 
 def db_init():
     from EditorialModel.backend.json_backend import EmBackendJson
     from EditorialModel.model import Model
-    mh = getattr(migrationhandler,Settings.mh_classname)()
+    import DataSource.utils
+    mh = DataSource.utils.get_migrationhandler_instance()
     em = Model(EmBackendJson(Settings.em_file))
     em.migrate_handler(mh)
 

leapi/leclass.py

@@ -37,7 +37,8 @@ class _LeClass(_LeObject):
         return list(cls.fieldtypes(complete).keys())
 
     @classmethod
-    def get(cls, query_filters, field_list=None, order=None, group=None, limit=None, offset=0):
+    def get(cls, query_filters = None, field_list=None, order=None, group=None, limit=None, offset=0):
+        query_filters = list() if query_filters is None else query_filters
         query_filters.append(('class_id', '=', cls._class_id))
         return super().get(query_filters, field_list, order=order, group=group, limit=limit, offset=offset)
 

leapi/lecrud.py

@@ -396,7 +396,8 @@ class _LeCrud(object, metaclass = _MetaLeCrud):
     # @return A list of lodel editorial components instance
     # @todo think about LeObject and LeClass instanciation (partial instanciation, etc)
     @classmethod
-    def get(cls, query_filters, field_list=None, order=None, group=None, limit=None, offset=0, instanciate=True):
+    def get(cls, query_filters = None, field_list=None, order=None, group=None, limit=None, offset=0, instanciate=True):
+        query_filters = list() if query_filters is None else query_filters
         kwargs = locals()
         del(kwargs['cls'])
         kwargs = LodelHook.call_hook('leapi_get_pre', cls, kwargs)

leapi/letype.py

@@ -52,7 +52,8 @@ class _LeType(_LeClass):
             return list(set(cls._fields + cls.name2class('LeObject').fieldlist()))
 
     @classmethod
-    def get(cls, query_filters, field_list = None, order = None, group = None, limit = None, offset = 0):
+    def get(cls, query_filters = None, field_list = None, order = None, group = None, limit = None, offset = 0):
+        query_filters = list() if query_filters is None else query_filters
         query_filters.append(('type_id', '=', cls._type_id))
         return super().get(
                             query_filters = query_filters,

settings.py

@@ -39,8 +39,8 @@ em_graph_output = '/tmp/em_%s_graph.png'
 
 logging = {
     'stderr': {
-        'level': 'INFO',
-        'context': False,
+        'level': 'DEBUG',
+        'context': True,
     },
     'logfile': {
         'level': 'DEBUG',