Rewrote some code from the migration handler

lodel/datasource/mongodb/migration_handler.py

@@ -11,138 +11,154 @@ from lodel.editorial_model.model import EditorialModel
 class MigrationHandlerChangeError(Exception):
     pass
 
-
 class MongoDbMigrationHandler(GenericMigrationHandler):
 
     COMMANDS_IFEXISTS_DROP = 'drop'
     COMMANDS_IFEXISTS_NOTHING = 'nothing'
 
+    INIT_COLLECTIONS_NAMES = ['object', 'relation', 'entitie', 'person', 'text', 'entry']
+
     ## @brief constructs a MongoDbMigrationHandler
-    # @param conn_args dict : a dictionary containing connection options
-    # @param **kwargs : extra arguments given to the connection method
+    # @param conn_args dict : a dictionary containing the connection options
+    # @param **kwargs : extra arguments
     def __init__(self, conn_args=None, **kwargs):
 
         if conn_args is None:
-            conn_args = {}  # TODO : get the connection parameters in the settings
+            conn_args = utils.get_connection_args()
 
         self.connection_name = conn_args['name']
-
         self.database = utils.mongodbconnect(self.connection_name)
 
-        # === Migration settings ===
-        # TODO reimplement the settings management here
-        mh_settings = {'dry_run': False, 'foreign_keys': True, 'drop_if_exists': False}
-        self.dryrun = kwargs['dryrun'] if 'dryrun' in kwargs else mh_settings['dryrun']
-        self.foreign_keys = kwargs['foreign_keys'] if 'foreign_keys' in kwargs else mh_settings['forein_keys']
-        self.drop_if_exists = kwargs['drop_if_exists'] if 'drop_if_exists' in kwargs else mh_settings['drop_if_exists']
+        # TODO : get the following parameters in the settings ?
+        migrationhandler_settings = {'dry_run': False, 'foreign_keys': True, 'drop_if_exists': False}
 
-        self._main_collection_name = 'object'
-        self._relation_collection_name = 'relations'
+        self.dryrun = kwargs['dryrun'] if 'dryrun' in kwargs else migrationhandler_settings['dry_run']
+        self.foreign_keys = kwargs['foreign_keys'] if 'foreign_keys' in kwargs else migrationhandler_settings['foreign_keys']
+        self.drop_if_exists = kwargs['drop_if_exists'] if 'drop_if_exists' in kwargs else migrationhandler_settings['drop_if_exists']
 
-        self._install_tables()
+        self._install_collections()
 
-    def _install_tables(self):
-        self._create_collection(self._main_collection_name)
-        self._create_collection(self._relation_collection_name)
+    def _install_collections(self):
+        for collection_name in MongoDbMigrationHandler.INIT_COLLECTIONS_NAMES:
+            collection_to_create = "%s%s" % ('class_', collection_name)
+            self._create_collection(collection_name=collection_to_create)
 
-    ## @brief Records a change in the EditorialModel and indicates whether or not it is possible to commit it in the database
-    # @note The states contains only the changing fields
-    # @param model EditorialModel : The EditorialModel object providing the global context
+    ## @brief Performs a change in the EditorialModel and indicates
+    # @note The states contains only the changing fields in the form of a dict : {field_name1: fieldvalue1, ...}
+    # @param model EditorialModel
     # @param uid str : the uid of the changing component
-    # @param initial_state dict|None: dict representing the original state ({field_name: field_value, ...}). None means the component is created
-    # @param new_state dict|None: dict representing the new state ({field_name: field_value, ...}). None means the component is deleted
+    # @param initial_state dict|None: dict representing the original state, None means the component will be created
+    # @param new_state dict|None: dict representing the new state, None means the component will be deleted
     def register_change(self, model, uid, initial_state, new_state):
-        if initial_state is None:
-            state_change = 'new'
-        elif new_state is None:
-            state_change = 'del'
+        if initial_state is not None and new_state is not None:
+            if initial_state is None:
+                state_change = 'new'
+            elif new_state is None:
+                state_change = 'del'
+            else:
+                state_change = 'upgrade'
+
+            component_class_name = model.classes(uid).__class__.name
+            handler_func(component_class_name.lower() + '_' + state_change)
+            if hasattr(self, handler_func):
+                getattr(self, handler_func)(model, uid, initial_state, new_state)
         else:
-            state_change = 'upgrade'
-
-        component_class_name = model.classes(uid).__class__.name
-        handler_func(component_class_name.lower() + '_' + state_change)
-        if hasattr(self, handler_func):
-            getattr(self, handler_func)(model, uid, initial_state, new_state)
+            pass  # TODO manage the case where no state at all was given
 
     def register_model_state(self, em, state_hash):
         pass
 
