Datasource implementation

- Implementation of the delete, insert and insert_multi methods + first implementation of the select method in the MongoDB datasource
- Added parsing methods in the mongodb/utils module

lodel/datasource/mongodb/datasource.py

@@ -56,39 +56,67 @@ class MongoDbDataSource(object):
         return (connection_args['login'], urllib.quote_plus(connection_args['password']), connection_args['host'],
                 connection_args['port'], connection_args['dbname'])
 
+
+    ## @brief returns a selection of documents from the datasource
+    # @param target_cls Emclass
+    # @param field_list list
     def select(self, target_cls, field_list, filters, rel_filters=None, order=None, group=None, limit=None, offset=0,
                instanciate=True):
-        pass
-
+        collection_name = utils.object_collection_name(target_cls.__class__)
+        collection = self.database[collection_name]
+        query_filters = utils.parse_query_filters(filters)
+        query_result_ordering = utils.parse_query_order(order) if order is not None else None
+        results_field_list = None if len(field_list) == 0 else field_list  # TODO On peut peut-être utiliser None dans les arguments au lieu d'une liste vide
+        limit = limit if limit is not None else 0
+        cursor = collection.find(
+            filter=query_filters,
+            projection=results_field_list,
+            skip=offset,
+            limit=limit,
+            sort=query_result_ordering
+        )
+        results = list()
+        for document in cursor:
+            results.append(document)
+
+        return results
+
+    ## @brief Deletes one record defined by its uid
+    # @param target_cls Emclass : class of the record to delete
+    # @param uid dict|list : a dictionary of fields and values composing the unique identifier of the record or a list of several dictionaries
+    # @return int : number of deleted records
+    # @TODO check the content of the result.raw_result property depending on the informations to return
+    # @TODO Implement the error management
     def delete(self, target_cls, uid):
-        pass
+        if isinstance(uid, dict):
+            uid = [uid]
+        collection_name = utils.object_collection_name(target_cls.__class__)
+        collection = self.database[collection_name]
+        result = collection.delete_many(uid)
+        return result.deleted_count
 
     def update(self, target_cls, uid, **datas):
+
         pass
 
     ## @brief Inserts a record in a given collection
     # @param target_cls Emclass : class of the object to insert
     # @param datas dict : datas to insert
-    # @return ObjectId : the uid of the inserted record
+    # @return bool
+    # @TODO Implement the error management
     def insert(self, target_cls, **datas):
         collection_name = utils.object_collection_name(target_cls.__class__)
         collection = self.database[collection_name]
         result = collection.insert_one(datas)
-        return result.inserted_id
+        return len(result.inserted_id)
 
     ## @brief Inserts a list of records in a given collection
     # @param target_cls Emclass : class of the objects inserted
     # @param datas_list
-    # @return int : Number of inserted records in the collection
+    # @return list : list of the inserted records' ids
+    # @TODO Implement the error management
     def insert_multi(self, target_cls, datas_list):
         collection_name = utils.object_collection_name(target_cls.__class__)
         collection = self.database[collection_name]
-        bulk = collection.initialize_ordered_bulk_op()
-        for datas_list_item in datas_list:
-            bulk.insert(datas_list_item)
-        try:
-            result = bulk.execute()
-        except BulkWriteError as bwe:
-            pass  # TODO add the behavior in case of an exception => bwe.details['writeErrors'], is a list of error info dicts
-
-        return result['nInserted']
+        result = collection.insert_many(datas_list)
+        return len(result.inserted_ids)

lodel/datasource/mongodb/utils.py

@@ -1,13 +1,89 @@
 # -*- coding: utf-8 -*-
 
+import pymongo
+
 collection_prefix = {
     'relation': 'rel_',
     'collection': 'class_'
 }
 
+# TODO Ajouter ici les conversions vers les opérateurs MongoDB correspondants
+LODEL_OPERATORS_MAP = {
+    '=': {'name': '$eq', 'value_type': None},
+    '<=': {'name': '$lte', 'value_type': None},
+    '>=': {'name': '$gte', 'value_type': None},
+    '!=': {'name': '$ne', 'value_type': None},
+    '<': {'name': '$lt', 'value_type': None},
+    '>': {'name': '$gt', 'value_type': None},
+    ' in ': {'name': '$in', 'value_type': list},
+    ' not in ': {'name': '$nin', 'value_type': list},
+    ' like ': {'name': '$eq', 'value_type': str},
+    ' not like ': {'name': '', 'value_type': str},  # TODO Add the operator
+    'OR': {'name': '$or', 'value_type': list},
+    'AND': {'name': '$and', 'value_type': list}
+}
+
+LODEL_SORT_OPERATORS_MAP = {
+    'ASC': pymongo.ASCENDING,
+    'DESC': pymongo.DESCENDING
+}
+
 
 ## @brief Returns a collection name given a Emclass name
 # @param class_name str : The class name
 # @return str
 def object_collection_name(class_name):
     return ("%s%s" % (collection_prefix['object'], class_name)).lower()
+
+
+## @brief converts the query filters into MongoDB filters
+# @param query_filters list
+# @return dict
+# @todo refactor this function by adding a return_type argument (default= dict) which can be a dict or a list, then delete the convert_filter_list function
+def parse_query_filters(query_filters):
+    filters_dict = dict()
+    for query_filter in query_filters:
+        if isinstance(query_filter, tuple):
+            filters_dict.update(convert_filter(query_filter))
+        elif isinstance(query_filter, dict):
+            query_item = list(query_filter.items())[0]
+            key = LODEL_OPERATORS_MAP[query_item[0]]
+            filters_dict.update({key: convert_filter_list(query_item[1])})
+        else:
+            # TODO Add an exception management here in case the filter is neither a tuple nor a dict
+            pass
+    return filters_dict
+
+
+## @brief converts a query filters list into MongoDB filters list
+#   It is used mainly in case of an "AND" or an "OR"
+# @param filters_list list
+# @return list
+def convert_filter_list(filters_list):
+    converted_filters_list = list()
+    for filter_list_item in filters_list:
+        if isinstance(filter_list_item, tuple):
+            converted_filters_list.append(convert_filter(filter_list_item))
+        elif isinstance(filter_list_item, dict):
+            query_item = list(filter_list_item.items())[0]
+            key = LODEL_OPERATORS_MAP[query_item[0]]['name']
+            converted_filters_list.append({key: convert_filter_list(query_item[1])})
+    return converted_filters_list
+
+## @brief converts a Lodel query filter into a MongoDB filter
+# @param filter 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):
+    key, operator, value = filter
+    converted_operator = LODEL_OPERATORS_MAP[operator]['name']
+    converted_filter = {key: {converted_operator: value}}
+    return converted_filter
+
+## @brief Returns a list of sorting options
+# @param query_filters_order list
+# @return list
+def parse_query_order(query_filters_order):
+    ordering = list()
+    return ordering