Add import and export pdps

Change-Id: I2c9b1f2b86af862887df4b890cd8b11db7c308ee

37 files changed, 2824 insertions, 55 deletions

diff --git a/README.md b/README.md
index 0bf6e8f2..51e5077f 100644
--- a/README.md
+++ b/README.md
@@ -69,6 +69,15 @@ moon slave delete <name_of_the_slave>
 ```
 If you don't put a name here, by default, the script will use `kubernetes-admin@kubernetes`.
 
+### inport/export of the moon database
+Using the moon python client, it is possible to export and import the content of the moon database. The format of the file must be json. Examples of files that can be imported are found in the moon_manager package (rbac.json and mls.json)
+
+The relations between different elements of the json in made using their names. Therefore, the name acts, for now, as a unique identifier in the json files. Importing several times the same json file can lead to unexpected behavior. It is advised to import json file in an empty database.
+
+Two particular entries in the json description are used to specify the way of performing the import:
+ - "mandatory": it can be true or false. This field is only valid for policies description. The policy having this field set to true, will be automatically added to the other elements of the json file that have an empty "policy" field (subject data for instance) or that have a "policies" field which does not already contain the mandatory policy name (such as subjects). 
+ - "override" : it can be true or false. This field is only valid for policies and models. If set to true and a policy/model with an identical name already exists in the database, it will be overwritten.
+
 
 ## Tests
 - [Python Unit Test](tests/python_unit/README.md)
@@ -106,4 +115,4 @@ curl -i \
 curl --header "X-Auth-Token: <token_retrieve_from_keystone>" http://moon_hostname:30001
 curl --header "X-Auth-Token: <token_retrieve_from_keystone>" http://moon_hostname:30001/pdp
 curl --header "X-Auth-Token: <token_retrieve_from_keystone>" http://moon_hostname:30001/policies
-```
\ No newline at end of file
+```
diff --git a/moon_authz/moon_authz/http_server.py b/moon_authz/moon_authz/http_server.py
index 836efbc8..b6ac6426 100644
--- a/moon_authz/moon_authz/http_server.py
+++ b/moon_authz/moon_authz/http_server.py
@@ -94,7 +94,6 @@ class Root(Resource):
 
 
 class HTTPServer(Server):
-
     def __init__(self, host="0.0.0.0", port=38001, **kwargs):
         super(HTTPServer, self).__init__(host=host, port=port, **kwargs)
         self.component_data = kwargs.get("component_data", {})
diff --git a/moon_manager/moon_manager/__init__.py b/moon_manager/moon_manager/__init__.py
index 85c245e0..af7fced5 100644
--- a/moon_manager/moon_manager/__init__.py
+++ b/moon_manager/moon_manager/__init__.py
@@ -3,4 +3,4 @@
 # license which can be found in the file 'LICENSE' in this package distribution
 # or at 'http://www.apache.org/licenses/LICENSE-2.0'.
 
-__version__ = "4.4.0"
+__version__ = "4.5.0"
diff --git a/moon_manager/moon_manager/api/base_exception.py b/moon_manager/moon_manager/api/base_exception.py
new file mode 100644
index 00000000..0af3b6d0
--- /dev/null
+++ b/moon_manager/moon_manager/api/base_exception.py
@@ -0,0 +1,18 @@
+
+class BaseException(Exception):
+    def __init__(self, message):
+        self._code = 500
+        self._message = message
+        # Call the base class constructor with the parameters it needs
+        super(BaseException, self).__init__(message)
+
+    @property
+    def code(self):
+        return self._code
+
+    @property
+    def message(self):
+        return self._message
+
+    def __str__(self):
+        return "Error " + str(self._code) + " " + self.__class__.__name__ + ': ' + self.message
\ No newline at end of file
diff --git a/moon_manager/moon_manager/api/json_export.py b/moon_manager/moon_manager/api/json_export.py
new file mode 100644
index 00000000..feb4fde2
--- /dev/null
+++ b/moon_manager/moon_manager/api/json_export.py
@@ -0,0 +1,225 @@
+import logging
+from flask_restful import Resource
+from python_moonutilities.security_functions import check_auth
+from python_moondb.core import PDPManager
+from python_moondb.core import PolicyManager
+from python_moondb.core import ModelManager
+from moon_manager.api.json_utils import JsonUtils, BaseException
+
+__version__ = "4.5.0"
+
+logger = logging.getLogger("moon.manager.api." + __name__)
+
+
+class JsonExport(Resource):
+
+    __urls__ = (
+        "/export",
+        "/export/",
+    )
+
+    def _export_rules(self, json_content):
+        policies = PolicyManager.get_policies(self._user_id)
+        rules_array = []
+
+        for policy_key in policies:
+            rules = PolicyManager.get_rules(self._user_id, policy_key)
+            rules = rules["rules"]
+            # logger.info(rules)
+            for rule in rules:
+                rule_dict = dict()
+                JsonUtils.copy_field_if_exists(rule, rule_dict, "instructions", dict)
+                JsonUtils.copy_field_if_exists(rule, rule_dict, "enabled", True)
+                JsonUtils.convert_id_to_name(rule["meta_rule_id"], rule_dict, "meta_rule", "meta_rule", ModelManager, self._user_id)
+                JsonUtils.convert_id_to_name(policy_key, rule_dict, "policy", "policy", PolicyManager, self._user_id)
+                ids = rule["rule"]
+                rule_description = dict()
+                JsonUtils.convert_ids_to_names([ids[0]], rule_description, "subject_data", "subject_data",  PolicyManager, self._user_id, policy_key)
+                JsonUtils.convert_ids_to_names([ids[1]], rule_description, "object_data", "object_data", PolicyManager, self._user_id, policy_key)
+                JsonUtils.convert_ids_to_names([ids[2]], rule_description, "action_data", "action_data", PolicyManager, self._user_id, policy_key)
+                rule_dict["rule"] = rule_description
+                logger.info("Exporting rule {}".format(rule_dict))
+                rules_array.append(rule_dict)
+
+        if len(rules_array) > 0:
+            json_content['rules'] = rules_array
+
+    def _export_meta_rules(self, json_content):
+        meta_rules = ModelManager.get_meta_rules(self._user_id)
+        meta_rules_array = []
+        # logger.info(meta_rules)
+        for meta_rule_key in meta_rules:
+            #logger.info(meta_rules[meta_rule_key])
+            meta_rule_dict = dict()
+            JsonUtils.copy_field_if_exists(meta_rules[meta_rule_key], meta_rule_dict, "name", str)
+            JsonUtils.copy_field_if_exists(meta_rules[meta_rule_key], meta_rule_dict, "description", str)
+            JsonUtils.convert_ids_to_names(meta_rules[meta_rule_key]["subject_categories"], meta_rule_dict, "subject_categories", "subject_category", ModelManager, self._user_id)
+            JsonUtils.convert_ids_to_names(meta_rules[meta_rule_key]["object_categories"], meta_rule_dict, "object_categories", "object_category", ModelManager, self._user_id)
+            JsonUtils.convert_ids_to_names(meta_rules[meta_rule_key]["action_categories"], meta_rule_dict, "action_categories", "action_category", ModelManager, self._user_id)
+            logger.info("Exporting meta rule {}".format(meta_rule_dict))
+            meta_rules_array.append(meta_rule_dict)
+        if len(meta_rules_array) > 0:
+            json_content['meta_rules'] = meta_rules_array
+
+    def _export_subject_object_action_assignments(self, type_element, json_content):
+        export_method_data = getattr(PolicyManager, 'get_' + type_element + '_assignments')
+        policies = PolicyManager.get_policies(self._user_id)
+        element_assignments_array = []
+        for policy_key in policies:
+            assignments = export_method_data(self._user_id, policy_key)
+            #logger.info(assignments)
+            for assignment_key in assignments:
+                assignment_dict = dict()
+                JsonUtils.convert_id_to_name(assignments[assignment_key][type_element + "_id"], assignment_dict, type_element, type_element , PolicyManager, self._user_id, policy_key)
+                JsonUtils.convert_id_to_name(assignments[assignment_key]["category_id"], assignment_dict, "category", type_element + "_category", ModelManager, self._user_id, policy_key)
+                JsonUtils.convert_ids_to_names(assignments[assignment_key]["assignments"], assignment_dict, "assignments", type_element + "_data", PolicyManager, self._user_id, policy_key)
+                element_assignments_array.append(assignment_dict)
+                logger.info("Exporting {} assignment {}".format(type_element, assignment_dict))
+        if len(element_assignments_array) > 0:
+            json_content[type_element + '_assignments'] = element_assignments_array
+
+    def _export_subject_object_action_datas(self, type_element, json_content):
+        export_method_data = getattr(PolicyManager, 'get_' + type_element + '_data')
+        policies = PolicyManager.get_policies(self._user_id)
+        element_datas_array = []
+        for policy_key in policies:
+            datas = export_method_data(self._user_id, policy_key)
+            #logger.info("data found : {}".format(datas))
+            for data_group in datas:
+                policy_id = data_group["policy_id"]
+                category_id = data_group["category_id"]
+                # logger.info(data_group["data"])
+                for data_key in data_group["data"]:
+                    data_dict = dict()
+                    if type_element == 'subject':
+                        JsonUtils.copy_field_if_exists(data_group["data"][data_key], data_dict, "name", str)
+                        JsonUtils.copy_field_if_exists(data_group["data"][data_key], data_dict, "description", str)
+                    else:
+                        JsonUtils.copy_field_if_exists(data_group["data"][data_key]["value"], data_dict, "name", str)
+                        JsonUtils.copy_field_if_exists(data_group["data"][data_key]["value"], data_dict, "description", str)
+
+                    JsonUtils.convert_id_to_name(policy_id, data_dict, "policy", "policy", PolicyManager, self._user_id)
+                    JsonUtils.convert_id_to_name(category_id, data_dict, "category", type_element + "_category", ModelManager, self._user_id, policy_key)
+                    logger.info("Exporting {} data {}".format(type_element, data_dict))
+                    element_datas_array.append(data_dict)
+
+        if len(element_datas_array) > 0:
+            json_content[type_element + '_data'] = element_datas_array
+
+    def _export_subject_object_action_categories(self, type_element, json_content):
+        export_method = getattr(ModelManager, 'get_' + type_element + '_categories')
+        element_categories = export_method(self._user_id)
+        element_categories_array = []
+        for element_category_key in element_categories:
+            element_category = dict()
+            JsonUtils.copy_field_if_exists(element_categories[element_category_key], element_category, "name", str)
+            JsonUtils.copy_field_if_exists(element_categories[element_category_key], element_category, "description", str)
+            element_categories_array.append(element_category)
+            logger.info("Exporting {} category {}".format(type_element, element_category))
+        if len(element_categories_array) > 0:
+            json_content[type_element + '_categories'] = element_categories_array
+
+    def _export_subject_object_action(self, type_element, json_content):
+        export_method = getattr(PolicyManager, 'get_' + type_element + 's')
+        policies = PolicyManager.get_policies(self._user_id)
+        element_dict = dict()
+        elements_array = []
+        for policy_key in policies:
+            elements = export_method(self._user_id, policy_key)
+            for element_key in elements:
+                #logger.info("Exporting {}".format(elements[element_key]))
+                element = dict()
+                JsonUtils.copy_field_if_exists(elements[element_key], element, "name", str)
+                JsonUtils.copy_field_if_exists(elements[element_key], element, "description", str)
+                JsonUtils.copy_field_if_exists(elements[element_key], element, "extra", dict)
+                if element["name"] not in element_dict:
+                    element["policies"] = []
+                    element_dict[element["name"]] = element
+                current_element = element_dict[element["name"]]
+                current_element["policies"].append({"name": JsonUtils.convert_id_to_name_string(policy_key, "policy", PolicyManager, self._user_id)})
+
+        for key in element_dict:
+            logger.info("Exporting {} {}".format(type_element, element_dict[key]))
+            elements_array.append(element_dict[key])
+
+        if len(elements_array) > 0:
+            json_content[type_element + 's'] = elements_array
+
+    def _export_policies(self, json_content):
+        policies = PolicyManager.get_policies(self._user_id)
+        policies_array = []
+        for policy_key in policies:
+            policy = dict()
+            JsonUtils.copy_field_if_exists(policies[policy_key], policy, "name", str)
+            JsonUtils.copy_field_if_exists(policies[policy_key], policy, "genre", str)
+            JsonUtils.copy_field_if_exists(policies[policy_key], policy, "description", str)
+            JsonUtils.convert_id_to_name(policies[policy_key]["model_id"], policy, "model", "model", ModelManager, self._user_id)
+            logger.info("Exporting policy {}".format(policy))
+            policies_array.append(policy)
+        if len(policies_array) > 0:
+            json_content["policies"] = policies_array
+
+    def _export_models(self, json_content):
+        models = ModelManager.get_models(self._user_id)
+        models_array = []
+        for model_key in models:
+            model = dict()
+            JsonUtils.copy_field_if_exists(models[model_key], model, "name", str)
+            JsonUtils.copy_field_if_exists(models[model_key], model, "description", str)
+            # logger.info(models[model_key]["meta_rules"])
+            JsonUtils.convert_ids_to_names(models[model_key]["meta_rules"], model, "meta_rules", "meta_rule", ModelManager, self._user_id)
+            logger.info("Exporting model {}".format(model))
+            models_array.append(model)
+        if len(models_array) > 0:
+            json_content["models"] = models_array
+
+    def _export_pdps(self, json_content):
+        pdps = PDPManager.get_pdp(self._user_id)
+        pdps_array = []
+        for pdp_key in pdps:
+            logger.info("Exporting pdp {}".format(pdps[pdp_key]))
+            pdps_array.append(pdps[pdp_key])
+        if len(pdps_array) > 0:
+            json_content["pdps"] = pdps_array
+
+    def _export_json(self, user_id):
+        self._user_id = user_id
+        json_content = dict()
+
+        logger.info("Exporting pdps...")
+        self._export_pdps(json_content)
+        logger.info("Exporting policies...")
+        self._export_policies(json_content)
+        logger.info("Exporting models...")
+        self._export_models(json_content)
+        # export subjects, subject_data, subject_categories, subject_assignements idem for object and action
+        list_element = [{"key": "subject"}, {"key": "object"}, {"key": "action"}]
+        for elt in list_element:
+            logger.info("Exporting {}s...".format(elt["key"]))
+            self._export_subject_object_action(elt["key"], json_content)
+            logger.info("Exporting {} categories...".format(elt["key"]))
+            self._export_subject_object_action_categories(elt["key"], json_content)
+            logger.info("Exporting {} data...".format(elt["key"]))
+            self._export_subject_object_action_datas(elt["key"], json_content)
+            logger.info("Exporting {} assignments...".format(elt["key"]))
+            self._export_subject_object_action_assignments(elt["key"], json_content)
+        logger.info("Exporting meta rules...")
+        self._export_meta_rules(json_content)
+        logger.info("Exporting rules...")
+        self._export_rules(json_content)
+
+        return json_content
+
+    @check_auth
+    def get(self, user_id=None):
+        """Import file.
+
+        :param user_id: user ID who do the request
+        :return: {
+
+        }
+        :internal_api:
+        """
+        json_file = self._export_json(user_id)
+        logger.info(json_file)
+        return {"content": json_file}
diff --git a/moon_manager/moon_manager/api/json_import.py b/moon_manager/moon_manager/api/json_import.py
new file mode 100644
index 00000000..a048baee
--- /dev/null
+++ b/moon_manager/moon_manager/api/json_import.py
@@ -0,0 +1,518 @@
+# Copyright 2015 Open Platform for NFV Project, Inc. and its contributors
+# This software is distributed under the terms and conditions of the 'Apache-2.0'
+# license which can be found in the file 'LICENSE' in this package distribution
+# or at 'http://www.apache.org/licenses/LICENSE-2.0'.
+
+from flask import request
+from flask_restful import Resource
+import flask_restful
+from flask import abort
+
+from python_moonutilities.security_functions import check_auth
+from python_moonutilities import exceptions
+import logging
+import json
+
+from moon_manager.api.base_exception import BaseException
+from moon_manager.api.json_utils import JsonUtils, UnknownName
+from python_moondb.core import PDPManager
+from python_moondb.core import PolicyManager
+from python_moondb.core import ModelManager
+
+
+__version__ = "4.5.0"
+
+logger = logging.getLogger("moon.manager.api." + __name__)
+
+INST_CALLBACK = 0
+DATA_CALLBACK = 1
+ASSIGNMENT_CALLBACK = 2
+CATEGORIES_CALLBACK = 3
+
+
+class ForbiddenOverride(BaseException):
+    def __init__(self, message):
+
+        # Call the base class constructor with the parameters it needs
+        super(ForbiddenOverride, self).__init__(message)
+
+
+class UnknownPolicy(BaseException):
+    def __init__(self, message):
+
+        # Call the base class constructor with the parameters it needs
+        super(UnknownPolicy, self).__init__(message)
+
+
+class UnknownModel(BaseException):
+    def __init__(self, message):
+
+        # Call the base class constructor with the parameters it needs
+        super(UnknownModel, self).__init__(message)
+
+
+class UnknownData(BaseException):
+    def __init__(self, message):
+
+        # Call the base class constructor with the parameters it needs
+        super(UnknownData, self).__init__(message)
+
+
+class MissingPolicy(BaseException):
+    def __init__(self, message):
+
+        # Call the base class constructor with the parameters it needs
+        super(MissingPolicy, self).__init__(message)
+
+
+class InvalidJson(BaseException):
+    def __init__(self, message):
+
+        # Call the base class constructor with the parameters it needs
+        super(InvalidJson, self).__init__(message)
+
+
+class JsonImport(Resource):
+
+    __urls__ = (
+        "/import",
+        "/import/",
+    )
+
+    def _import_rules(self, json_rules):
+        if not isinstance(json_rules, list):
+            raise InvalidJson("rules shall be a list!")
+
+        for json_rule in json_rules:
+            json_to_use = dict()
+            JsonUtils.copy_field_if_exists(json_rule, json_to_use, "instructions", str)
+            JsonUtils.copy_field_if_exists(json_rule, json_to_use, "enabled", bool, default_value=True)
+
+            json_ids = dict()
+            JsonUtils.convert_name_to_id(json_rule, json_ids, "policy", "policy_id", "policy", PolicyManager, self._user_id)
+            JsonUtils.convert_name_to_id(json_rule, json_to_use, "meta_rule", "meta_rule_id", "meta_rule", ModelManager, self._user_id)
+
+            json_subject_ids = dict()
+            json_object_ids = dict()
+            json_action_ids = dict()
+            json_rule_to_use = dict()
+            JsonUtils.convert_names_to_ids(json_rule["rule"], json_subject_ids, "subject_data", "subject", "subject_data", PolicyManager, self._user_id, json_ids["policy_id"])
+            JsonUtils.convert_names_to_ids(json_rule["rule"], json_object_ids, "object_data", "object", "object_data", PolicyManager, self._user_id, json_ids["policy_id"])
+            JsonUtils.convert_names_to_ids(json_rule["rule"], json_action_ids, "action_data", "action", "action_data", PolicyManager, self._user_id, json_ids["policy_id"])
+            logger.info(json_rule_to_use)
+            for json_subject_id in json_subject_ids["subject"]:
+                for json_object_id in json_object_ids["object"]:
+                    for json_action_id in json_action_ids["action"]:
+                        json_to_use["rule"] = [json_subject_id, json_object_id, json_action_id]
+                    try:
+                        logger.info("Adding / updating a rule from json {}".format(json_to_use))
+                        PolicyManager.add_rule(self._user_id, json_ids["policy_id"], json_to_use["meta_rule_id"], json_to_use)
+                    except exceptions.RuleExisting:
+                        pass
+                    except exceptions.PolicyUnknown:
+                        raise UnknownPolicy("Unknown policy with id {}".format(json_ids["policy_id"]))
+
+    def _import_meta_rules(self, json_meta_rules):
+        logger.info("Input meta rules : {}".format(json_meta_rules))
+        for json_meta_rule in json_meta_rules:
+            json_to_use = dict()
+            logger.info("Input meta rule : {}".format(json_meta_rule))
+            JsonUtils.copy_field_if_exists(json_meta_rule, json_to_use, "name", str)
+            JsonUtils.copy_field_if_exists(json_meta_rule, json_to_use, "description", str)
+            JsonUtils.convert_names_to_ids(json_meta_rule, json_to_use, "subject_categories", "subject_categories", "subject_category", ModelManager, self._user_id)
+            JsonUtils.convert_names_to_ids(json_meta_rule, json_to_use, "object_categories", "object_categories", "object_category", ModelManager, self._user_id)
+            JsonUtils.convert_names_to_ids(json_meta_rule, json_to_use, "action_categories", "action_categories", "action_category", ModelManager, self._user_id)
+            logger.info("Adding / updating a metarule from json {}".format(json_meta_rule))
+            meta_rule = ModelManager.add_meta_rule(self._user_id, meta_rule_id=None, value=json_to_use)
+            logger.info("Added / updated meta rule : {}".format(meta_rule))
+
+    def _import_subject_object_action_assignments(self, json_item_assignments, type_element):
+        import_method = getattr(PolicyManager, 'add_' + type_element + '_assignment')
+        get_method = getattr(PolicyManager, 'get_' + type_element + '_data')
+
+        if not isinstance(json_item_assignments, list):
+            raise InvalidJson(type_element + " assignments shall be a list!")
+
+        # get the policy id related to the user
+        policies = PolicyManager.get_policies(self._user_id)
+
+        for json_item_assignment in json_item_assignments:
+            item_override = JsonUtils.get_override(json_item_assignment)
+            if item_override is True:
+                raise ForbiddenOverride("{} assignments do not support override flag !".format(type_element))
+
+            json_assignment = dict()
+            JsonUtils.convert_name_to_id(json_item_assignment, json_assignment, "category", "category_id", type_element + "_category", ModelManager, self._user_id)
+
+            has_found_data = False
+            # loop over policies
+            for policy_id in policies:
+                json_data = dict()
+                try:
+                    JsonUtils.convert_name_to_id(json_item_assignment, json_assignment, type_element, "id", type_element, PolicyManager, self._user_id, policy_id)
+                    JsonUtils.convert_names_to_ids(json_item_assignment, json_data, "assignments", "data_id", type_element + "_data", PolicyManager, self._user_id, policy_id, json_assignment["category_id"])
+                    has_found_data = True
+                except UnknownName:
+                    # the category or data has not been found in this policy : we look into the next one
+                    continue
+                for data_id in json_data["data_id"]:
+                    # find the policy related to the current data
+                    data = get_method(self._user_id, policy_id, data_id, json_assignment["category_id"])
+                    if data is not None and len(data) == 1:
+                        logger.info("Adding / updating a {} assignment from json {}".format(type_element, json_assignment))
+                        import_method(self._user_id, policy_id, json_assignment["id"], json_assignment["category_id"], data_id)
+                    else:
+                        raise UnknownData("Unknown data with id {}".format(data_id))
+
+            # case the data has not been found in any policies
+            if has_found_data is False:
+                raise InvalidJson("The json contains unknown {} data or category : {}".format(type_element,json_item_assignment))
+
+    def _import_subject_object_action_datas(self, json_items_data,  mandatory_policy_ids, type_element):
+        if type_element == "subject":
+            import_method = getattr(PolicyManager, 'set_' + type_element + '_data')
+        else:
+            import_method = getattr(PolicyManager, 'add_' + type_element + '_data')
+        # get_method = getattr(PolicyManager, 'get_' + type_element + '_data')
+
+        if not isinstance(json_items_data, list):
+            raise InvalidJson(type_element + " data shall be a list!")
+
+        for json_item_data in json_items_data:
+            item_override = JsonUtils.get_override(json_items_data)
+            if item_override is True:
+                raise ForbiddenOverride("{} datas do not support override flag !".format(type_element))
+            logger.info("json_item_data {}".format(json_item_data))
+            json_to_use = dict()
+            JsonUtils.copy_field_if_exists(json_item_data, json_to_use, "name", str)
+            JsonUtils.copy_field_if_exists(json_item_data, json_to_use, "description", str)
+            json_policy = dict()
+            # field_mandatory : not mandatory if there is some mandatory policies
+            JsonUtils.convert_name_to_id(json_item_data, json_policy, "policy", "policy_id", "policy",
+                                         PolicyManager, self._user_id, field_mandatory=len(mandatory_policy_ids) == 0)
+            logger.info("json_policy {}".format(json_policy))
+            json_category = dict()
+            JsonUtils.convert_name_to_id(json_item_data, json_category, "category", "category_id", type_element+"_category",
+                                         ModelManager, self._user_id)
+            logger.info("json_category {}".format(json_category))
+            policy_id = None
+            if "policy_id" in json_policy:
+                policy_id = json_policy["policy_id"]
+
+            if policy_id is not None and policy_id not in mandatory_policy_ids:
+                mandatory_policy_ids.append(policy_id)
+
+            if len(mandatory_policy_ids) == 0:
+                raise InvalidJson("Invalid data, the policy shall be set when importing {}".format(json_item_data))
+            category_id = None
+            if "category_id" in json_category:
+                category_id = json_category["category_id"]
+            if category_id is None:
+                raise InvalidJson("Invalid data, the category shall be set when importing {}".format(json_item_data))
+
+            for policy_id in mandatory_policy_ids:
+                try:
+                    # existing_datas = get_method(self._user_id, policy_id,category_id=category_id)
+                    # logger.info(existing_datas)
+                    logger.info("Adding / updating a {} data with policy id {} and category id {} from json {}".format(type_element, policy_id, category_id, json_to_use))
+                    data = import_method(self._user_id, policy_id,  category_id=category_id, value=json_to_use)
+                    logger.info("Added / updated {} data : {}".format(type_element, data))
+                except exceptions.PolicyUnknown:
+                    raise UnknownPolicy("Unknown policy with id {}".format(policy_id))
+                except Exception as e:
+                    raise BaseException(str(e))
+
+    def _import_subject_object_action_categories(self, json_item_categories, type_element):
+        import_method = getattr(ModelManager, 'add_' + type_element + '_category')
+        get_method = getattr(ModelManager, 'get_' + type_element + '_categories')
+
+        categories = get_method(self._user_id)
+
+        if not isinstance(json_item_categories, list):
+            raise InvalidJson(type_element + " categories shall be a list!")
+
+        for json_item_category in json_item_categories:
+            json_to_use = dict()
+            JsonUtils.copy_field_if_exists(json_item_category, json_to_use, "name", str)
+
+            # check if category with the same name exists : do this in moondb ?
+            existing_id = None
+            for category_key in categories:
+                if categories[category_key]["name"] == json_to_use["name"]:
+                    existing_id = category_key
+
+            JsonUtils.copy_field_if_exists(json_item_category, json_to_use, "description", str)
+            item_override = JsonUtils.get_override(json_item_category)
+            if item_override is True:
+                raise ForbiddenOverride("{} categories do not support override flag !".format(type_element))
+
+            try:
+                logger.info("Adding a {} category from json {}".format(type_element, json_to_use))
+                category = import_method(self._user_id, existing_id, json_to_use)
+                logger.info("Added category {}".format(category))
+            except (exceptions.SubjectCategoryExisting, exceptions.ObjectCategoryExisting, exceptions.ActionCategoryExisting):
+                # it already exists: do nothing
+                logger.info("Ignored {} category with name {} is already in the database".format(type_element, json_to_use["name"]))
+            except Exception as e:
+                logger.info("Error while importing the category : {}".format(str(e)))
+                raise e
+
+    def _import_subject_object_action(self, json_items, mandatory_policy_ids, type_element):
+        import_method = getattr(PolicyManager, 'add_' + type_element)
+        get_method = getattr(PolicyManager, 'get_' + type_element + 's')
+
+        if not isinstance(json_items, list):
+            raise InvalidJson(type_element + " items shall be a list!")
+
+        for json_item in json_items:
+            json_without_policy_name = dict()
+            JsonUtils.copy_field_if_exists(json_item, json_without_policy_name, "name", str)
+            JsonUtils.copy_field_if_exists(json_item, json_without_policy_name, "description", str)
+            JsonUtils.copy_field_if_exists(json_item, json_without_policy_name, "extra", dict)
+            JsonUtils.convert_names_to_ids(json_item, json_without_policy_name, "policies", "policy_list", "policy", PolicyManager, self._user_id, field_mandatory=False)
+            policy_ids = json_without_policy_name["policy_list"]
+            for mandatory_policy_id in mandatory_policy_ids:
+                if mandatory_policy_id not in policy_ids:
+                    policy_ids.append(mandatory_policy_id)
+                    # policy_ids and json_without_policy_name are references to the same array...
+                    # json_without_policy_name["policy_list"].append(mandatory_policy_id)
+
+            item_override = JsonUtils.get_override(json_item)
+            if item_override is True:
+                raise ForbiddenOverride("{} does not support override flag !".format(type_element))
+
+            if len(policy_ids) == 0:
+                raise MissingPolicy("a {} needs at least one policy to be created or updated : {}".format(type_element,  json.dumps(json_item)))
+
+            for policy_id in policy_ids:
+                try:
+                    items_in_db = get_method(self._user_id, policy_id)
+                    key = None
+                    for key_in_db in items_in_db:
+                        if items_in_db[key_in_db]["name"] == json_without_policy_name["name"]:
+                            key = key_in_db
+                            break
+                    if key is None:
+                        logger.info("Adding a {} from json {} to the policy with id {}".format(type_element, json_without_policy_name, policy_id))
+                    else:
+                        logger.info("Updating a {} from json {} to the policy with id {}".format(type_element, json_without_policy_name, policy_id))
+                    element = import_method(self._user_id, policy_id, perimeter_id=key, value=json_without_policy_name)
+                    logger.info("Added / updated {} : {}".format(type_element, element))
+
+                except exceptions.PolicyUnknown:
+                    raise UnknownPolicy("Unknown policy when adding a {}!".format(type_element))
+                except Exception as e:
+                    raise BaseException(str(e))
+
+    def _import_policies(self, json_policies):
+        policy_mandatory_ids = []
+
+        if not isinstance(json_policies, list):
+            raise InvalidJson("policies shall be a list!")
+
+        for json_policy in json_policies:
+            # TODO put this in moondb
+            # policy_in_db = PolicyManager.get_policies_by_name(json_without_model_name["name"])
+            policies = PolicyManager.get_policies(self._user_id)
+            policy_in_db = None
+            logger.info(policies)
+            for policy_key in policies:
+                if policies[policy_key]["name"] == json_policy["name"]:
+                    policy_in_db = policies[policy_key]
+                    policy_id = policy_key
+            # end TODO
+            if policy_in_db is None:
+                policy_does_exist = False
+            else:
+                policy_does_exist = True
+
+            policy_override = JsonUtils.get_override(json_policy)
+            policy_mandatory = JsonUtils.get_mandatory(json_policy)
+
+            if policy_override is False and policy_does_exist:
+                policy_mandatory_ids.append(policy_id)
+                logger.warning("Existing policy not updated because of the override option is not set !")
+                continue
+
+            json_without_model_name = dict()
+            JsonUtils.copy_field_if_exists(json_policy, json_without_model_name, "name", str)
+            JsonUtils.copy_field_if_exists(json_policy, json_without_model_name, "description", str)
+            JsonUtils.copy_field_if_exists(json_policy, json_without_model_name, "genre", str)
+            JsonUtils.convert_name_to_id(json_policy, json_without_model_name, "model", "model_id", "model", ModelManager, self._user_id, field_mandatory=False)
+
+            if not policy_does_exist:
+                logger.info("Creating policy {} ".format(json_without_model_name))
+                added_policy = PolicyManager.add_policy(self._user_id, None, json_without_model_name)
+                logger.info("Added policy {}".format(added_policy))
+                if policy_mandatory is True:
+                    keys = list(added_policy.keys())
+                    policy_mandatory_ids.append(keys[0])
+            elif policy_override is True:
+                logger.info("Updating policy {} ".format(json_without_model_name))
+                updated_policy = PolicyManager.update_policy(self._user_id, policy_id, json_without_model_name)
+                logger.info("Updated policy {}".format(updated_policy))
+                if policy_mandatory is True:
+                    policy_mandatory_ids.append(policy_id)
+        return policy_mandatory_ids
+
+    def _import_models_with_new_meta_rules(self, json_models):
+        if not isinstance(json_models, list):
+            raise InvalidJson("models shall be a list!")
+
+        for json_model in json_models:
+            logger.info("json_model {}".format(json_model))
+            models = ModelManager.get_models(self._user_id)
+            model_in_db = None
+            model_id = None
+            for model_key in models:
+                if ("id" in json_model and model_key == json_model["id"]) or ("name" in json_model and models[model_key]["name"] == json_model["name"]):
+                    model_in_db = models[model_key]
+                    model_id = model_key
+
+            logger.info("model in db".format(model_in_db))
+            # this should not occur as the model has been put in db previously in _import_models_without_new_meta_rules
+            if model_in_db is None:
+                raise UnknownModel("Unknwon model ")
+
+            json_key = dict()
+            JsonUtils.convert_names_to_ids(json_model, json_key, "meta_rules", "meta_rule_id", "meta_rule", ModelManager, self._user_id)
+            logger.info("json_key {}".format(json_key))
+            for meta_rule_id in json_key["meta_rule_id"]:
+                if meta_rule_id not in model_in_db["meta_rules"]:
+                    model_in_db["meta_rules"].append(meta_rule_id)
+
+            logger.info("Updating model with id {} : {} ".format(model_id, model_in_db))
+            ModelManager.update_model(self._user_id, model_id, model_in_db)
+
+    def _import_models_without_new_meta_rules(self, json_models):
+        if not isinstance(json_models, list):
+            raise InvalidJson("models shall be a list!")
+
+        for json_model in json_models:
+            json_without_new_metarules = dict()
+            JsonUtils.copy_field_if_exists(json_model, json_without_new_metarules, "name", str)
+
+            # TODO put this in moondb
+            # model_in_db = ModelManager.get_models_by_name(json_without_new_metarules["name"])
+            models = ModelManager.get_models(self._user_id)
+            model_in_db = None
+            for model_key in models:
+                if models[model_key]["name"] == json_without_new_metarules["name"]:
+                    model_in_db = models[model_key]
+                    model_id = model_key
+            # end TODO
+
+            JsonUtils.copy_field_if_exists(json_model, json_without_new_metarules, "description", str)
+            if model_in_db is None:
+                model_does_exist = False
+            else:
+                logger.info("model_in_db {}".format(model_in_db))
+                # JsonUtils.convert_names_to_ids(model_in_db, json_without_new_metarules, "meta_rules", "meta_rule_id", "meta_rule", ModelManager, self._user_id)
+                json_without_new_metarules["meta_rule_id"] = model_in_db["meta_rules"]
+                model_does_exist = True
+            model_override = JsonUtils.get_override(json_model)
+            if not model_does_exist:
+                logger.info("Creating model {} ".format(json_without_new_metarules))
+                ModelManager.add_model(self._user_id, None, json_without_new_metarules)
+            elif model_override is True:
+                logger.info("Updating model with id {} : {} ".format(model_id, json_without_new_metarules))
+                ModelManager.update_model(self._user_id, model_id, json_without_new_metarules)
+
+    def _import_pdps(self, json_pdps):
+        if not isinstance(json_pdps, list):
+            raise InvalidJson("pdps shall be a list!")
+
+        for json_pdp in json_pdps:
+            json_to_use = dict()
+            JsonUtils.copy_field_if_exists(json_pdp, json_to_use, "name", str)
+            JsonUtils.copy_field_if_exists(json_pdp, json_to_use, "keystone_project_id", str)
+            JsonUtils.copy_field_if_exists(json_pdp, json_to_use, "security_pipeline", list)
+            JsonUtils.copy_field_if_exists(json_pdp, json_to_use, "description", str)
+
+            pdps = PDPManager.get_pdp(self._user_id)
+            exists = False
+            for pdp_key in pdps:
+                if pdps[pdp_key]["name"] == json_to_use["name"]:
+                    PDPManager.update_pdp(self._user_id, pdp_id=pdp_key, value=json_to_use)
+                    exists = True
+            if exists is False:
+                PDPManager.add_pdp(self._user_id, value=json_to_use)
+
+    def _import_json(self, user_id):
+        self._user_id = user_id
+        if 'file' in request.files:
+            file = request.files['file']
+            logger.info("Importing {} file...".format(file))
+            json_content = json.load(file)
+        else:
+            json_content = request.json
+        logger.info("Importing content:  {} ...".format(json_content))
+
+        # first import the models without the meta rules as they are not yet defined
+        if "models" in json_content:
+            logger.info("Importing models...")
+            self._import_models_without_new_meta_rules(json_content["models"])
+
+        # import the policies that depends on the models
+        mandatory_policy_ids = []
+        if "policies" in json_content:
+            logger.info("Importing policies...")
+            mandatory_policy_ids = self._import_policies(json_content["policies"])
+
+        # import subjects, subject_data, subject_categories, idem for object and action
+        list_element = [{"key": "subject"}, {"key": "object"}, {"key": "action"}]
+        for elt in list_element:
+            in_key = elt["key"]
+            key = in_key + "s"
+            if key in json_content:
+                logger.info("Importing {}...".format(key))
+                self._import_subject_object_action(json_content[key], mandatory_policy_ids, in_key)
+            key = in_key + "_categories"
+            if key in json_content:
+                logger.info("Importing {}...".format(key))
+                self._import_subject_object_action_categories(json_content[key], in_key)
+            key = in_key + "_data"
+            if key in json_content:
+                logger.info("Importing {}...".format(key))
+                self._import_subject_object_action_datas(json_content[key], mandatory_policy_ids, in_key)
+
+        # import meta rules
+        if "meta_rules" in json_content:
+            logger.info("Importing meta rules...")
+            self._import_meta_rules(json_content["meta_rules"])
+
+        # add the metarule to model
+        if "models" in json_content:
+            logger.info("Updating models with meta rules...")
+            self._import_models_with_new_meta_rules(json_content["models"])
+
+        # import subjects assignments, idem for object and action
+        for elt in list_element:
+            in_key = elt["key"]
+            key = in_key + "_assignments"
+            if key in json_content:
+                logger.info("Importing {}...".format(key))
+                self._import_subject_object_action_assignments(json_content[key], in_key)
+
+        # import rules
+        if "rules" in json_content:
+            logger.info("Importing rules...")
+            self._import_rules(json_content["rules"])
+
+        # import pdps
+        if "pdps" in json_content:
+            logger.info("Importing pdps...")
+            self._import_pdps(json_content["pdps"])
+
+    @check_auth
+    def post(self, user_id=None):
+        """Import file.
+
+        :param user_id: user ID who do the request
+        :return: {
+
+        }
+        :internal_api:
+        """
+        self._import_json(user_id)
+        return "Import ok !"
diff --git a/moon_manager/moon_manager/api/json_utils.py b/moon_manager/moon_manager/api/json_utils.py
new file mode 100644
index 00000000..cc4c8b0f
--- /dev/null
+++ b/moon_manager/moon_manager/api/json_utils.py
@@ -0,0 +1,255 @@
+import logging
+from moon_manager.api.base_exception import BaseException
+
+logger = logging.getLogger("moon.manager.api." + __name__)
+
+
+class UnknownName(BaseException):
+    def __init__(self, message):
+
+        # Call the base class constructor with the parameters it needs
+        super(UnknownName, self).__init__(message)
+
+
+class UnknownId(BaseException):
+    def __init__(self, message):
+
+        # Call the base class constructor with the parameters it needs
+        super(UnknownId, self).__init__(message)
+
+
+class MissingIdOrName(BaseException):
+    def __init__(self, message):
+
+        # Call the base class constructor with the parameters it needs
+        super(MissingIdOrName, self).__init__(message)
+
+
+class UnknownField(BaseException):
+    def __init__(self, message):
+
+        # Call the base class constructor with the parameters it needs
+        super(UnknownField, self).__init__(message)
+
+
+class JsonUtils:
+    @staticmethod
+    def get_override(json_content):
+        if "override" in json_content:
+            return json_content["override"]
+        return False
+
+    @staticmethod
+    def get_mandatory(json_content):
+        if "mandatory" in json_content:
+            return json_content["mandatory"]
+        return False
+
+    @staticmethod
+    def copy_field_if_exists(json_in, json_out, field_name, type_field, default_value=None):
+        if field_name in json_in:
+            json_out[field_name] = json_in[field_name]
+        else:
+            if type_field is bool:
+                if default_value is None:
+                    default_value = False
+                json_out[field_name] = default_value
+            if type_field is str:
+                if default_value is None:
+                    default_value = ""
+                json_out[field_name] = default_value
+            if type_field is dict:
+                json_out[field_name] = dict()
+            if type_field is list:
+                json_out[field_name] = []
+
+    @staticmethod
+    def _get_element_in_db_from_id(element_type, element_id, user_id, policy_id, category_id, meta_rule_id, manager):
+        # the item is supposed to be in the db, we check it exists!
+        if element_type == "model":
+            data_db = manager.get_models(user_id, model_id=element_id)
+        elif element_type == "policy":
+            data_db = manager.get_policies(user_id, policy_id=element_id)
+        elif element_type == "subject":
+            data_db = manager.get_subjects(user_id, policy_id, perimeter_id=element_id)
+        elif element_type == "object":
+            data_db = manager.get_objects(user_id, policy_id, perimeter_id=element_id)
+        elif element_type == "action":
+            data_db = manager.get_actions(user_id, policy_id, perimeter_id=element_id)
+        elif element_type == "subject_category":
+            data_db = manager.get_subject_categories(user_id, category_id=element_id)
+        elif element_type == "object_category":
+            data_db = manager.get_object_categories(user_id, category_id=element_id)
+        elif element_type == "action_category":
+            data_db = manager.get_action_categories(user_id, category_id=element_id)
+        elif element_type == "meta_rule":
+            data_db = manager.get_meta_rules(user_id, meta_rule_id=element_id)
+        elif element_type == "subject_data":
+            data_db = manager.get_subject_data(user_id, policy_id, data_id=element_id, category_id=category_id)
+        elif element_type == "object_data":
+            data_db = manager.get_object_data(user_id, policy_id, data_id=element_id, category_id=category_id)
+        elif element_type == "action_data":
+            data_db = manager.get_action_data(user_id, policy_id, data_id=element_id, category_id=category_id)
+        elif element_type == "meta_rule":
+            data_db = manager.get_meta_rules(user_id, meta_rule_id=meta_rule_id)
+        else:
+            raise Exception("Conversion of {} not implemented yet!".format(element_type))
+
+        # logger.info(data_db)
+
+        # do some post processing ... the result should be {key : { .... .... } }
+        if element_type == "subject_data" or element_type == "object_data" or element_type == "action_data":
+            if data_db is not None and isinstance(data_db, list):
+                # TODO remove comments after fixing the bug on moondb when adding metarule : we can have several identical entries !
+                #if len(data_db) > 1:
+                #    raise Exception("Several {} with the same id : {}".format(element_type, data_db))
+                data_db = data_db[0]
+
+            if data_db is not None and data_db["data"] is not None and isinstance(data_db["data"], dict):
+                # TODO remove comments after fixing the bug on moondb when adding metarule : we can have several identical entries !
+                #if len(data_db["data"].values()) != 1:
+                #    raise Exception("Several {} with the same id : {}".format(element_type, data_db))
+                #data_db = data_db["data"]
+                # TODO remove these two lines after fixing the bug on moondb when adding metarule : we can have several identical entries !
+                list_values = list(data_db["data"].values())
+                data_db = list_values[0]
+            # logger.info("subject data after postprocessing {}".format(data_db))
+        return data_db
+
+    @staticmethod
+    def _get_element_id_in_db_from_name(element_type, element_name, user_id, policy_id, category_id, meta_rule_id, manager):
+        if element_type == "model":
+            data_db = manager.get_models(user_id)
+        elif element_type == "policy":
+            data_db = manager.get_policies(user_id)
+        elif element_type == "subject":
+            data_db = manager.get_subjects(user_id, policy_id)
+        elif element_type == "object":
+            data_db = manager.get_objects(user_id, policy_id)
+        elif element_type == "action":
+            data_db = manager.get_actions(user_id, policy_id)
+        elif element_type == "subject_category":
+            data_db = manager.get_subject_categories(user_id)
+        elif element_type == "object_category":
+            data_db = manager.get_object_categories(user_id)
+        elif element_type == "action_category":
+            data_db = manager.get_action_categories(user_id)
+        elif element_type == "meta_rule":
+            data_db = manager.get_meta_rules(user_id)
+        elif element_type == "subject_data":
+            data_db = manager.get_subject_data(user_id, policy_id, category_id=category_id)
+        elif element_type == "object_data":
+            data_db = manager.get_object_data(user_id, policy_id, category_id=category_id)
+        elif element_type == "action_data":
+            data_db = manager.get_action_data(user_id, policy_id, category_id=category_id)
+        elif element_type == "meta_rule":
+            data_db = manager.get_meta_rules(user_id)
+        elif element_type == "rule":
+            data_db = manager.get_rules(user_id, policy_id)
+        else:
+            raise BaseException("Conversion of {} not implemented yet!".format(element_type))
+
+        if isinstance(data_db, dict):
+            for key_id in data_db:
+                if isinstance(data_db[key_id], dict) and "name" in data_db[key_id]:
+                    if data_db[key_id]["name"] == element_name:
+                        return key_id
+        else:
+            for elt in data_db:
+                if isinstance(elt, dict) and "data" in elt: # we handle here subject_data, object_data and action_data...
+                    for data_key in elt["data"]:
+                        # logger.info("data from the db {} ".format(elt["data"][data_key]))
+                        data = elt["data"][data_key]
+                        if "name" in data and data["name"] == element_name:
+                            return data_key
+                        if "value" in data and data["value"]["name"] == element_name:
+                            return data_key
+        return None
+
+    @staticmethod
+    def convert_name_to_id(json_in, json_out, field_name_in, field_name_out, element_type, manager, user_id, policy_id=None, category_id=None, meta_rule_id=None, field_mandatory=True):
+        if field_name_in not in json_in:
+            raise UnknownField("The field {} is not in the input json".format(field_name_in))
+
+        if "id" in json_in[field_name_in]:
+            data_db = JsonUtils._get_element_in_db_from_id(element_type, json_in[field_name_in]["id"], user_id, policy_id, category_id, meta_rule_id, manager)
+            if data_db is None:
+                raise UnknownId("No {} with id {} found in database".format(element_type, json_in[field_name_in]["id"]))
+            json_out[field_name_out] = json_in[field_name_in]["id"]
+
+        elif "name" in json_in[field_name_in]:
+            id_in_db = JsonUtils._get_element_id_in_db_from_name(element_type, json_in[field_name_in]["name"], user_id, policy_id, category_id, meta_rule_id, manager)
+            if id_in_db is None:
+                raise UnknownName("No {} with name {} found in database".format(element_type,json_in[field_name_in]["name"]))
+            json_out[field_name_out] = id_in_db
+        elif field_mandatory is True:
+            raise MissingIdOrName("No id or name found in the input json {}".format(json_in))
+
+    @staticmethod
+    def convert_id_to_name(id_, json_out, field_name_out, element_type, manager, user_id,
+                           policy_id=None, category_id=None, meta_rule_id=None):
+        json_out[field_name_out] = {"name": JsonUtils.convert_id_to_name_string(id_, element_type, manager, user_id, policy_id, category_id, meta_rule_id)}
+
+    @staticmethod
+    def __convert_results_to_element(element):
+        if isinstance(element, dict) and "name" not in element and "value" not in element:
+            list_values = [v for v in element.values()]
+        elif isinstance(element, list):
+            list_values = element
+        else:
+            list_values = []
+            list_values.append(element)
+        return list_values[0]
+
+    @staticmethod
+    def convert_id_to_name_string(id_, element_type, manager, user_id,
+                           policy_id=None, category_id=None, meta_rule_id=None):
+
+        element = JsonUtils._get_element_in_db_from_id(element_type, id_, user_id, policy_id, category_id, meta_rule_id, manager)
+        # logger.info(element)
+        if element is None:
+            raise UnknownId("No {} with id {} found in database".format(element_type, id_))
+        res = JsonUtils.__convert_results_to_element(element)
+        # logger.info(res)
+        if "name" in res:
+            return res["name"]
+        if "value" in res and "name" in res["value"]:
+            return res["value"]["name"]
+        return None
+
+    @staticmethod
+    def convert_names_to_ids(json_in, json_out, field_name_in, field_name_out, element_type, manager, user_id, policy_id=None, category_id=None, meta_rule_id=None, field_mandatory=True):
+        ids = []
+        if field_name_in not in json_in:
+            raise UnknownField("The field {} is not in the input json".format(field_name_in))
+
+        for elt in json_in[field_name_in]:
+            if "id" in elt:
+                data_db = JsonUtils._get_element_in_db_from_id(element_type, elt["id"], user_id, policy_id, category_id, meta_rule_id, manager)
+                if data_db is None:
+                    raise UnknownId("No {} with id {} found in database".format(element_type, elt["id"]))
+                ids.append(elt["id"])
+            elif "name" in elt:
+                id_in_db = JsonUtils._get_element_id_in_db_from_name(element_type, elt["name"], user_id, policy_id, category_id, meta_rule_id, manager)
+                if id_in_db is None:
+                    raise UnknownName("No {} with name {} found in database".format(element_type, elt["name"]))
+                ids.append(id_in_db)
+            elif field_mandatory is True:
+                raise MissingIdOrName("No id or name found in the input json {}".format(elt))
+        json_out[field_name_out] = ids
+
+    @staticmethod
+    def convert_ids_to_names(ids, json_out, field_name_out, element_type, manager, user_id, policy_id=None, category_id=None, meta_rule_id=None):
+        res_array = []
+        for id_ in ids:
+            element = JsonUtils._get_element_in_db_from_id(element_type, id_, user_id, policy_id, category_id, meta_rule_id, manager)
+            if element is None:
+                raise UnknownId("No {} with id {} found in database".format(element_type, id_))
+            res = JsonUtils.__convert_results_to_element(element)
+            # logger.info(res)
+            if "name" in res:
+                res_array.append({"name": res["name"]})
+            if "value" in res and "name" in res["value"]:
+                res_array.append({"name": res["value"]["name"]})
+        json_out[field_name_out] = res_array
+
diff --git a/moon_manager/moon_manager/http_server.py b/moon_manager/moon_manager/http_server.py
index a98cab43..28d77ea0 100644
--- a/moon_manager/moon_manager/http_server.py
+++ b/moon_manager/moon_manager/http_server.py
@@ -2,10 +2,12 @@
 # This software is distributed under the terms and conditions of the 'Apache-2.0'
 # license which can be found in the file 'LICENSE' in this package distribution
 # or at 'http://www.apache.org/licenses/LICENSE-2.0'.
-
-from flask import Flask, jsonify
+from werkzeug.exceptions import HTTPException
+from flask import Flask, jsonify, Response, make_response
 from flask_cors import CORS, cross_origin
+from json import dumps
 from flask_restful import Resource, Api
+import flask_restful
 import logging
 import sqlalchemy.exc
 import time
@@ -21,7 +23,10 @@ from moon_manager.api.perimeter import Subjects, Objects, Actions
 from moon_manager.api.data import SubjectData, ObjectData, ActionData
 from moon_manager.api.assignments import SubjectAssignments, ObjectAssignments, ActionAssignments
 from moon_manager.api.rules import Rules
-from python_moonutilities import configuration, exceptions
+from moon_manager.api.json_import import JsonImport
+from moon_manager.api.base_exception import BaseException
+from moon_manager.api.json_export import JsonExport
+from python_moonutilities import configuration
 from python_moondb.core import PDPManager
 
 
@@ -33,7 +38,7 @@ __API__ = (
     Subjects, Objects, Actions, Rules,
     SubjectAssignments, ObjectAssignments, ActionAssignments,
     SubjectData, ObjectData, ActionData,
-    Models, Policies, PDP, Slaves
+    Models, Policies, PDP, Slaves, JsonImport, JsonExport
  )
 
 
@@ -105,31 +110,51 @@ class Root(Resource):
         }
 
 
-class HTTPServer(Server):
+class CustomApi(Api):
+
+    def handle_error(self, e):
+        try:
+            error_message = dumps({'message': str(e)})
+            logger.error(error_message)
+            return make_response(error_message, e.code)
+        except Exception as e2: # unhandled exception in the api...
+            logger.error(str(e2))
+            return make_response(error_message, 500)
+
 
+class HTTPServer(Server):
     def __init__(self, host="localhost", port=80, **kwargs):
         super(HTTPServer, self).__init__(host=host, port=port, **kwargs)
         self.app = Flask(__name__)
+        self.app.config['TRAP_HTTP_EXCEPTIONS'] = True
         conf = configuration.get_configuration("components/manager")
         self.manager_hostname = conf["components/manager"].get("hostname",
                                                                "manager")
         self.manager_port = conf["components/manager"].get("port", 80)
         # TODO : specify only few urls instead of *
         CORS(self.app)
-        self.api = Api(self.app)
+        self.api = CustomApi(self.app)
         self.__set_route()
-        self.__hook_errors()
-
-    def __hook_errors(self):
-
-        def get_404_json(e):
-            return jsonify({"result": False, "code": 404, "description": str(e)}), 404
-        self.app.register_error_handler(404, get_404_json)
-
-        def get_400_json(e):
-            return jsonify({"result": False, "code": 400, "description": str(e)}), 400
-        self.app.register_error_handler(400, lambda e: get_400_json)
-        self.app.register_error_handler(403, exceptions.AuthException)
+    #    self.__hook_errors()
+
+    #def __hook_errors(self):
+    #    def get_500_json(e):
+    #        logger.error("get_500_json")
+    #        return jsonify({"result": False, "code": 500, "description": str(e)}), 500
+    #    self.app.register_error_handler(JsonUtilsException, get_500_json)
+    #    self.app.register_error_handler(JsonImportException, get_500_json)
+    #    self.app.register_error_handler(UnknownName, get_500_json)
+
+    #    def get_404_json(e):
+    #        return jsonify({"result": False, "code": 404, "description": str(e)}), 404
+    #    self.app.register_error_handler(404, get_404_json)
+
+    #   def get_400_json(e):
+    #        return jsonify({"result": False, "code": 400, "description": str(e)}), 400
+
+    #    self.app.register_error_handler(500, lambda e: get_500_json)
+    #    self.app.register_error_handler(400, lambda e: get_400_json)
+    #    self.app.register_error_handler(403, exceptions.AuthException)
 
     def __set_route(self):
         self.api.add_resource(Root, '/')
diff --git a/moon_manager/moon_manager/server.py b/moon_manager/moon_manager/server.py
index 70ddaee0..a8db8fd5 100644
--- a/moon_manager/moon_manager/server.py
+++ b/moon_manager/moon_manager/server.py
@@ -7,6 +7,7 @@ import logging
 from python_moonutilities import configuration, exceptions
 from moon_manager.http_server import HTTPServer
 
+
 logger = logging.getLogger("moon.manager.server")
 
 
diff --git a/moon_manager/tests/functional_pod/json/mls.json b/moon_manager/tests/functional_pod/json/mls.json
new file mode 100644
index 00000000..d2a5c67c
--- /dev/null
+++ b/moon_manager/tests/functional_pod/json/mls.json
@@ -0,0 +1,89 @@
+{
+  "pdps": [{"name" : "pdp_mls", "keystone_project_id" : "", "description": "", "policies": [{"name": "MLS policy example"}]}],
+
+  "policies":[{ "name": "MLS policy example", "genre": "authz", "description": "", "model": {"name": "MLS"} , "mandatory" :false , "override":true}],
+
+  "models":[{"name":"MLS", "description":"","meta_rules": [{"name" : "mls"}], "override":true}],
+
+
+
+
+
+  "subjects": [{ "name":"adminuser", "description": "", "extra": {}, "policies": [{ "name": "MLS policy example"}]} ,
+               { "name": "user1", "description": "", "extra": {}, "policies": [{ "name": "MLS policy example"}] },
+               { "name": "user2", "description": "", "extra": {}, "policies": [{ "name": "MLS policy example"}] }],
+
+  "subject_categories": [{ "name":"subject-security-level", "description": "" }],
+
+  "subject_data": [{ "name":"low", "description": "", "policy": {"name" :"MLS policy example"}, "category": {"name": "subject-security-level"}},
+                   { "name":"medium", "description": "", "policy": {"name" :"MLS policy example"}, "category": {"name": "subject-security-level"}},
+                   { "name":"high",  "description": "", "policy": {"name" :"MLS policy example"}, "category": {"name": "subject-security-level"}}],
+
+  "subject_assignments":[{ "subject" : {"name": "adminuser"}, "category" : {"name": "subject-security-level"}, "assignments": [{"name" : "high"}]},
+                         { "subject" : {"name": "user1"}, "category" : {"name": "subject-security-level"}, "assignments": [{"name" : "medium"}] }],
+
+
+
+
+
+
+  "objects": [{ "name":"vm0", "description": "", "extra": {}, "policies": [{"name": "MLS policy example"}]} ,
+              {"name": "vm1", "description": "", "extra": {}, "policies": [{"name": "MLS policy example"}]} ],
+
+  "object_categories": [{"name":"object-security-level", "description": ""}],
+
+  "object_data": [{ "name":"low", "description": "", "policy": {"name" :"MLS policy example"}, "category": {"name": "object-security-level"}},
+                  { "name":"medium", "description": "", "policy": {"name" :"MLS policy example"}, "category": {"name": "object-security-level"}},
+                  { "name":"high",  "description": "", "policy": {"name" :"MLS policy example"}, "category": {"name": "object-security-level"}}],
+
+  "object_assignments":[{ "object" : {"name": "vm0"}, "category" : {"name": "object-security-level"}, "assignments": [{"name" : "medium"}]},
+                        { "object" : {"name": "vm1"}, "category" : {"name": "object-security-level"}, "assignments": [{"name" : "low"}]}],
+
+
+
+
+
+
+  "actions": [{ "name": "start", "description": "", "extra": {}, "policies": [{"name": "MLS policy example"}]} ,
+              { "name": "stop", "description": "", "extra": {}, "policies": [{"name": "MLS policy example"}]}],
+
+  "action_categories": [{"name":"action-type", "description": ""}],
+
+  "action_data": [{"name":"vm-action", "description": "", "policy": {"name": "MLS policy example"}, "category": {"name": "action-type"}},
+                  {"name":"storage-action", "description": "", "policy": {"name" :"MLS policy example"}, "category": {"name": "action-type"}}],
+
+  "action_assignments":[{ "action" : {"name": "start"}, "category" : {"name": "action-type"}, "assignments": [{"name" : "vm-action"}]},
+                        { "action" : {"name": "stop"}, "category" : {"name": "action-type"}, "assignments": [{"name" : "vm-action"}]}],
+
+
+
+
+
+
+  "meta_rules":[{"name":"mls", "description": "",
+    "subject_categories": [{"name": "subject-security-level"}],
+    "object_categories": [{"name": "object-security-level"}],
+    "action_categories": [{"name": "action-type"}]
+  }],
+
+  "rules": [{
+    "meta_rule": {"name" : "mls"},
+    "rule": {"subject_data" : [{"name":"high"}], "object_data": [{"name": "medium"}], "action_data": [{"name": "vm-action"}]},
+    "policy": {"name" :"MLS policy example"},
+    "instructions" : {"decision" : "grant"}
+  }, {
+    "meta_rule": {"name" : "mls"},
+    "rule": {"subject_data" : [{"name":"high"}], "object_data": [{"name": "low"}], "action_data":  [{"name": "vm-action"}]},
+    "policy": {"name" :"MLS policy example"},
+    "instructions" : {"decision" : "grant"}
+  }, {
+    "meta_rule": {"name" : "mls"},
+    "rule": {"subject_data" : [{"name":"medium"}], "object_data": [{"name": "low"}], "action_data":  [{"name": "vm-action"}]},
+    "policy": {"name" :"MLS policy example"},
+    "instructions" : {"decision" : "grant"}
+  }]
+
+
+
+
+}
\ No newline at end of file
diff --git a/moon_manager/tests/functional_pod/json/rbac.json b/moon_manager/tests/functional_pod/json/rbac.json
new file mode 100644
index 00000000..eddbb654
--- /dev/null
+++ b/moon_manager/tests/functional_pod/json/rbac.json
@@ -0,0 +1,85 @@
+{
+  "pdps": [{"name" : "pdp_rbac", "keystone_project_id" : "", "description": "", "policies": [{"name": "RBAC policy example"}]}],
+
+  "policies":[{ "name": "RBAC policy example", "genre": "authz", "description": "", "model": {"name": "RBAC"} , "mandatory" :true , "override":true}],
+
+  "models":[{"name":"RBAC", "description":"","meta_rules": [{"name" : "rbac"}], "override":true}],
+
+
+
+
+
+  "subjects": [{ "name":"adminuser", "description": "", "extra": {}, "policies": [{ "name": "RBAC policy example"}]} ,
+               { "name": "user1", "description": "", "extra": {}, "policies": [{ "name": "RBAC policy example"}] },
+               { "name": "public", "description": "", "extra": {}, "policies": [] }],
+
+  "subject_categories": [{ "name":"role", "description": "" }],
+
+  "subject_data": [{ "name":"admin", "description": "", "policy": {"name" :"RBAC policy example"}, "category": {"name": "role"}},
+                   { "name":"employee", "description": "", "policy": {"name" :"RBAC policy example"}, "category": {"name": "role"}},
+                   { "name":"*",  "description": "", "policy": {"name" :"RBAC policy example"}, "category": {"name": "role"}}],
+
+  "subject_assignments":[{ "subject" : {"name": "adminuser"}, "category" : {"name": "role"}, "assignments": [{"name" : "admin"}, {"name" : "employee"}, {"name" : "*"}]},
+                         { "subject" : {"name": "user1"}, "category" : {"name": "role"}, "assignments": [{"name" : "employee"}, {"name" : "*"}] }],
+
+
+
+
+
+
+  "objects": [{ "name":"vm0", "description": "", "extra": {}, "policies": [{"name": "RBAC policy example"}]} ,
+              {"name": "vm1", "description": "", "extra": {}, "policies": [{"name": "RBAC policy example"}]} ],
+
+  "object_categories": [{"name":"id", "description": ""}],
+
+  "object_data": [{ "name":"vm0", "description": "", "policy": {"name" :"RBAC policy example"}, "category": {"name": "id"}},
+                  { "name":"vm1", "description": "", "policy": {"name" :"RBAC policy example"}, "category": {"name": "id"}},
+                  { "name":"*",  "description": "", "policy": {"name" :"RBAC policy example"}, "category": {"name": "id"}}],
+
+  "object_assignments":[{ "object" : {"name": "vm0"}, "category" : {"name": "id"}, "assignments": [{"name" : "vm0"}, {"name" : "*"}]},
+                        { "object" : {"name": "vm1"}, "category" : {"name": "id"}, "assignments": [{"name" : "vm1"}, {"name" : "*"}]}],
+
+
+
+
+
+
+  "actions": [{ "name": "start", "description": "", "extra": {}, "policies": [{"name": "RBAC policy example"}]} ,
+              { "name": "stop", "description": "", "extra": {}, "policies": [{"name": "RBAC policy example"}]}],
+
+  "action_categories": [{"name":"action-type", "description": ""}],
+
+  "action_data": [{"name":"vm-action", "description": "", "policy": {"name": "RBAC policy example"}, "category": {"name": "action-type"}},
+                  {"name":"*", "description": "", "policy": {"name" :"RBAC policy example"}, "category": {"name": "action-type"}}],
+
+  "action_assignments":[{ "action" : {"name": "start"}, "category" : {"name": "action-type"}, "assignments": [{"name" : "vm-action"}, {"name" : "*"}]},
+                        { "action" : {"name": "stop"}, "category" : {"name": "action-type"}, "assignments": [{"name" : "vm-action"}, {"name" : "*"}]}],
+
+
+
+
+
+
+  "meta_rules":[{"name":"rbac", "description": "",
+    "subject_categories": [{"name": "role"}],
+    "object_categories": [{"name": "id"}],
+    "action_categories": [{"name": "action-type"}]
+  }],
+
+  "rules": [{
+    "meta_rule": {"name" : "rbac"},
+    "rule": {"subject_data" : [{"name":"admin"}], "object_data": [{"name": "vm0"}], "action_data": [{"name": "vm-action"}]},
+    "policy": {"name" :"RBAC policy example"},
+    "instructions" : {"decision" : "grant"},
+    "enabled": true
+  }, {
+    "meta_rule": {"name" : "rbac"},
+    "rule": {"subject_data" : [{"name":"employee"}], "object_data": [{"name": "vm1"}], "action_data":  [{"name": "vm-action"}]},
+    "policy": {"name" :"RBAC policy example"},
+    "instructions" : {"decision" : "grant"}
+  }]
+
+
+
+
+}
\ No newline at end of file
diff --git a/moon_manager/tests/functional_pod/test_manager.py b/moon_manager/tests/functional_pod/test_manager.py
index aab5fba4..454d861b 100644
--- a/moon_manager/tests/functional_pod/test_manager.py
+++ b/moon_manager/tests/functional_pod/test_manager.py
@@ -1,6 +1,45 @@
 import json
 import requests
 
+def test_import_rbac(context):
+    files = {'file': open('/data/tests/functional_pod/json/rbac.json', 'r')}
+    req = requests.post("http://{}:{}/import".format(
+        context.get("hostname"),
+        context.get("port"))
+        , files=files)
+    print(req)
+    result = req.json()
+    print(result)
+    req.raise_for_status()
+
+def test_import_mls(context):
+    files = {'file': open('/data/tests/functional_pod/json/mls.json', 'r')}
+    req = requests.post("http://{}:{}/import".format(
+        context.get("hostname"),
+        context.get("port"))
+        , files=files)
+    req.raise_for_status()
+
+
+def test_export_rbac(context):
+    test_import_rbac(context)
+    req = requests.get("http://{}:{}/export".format(
+       context.get("hostname"),
+       context.get("port")),
+       data={"filename":"/data/tests/functional_pod/json/rbac_export.json"}
+    )
+    req.raise_for_status()
+
+
+def test_export_mls(context):
+    test_import_mls(context)
+    req = requests.get("http://{}:{}/export".format(
+       context.get("hostname"),
+       context.get("port")),
+       data={"filename":"/data/tests/functional_pod/json/mls_export.json"}
+    )
+    req.raise_for_status()
+      
 
 def get_json(data):
     return json.loads(data.decode("utf-8"))
diff --git a/moon_manager/tests/unit_python/api/__init__.py b/moon_manager/tests/unit_python/api/__init__.py
deleted file mode 100644
index e69de29b..00000000
--- a/moon_manager/tests/unit_python/api/__init__.py
+++ /dev/null
diff --git a/moon_manager/tests/unit_python/api/import_export_utilities.py b/moon_manager/tests/unit_python/api/import_export_utilities.py
new file mode 100644
index 00000000..15c3e333
--- /dev/null
+++ b/moon_manager/tests/unit_python/api/import_export_utilities.py
@@ -0,0 +1,181 @@
+import api.utilities as utilities
+import api.test_models as test_models
+import api.test_policies as test_policies
+import api.test_perimeter as test_perimeter
+import api.meta_data_test as test_categories
+import api.test_data as test_data
+import api.meta_rules_test as test_meta_rules
+import api.test_assignemnt as test_assignments
+import api.test_rules as test_rules
+
+def clean_models(client):
+    req, models = test_models.get_models(client)
+    for key in models["models"]:
+        client.delete("/models/{}".format(key))
+        print("deleted model with id {}".format(key))
+
+
+def clean_policies(client):
+    req, policies = test_policies.get_policies(client)
+    for key in policies["policies"]:
+        req = client.delete("/policies/{}".format(key))
+        assert req.status_code == 200
+        print("deleted policy with id {}".format(key))
+
+
+def clean_subjects(client):
+    subjects = test_perimeter.get_subjects(client)
+    for key in subjects["subjects"]:
+        subject = subjects["subjects"][key]
+        policy_keys = subject["policy_list"]
+        for policy_key in policy_keys:
+            client.delete("/policies/{}/subjects/{}".format(policy_key,key))
+        client.delete("/subjects/{}".format(key))
+        print("deleted subject with id {}".format(key))
+
+
+def clean_objects(client):
+    objects = test_perimeter.get_objects(client)
+    for key in objects["objects"]:
+        object_ = objects["objects"][key]
+        policy_keys = object_["policy_list"]
+        for policy_key in policy_keys:
+            print("/policies/{}/objects/{}".format(policy_key, key))
+            req = client.delete("/policies/{}/objects/{}".format(policy_key, key))
+        client.delete("/objects/{}".format(key))
+        print("deleted object with id {}".format(key))
+
+
+def clean_actions(client):
+    actions = test_perimeter.get_actions(client)
+    for key in actions["actions"]:
+        action = actions["actions"][key]
+        policy_keys = action["policy_list"]
+        for policy_key in policy_keys:
+            client.delete("/policies/{}/actions/{}".format(policy_key, key))
+        client.delete("/actions/{}".format(key))
+        print("deleted action with id {}".format(key))
+
+
+def clean_subject_categories(client):
+    req, categories = test_categories.get_subject_categories(client)
+    print(categories)
+    for key in categories["subject_categories"]:
+        client.delete("/subject_categories/{}".format(key))
+
+
+def clean_object_categories(client):
+    req, categories = test_categories.get_object_categories(client)
+    for key in categories["object_categories"]:
+        client.delete("/object_categories/{}".format(key))
+
+
+def clean_action_categories(client):
+    req, categories = test_categories.get_action_categories(client)
+    for key in categories["action_categories"]:
+        client.delete("/action_categories/{}".format(key))
+
+
+def clean_subject_data(client):
+    req, policies = test_policies.get_policies(client)
+    for policy_key in policies["policies"]:
+        req, data = test_data.get_subject_data(client, policy_id=policy_key)
+        print(data)
+        for key in data["subject_data"]:
+            client.delete("/policies/{}/subject_data/{}".format(policy_key, key))
+
+
+def clean_object_data(client):
+    req, policies = test_policies.get_policies(client)
+    for policy_key in policies["policies"]:
+        req, data = test_data.get_object_data(client, policy_id=policy_key)
+        print(data)
+        for key in data["object_data"]:
+            client.delete("/policies/{}/object_data/{}".format(policy_key, key))
+
+
+def clean_action_data(client):
+    req, policies = test_policies.get_policies(client)
+    for policy_key in policies["policies"]:
+        req, data = test_data.get_action_data(client, policy_id=policy_key)
+        for key in data["action_data"]:
+            client.delete("/policies/{}/action_data/{}".format(policy_key, key))
+
+
+def clean_meta_rule(client):
+    req, meta_rules = test_meta_rules.get_meta_rules(client)
+    meta_rules = meta_rules["meta_rules"]
+    for meta_rule_key in meta_rules:
+        print(meta_rule_key)
+        client.delete("/meta_rules/{}".format(meta_rule_key))
+
+
+def clean_subject_assignments(client):
+    req, policies = test_policies.get_policies(client)
+    for policy_key in policies["policies"]:
+        req, assignments = test_assignments.get_subject_assignment(client, policy_key)
+        for key in assignments["subject_assignments"]:
+            subject_key = assignments["subject_assignments"][key]["subject_id"]
+            cat_key = assignments["subject_assignments"][key]["category_id"]
+            data_keys = assignments["subject_assignments"][key]["assignments"]
+            for data_key in data_keys:
+                req = client.delete("/policies/{}/subject_assignments/{}/{}/{}".format(policy_key, subject_key, cat_key, data_key))
+
+
+def clean_object_assignments(client):
+    req, policies = test_policies.get_policies(client)
+    for policy_key in policies["policies"]:
+        req, assignments = test_assignments.get_object_assignment(client, policy_key)
+        for key in assignments["object_assignments"]:
+            object_key = assignments["object_assignments"][key]["object_id"]
+            cat_key = assignments["object_assignments"][key]["category_id"]
+            data_keys = assignments["object_assignments"][key]["assignments"]
+            for data_key in data_keys:
+                req = client.delete("/policies/{}/object_assignments/{}/{}/{}".format(policy_key, object_key, cat_key, data_key))
+
+
+def clean_action_assignments(client):
+    req, policies = test_policies.get_policies(client)
+    for policy_key in policies["policies"]:
+        req, assignments = test_assignments.get_action_assignment(client, policy_key)
+        for key in assignments["action_assignments"]:
+            action_key = assignments["action_assignments"][key]["action_id"]
+            cat_key = assignments["action_assignments"][key]["category_id"]
+            data_keys = assignments["action_assignments"][key]["assignments"]
+            for data_key in data_keys:
+                req = client.delete("/policies/{}/action_assignments/{}/{}/{}".format(policy_key, action_key, cat_key, data_key))
+
+
+def clean_rules(client):
+    req, policies = test_policies.get_policies(client)
+    for policy_key in policies["policies"]:
+        req, rules = test_rules.get_rules(client, policy_key)
+        print(rules)
+        rules = rules["rules"]
+        rules = rules["rules"]
+        for rule_key in rules:
+            client.delete("/policies/{}/rules/{}".format(policy_key, rule_key))
+
+
+def clean_all(client):
+    clean_rules(client)
+
+    clean_subject_assignments(client)
+    clean_object_assignments(client)
+    clean_action_assignments(client)
+
+    clean_meta_rule(client)
+
+    clean_subject_categories(client)
+    clean_object_categories(client)
+    clean_action_categories(client)
+
+    clean_subject_data(client)
+    clean_object_data(client)
+    clean_action_data(client)
+
+    clean_policies(client)
+    clean_models(client)
+    clean_actions(client)
+    clean_objects(client)
+    clean_subjects(client)
diff --git a/moon_manager/tests/unit_python/api/meta_data_test.py b/moon_manager/tests/unit_python/api/meta_data_test.py
index 8fb39ae1..0d67a8cd 100644
--- a/moon_manager/tests/unit_python/api/meta_data_test.py
+++ b/moon_manager/tests/unit_python/api/meta_data_test.py
@@ -193,4 +193,4 @@ def test_delete_action_categories():
 def test_delete_action_categories_without_id():
     client = utilities.register_client()
     req = delete_action_categories_without_id(client)
-    assert req.status_code == 500
\ No newline at end of file
+    assert req.status_code == 500
diff --git a/moon_manager/tests/unit_python/api/test_assignemnt.py b/moon_manager/tests/unit_python/api/test_assignemnt.py
index 08688e04..9fd83857 100644
--- a/moon_manager/tests/unit_python/api/test_assignemnt.py
+++ b/moon_manager/tests/unit_python/api/test_assignemnt.py
@@ -28,15 +28,6 @@ def delete_subject_assignment(client, policy_id):
     return req
 
 
-def test_get_subject_assignment():
-    policy_id = utilities.get_policy_id()
-    client = utilities.register_client()
-    req, subject_assignment = get_subject_assignment(client, policy_id)
-    assert req.status_code == 200
-    assert isinstance(subject_assignment, dict)
-    assert "subject_assignments" in subject_assignment
-
-
 def test_add_subject_assignment():
     policy_id = utilities.get_policy_id()
     client = utilities.register_client()
@@ -51,6 +42,15 @@ def test_add_subject_assignment():
     assert value[id]['subject_id'] == "id1"
 
 
+def test_get_subject_assignment():
+    policy_id = utilities.get_policy_id()
+    client = utilities.register_client()
+    req, subject_assignment = get_subject_assignment(client, policy_id)
+    assert req.status_code == 200
+    assert isinstance(subject_assignment, dict)
+    assert "subject_assignments" in subject_assignment
+
+
 def test_delete_subject_assignment():
     client = utilities.register_client()
     policy_id = utilities.get_policy_id()
diff --git a/moon_manager/tests/unit_python/api/test_data.py b/moon_manager/tests/unit_python/api/test_data.py
index 714414bb..f636aaa5 100644
--- a/moon_manager/tests/unit_python/api/test_data.py
+++ b/moon_manager/tests/unit_python/api/test_data.py
@@ -5,8 +5,11 @@ import json
 # subject_categories_test
 
 
-def get_subject_data(client, policy_id):
-    req = client.get("/policies/{}/subject_data".format(policy_id))
+def get_subject_data(client, policy_id, category_id=None):
+    if category_id is None:
+        req = client.get("/policies/{}/subject_data".format(policy_id))
+    else:
+        req = client.get("/policies/{}/subject_data/{}".format(policy_id, category_id))
     subject_data = utilities.get_json(req.data)
     return req, subject_data
 
@@ -60,8 +63,11 @@ def test_delete_subject_data():
 # object_categories_test
 
 
-def get_object_data(client, policy_id):
-    req = client.get("/policies/{}/object_data".format(policy_id))
+def get_object_data(client, policy_id, category_id=None):
+    if category_id is None:
+        req = client.get("/policies/{}/object_data".format(policy_id))
+    else:
+        req = client.get("/policies/{}/object_data/{}".format(policy_id, category_id))
     object_data = utilities.get_json(req.data)
     return req, object_data
 
@@ -115,8 +121,11 @@ def test_delete_object_data():
 # action_categories_test
 
 
-def get_action_data(client, policy_id):
-    req = client.get("/policies/{}/action_data".format(policy_id))
+def get_action_data(client, policy_id, category_id=None):
+    if category_id is None:
+        req = client.get("/policies/{}/action_data".format(policy_id))
+    else:
+        req = client.get("/policies/{}/action_data/{}".format(policy_id, category_id))
     action_data = utilities.get_json(req.data)
     return req, action_data
 
diff --git a/moon_manager/tests/unit_python/api/test_export.py b/moon_manager/tests/unit_python/api/test_export.py
new file mode 100644
index 00000000..25097180
--- /dev/null
+++ b/moon_manager/tests/unit_python/api/test_export.py
@@ -0,0 +1,284 @@
+import json
+import api.utilities as utilities
+import api.import_export_utilities as import_export_utilities
+
+
+MODEL_WITHOUT_META_RULES = {"models": [{"name": "test model", "description": "model description", "meta_rules": []}]}
+
+POLICIES = {"models": [{"name": "test model", "description": "", "meta_rules": []}],
+            "policies": [{"name": "test policy", "genre": "authz", "description": "policy description", "model": {"name" : "test model"}}]}
+
+SUBJECTS_OBJECTS_ACTIONS = {"models": [{"name": "test model", "description": "", "meta_rules": []}],
+                            "policies": [{"name": "test policy", "genre": "authz", "description": "policy description", "model": {"name" : "test model"}}],
+                            "subjects": [{"name": "testuser", "description": "description of the subject", "extra": {"field_extra_subject": "value extra subject"}, "policies": [{"name": "test policy"}]}],
+                            "objects": [{"name": "test object", "description": "description of the object", "extra": {"field_extra_object": "value extra object"}, "policies": [{"name": "test policy"}]}],
+                            "actions": [{"name": "test action", "description": "description of the action", "extra": {"field_extra_action": "value extra action"}, "policies": [{"name": "test policy"}]}]}
+
+
+SUBJECT_OBJECT_ACTION_CATEGORIES = {"subject_categories": [{"name": "test subject categories", "description": "subject category description"}],
+                                    "object_categories": [{"name": "test object categories", "description": "object category description"}],
+                                    "action_categories": [{"name": "test action categories", "description": "action category description"}]}
+
+SUBJECT_OBJECT_ACTION_DATA = {"models": [{"name": "test model", "description": "", "meta_rules": [{"name": "meta rule"}]}],
+                            "policies": [{"name": "test policy", "genre": "authz", "description": "policy description", "model": {"name" : "test model"}}],
+                            "subject_categories": [{"name": "test subject categories", "description": "subject category description"}],
+                            "object_categories": [{"name": "test object categories", "description": "object category description"}],
+                            "action_categories": [{"name": "test action categories", "description": "action category description"}],
+                            "subject_data": [{"name": "test subject data", "description": "subject data description", "policy": {"name": "test policy"}, "category": {"name": "test subject categories"}}],
+                            "object_data": [{"name": "test object data", "description": "object data description", "policy": {"name": "test policy"}, "category": {"name": "test object categories"}}],
+                            "action_data": [{"name": "test action data", "description": "action data description", "policy": {"name": "test policy"}, "category": {"name": "test action categories"}}],
+                            "meta_rules": [{"name": "meta rule", "description": "valid meta rule", "subject_categories": [{"name": "test subject categories"}], "object_categories": [{"name": "test object categories"}], "action_categories": [{"name": "test action categories"}]}]}
+
+
+META_RULES = {"subject_categories": [{"name": "test subject categories", "description": "subject category description"}],
+              "object_categories": [{"name": "test object categories", "description": "object category description"}],
+              "action_categories": [{"name": "test action categories", "description": "object action description"}],
+              "meta_rules": [{"name": "meta rule", "description": "valid meta rule", "subject_categories": [{"name": "test subject categories"}], "object_categories": [{"name": "test object categories"}], "action_categories": [{"name": "test action categories"}]}]}
+
+
+ASSIGNMENTS = {"models": [{"name": "test model", "description": "", "meta_rules": [{"name": "meta rule"}]}],
+               "policies": [{"name": "test policy", "genre": "authz", "description": "policy description", "model": {"name" : "test model"}}],
+               "subject_categories": [{"name": "test subject categories", "description": "subject category description"}],
+               "object_categories": [{"name": "test object categories", "description": "object category description"}],
+               "action_categories": [{"name": "test action categories", "description": "action category description"}],
+               "subject_data": [{"name": "test subject data", "description": "subject data description", "policy": {"name": "test policy"}, "category": {"name": "test subject categories"}}],
+               "object_data": [{"name": "test object data", "description": "object data description", "policy": {"name": "test policy"}, "category": {"name": "test object categories"}}],
+               "action_data": [{"name": "test action data", "description": "action data description", "policy": {"name": "test policy"}, "category": {"name": "test action categories"}}],
+               "meta_rules": [{"name": "meta rule", "description": "valid meta rule", "subject_categories": [{"name": "test subject categories"}], "object_categories": [{"name": "test object categories"}], "action_categories": [{"name": "test action categories"}]}],
+               "subjects": [{"name": "testuser", "description": "description of the subject", "extra": {"field_extra_subject": "value extra subject"}, "policies": [{"name": "test policy"}]}],
+               "objects": [{"name": "test object", "description": "description of the object", "extra": {"field_extra_object": "value extra object"}, "policies": [{"name": "test policy"}]}],
+               "actions": [{"name": "test action", "description": "description of the action", "extra": {"field_extra_action": "value extra action"}, "policies": [{"name": "test policy"}]}],
+               "subject_assignments": [{"subject": {"name": "testuser"}, "category": {"name": "test subject categories"}, "assignments": [{"name": "test subject data"}]}],
+               "object_assignments": [{"object": {"name": "test object"}, "category": {"name": "test object categories"}, "assignments": [{"name": "test object data"}]}],
+               "action_assignments": [{"action": {"name": "test action"}, "category": {"name": "test action categories"}, "assignments": [{"name": "test action data"}]}]}
+
+RULES = {"models": [{"name": "test model", "description": "", "meta_rules": [{"name": "meta rule"}]}],
+         "policies": [{"name": "test policy", "genre": "authz", "description": "policy description", "model": {"name" : "test model"}}],
+         "subject_categories": [{"name": "test subject categories", "description": "subject category description"}],
+         "object_categories": [{"name": "test object categories", "description": "object category description"}],
+         "action_categories": [{"name": "test action categories", "description": "action category description"}],
+         "subject_data": [{"name": "test subject data", "description": "subject data description", "policy": {"name": "test policy"}, "category": {"name": "test subject categories"}}],
+         "object_data": [{"name": "test object data", "description": "object data description", "policy": {"name": "test policy"}, "category": {"name": "test object categories"}}],
+         "action_data": [{"name": "test action data", "description": "action data description", "policy": {"name": "test policy"}, "category": {"name": "test action categories"}}],
+         "meta_rules": [{"name": "meta rule", "description": "valid meta rule", "subject_categories": [{"name": "test subject categories"}], "object_categories": [{"name": "test object categories"}], "action_categories": [{"name": "test action categories"}]}],
+         "subjects": [{"name": "testuser", "description": "description of the subject", "extra": {"field_extra_subject": "value extra subject"}, "policies": [{"name": "test policy"}]}],
+         "objects": [{"name": "test object", "description": "description of the object", "extra": {"field_extra_object": "value extra object"}, "policies": [{"name": "test policy"}]}],
+         "actions": [{"name": "test action", "description": "description of the action", "extra": {"field_extra_action": "value extra action"}, "policies": [{"name": "test policy"}]}],
+         "subject_assignments": [{"subject": {"name": "testuser"}, "category": {"name": "test subject categories"}, "assignments": [{"name": "test subject data"}]}],
+         "object_assignments": [{"object": {"name": "test object"}, "category": {"name": "test object categories"}, "assignments": [{"name": "test object data"}]}],
+         "action_assignments": [{"action": {"name": "test action"}, "category": {"name": "test action categories"}, "assignments": [{"name": "test action data"}]}],
+         "rules": [{"meta_rule": {"name" : "meta rule"}, "rule": {"subject_data" : [{"name":"test subject data"}], "object_data": [{"name": "test object data"}], "action_data": [{"name": "test action data"}]}, "policy": {"name" :"test policy"}, "instructions" : {"decision" : "grant"}, "enabled": True}]
+        }
+
+
+def test_export_models():
+    client = utilities.register_client()
+    import_export_utilities.clean_all(client)
+    req = client.post("/import", content_type='application/json', data=json.dumps(MODEL_WITHOUT_META_RULES))
+    data = utilities.get_json(req.data)
+    assert data == "Import ok !"
+
+    req = client.get("/export")
+    assert req.status_code == 200
+    data = utilities.get_json(req.data)
+
+    print(data)
+    assert "content" in data
+    assert "models" in data["content"]
+    assert isinstance(data["content"]["models"], list)
+    assert len(data["content"]["models"]) == 1
+    model = data["content"]["models"][0]
+    assert model["name"] == "test model"
+    assert model["description"] == "model description"
+    assert isinstance(model["meta_rules"], list)
+    assert len(model["meta_rules"]) == 0
+
+
+def test_export_policies():
+    client = utilities.register_client()
+    import_export_utilities.clean_all(client)
+    req = client.post("/import", content_type='application/json', data=json.dumps(POLICIES))
+    data = utilities.get_json(req.data)
+    assert data == "Import ok !"
+
+    req = client.get("/export")
+    assert req.status_code == 200
+    data = utilities.get_json(req.data)
+
+    print(data)
+    assert "content" in data
+    assert "policies" in data["content"]
+    assert isinstance(data["content"]["policies"], list)
+    assert len(data["content"]["policies"]) == 1
+    policy = data["content"]["policies"][0]
+    assert policy["name"] == "test policy"
+    assert policy["genre"] == "authz"
+    assert policy["description"] == "policy description"
+    assert "model" in policy
+    assert "name" in policy["model"]
+    model = policy["model"]
+    assert model["name"] == "test model"
+
+
+def test_export_subject_object_action():
+    client = utilities.register_client()
+    import_export_utilities.clean_all(client)
+    req = client.post("/import", content_type='application/json', data=json.dumps(SUBJECTS_OBJECTS_ACTIONS))
+    data = utilities.get_json(req.data)
+    assert data == "Import ok !"
+
+    req = client.get("/export")
+    assert req.status_code == 200
+    data = utilities.get_json(req.data)
+
+    print(data)
+    assert "content" in data
+    type_elements = ["subject", "object", "action"]
+    for type_element in type_elements:
+        key = type_element + "s"
+        assert key in data["content"]
+        assert isinstance(data["content"][key], list)
+        assert len(data["content"][key]) == 1
+        element = data["content"][key][0]
+        if type_element == "subject":
+            assert element["name"] == "testuser"
+        else:
+            assert element["name"] == "test "+ type_element
+        assert element["description"] == "description of the " + type_element
+        assert "policies" in element
+        assert isinstance(element["policies"], list)
+        assert len(element["policies"]) == 1
+        assert isinstance(element["policies"][0], dict)
+        assert element["policies"][0]["name"] == "test policy"
+        assert isinstance(element["extra"], dict)
+        key_dict = "field_extra_" + type_element
+        value_dict = "value extra " + type_element
+        #TODO change this after bug fix on extra
+        if False:
+            assert key_dict in element["extra"]
+            assert element["extra"][key_dict] == value_dict
+
+
+def test_export_subject_object_action_categories():
+    client = utilities.register_client()
+    import_export_utilities.clean_all(client)
+    req = client.post("/import", content_type='application/json', data=json.dumps(SUBJECT_OBJECT_ACTION_CATEGORIES))
+    data = utilities.get_json(req.data)
+    assert data == "Import ok !"
+
+    req = client.get("/export")
+    assert req.status_code == 200
+    data = utilities.get_json(req.data)
+    print(data)
+    assert "content" in data
+    type_elements = ["subject", "object", "action"]
+    for type_element in type_elements:
+        key = type_element + "_categories"
+        assert key in data["content"]
+        assert isinstance(data["content"][key], list)
+        assert len(data["content"][key]) == 1
+        category = data["content"][key][0]
+        assert category["name"] == "test " + type_element + " categories"
+        assert category["description"] == type_element + " category description"
+
+
+def test_export_subject_object_action_data():
+    client = utilities.register_client()
+    import_export_utilities.clean_all(client)
+    req = client.post("/import", content_type='application/json', data=json.dumps(SUBJECT_OBJECT_ACTION_DATA))
+    data = utilities.get_json(req.data)
+    assert data == "Import ok !"
+
+    req = client.get("/export")
+    assert req.status_code == 200
+    data = utilities.get_json(req.data)
+    print(data)
+    assert "content" in data
+    type_elements = ["subject", "object", "action"]
+    for type_element in type_elements:
+        key = type_element + "_data"
+        assert key in data["content"]
+        assert isinstance(data["content"][key], list)
+        assert len(data["content"][key]) == 1
+        data_elt = data["content"][key][0]
+        assert data_elt["name"] == "test " + type_element + " data"
+        assert data_elt["description"] == type_element + " data description"
+        assert isinstance(data_elt["policy"],dict)
+        assert data_elt["policy"]["name"] == "test policy"
+        assert isinstance(data_elt["category"],dict)
+        assert data_elt["category"]["name"] == "test " + type_element + " categories"
+
+
+def test_export_assignments():
+    client = utilities.register_client()
+    import_export_utilities.clean_all(client)
+    req = client.post("/import", content_type='application/json', data=json.dumps(ASSIGNMENTS))
+    data = utilities.get_json(req.data)
+    assert data == "Import ok !"
+
+    req = client.get("/export")
+    assert req.status_code == 200
+    data = utilities.get_json(req.data)
+    print(data)
+    assert "content" in data
+    type_elements = ["subject", "object", "action"]
+    for type_element in type_elements:
+        key = type_element + "_assignments"
+        assert key in data["content"]
+        assert isinstance(data["content"][key], list)
+        assert len(data["content"][key]) == 1
+        assignment_elt = data["content"][key][0]
+        assert type_element in assignment_elt
+        assert isinstance(assignment_elt[type_element], dict)
+        if type_element == "subject":
+            assert assignment_elt[type_element]["name"] == "testuser"
+        else:
+            assert assignment_elt[type_element]["name"] == "test " + type_element
+        assert "category" in assignment_elt
+        assert isinstance(assignment_elt["category"], dict)
+        assert assignment_elt["category"]["name"] == "test " + type_element + " categories"
+        assert "assignments" in assignment_elt
+        assert isinstance(assignment_elt["assignments"], list)
+        assert len(assignment_elt["assignments"]) == 1
+        assert assignment_elt["assignments"][0]["name"] == "test " + type_element + " data"
+
+
+def test_export_rules():
+    client = utilities.register_client()
+    import_export_utilities.clean_all(client)
+    req = client.post("/import", content_type='application/json', data=json.dumps(RULES))
+    data = utilities.get_json(req.data)
+    assert data == "Import ok !"
+
+    req = client.get("/export")
+    assert req.status_code == 200
+    data = utilities.get_json(req.data)
+    print(data)
+    assert "content" in data
+    assert "rules" in data["content"]
+    assert isinstance(data["content"]["rules"], list)
+    assert len(data["content"]["rules"]) == 1
+    rule = data["content"]["rules"][0]
+    assert "instructions" in rule
+    assert "decision" in rule["instructions"]
+    assert rule["instructions"]["decision"] == "grant"
+    assert "enabled" in rule
+    assert rule["enabled"] == True
+    assert "meta_rule" in rule
+    assert rule["meta_rule"]["name"] == "meta rule"
+    assert "policy" in rule
+    assert rule["policy"]["name"] == "test policy"
+    assert "rule" in rule
+    rule = rule["rule"]
+    assert "subject_data" in rule
+    assert isinstance(rule["subject_data"], list)
+    assert len(rule["subject_data"]) == 1
+    assert rule["subject_data"][0]["name"] == "test subject data"
+    assert "object_data" in rule
+    assert isinstance(rule["object_data"], list)
+    assert len(rule["object_data"]) == 1
+    assert rule["object_data"][0]["name"] == "test object data"
+    assert "action_data" in rule
+    assert isinstance(rule["action_data"], list)
+    assert len(rule["action_data"]) == 1
+    assert rule["action_data"][0]["name"] == "test action data"
diff --git a/moon_manager/tests/unit_python/api/test_import.py b/moon_manager/tests/unit_python/api/test_import.py
new file mode 100644
index 00000000..ef2267ed
--- /dev/null
+++ b/moon_manager/tests/unit_python/api/test_import.py
@@ -0,0 +1,515 @@
+import api.utilities as utilities
+import api.test_models as test_models
+import api.test_policies as test_policies
+import api.test_perimeter as test_perimeter
+import api.meta_data_test as test_categories
+import api.test_data as test_data
+import api.meta_rules_test as test_meta_rules
+import api.test_assignemnt as test_assignments
+import api.test_rules as test_rules
+import api.import_export_utilities as import_export_utilities
+
+import json
+
+
+MODEL_WITHOUT_META_RULES = [
+        {"models": [{"name": "test model", "description": "", "meta_rules": []}]},
+        {"models": [{"name": "test model", "description": "new description", "meta_rules": [], "override": True}]},
+        {"models": [{"name": "test model", "description": "description not taken into account", "meta_rules": [], "override": False}]}
+    ]
+
+POLICIES = [
+    {"policies": [{"name": "test policy", "genre": "authz", "description": "description", "model": {}, "mandatory": False}]},
+    {"policies": [{"name": "test policy", "genre": "authz", "description": "new description not taken into account", "model": {"name" : "test model"}, "mandatory": True}]},
+    {"policies": [{"name": "test policy", "genre": "not authz ?", "description": "generates an exception", "model": {"name" : "test model"}, "override": True}]},
+    {"models": [{"name": "test model", "description": "", "meta_rules": []}], "policies": [{"name": "test policy", "genre": "not authz ?", "description": "changes taken into account", "model": {"name" : "test model"}, "override": True}]},
+]
+
+SUBJECTS = [{"subjects": [{"name": "testuser", "description": "description of the subject", "extra": {}, "policies": []}]},
+            {"policies": [{"name": "test policy", "genre": "authz", "description": "description", "model": {}, "mandatory": False}], "subjects": [{"name": "testuser", "description": "description of the subject", "extra": {}, "policies": []}]},
+            {"policies": [{"name": "test other policy", "genre": "authz", "description": "description", "model": {}, "mandatory": True}], "subjects": [{"name": "testuser", "description": "description of the subject", "extra": {}, "policies": []}]},
+            {"subjects": [{"name": "testuser", "description": "new description of the subject", "extra": {"email": "new-email@test.com"}, "policies": [{"name": "test other policy"}]}]},
+            {"policies": [{"name": "test policy", "genre": "authz", "description": "description", "model": {}, "mandatory": False}], "subjects": [{"name": "testuser", "description": "description of the subject", "extra": {}, "policies": [{"name": "test policy"}]}]}]
+
+
+OBJECTS = [{"objects": [{"name": "test object", "description": "description of the object", "extra": {}, "policies": []}]},
+           {"policies": [{"name": "test policy", "genre": "authz", "description": "description", "model": {}, "mandatory": False}], "objects": [{"name": "test object", "description": "description of the object", "extra": {}, "policies": []}]},
+           {"policies": [{"name": "test other policy", "genre": "authz", "description": "description", "model": {}, "mandatory": True}], "objects": [{"name": "test object", "description": "description of the object", "extra": {}, "policies": []}]},
+           {"objects": [{"name": "test object", "description": "new description of the object", "extra": {"test": "test extra"}, "policies": [{"name": "test other policy"}]}]},
+           {"policies": [{"name": "test policy", "genre": "authz", "description": "description", "model": {}, "mandatory": False}], "objects": [{"name": "test object", "description": "description of the object", "extra": {}, "policies": [{"name": "test policy"}]}]}]
+
+
+ACTIONS = [{"actions": [{"name": "test action", "description": "description of the action", "extra": {}, "policies": []}]},
+           {"policies": [{"name": "test policy", "genre": "authz", "description": "description", "model": {}, "mandatory": False}], "actions": [{"name": "test action", "description": "description of the action", "extra": {}, "policies": []}]},
+           {"policies": [{"name": "test other policy", "genre": "authz", "description": "description", "model": {}, "mandatory": True}], "actions": [{"name": "test action", "description": "description of the action", "extra": {}, "policies": []}]},
+           {"actions": [{"name": "test action", "description": "new description of the action", "extra": {"test": "test extra"}, "policies": [{"name": "test other policy"}]}]},
+           {"policies": [{"name": "test policy", "genre": "authz", "description": "description", "model": {}, "mandatory": False}], "actions": [{"name": "test action", "description": "description of the action", "extra": {}, "policies": [{"name": "test policy"}]}]}]
+
+
+SUBJECT_CATEGORIES = [{"subject_categories": [{"name": "test subject categories", "description": "subject category description"}]},
+                      {"subject_categories": [{"name": "test subject categories", "description": "new subject category description"}]}]
+
+
+OBJECT_CATEGORIES = [{"object_categories": [{"name": "test object categories", "description": "object category description"}]},
+                     {"object_categories": [{"name": "test object categories", "description": "new object category description"}]}]
+
+
+ACTION_CATEGORIES = [{"action_categories": [{"name": "test action categories", "description": "action category description"}]},
+                     {"action_categories": [{"name": "test action categories", "description": "new action category description"}]}]
+
+# meta_rules import is needed otherwise the search for data do not work !!!
+PRE_DATA = {"models": [{"name": "test model", "description": "", "meta_rules": [{"name": "good meta rule"}, {"name": "other good meta rule"}]}],
+            "policies": [{"name": "test other policy", "genre": "authz", "description": "description", "model": {"name": "test model"}, "mandatory": True}],
+            "subject_categories": [{"name": "test subject categories", "description": "subject category description"}, {"name": "other test subject categories", "description": "subject category description"}],
+            "object_categories": [{"name": "test object categories", "description": "object category description"}, {"name": "other test object categories", "description": "object category description"}],
+            "action_categories": [{"name": "test action categories", "description": "action category description"}, {"name": "other test action categories", "description": "action category description"}],
+            "meta_rules": [{"name": "good meta rule", "description": "valid meta rule", "subject_categories": [{"name": "test subject categories"}], "object_categories": [{"name": "test object categories"}], "action_categories": [{"name": "test action categories"}]},
+                           {"name": "other good meta rule", "description": "valid meta rule", "subject_categories": [{"name": "other test subject categories"}], "object_categories": [{"name": "other test object categories"}], "action_categories": [{"name": "other test action categories"}]}]}
+
+SUBJECT_DATA = [{"subject_data": [{"name": "not valid subject data", "description": "", "policy": {}, "category": {}}]},
+                {"subject_data": [{"name": "not valid subject data", "description": "", "policy": {}, "category": {"name": "test subject categories"}}]},
+                {"policies": [{"name": "test policy", "genre": "authz", "description": "description", "model": {"name": "test model"}, "mandatory": True}], "subject_data": [{"name": "one valid subject data", "description": "description", "policy": {}, "category": {"name": "test subject categories"}}]},
+                {"subject_data": [{"name": "valid subject data", "description": "description", "policy": {"name": "test policy"}, "category": {"name": "test subject categories"}}]},
+                {"subject_data": [{"name": "valid subject data", "description": "new description", "policy": {"name": "test other policy"}, "category": {"name": "test subject categories"}}]}]
+
+OBJECT_DATA = [{"object_data": [{"name": "not valid object data", "description": "", "policy": {}, "category": {}}]},
+                {"object_data": [{"name": "not valid object data", "description": "", "policy": {}, "category": {"name": "test object categories"}}]},
+                {"policies": [{"name": "test policy", "genre": "authz", "description": "description", "model": {"name": "test model"}, "mandatory": True}], "object_data": [{"name": "one valid object data", "description": "description", "policy": {}, "category": {"name": "test object categories"}}]},
+                {"object_data": [{"name": "valid object data", "description": "description", "policy": {"name": "test policy"}, "category": {"name": "test object categories"}}]},
+                {"object_data": [{"name": "valid object data", "description": "new description", "policy": {"name": "test other policy"}, "category": {"name": "test object categories"}}]}]
+
+
+ACTION_DATA = [{"action_data": [{"name": "not valid action data", "description": "", "policy": {}, "category": {}}]},
+                {"action_data": [{"name": "not valid action data", "description": "", "policy": {}, "category": {"name": "test action categories"}}]},
+                {"policies": [{"name": "test policy", "genre": "authz", "description": "description", "model": {"name": "test model"}, "mandatory": True}], "action_data": [{"name": "one valid action data", "description": "description", "policy": {}, "category": {"name": "test action categories"}}]},
+                {"action_data": [{"name": "valid action data", "description": "description", "policy": {"name": "test policy"}, "category": {"name": "test action categories"}}]},
+                {"action_data": [{"name": "valid action data", "description": "new description", "policy": {"name": "test other policy"}, "category": {"name": "test action categories"}}]}]
+
+
+PRE_META_RULES = {"subject_categories": [{"name": "test subject categories", "description": "subject category description"}],
+                   "object_categories": [{"name": "test object categories", "description": "object category description"}],
+                   "action_categories": [{"name": "test action categories", "description": "object action description"}]}
+
+META_RULES = [{"meta_rules" :[{"name": "bad meta rule", "description": "not valid meta rule", "subject_categories": [{"name": "not valid category"}], "object_categories": [{"name": "test object categories"}], "action_categories": [{"name": "test action categories"}]}]},
+              {"meta_rules": [{"name": "bad meta rule", "description": "not valid meta rule", "subject_categories": [{"name": "test subject categories"}], "object_categories": [{"name": "not valid category"}], "action_categories": [{"name": "test action categories"}]}]},
+              {"meta_rules": [{"name": "bad meta rule", "description": "not valid meta rule", "subject_categories": [{"name": "test subject categories"}], "object_categories": [{"name": "test object categories"}], "action_categories": [{"name": "not valid category"}]}]},
+              {"meta_rules": [{"name": "good meta rule", "description": "valid meta rule", "subject_categories": [{"name": "test subject categories"}], "object_categories": [{"name": "test object categories"}], "action_categories": [{"name": "test action categories"}]}]}]
+
+PRE_ASSIGNMENTS = {"models": [{"name": "test model", "description": "", "meta_rules": [{"name" : "good meta rule"}]}],
+                   "policies": [{"name": "test policy", "genre": "authz", "description": "description", "model": {"name" : "test model"}, "mandatory": True}],
+                   "subject_categories": [{"name": "test subject categories", "description": "subject category description"}],
+                   "object_categories": [{"name": "test object categories", "description": "object category description"}],
+                   "action_categories": [{"name": "test action categories", "description": "object action description"}],
+                   "subjects": [{"name": "testuser", "description": "description of the subject", "extra": {}, "policies": [{"name": "test policy"}]}],
+                   "objects": [{"name": "test object", "description": "description of the object", "extra": {}, "policies": [{"name": "test policy"}]}],
+                   "actions": [{"name": "test action", "description": "description of the action", "extra": {}, "policies": [{"name": "test policy"}]}],
+                   "meta_rules": [{"name": "good meta rule", "description": "valid meta rule", "subject_categories": [{"name": "test subject categories"}], "object_categories": [{"name": "test object categories"}], "action_categories": [{"name": "test action categories"}]}],
+                   "subject_data": [{"name": "subject data", "description": "test subject data", "policy": {"name": "test policy"}, "category": {"name": "test subject categories"}}],
+                   "object_data": [{"name": "object data", "description": "test object data", "policy": {"name": "test policy"}, "category": {"name": "test object categories"}}],
+                   "action_data": [{"name": "action data", "description": "test action data", "policy": {"name": "test policy"}, "category": {"name": "test action categories"}}]}
+
+
+SUBJECT_ASSIGNMENTS = [{"subject_assignments": [{"subject": {"name": "unknonw"}, "category" : {"name": "test subject categories"}, "assignments": [{"name": "subject data"}]}]},
+                       {"subject_assignments": [{"subject": {"name": "testuser"}, "category": {"name": "unknown"}, "assignments": [{"name": "subject data"}]}]},
+                       {"subject_assignments": [{"subject": {"name": "testuser"}, "category" : {"name": "test subject categories"}, "assignments": [{"name": "unknwon"}]}]},
+                       {"subject_assignments": [{"subject": {"name": "testuser"}, "category": {"name": "test subject categories"}, "assignments": [{"name": "subject data"}]}]}]
+
+OBJECT_ASSIGNMENTS = [{"object_assignments": [{"object": {"name": "unknown"}, "category" : {"name": "test object categories"}, "assignments": [{"name": "object data"}]}]},
+                      {"object_assignments": [{"object": {"name": "test object"}, "category" : {"name": "unknown"}, "assignments": [{"name": "object data"}]}]},
+                      {"object_assignments": [{"object": {"name": "test object"}, "category" : {"name": "test object categories"}, "assignments": [{"name": "unknown"}]}]},
+                      {"object_assignments": [{"object": {"name": "test object"}, "category" : {"name": "test object categories"}, "assignments": [{"name": "object data"}]}]}]
+
+ACTION_ASSIGNMENTS = [{"action_assignments": [{"action": {"name": "unknown"}, "category" : {"name": "test action categories"}, "assignments": [{"name": "action data"}]}]},
+                      {"action_assignments": [{"action": {"name": "test action"}, "category" : {"name": "unknown"}, "assignments": [{"name": "action data"}]}]},
+                      {"action_assignments": [{"action": {"name": "test action"}, "category" : {"name": "test action categories"}, "assignments": [{"name": "unknown"}]}]},
+                      {"action_assignments": [{"action": {"name": "test action"}, "category" : {"name": "test action categories"}, "assignments": [{"name": "action data"}]}]}]
+
+RULES = [{"rules": [{"meta_rule": {"name": "unknown meta rule"}, "policy": {"name": "test policy"}, "instructions": {"decision": "grant"}, "enabled": True, "rule": {"subject_data": [{"name": "subject data"}], "object_data": [{"name": "object data"}], "action_data": [{"name": "action data"}]}}]},
+         {"rules": [{"meta_rule": {"name": "good meta rule"}, "policy": {"name": "unknown policy"}, "instructions": {"decision": "grant"}, "enabled": True, "rule": {"subject_data": [{"name": "subject data"}], "object_data": [{"name": "object data"}], "action_data": [{"name": "action data"}]}}]},
+         {"rules": [{"meta_rule": {"name": "good meta rule"}, "policy": {"name": "test policy"}, "instructions": {"decision": "grant"}, "enabled": True, "rule": {"subject_data": [{"name": "unknown subject data"}], "object_data": [{"name": "object data"}], "action_data": [{"name": "action data"}]}}]},
+         {"rules": [{"meta_rule": {"name": "good meta rule"}, "policy": {"name": "test policy"}, "instructions": {"decision": "grant"}, "enabled": True, "rule": {"subject_data": [{"name": "subject data"}], "object_data": [{"name": "unknown object data"}], "action_data": [{"name": "action data"}]}}]},
+         {"rules": [{"meta_rule": {"name": "good meta rule"}, "policy": {"name": "test policy"}, "instructions": {"decision": "grant"}, "enabled": True, "rule": {"subject_data": [{"name": "subject data"}], "object_data": [{"name": "object data"}], "action_data": [{"name": "unknown action data"}]}}]},
+         {"rules": [{"meta_rule": {"name": "good meta rule"}, "policy": {"name": "test policy"}, "instructions": {"decision": "grant"}, "enabled": True, "rule": {"subject_data": [{"name": "subject data"}], "object_data": [{"name": "object data"}], "action_data": [{"name": "action data"}]}}]}]
+
+
+
+
+def test_import_models_without_new_meta_rules():
+    client = utilities.register_client()
+    import_export_utilities.clean_all(client)
+    counter = 0
+    for models_description in MODEL_WITHOUT_META_RULES:
+        req = client.post("/import", content_type='application/json', data=json.dumps(models_description))
+        data = utilities.get_json(req.data)
+        assert data == "Import ok !"
+        req, models = test_models.get_models(client)
+        models = models["models"]
+        assert len(list(models.keys())) == 1
+        values = list(models.values())
+        assert values[0]["name"] == "test model"
+        if counter == 0:
+            assert len(values[0]["description"]) == 0
+        if counter == 1 or counter == 2:
+            assert values[0]["description"] == "new description"
+        counter = counter + 1
+    import_export_utilities.clean_all(client)
+
+
+def test_import_policies():
+    client = utilities.register_client()
+    import_export_utilities.clean_all(client)
+    counter = -1
+    for policy_description in POLICIES:
+        counter = counter + 1
+        req = client.post("/import", content_type='application/json', data=json.dumps(policy_description))
+        try:
+            data = utilities.get_json(req.data)
+            assert data == "Import ok !"
+        except Exception as e:
+            assert counter == 2 # this is an expected failure
+            continue
+
+        req, policies = test_policies.get_policies(client)
+        policies = policies["policies"]
+        assert len(list(policies.keys())) == 1
+        values = list(policies.values())
+        assert values[0]["name"] == "test policy"
+        if counter < 3:
+            assert values[0]["genre"] == "authz"
+            assert values[0]["description"] == "description"
+        else:
+            assert values[0]["genre"] == "not authz ?"
+            assert values[0]["description"] == "changes taken into account"
+            assert len(values[0]["model_id"]) > 0
+    import_export_utilities.clean_all(client)
+
+
+def test_import_subject_object_action():
+    client = utilities.register_client()
+    type_elements =["object", "action"]
+
+    for type_element in type_elements:
+        import_export_utilities.clean_all(client)
+        counter = -1
+        # set the getters and the comparison values
+        if type_element == "subject":
+            elements = SUBJECTS
+            get_method = test_perimeter.get_subjects
+            clean_method= import_export_utilities.clean_subjects
+            name = "testuser"
+            key_extra = "email"
+            value_extra = "new-email@test.com"
+        elif type_element == "object":
+            elements = OBJECTS
+            get_method = test_perimeter.get_objects
+            clean_method = import_export_utilities.clean_objects
+            name = "test object"
+            key_extra = "test"
+            value_extra = "test extra"
+        else:
+            elements = ACTIONS
+            get_method = test_perimeter.get_actions
+            clean_method = import_export_utilities.clean_actions
+            name = "test action"
+            key_extra = "test"
+            value_extra = "test extra"
+
+        for element in elements:
+            counter = counter + 1
+            print("counter {}".format(counter))
+            if counter == 2 or counter == 4:
+                clean_method(client)
+
+            req = client.post("/import", content_type='application/json', data=json.dumps(element))
+            if counter < 2:
+                assert req.status_code == 500
+                continue
+
+            try:
+                data = utilities.get_json(req.data)
+            except Exception as e:
+                print(str(e))
+                assert False
+                #assert counter < 2  #  this is an expected failure
+                #continue
+
+            assert data == "Import ok !"
+            get_elements = get_method(client)
+            get_elements = get_elements[type_element + "s"]
+
+            assert len(list(get_elements.keys())) == 1
+            values = list(get_elements.values())
+            assert values[0]["name"] == name
+            print(values[0])
+            if counter == 2 or counter == 4:
+                assert values[0]["description"] == "description of the " + type_element
+                print(values[0])
+                #assert not values[0]["extra"]
+            if counter == 3:
+                #TODO uncomment this if update shall be done through import !
+                #assert values[0]["description"] == "new description of the " + type_element
+                #assert values[0]["extra"][key_extra] == value_extra
+                assert True
+
+            # assert len(values[0]["policy_list"]) == 1
+    import_export_utilities.clean_all(client)
+
+
+def test_import_subject_object_action_categories():
+    client = utilities.register_client()
+    type_elements = ["subject", "object", "action"]
+
+    for type_element in type_elements:
+        import_export_utilities.clean_all(client)
+        counter = -1
+        # set the getters and the comparison values
+        if type_element == "subject":
+            elements = SUBJECT_CATEGORIES
+            get_method = test_categories.get_subject_categories
+        elif type_element == "object":
+            elements = OBJECT_CATEGORIES
+            get_method = test_categories.get_object_categories
+        else:
+            elements = ACTION_CATEGORIES
+            get_method = test_categories.get_action_categories
+
+        for element in elements:
+            req = client.post("/import", content_type='application/json', data=json.dumps(element))
+            counter = counter + 1
+            data = utilities.get_json(req.data)
+            assert data == "Import ok !"
+            req, get_elements = get_method(client)
+            get_elements = get_elements[type_element + "_categories"]
+            assert len(list(get_elements.keys())) == 1
+            values = list(get_elements.values())
+            assert values[0]["name"] == "test " + type_element + " categories"
+            assert values[0]["description"] == type_element + " category description"
+
+
+def test_import_meta_rules():
+    client = utilities.register_client()
+    import_export_utilities.clean_all(client)
+    # import some categories
+    req = client.post("/import", content_type='application/json', data=json.dumps(PRE_META_RULES))
+    data = utilities.get_json(req.data)
+    assert data == "Import ok !"
+
+    counter = -1
+    for meta_rule in META_RULES:
+        counter = counter + 1
+        req = client.post("/import", content_type='application/json', data=json.dumps(meta_rule))
+        if counter != 3:
+            assert req.status_code == 500
+            continue
+        else:
+            data = utilities.get_json(req.data)
+            assert data == "Import ok !"
+            assert req.status_code == 200
+
+        req ,meta_rules= test_meta_rules.get_meta_rules(client)
+        meta_rules = meta_rules["meta_rules"]
+        key = list(meta_rules.keys())[0]
+        print(meta_rules)
+        assert isinstance(meta_rules,dict)
+        assert meta_rules[key]["name"] == "good meta rule"
+        assert meta_rules[key]["description"] == "valid meta rule"
+        assert len(meta_rules[key]["subject_categories"]) == 1
+        assert len(meta_rules[key]["object_categories"]) == 1
+        assert len(meta_rules[key]["action_categories"]) == 1
+
+        subject_category_key = meta_rules[key]["subject_categories"][0]
+        object_category_key = meta_rules[key]["object_categories"][0]
+        action_category_key = meta_rules[key]["action_categories"][0]
+
+        req, sub_cat = test_categories.get_subject_categories(client)
+        sub_cat = sub_cat["subject_categories"]
+        assert sub_cat[subject_category_key]["name"] == "test subject categories"
+
+        req, ob_cat = test_categories.get_object_categories(client)
+        ob_cat = ob_cat["object_categories"]
+        assert ob_cat[object_category_key]["name"] == "test object categories"
+
+        req, ac_cat = test_categories.get_action_categories(client)
+        ac_cat = ac_cat["action_categories"]
+        assert ac_cat[action_category_key]["name"] == "test action categories"
+
+    import_export_utilities.clean_all(client)
+
+
+def test_import_subject_object_action_assignments():
+    client = utilities.register_client()
+    import_export_utilities.clean_all(client)
+    req = client.post("/import", content_type='application/json', data=json.dumps(PRE_ASSIGNMENTS))
+    data = utilities.get_json(req.data)
+    assert data == "Import ok !"
+
+    type_elements = ["subject", "object", "action"]
+
+    for type_element in type_elements:
+        counter = -1
+        if type_element == "subject":
+            datas = SUBJECT_ASSIGNMENTS
+            get_method = test_assignments.get_subject_assignment
+        elif type_element == "object":
+            datas = OBJECT_ASSIGNMENTS
+            get_method = test_assignments.get_object_assignment
+        else:
+            datas = ACTION_ASSIGNMENTS
+            get_method = test_assignments.get_action_assignment
+
+        for assignments in datas:
+            counter = counter + 1
+            req = client.post("/import", content_type='application/json', data=json.dumps(assignments))
+            if counter != 3:
+                assert req.status_code == 500
+                continue
+            else:
+                print(data)
+                print(req)
+                assert data == "Import ok !"
+                assert req.status_code == 200
+                req, policies = test_policies.get_policies(client)
+                for policy_key in policies["policies"]:
+                    req, get_assignments = get_method(client, policy_key)
+                    get_assignments = get_assignments[type_element+"_assignments"]
+                    assert len(get_assignments) == 1
+
+
+def test_import_rules():
+    client = utilities.register_client()
+    import_export_utilities.clean_all(client)
+    req = client.post("/import", content_type='application/json', data=json.dumps(PRE_ASSIGNMENTS))
+    data = utilities.get_json(req.data)
+    assert data == "Import ok !"
+
+    counter = -1
+    for rule in RULES:
+        counter = counter + 1
+        req = client.post("/import", content_type='application/json', data=json.dumps(rule))
+
+        if counter < 5:
+            assert req.status_code == 500
+            continue
+
+        assert req.status_code == 200
+
+        req, rules = test_rules.test_get_rules()
+        rules = rules["rules"]
+        policy_key = rules["policy_id"]
+        rules = rules["rules"]
+        print(rules)
+        assert len(rules) == 1
+        rules = rules[0]
+        assert rules["enabled"] == True
+        assert rules["instructions"]["decision"] == "grant"
+
+        req, meta_rules = test_meta_rules.get_meta_rules(client)
+        print(meta_rules)
+        assert meta_rules["meta_rules"][list(meta_rules["meta_rules"].keys())[0]]["name"] == "good meta rule"
+
+
+def test_import_subject_object_action_data():
+    client = utilities.register_client()
+    type_elements = ["subject", "object", "action"]
+
+    for type_element in type_elements:
+        import_export_utilities.clean_all(client)
+        req = client.post("/import", content_type='application/json', data=json.dumps(PRE_DATA))
+        counter = -1
+        # set the getters and the comparison values
+        if type_element == "subject":
+            elements = SUBJECT_DATA
+            get_method = test_data.get_subject_data
+            get_categories = test_categories.get_subject_categories
+        elif type_element == "object":
+            elements = OBJECT_DATA
+            get_method = test_data.get_object_data
+            get_categories = test_categories.get_object_categories
+        else:
+            elements = ACTION_DATA
+            get_method = test_data.get_action_data
+            get_categories = test_categories.get_action_categories
+
+        for element in elements:
+            req = client.post("/import", content_type='application/json', data=json.dumps(element))
+            counter = counter + 1
+            if counter == 0 or counter == 1:
+                assert req.status_code == 500
+                continue
+            print(counter)
+            assert req.status_code == 200
+            data = utilities.get_json(req.data)
+            assert data == "Import ok !"
+
+            req, policies = test_policies.get_policies(client)
+            policies = policies["policies"]
+            req, categories = get_categories(client)
+            categories = categories[type_element + "_categories"]
+            print("categories {}".format(categories))
+            print("policies {}".format(policies))
+            print("data in import {}".format(element))
+            case_tested = False
+            for policy_key in policies.keys():
+                print("policy in test {}".format(policy_key))
+                policy = policies[policy_key]
+                print("policy {}".format(policy))
+                for category_key in categories:
+                    print("category in test {}".format(category_key))
+                    print("looking for {} data with policy {} and category {}".format(type_element, policy_key,category_key))
+                    req, get_elements = get_method(client, policy_id=policy_key, category_id=category_key)
+                    if len(get_elements[type_element+"_data"]) == 0:
+                        continue
+
+                    # do this because the backend gives an element with empty data if the policy_key, category_key couple does not have any data...
+                    get_elements = get_elements[type_element+"_data"]
+                    print("test")
+                    if len(get_elements[0]["data"]) == 0:
+                        print("test2")
+                        continue
+
+                    print("get_elements {}".format(get_elements))
+
+                    if policy["name"] == "test policy":
+                        assert len(get_elements) == 1
+                        el = get_elements[0]
+                        assert isinstance(el["data"], dict)
+                        if counter == 2:
+                            assert len(el["data"].keys()) == 1
+                            el = el["data"][list(el["data"].keys())[0]]
+                            if "value" in el:
+                                el = el["value"]
+                            print(el)
+                            assert el["name"] == "one valid " + type_element + " data"
+                        if counter == 3:
+                            assert len(el["data"].keys()) == 2
+                            el1 = el["data"][list(el["data"].keys())[0]]
+                            el2 = el["data"][list(el["data"].keys())[1]]
+                            if "value" in el1:
+                                el1 = el1["value"]
+                                el2 = el2["value"]
+                            assert (el1["name"] == "one valid " + type_element + " data" and el2["name"] == "valid " + type_element + " data") or (el2["name"] == "one valid " + type_element + " data" and el1["name"] == "valid " + type_element + " data")
+                            assert el1["description"] == "description"
+                            assert el2["description"] == "description"
+
+                        case_tested = True
+
+                    if policy["name"] == "test other policy":
+                        if counter == 4:
+                            assert len(get_elements) == 1
+                            el = get_elements[0]
+                            assert isinstance(el["data"], dict)
+                            assert len(el["data"].keys()) == 1
+                            el = el["data"][list(el["data"].keys())[0]]
+                            print(el)
+                            if "value" in el:
+                                el = el["value"]
+                            assert el["name"] == "valid " + type_element + " data"
+                            assert el["description"] == "new description"
+                            case_tested = True
+
+            assert case_tested is True
+
+
+def test_clean():
+    client = utilities.register_client()
+    import_export_utilities.clean_all(client)
\ No newline at end of file
diff --git a/moon_manager/tests/unit_python/api/test_rules.py b/moon_manager/tests/unit_python/api/test_rules.py
index 86a3d390..0b302494 100644
--- a/moon_manager/tests/unit_python/api/test_rules.py
+++ b/moon_manager/tests/unit_python/api/test_rules.py
@@ -35,6 +35,7 @@ def test_get_rules():
     assert req.status_code == 200
     assert isinstance(rules, dict)
     assert "rules" in rules
+    return req, rules
 
 
 def test_add_rules():
diff --git a/moon_manager/tests/unit_python/api/utilities.py b/moon_manager/tests/unit_python/api/utilities.py
index 66ca30c5..ce897619 100644
--- a/moon_manager/tests/unit_python/api/utilities.py
+++ b/moon_manager/tests/unit_python/api/utilities.py
@@ -21,6 +21,8 @@ def get_policy_id():
         if id:
             policy_id = id
             break
+    print("policy id {}".format(policy_id))
     if not policy_id:
         policies.add_policies(client, "testuser")
+        policy_id = get_policy_id()
     return policy_id
diff --git a/moon_pythonunittest/run_tests.sh b/moon_pythonunittest/run_tests.sh
index 8175d00b..b59a9ec2 100644
--- a/moon_pythonunittest/run_tests.sh
+++ b/moon_pythonunittest/run_tests.sh
@@ -9,5 +9,5 @@ then
     bash /data/tests/unit_python/run_tests.sh;
 fi
 
-cd /data/tests/python_python
-pytest .
+cd /data/tests/unit_python
+pytest -s .
diff --git a/python_moonclient/Changelog b/python_moonclient/Changelog
index 927663ec..9a2971cb 100644
--- a/python_moonclient/Changelog
+++ b/python_moonclient/Changelog
@@ -53,3 +53,18 @@ CHANGES
     - moon slave delete
     - moon slave list
     - moon slave set
+
+1.4.0
+-----
+- Add some commands:
+    - moon import
+    - moon export
+    - moon subject category create
+    - moon subject category list
+    - moon object category list
+    - moon action category list
+    - moon subject data create
+    - moon subject data list
+    - moon object data list
+    - moon action data list
+    - moon metarule list
diff --git a/python_moonclient/python_moonclient/__init__.py b/python_moonclient/python_moonclient/__init__.py
index 6e5782ce..8b353f9f 100644
--- a/python_moonclient/python_moonclient/__init__.py
+++ b/python_moonclient/python_moonclient/__init__.py
@@ -3,4 +3,4 @@
 # license which can be found in the file 'LICENSE' in this package distribution
 # or at 'http://www.apache.org/licenses/LICENSE-2.0'.
 
-__version__ = "1.3.0"
+__version__ = "1.4.0"
diff --git a/python_moonclient/python_moonclient/cli/export.py b/python_moonclient/python_moonclient/cli/export.py
new file mode 100644
index 00000000..a16928de
--- /dev/null
+++ b/python_moonclient/python_moonclient/cli/export.py
@@ -0,0 +1,32 @@
+import json
+
+from python_moonclient.core import models, policies, pdp, json_export
+from python_moonclient.cli.parser import Parser
+
+from cliff.command import Command
+
+
+class Export(Command):
+    """dump the complete moon database into a json file"""
+    def get_parser(self, prog_name):
+        parser = super().get_parser(prog_name)
+        Parser.add_filename_argument(parser)
+        Parser.add_common_options(parser)
+        return parser
+
+    def take_action(self, parsed_args):
+        consul_host = parsed_args.consul_host
+        consul_port = parsed_args.consul_port
+
+        models.init(consul_host, consul_port)
+        policies.init(consul_host, consul_port)
+        pdp.init(consul_host, consul_port)
+        json_export.init(consul_host, consul_port)
+        res = json_export.export_to_json()
+        if "content" in res:
+            json_file = open(parsed_args.filename, "w")
+            json.dump(res["content"], json_file)
+            return "Export ok!"
+        else:
+            return "Unexpected results : the returned json does not have the correct syntax"
+
diff --git a/python_moonclient/python_moonclient/cli/import.py b/python_moonclient/python_moonclient/cli/import.py
new file mode 100644
index 00000000..c6c43439
--- /dev/null
+++ b/python_moonclient/python_moonclient/cli/import.py
@@ -0,0 +1,29 @@
+
+from python_moonclient.core import models, policies, pdp, json_import
+from python_moonclient.cli.parser import Parser
+from python_moonclient.cli.projects import ProjectsUtils
+
+from cliff.command import Command
+
+
+class Import(Command):
+    """import a json file describing pdps """
+    def get_parser(self, prog_name):
+        parser = super().get_parser(prog_name)
+        Parser.add_common_options(parser)
+        Parser.add_filename_argument(parser)
+        return parser
+
+    def take_action(self, parsed_args):
+        consul_host = parsed_args.consul_host
+        consul_port = parsed_args.consul_port
+
+        models.init(consul_host, consul_port)
+        policies.init(consul_host, consul_port)
+        pdp.init(consul_host, consul_port)
+        json_import.init(consul_host, consul_port)
+        res = json_import.import_json(parsed_args.filename)
+        if "message" in res:
+            return res["message"]
+        return res
+
diff --git a/python_moonclient/python_moonclient/cli/models.py b/python_moonclient/python_moonclient/cli/models.py
new file mode 100644
index 00000000..922a1830
--- /dev/null
+++ b/python_moonclient/python_moonclient/cli/models.py
@@ -0,0 +1,161 @@
+import logging
+from cliff.lister import Lister
+from cliff.command import Command
+from importlib.machinery import SourceFileLoader
+
+from python_moonclient.core import models, policies, pdp
+from python_moonclient.cli.parser import Parser
+from python_moonclient.cli.projects import ProjectsUtils
+
+logger = logging.getLogger("moonclient.cli.pdps")
+
+
+class ModelUtils:
+    def __init__(self):
+        pass
+
+    @staticmethod
+    def get_model_id(model, parsed_id, parsed_name):
+        modelz = models.check_model()
+        for _model_key, _model_value in modelz["models"].items():
+            if _model_key == parsed_id or _model_value['name'] == parsed_name:
+                # logger.info("Found pdp : [key='{}' , name='{}']".format(_pdp_key, _pdp_value['name']))
+                return _model_key
+        return None
+
+    @staticmethod
+    def get_model_name(pdp, parsed_id, parsed_name):
+        modelz = models.check_model()
+        for _model_key, _model_value in modelz["models"].items():
+            if _model_key == parsed_id or _model_value['name'] == parsed_name:
+                # logger.info("Found pdp : [key='{}' , name='{}']".format(_pdp_key, _pdp_value['name']))
+                return _model_value['name']
+        return None
+
+
+class Models(Lister):
+    """show the list of existing pdps """
+
+    def get_parser(self, prog_name):
+        parser = super().get_parser(prog_name)
+        Parser.add_common_options(parser)
+        return parser
+
+    def take_action(self, parsed_args):
+        consul_host = parsed_args.consul_host
+        consul_port = parsed_args.consul_port
+
+        models.init(consul_host, consul_port)
+        policies.init(consul_host, consul_port)
+        pdp.init(consul_host, consul_port)
+
+        modelz = models.check_model()
+
+        return (('Key', 'Name'),
+                ((_model_key, _model_value['name']) for _model_key, _model_value in
+                 modelz["models"].items())
+                )
+
+
+class SubjectCategories(Lister):
+    """show the list of existing categories """
+
+    def get_parser(self, prog_name):
+        parser = super().get_parser(prog_name)
+        Parser.add_common_options(parser)
+
+        return parser
+
+    def take_action(self, parsed_args):
+        consul_host = parsed_args.consul_host
+        consul_port = parsed_args.consul_port
+
+        models.init(consul_host, consul_port)
+        policies.init(consul_host, consul_port)
+        pdp.init(consul_host, consul_port)
+
+        subject_categories = models.check_subject_category()
+        print(subject_categories)
+        return (('Key', 'Name'),
+                ((_model_key, _model_value['name']) for _model_key, _model_value in
+                 subject_categories["subject_categories"].items())
+                )
+
+
+class ObjectCategories(Lister):
+    """show the list of existing categories """
+
+    def get_parser(self, prog_name):
+        parser = super().get_parser(prog_name)
+        Parser.add_common_options(parser)
+
+        return parser
+
+    def take_action(self, parsed_args):
+        consul_host = parsed_args.consul_host
+        consul_port = parsed_args.consul_port
+
+        models.init(consul_host, consul_port)
+        policies.init(consul_host, consul_port)
+        pdp.init(consul_host, consul_port)
+
+        object_categories = models.check_object_category()
+        print(object_categories)
+        return (('Key', 'Name'),
+                ((_model_key, _model_value['name']) for _model_key, _model_value in
+                 object_categories["object_categories"].items())
+                )
+
+
+class ActionCategories(Lister):
+    """show the list of existing categories """
+
+    def get_parser(self, prog_name):
+        parser = super().get_parser(prog_name)
+        Parser.add_common_options(parser)
+
+        return parser
+
+    def take_action(self, parsed_args):
+        consul_host = parsed_args.consul_host
+        consul_port = parsed_args.consul_port
+
+        models.init(consul_host, consul_port)
+        policies.init(consul_host, consul_port)
+        pdp.init(consul_host, consul_port)
+
+        action_categories = models.check_action_category()
+        print(action_categories)
+        return (('Key', 'Name'),
+                ((_model_key, _model_value['name']) for _model_key, _model_value in
+                 action_categories["action_categories"].items())
+                )
+
+
+class SubjectCategoryAdd(Command):
+    """show the list of existing categories """
+
+    def get_parser(self, prog_name):
+        parser = super().get_parser(prog_name)
+        Parser.add_common_options(parser)
+        Parser.add_name_argument(parser)
+
+        return parser
+
+    def take_action(self, parsed_args):
+        consul_host = parsed_args.consul_host
+        consul_port = parsed_args.consul_port
+
+        models.init(consul_host, consul_port)
+        policies.init(consul_host, consul_port)
+        pdp.init(consul_host, consul_port)
+
+        subject_category_id = models.add_subject_category(parsed_args.name)
+        if subject_category_id is not None:
+            print("Subject category created with id {}".format(subject_category_id))
+        else:
+            print("Error while creating subject category")
+        # subject_categories = models.check_subject_category(subject_category_id)
+
+
+
diff --git a/python_moonclient/python_moonclient/cli/parser.py b/python_moonclient/python_moonclient/cli/parser.py
index f32a5484..edd18a25 100644
--- a/python_moonclient/python_moonclient/cli/parser.py
+++ b/python_moonclient/python_moonclient/cli/parser.py
@@ -17,6 +17,18 @@ class Parser:
         Parser._add_name_argument(parser)
 
     @staticmethod
+    def add_policy_argument(parser):
+        group = parser.add_mutually_exclusive_group(required=True)
+        group.add_argument('--policy-name', help='name of the policy')
+        group.add_argument('--policy-id', help='id of the policy')
+
+    @staticmethod
+    def add_category_argument(parser):
+        group = parser.add_mutually_exclusive_group(required=True)
+        group.add_argument('--category-name', help='name of the category')
+        group.add_argument('--category-id', help='id of the category')
+
+    @staticmethod
     def add_id_or_name_argument(parser):
         group = parser.add_mutually_exclusive_group(required=True) 
         Parser._add_id_argument(group)
diff --git a/python_moonclient/python_moonclient/cli/policies.py b/python_moonclient/python_moonclient/cli/policies.py
index a528ea8d..94d13db1 100644
--- a/python_moonclient/python_moonclient/cli/policies.py
+++ b/python_moonclient/python_moonclient/cli/policies.py
@@ -31,7 +31,6 @@ class PoliciesUtils:
                 return _policy_value['name']
         return None
 
-
 class Policies(Lister):
     """show the list of existing policies"""
     def get_parser(self, prog_name):
@@ -53,6 +52,30 @@ class Policies(Lister):
                )
 
 
+class Subjects(Lister):
+    def get_parser(self, prog_name):
+        parser = super().get_parser(prog_name)
+        Parser.add_common_options(parser)
+        Parser.add_id_or_name_argument(parser)
+        Parser.add_policy_argument(parser)
+        return parser
+
+    def take_action(self, parsed_args):
+        consul_host = parsed_args.consul_host
+        consul_port = parsed_args.consul_port
+
+        models.init(consul_host, consul_port)
+        policies.init(consul_host, consul_port)
+        pdp.init(consul_host, consul_port)
+
+        _policies = policies.check_subject(parsed_args.id, parsed_args.policy_id)
+
+        return (('Key' , 'Name'),
+                   ((_policy_key,  _policy_value['name']) for _policy_key, _policy_value in _policies["policies"].items())
+               )
+
+
+
 class DeletePolicy(Command):
     """delete an existing policy"""
     def get_parser(self, prog_name):
@@ -85,3 +108,139 @@ class DeletePolicy(Command):
         return (('Key', 'Value'),
                 ((_policy_key, _policy_value) for _policy_key, _policy_value in _policies["policies"].items())
                 )
+
+
+
+class SubjectDatas(Lister):
+    """list the subject data """
+    def get_parser(self, prog_name):
+        parser = super().get_parser(prog_name)
+        Parser.add_common_options(parser)
+        Parser.add_policy_argument(parser)
+        Parser.add_category_argument(parser)
+        return parser
+
+    def take_action(self, parsed_args):
+        consul_host = parsed_args.consul_host
+        consul_port = parsed_args.consul_port
+
+        models.init(consul_host, consul_port)
+        policies.init(consul_host, consul_port)
+        pdp.init(consul_host, consul_port)
+
+        subject_data = policies.check_subject_data(parsed_args.policy_id, None, parsed_args.category_id)
+        if len(subject_data["subject_data"]) == 0:
+            return (('Key', 'Name'),())
+
+        return (('Key', 'Name'),
+                   ((_subject_key, subject_data["subject_data"][0]["data"][_subject_key]['name']) for _subject_key in subject_data["subject_data"][0]["data"].keys())
+               )
+
+
+class ObjectDatas(Lister):
+    """list the object data"""
+    def get_parser(self, prog_name):
+        parser = super().get_parser(prog_name)
+        Parser.add_common_options(parser)
+        Parser.add_policy_argument(parser)
+        Parser.add_category_argument(parser)
+        return parser
+
+    def take_action(self, parsed_args):
+        consul_host = parsed_args.consul_host
+        consul_port = parsed_args.consul_port
+
+        models.init(consul_host, consul_port)
+        policies.init(consul_host, consul_port)
+        pdp.init(consul_host, consul_port)
+
+        object_datas = policies.check_object_data(parsed_args.policy_id, None, parsed_args.category_id)
+
+        if len(object_datas["object_data"]) == 0:
+            return (('Key', 'Name'),())
+        object_data = object_datas["object_data"][0]["data"]
+        res =  (('Key', 'Name'),
+                   ((_object_key, object_data[_object_key]["value"]['name']) for _object_key in list(object_data))
+               )
+        return res
+
+
+class ActionDatas(Lister):
+    """list the action data"""
+    def get_parser(self, prog_name):
+        parser = super().get_parser(prog_name)
+        Parser.add_common_options(parser)
+        Parser.add_policy_argument(parser)
+        Parser.add_category_argument(parser)
+        return parser
+
+    def take_action(self, parsed_args):
+        consul_host = parsed_args.consul_host
+        consul_port = parsed_args.consul_port
+
+        models.init(consul_host, consul_port)
+        policies.init(consul_host, consul_port)
+        pdp.init(consul_host, consul_port)
+
+        action_datas = policies.check_action_data(parsed_args.policy_id, None, parsed_args.category_id)
+
+        if len(action_datas["action_data"]) == 0:
+            return (('Key', 'Name'),())
+        action_data = action_datas["action_data"][0]["data"]
+        res =  (('Key', 'Name'),
+                   ((_action_key, action_data[_action_key]["value"]['name']) for _action_key in list(action_data))
+               )
+        return res
+
+
+class MetaRules(Lister):
+    """list the meta rules"""
+    def get_parser(self, prog_name):
+        parser = super().get_parser(prog_name)
+        Parser.add_common_options(parser)
+        return parser
+
+    def take_action(self, parsed_args):
+        consul_host = parsed_args.consul_host
+        consul_port = parsed_args.consul_port
+
+        models.init(consul_host, consul_port)
+        policies.init(consul_host, consul_port)
+        pdp.init(consul_host, consul_port)
+
+        metarule_datas = policies.check_meta_rule()
+
+        if len(metarule_datas["meta_rules"]) == 0:
+            return (('Key', 'Name'),())
+
+        metarule_data = metarule_datas["meta_rules"]
+        res =  (('Key', 'Name'),
+                   ((_key, metarule_data[_key]['name']) for _key in list(metarule_data))
+               )
+        return res
+
+class CreateSubjectData(Command):
+    """create a subject data according to a policy and a category"""
+    def get_parser(self, prog_name):
+        parser = super().get_parser(prog_name)
+        Parser.add_common_options(parser)
+        Parser.add_policy_argument(parser)
+        Parser.add_category_argument(parser)
+        Parser.add_name_argument(parser)
+        return parser
+
+    def take_action(self, parsed_args):
+        consul_host = parsed_args.consul_host
+        consul_port = parsed_args.consul_port
+
+        models.init(consul_host, consul_port)
+        policies.init(consul_host, consul_port)
+        pdp.init(consul_host, consul_port)
+
+        subject_data_id = policies.add_subject_data(parsed_args.policy_id, parsed_args.category_id, parsed_args.name)
+        if subject_data_id is not None:
+            print("Subject category created with id {}".format(subject_data_id))
+        else:
+            print("Error while creating subject category")
+        subject_data = policies.check_subject_data(parsed_args.policy_id, None, parsed_args.category_id)
+        # subject_categories = models.check_subject_category(subject_category_id)
diff --git a/python_moonclient/python_moonclient/core/json_export.py b/python_moonclient/python_moonclient/core/json_export.py
new file mode 100644
index 00000000..53c1b1f0
--- /dev/null
+++ b/python_moonclient/python_moonclient/core/json_export.py
@@ -0,0 +1,26 @@
+import logging
+import requests
+import copy
+from python_moonclient.core import config
+
+
+logger = logging.getLogger("moonclient.core.export_json")
+
+URL = None
+HEADERS = None
+
+def init(consul_host, consul_port):
+    conf_data = config.get_config_data(consul_host, consul_port)
+    global URL, HEADERS
+    URL = "http://{}:{}".format(
+        conf_data['manager_host'],
+        conf_data['manager_port'])
+    URL = URL + "{}"
+    HEADERS = {"content-type": "application/json"}
+
+
+def export_to_json():
+    req = requests.get(URL.format("/export"))
+    req.raise_for_status()
+    result = req.json()
+    return result
\ No newline at end of file
diff --git a/python_moonclient/python_moonclient/core/json_import.py b/python_moonclient/python_moonclient/core/json_import.py
new file mode 100644
index 00000000..a724476b
--- /dev/null
+++ b/python_moonclient/python_moonclient/core/json_import.py
@@ -0,0 +1,29 @@
+import logging
+import requests
+import copy
+from python_moonclient.core import config
+
+
+logger = logging.getLogger("moonclient.core.import_json")
+
+URL = None
+HEADERS = None
+
+def init(consul_host, consul_port):
+    conf_data = config.get_config_data(consul_host, consul_port)
+    global URL, HEADERS
+    URL = "http://{}:{}".format(
+        conf_data['manager_host'],
+        conf_data['manager_port'])
+    URL = URL + "{}"
+    HEADERS = {"content-type": "application/json"}
+
+
+def import_json(file_name):
+    files = {'file': open(file_name, 'rb')}
+    req = requests.post(URL.format("/import"), files=files)
+    result = req.json()
+    if isinstance(result,dict) and "message" in result:
+        req.reason = result["message"]
+    req.raise_for_status()
+    return result
\ No newline at end of file
diff --git a/python_moonclient/python_moonclient/core/models.py b/python_moonclient/python_moonclient/core/models.py
index ba6c9a92..709b4a7a 100644
--- a/python_moonclient/python_moonclient/core/models.py
+++ b/python_moonclient/python_moonclient/core/models.py
@@ -81,14 +81,16 @@ def add_subject_category(name="subject_cat_1"):
     return category_id
 
 
-def check_subject_category(category_id):
+def check_subject_category(category_id=None):
     req = requests.get(URL.format("/subject_categories"))
     req.raise_for_status()
     result = req.json()
 
     check_subject_category_in_result(result)
     check_optionnal_result(result)
-    check_subject_categories_name(category_template["name"], category_id, result)
+    if category_id is not None:
+        check_subject_categories_name(category_template["name"], category_id, result)
+    return result
 
 
 def delete_subject_category(category_id):
@@ -110,13 +112,15 @@ def add_object_category(name="object_cat_1"):
     return category_id
 
 
-def check_object_category(category_id):
+def check_object_category(category_id=None):
     req = requests.get(URL.format("/object_categories"))
     req.raise_for_status()
     result = req.json()
     check_object_category_in_result(result)
     check_optionnal_result(result)
-    check_object_categories_name(category_template["name"], category_id, result)
+    if category_id is not None:
+        check_object_categories_name(category_template["name"], category_id, result)
+    return result
 
 
 def delete_object_category(category_id):
@@ -138,13 +142,16 @@ def add_action_category(name="action_cat_1"):
     return category_id
 
 
-def check_action_category(category_id):
+def check_action_category(category_id=None):
     req = requests.get(URL.format("/action_categories"))
     req.raise_for_status()
     result = req.json()
+    print(result)
     check_action_category_in_result(result)
     check_optionnal_result(result)
-    check_action_categories_name(category_template["name"], category_id, result)
+    if category_id is not None:
+        check_action_categories_name(category_template["name"], category_id, result)
+    return result
 
 
 def delete_action_category(category_id):
@@ -207,6 +214,7 @@ def check_meta_rule(meta_rule_id, scat_id=None, ocat_id=None, acat_id=None):
         check_ocat_id_in_dict(ocat_id, result['meta_rules'][meta_rule_id]["object_categories"])
     if acat_id:
         check_acat_id_in_dict(acat_id, result['meta_rules'][meta_rule_id]["action_categories"])
+    return result
 
 
 def delete_meta_rule(meta_rule_id):
diff --git a/python_moonclient/python_moonclient/core/policies.py b/python_moonclient/python_moonclient/core/policies.py
index 01067a98..46d918aa 100644
--- a/python_moonclient/python_moonclient/core/policies.py
+++ b/python_moonclient/python_moonclient/core/policies.py
@@ -302,8 +302,11 @@ def check_subject_data(policy_id, data_id, category_id):
     req = requests.get(URL.format("/policies/{}/subject_data/{}".format(policy_id, category_id)))
     req.raise_for_status()
     result = req.json()
-    check_id_in_subject_data_data(data_id, result)
+    print(result)
+    if data_id is not None:
+        check_id_in_subject_data_data(data_id, result)
     check_category_id_in_subject_data_data(category_id, result)
+    return result
 
 
 def delete_subject_data(policy_id, category_id, data_id):
@@ -332,9 +335,10 @@ def check_object_data(policy_id, data_id, category_id):
     req = requests.get(URL.format("/policies/{}/object_data/{}".format(policy_id, category_id)))
     req.raise_for_status()
     result = req.json()
-    check_id_in_object_data_data(data_id, result)
+    if data_id is not None:
+        check_id_in_object_data_data(data_id, result)
     check_category_id_in_object_data_data(category_id, result)
-
+    return result
 
 def delete_object_data(policy_id, category_id, data_id):
     req = requests.delete(URL.format("/policies/{}/object_data/{}/{}".format(policy_id, category_id, data_id)),
@@ -362,9 +366,11 @@ def check_action_data(policy_id, data_id, category_id):
     req = requests.get(URL.format("/policies/{}/action_data/{}".format(policy_id, category_id)))
     req.raise_for_status()
     result = req.json()
-    check_id_in_action_data_data(data_id, result)
+    print(result)
+    if data_id is not None:
+        check_id_in_action_data_data(data_id, result)
     check_category_id_in_action_data_data(category_id, result)
-
+    return result
 
 def delete_action_data(policy_id, category_id, data_id):
     req = requests.delete(URL.format("/policies/{}/action_data/{}/{}".format(policy_id, category_id, data_id)),
@@ -526,6 +532,13 @@ def delete_rule(policy_id, rule_id):
     check_rule_id_not_in_list(rule_id, result["rules"]["rules"])
 
 
+def check_meta_rule():
+    req = requests.get(URL.format("/meta_rules/"))
+    req.raise_for_status()
+    result = req.json()
+    print(result)
+    return result
+
 def create_policy(scenario, model_id, meta_rule_list):
     logger.info("Creating policy {}".format(scenario.policy_name))
     _policies = check_policy()
diff --git a/python_moonclient/python_moonclient/moon.py b/python_moonclient/python_moonclient/moon.py
index cbf62681..f8cf027d 100644
--- a/python_moonclient/python_moonclient/moon.py
+++ b/python_moonclient/python_moonclient/moon.py
@@ -22,6 +22,19 @@ def main(argv=sys.argv[1:]):
 
 
 if __name__ == '__main__':
+    #import python_moonclient.python_moonclient.core.import_json
+    #import python_moonclient.python_moonclient.core.models
+    #import python_moonclient.core.policies.init as init_policy
+    #import python_moonclient.core.pdp.init as init_pdp
+    #consul_host = "consul"
+    #consul_port = "8005"
+
+    #init_model(consul_host, consul_port)
+    #init_policy.init(consul_host, consul_port)
+    #init_pdp.init(consul_host, consul_port)
+    #import_json('/home/fcellier/moon/tests/functional/scenario_available/rbac.json')
+
+
     sys.exit(Moon(sys.argv[1:]))
 
 
diff --git a/python_moonclient/setup.py b/python_moonclient/setup.py
index 847f62e7..4a3a8233 100644
--- a/python_moonclient/setup.py
+++ b/python_moonclient/setup.py
@@ -56,7 +56,19 @@ setup(
           'slave_list = python_moonclient.cli.slaves:Slaves',
           'slave_set = python_moonclient.cli.slaves:SetSlave',
           'slave_delete = python_moonclient.cli.slaves:DeleteSlave',
-          'authz_send = python_moonclient.cli.authz:SendAuthz'
+          'authz_send = python_moonclient.cli.authz:SendAuthz',
+          'import = python_moonclient.cli.import:Import',
+          'export = python_moonclient.cli.export:Export',
+          'model_list = python_moonclient.cli.models:Models',
+          'subject_data_list = python_moonclient.cli.policies:SubjectDatas',
+          'object_data_list = python_moonclient.cli.policies:ObjectDatas',
+          'action_data_list = python_moonclient.cli.policies:ActionDatas',
+          'subject_category_list = python_moonclient.cli.models:SubjectCategories',
+          'object_category_list = python_moonclient.cli.models:ObjectCategories',
+          'action_category_list = python_moonclient.cli.models:ActionCategories',
+          'subject_category_create = python_moonclient.cli.models:SubjectCategoryAdd',
+          'subject_data_create = python_moonclient.cli.policies:CreateSubjectData',
+          'metarule_list = python_moonclient.cli.policies:MetaRules'
         ], 
     }
 
diff --git a/tests/python_unit/run_tests.sh b/tests/python_unit/run_tests.sh
index 33c1ab98..0a9ac1f3 100644
--- a/tests/python_unit/run_tests.sh
+++ b/tests/python_unit/run_tests.sh
@@ -9,4 +9,9 @@ cd ../python_moondb
 docker run --rm --volume $(pwd):/data wukongsun/moon_python_unit_test:latest
 
 cd ../python_moonclient
-docker run --rm --volume $(pwd):/data wukongsun/moon_python_unit_test:latest
\ No newline at end of file
+docker run --rm --volume $(pwd):/data wukongsun/moon_python_unit_test:latest
+
+cd ../moon_manager
+rm -f tests/unit_python/database.db
+docker run --rm --volume $(pwd):/data wukongsun/moon_python_unit_test:latest
+
diff --git a/tools/moon_kubernetes/templates/moon_functest.yaml b/tools/moon_kubernetes/templates/moon_functest.yaml
index d70ebb96..e876849e 100644
--- a/tools/moon_kubernetes/templates/moon_functest.yaml
+++ b/tools/moon_kubernetes/templates/moon_functest.yaml
@@ -10,7 +10,7 @@ spec:
     spec:
       containers:
       - name: functest
-        image: wukongsun/moon_python_func_test:latest
+        image: moonplatform/moon_python_func_test:latest
         volumeMounts:
         - name: config-volume
           mountPath: /etc/moon