+    ## @brief creates a new collection corresponding to a given uid
     def emclass_new(self, model, uid, initial_state, new_state):
-        class_collection_name = model.classes(uid).name
-        self._create_collection(class_collection_name)
+        emclass = model.classes(uid)
+        if not isinstance(emclass, EmClass):
+            raise ValueError("The given uid is not an EmClass uid")
+        collection_name = utils.object_collection_name(emclass)
+        self._create_collection(collection_name)
 
+    ## @brief deletes a collection corresponding to a given uid
     def emclass_del(self, model, uid, initial_state, new_state):
         emclass = model.classes(uid)
         if not isinstance(emclass, EmClass):
             raise ValueError("The given uid is not an EmClass uid")
+        collection_name = utils.object.collection_name(emclass)
+        self._delete_collection(collection_name)
 
-        class_collection_name = utils.object.collection_name(emclass.uid)
-        self._delete_collection(class_collection_name)
-
-    ## @brief creates a new collection for a new class
+    ## @brief creates a new field in a collection
     # @param model EditorialModel
     # @param uid str
-    # @param initial_state dict|None: dict with field name as key and field value as value. Represents the original state.
-    # @param new_state dict|None : dict with field name as key and field value as value. Represents the new state.
+    # @param initial_state dict|None: dict representing the original state
+    # @param new_state dict|None: dict representing the new state
     def emfield_new(self, model, uid, initial_state, new_state):
         if new_state['data_handler'] == 'relation':
             # find relational_type name, and class_name of the field
             class_name = self._class_collection_name_from_field(model, new_state)
             self._create_field_in_collection(class_name, uid, new_state)
-            return True
-
-        collection_name = self._class_collection_name_from_field(model, new_state)
-
-        field_definition = self._field_definition(new_state['data_handler'], new_state)
-        self._create_field_in_collection(collection_name, uid, field_definition)
+        else:
+            collection_name = self._class_collection_name_from_field(model, new_state)
+            field_definition = self._field_defition(new_state['data_handler'], new_state)
+            self._create_field_in_collection(collection_name, uid, field_definition)
 
+    ## @brief deletes a field in a collection
+    # @param model EditorialModel
+    # @param uid str
+    # @param initial_state dict|None: dict representing the original state
+    # @param new_state dict|None: dict representing the new state
     def emfield_del(self, model, uid, initial_state, new_state):
-        if uid != '_id':
-            collection_name = self._class_collection_name_from_field(model, initial_state)
-            self.database[collection_name].update_many({field:{'$exists':True}}, {'$unset':{field:1}}, False)
-
+        collection_name = self._class_collection_name_from_field(model, initial_state)
+        field_name = model.field(uid).name
+        self._delete_field_in_collection(collection_name, field_name)
+
+    ## @brief Defines the default value when a new field is added to a collection's items
+    # @param fieldtype str : name of the field's type
+    # @param options dict : dictionary giving the options to use to initiate the field's value.
+    # @return dict (containing a 'default' key with the default value)
     def _field_definition(self, fieldtype, options):
         basic_type = DataHandler.from_name(fieldtype).ftype
-
-        field_definition = {'default_value':None}
-
         if basic_type == 'datetime':
             if 'now_on_create' in options and options['now_on_create']:
                 return {'default': datetime.datetime.utcnow()}
         if basic_type == 'relation':
-            return {'default' : []}
+            return {'default': []}
 
         return {'default': ''}
 
     def _class_collection_name_from_field(self, model, field):
         class_id = field['class_id']
-        class_name = model.classes(class_id).name
-        class_collection_name = utils.object_collection_name(class_name)
-        return class_collection_name
-
+        component_class = model.classes(class_id)
+        component_collection = utils.object_collection_name(component_class)
+        return component_collection
+
+    ## @brief Creates a new collection in MongoDb Database
+    # @param collection_name str
+    # @param charset str
+    # @param if_exists str : defines the behavior when the collection already exists (default : 'nothing')
     def _create_collection(self, collection_name, charset='utf8', if_exists=MongoDbMigrationHandler.COMMANDS_IFEXISTS_NOTHING):
-        if if_exists == self.__class__.COMMANDS_IFEXISTS_DROP:
-            if collection_name in self.database.collection_names(include_system_collections = False):
+        if collection_name in self.database.collection_names(include_system_collections=False):
+            # The collection already exists
+            if if_exists == MongoDbMigrationHandler.COMMANDS_IFEXISTS_DROP:
                 self._delete_collection(collection_name)
-        self.database.create_collection(name=collection_name)
+                self.database.create_collection(name=collection_name)
+        else:
+            self.database.create_collection(name=collection_name)
 
