def get(self, meta_rule_id=None, user_id=None):
"""Retrieve all sub meta rules
:param meta_rule_id: Meta rule algorithm ID
:param user_id: user ID who do the request
:return: {
"meta_rules": {
"meta_rule_id1": {
"name": "name of the meta rule",
"algorithm": "name of the meta rule algorithm",
"subject_categories": ["subject_category_id1",
"subject_category_id2"],
"object_categories": ["object_category_id1"],
"action_categories": ["action_category_id1"]
},
}
}
:internal_api: get_meta_rules
"""
try:
data = ModelManager.get_meta_rules(
user_id=user_id, meta_rule_id=meta_rule_id)
except Exception as e:
logger.error(e, exc_info=True)
return {"result": False,
"error": str(e)}, 500
return {"meta_rules": data}
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_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()
meta_rule = ModelManager.get_meta_rules(
self._user_id, rule["meta_rule_id"])
meta_rule = [v for v in meta_rule.values()]
meta_rule = meta_rule[0]
index_subject_data = len(meta_rule["subject_categories"]) - 1
index_object_data = len(meta_rule["subject_categories"]) + len(
meta_rule["object_categories"]) - 1
index_action_data = len(meta_rule["subject_categories"]) + len(
meta_rule["object_categories"]) + len(
meta_rule["action_categories"]) - 1
ids_subject_data = [ids[0]] if len(
meta_rule["subject_categories"]
) == 1 else ids[0:index_subject_data]
ids_object_data = [ids[index_object_data]] if len(
meta_rule["object_categories"]
) == 1 else ids[index_subject_data + 1:index_object_data]
ids_action_date = [ids[index_action_data]] if len(
meta_rule["action_categories"]
) == 1 else ids[index_object_data + 1:index_action_data]
JsonUtils.convert_ids_to_names(ids_subject_data,
rule_description,
"subject_data", "subject_data",
PolicyManager, self._user_id,
policy_key)
JsonUtils.convert_ids_to_names(ids_object_data,
rule_description, "object_data",
"object_data", PolicyManager,
self._user_id, policy_key)
JsonUtils.convert_ids_to_names(ids_action_date,
rule_description, "action_data",
"action_data", PolicyManager,
self._user_id, policy_key)
rule_dict["rule"] = rule_description
rules_array.append(rule_dict)
if len(rules_array) > 0:
json_content['rules'] = rules_array
def get(self, meta_rule_id=None, user_id=None):
"""Retrieve all sub meta rules
:param meta_rule_id: Meta rule algorithm ID
:param user_id: user ID who do the request
:return: {
"meta_rules": {
"meta_rule_id1": {
"name": "name of the meta rule",
"subject_categories": ["subject_category_id1",
"subject_category_id2"],
"object_categories": ["object_category_id1"],
"action_categories": ["action_category_id1"]
},
}
}
:internal_api: get_meta_rules
"""
data = ModelManager.get_meta_rules(user_id=user_id,
meta_rule_id=meta_rule_id)
return {"meta_rules": data}
def get_meta_rules(meta_rule_id=None):
from python_moondb.core import ModelManager
return ModelManager.get_meta_rules(user_id=None, meta_rule_id=meta_rule_id)
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()
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"])
meta_rule = ModelManager.get_meta_rules(
self._user_id, json_to_use["meta_rule_id"])
meta_rule = [v for v in meta_rule.values()]
meta_rule = meta_rule[0]
json_to_use_rule = self._reorder_rules_ids(
json_rule, meta_rule["subject_categories"],
json_subject_ids["subject"], json_ids["policy_id"],
PolicyManager.get_subject_data)
json_to_use_rule = json_to_use_rule + self._reorder_rules_ids(
json_rule, meta_rule["object_categories"],
json_object_ids["object"], json_ids["policy_id"],
PolicyManager.get_object_data)
json_to_use_rule = json_to_use_rule + self._reorder_rules_ids(
json_rule, meta_rule["action_categories"],
json_action_ids["action"], json_ids["policy_id"],
PolicyManager.get_action_data)
json_to_use["rule"] = json_to_use_rule
try:
logger.debug("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"]))
