Merge "Add import and export pdps"

7 files changed, 1061 insertions, 19 deletions

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")