+    ## @brief Delete an existing collection in MongoDb Database
+    # @param collection_name str
     def _delete_collection(self, collection_name):
         collection = self.database[collection_name]
         collection.drop_indexes()
         collection.drop()
 
+    ## @brief Creates a new field in a collection
+    # @param collection_name str
+    # @param field str
+    # @param options dict
     def _create_field_in_collection(self, collection_name, field, options):
-        self.database[collection_name].update_many({field: {'$exists': False}}, {'$set': {field: options['default']}},
-                                                   False)
-
-    def _add_fk(self, src_collection_name, dst_collection_name, src_field_name, dst_field_name, fk_name=None):
-        if fk_name is None:
-            fk_name = utils.get_fk_name(src_collection_name, dst_collection_name)
-        self._del_fk(src_collection_name, dst_collection_name, fk_name)
-
-        self.database[src_collection_name].update_many({fk_name: {'$exists': False}}, {'$set': {fk_name: []}}, False)
-
-    def del_fk(self, src_collection_name, dst_collection_name, fk_name=None):
-        if fk_name is None:
-            fk_name = utils.get_fk_name(src_collection_name, dst_collection_name)
-        self.database[src_collection_name].update_many({}, {'$unset': {fk_name:1}}, False)
+        self.database[collection_name].update_many({field: {'$exists': False}}, {'$set': {field: options['default']}}, False)
+
+    ## @brief Deletes a field in a collection
+    # @param collection_name str
+    # @param field_name str
+    def _delete_field_in_collection(self, collection_name, field_name):
+        if field_name != '_id':
+            self.database[collection_name].update_many({field_name:{'$exists': True}}, {'$unset':{field_name:1}}, False)

lodel/datasource/mongodb/utils.py

@@ -3,6 +3,8 @@
 import pymongo
 from pymongo import MongoClient
 
+from lodel.settings.settings import Settings as settings
+
 common_collections = {
     'object': 'object',
     'relation': 'relation'
@@ -10,7 +12,7 @@ common_collections = {
 
 collection_prefix = {
     'relation': 'rel_',
-    'collection': 'class_'
+    'object': 'class_'
 }
 
 LODEL_OPERATORS_MAP = {
@@ -67,8 +69,8 @@ def mongodbconnect(connection_name):
 ## @brief gets the settings given a connection name
 # @param connection_name str
 # @return dict
-# @todo connect this method to the settings
-def get_connection_args(connnection_name):
+# @todo Use the settings module to store the connections parameters
+def get_connection_args(connnection_name='default'):
     return {'host': 'localhost', 'port': 28015, 'login': 'lodel_admin', 'password': 'lapwd', 'dbname': 'lodel'}
 
 
@@ -85,11 +87,17 @@ def check_connection_args(connection_args):
     return check_result
 
 
-## @brief Returns a collection name given a Emclass name
-# @param class_name str : The class name
+## @brief Returns a collection name given a Emclass
+# @param class_object EmClass
 # @return str
-def object_collection_name(class_name):
-    return ("%s%s" % (collection_prefix['object'], class_name)).lower()
+def object_collection_name(class_object):
+    if class_object.pure_abstract == False:
+        class_parent = class_object.parents[0].uid
+        collection_name = ("%s%s" % (collection_prefix['object'], class_parent)).lower()
+    else:
+        collection_name = ("%s%s" % (collection_prefix['object'], class_object.name)).lower()
+
+    return collection_name
 
 
 ## @brief converts the query filters into MongoDB filters
@@ -122,10 +130,12 @@ def parse_query_filters(query_filters, as_list=False):
 # @param filter_params tuple : (FIELD, OPERATOR, VALUE) representing the query filter to convert
 # @return dict : {KEY: {OPERATOR:VALUE}}
 # @todo Add an error management for the operator mismatch
-# @todo Add the checks for the type of values authorized in certain mongodb operators, such "$in" for example which takes a list
 def convert_filter(filter_params):
     key, operator, value = filter_params
     if operator not in ('like', 'not like'):
+        if operator == 'in' and not isinstance(value, list):
+            raise ValueError('A list should be used as value for an IN operator, %s given' % value.__class__)
+
         converted_operator = LODEL_OPERATORS_MAP[operator]['name']
         converted_filter = {key: {converted_operator: value}}
     else:
@@ -178,10 +188,3 @@ def escape_idname(idname):
         raise ValueError("Invalid name : '%s'" % idname)
     return '`%s`' % idname
 
-
-## @brief gets the fk name between two collections
-# @param src_collection_name str
-# @param dst_collection_name str
-# @return str
-def get_fk_name(src_collection_name, dst_collection_name):
-    return ("fk_%s_%s" % (src_collection_name, dst_collection_name)).lower()