class ObjectAssignment(sql.ModelBase, sql.DictBase):
__tablename__ = 'object_assignments'
- attributes = ['id', 'object_assignment', 'intra_extension_id', 'object_id']
+ attributes = ['id', 'object_assignment', 'intra_extension_id', 'object_id', 'object_category_id']
id = sql.Column(sql.String(64), primary_key=True)
object_assignment = sql.Column(sql.JsonBlob(), nullable=True)
intra_extension_id = sql.Column(sql.ForeignKey("intra_extensions.id"), nullable=False)
object_id = sql.Column(sql.ForeignKey("objects.id"), nullable=False)
+ object_category_id = sql.Column(sql.ForeignKey("object_categories.id"), nullable=False)
@classmethod
def from_dict(cls, d):
class ActionAssignment(sql.ModelBase, sql.DictBase):
__tablename__ = 'action_assignments'
- attributes = ['id', 'action_assignment', 'intra_extension_id', 'action_id']
+ attributes = ['id', 'action_assignment', 'intra_extension_id', 'action_id', 'action_category_id']
id = sql.Column(sql.String(64), primary_key=True)
action_assignment = sql.Column(sql.JsonBlob(), nullable=True)
intra_extension_id = sql.Column(sql.ForeignKey("intra_extensions.id"), nullable=False)
action_id = sql.Column(sql.ForeignKey("actions.id"), nullable=False)
+ action_category_id = sql.Column(sql.ForeignKey("action_categories.id"), nullable=False)
@classmethod
def from_dict(cls, d):
def get_intra_extensions_dict(self):
with sql.transaction() as session:
query = session.query(IntraExtension.id)
- intraextensions = query.all()
- return {intraextension.id: IntraExtension.to_dict(intraextension) for intraextension in intraextensions}
+ ref_list = query.all()
+ return {_ref.id: _ref.intraextension for _ref in ref_list}
# TODO (dthom): load_intra_extension(self):
ref = query.first()
intra_extension_ref = ref.to_dict()
intra_extension_ref.update(intra_extension_dict)
- new_intra_extension = IntraExtension(
- id=intra_extension_id,
- intra_extension=intra_extension_ref
- )
+ new_intra_extension = IntraExtension(id=intra_extension_id, intra_extension=intra_extension_ref)
for attr in Tenant.attributes:
if attr != 'id':
setattr(ref, attr, getattr(new_intra_extension, attr))
query = session.query(SubjectCategory)
query = query.filter_by(intra_extension_id=intra_extension_id)
ref_list = query.all()
- return {_ref.id: _ref.to_dict()['subject_category'] for _ref in ref_list}
+ return {_ref.id: _ref.subject_category for _ref in ref_list}
def set_subject_category_dict(self, intra_extension_id, subject_category_id, subject_category_dict):
with sql.transaction() as session:
# Getter and Setter for object_category
- def get_object_category_dict(self, intra_extension_id):
+ def get_object_categories_dict(self, intra_extension_id):
with sql.transaction() as session:
query = session.query(ObjectCategory)
query = query.filter_by(intra_extension_id=intra_extension_id)
raise IntraExtensionUnknown()
return ref.to_dict()
- # TODO: to recheck
- def set_object_category_dict(self, intra_extension_id, object_categories):
+ def set_object_category_dict(self, intra_extension_id, object_category_id, object_category_dict):
with sql.transaction() as session:
query = session.query(ObjectCategory)
query = query.filter_by(intra_extension_id=intra_extension_id)
setattr(ref, attr, getattr(new_ref, attr))
return ref.to_dict()
- def add_object_category(self, intra_extension_id, object_category_id, object_category_name):
- with sql.transaction() as session:
- query = session.query(ObjectCategory)
- query = query.filter_by(intra_extension_id=intra_extension_id)
- ref = query.first()
- if not ref:
- raise IntraExtensionUnknown()
- old_ref = ref.to_dict()
- object_categories = dict(old_ref["object_categories"])
- # TODO: object_categories[object_category_id] is a dict
- object_categories[object_category_id] = object_category_name
- new_ref = ObjectCategory.from_dict(
- {
- "id": old_ref["id"],
- 'object_categories': object_categories,
- 'intra_extension_id': old_ref["intra_extension_id"]
- }
- )
- for attr in ObjectCategory.attributes:
- if attr != 'id':
- setattr(ref, attr, getattr(new_ref, attr))
- return ref.to_dict()
-
def del_object_category(self, intra_extension_id, object_category_id):
with sql.transaction() as session:
query = session.query(ObjectCategory)
# Getter and Setter for action_category
- def get_action_category_dict(self, intra_extension_id):
+ def get_action_categories_dict(self, intra_extension_id):
with sql.transaction() as session:
query = session.query(ActionCategory)
query = query.filter_by(intra_extension_id=intra_extension_id)
raise IntraExtensionUnknown()
return ref.to_dict()
- # TODO: to recheck
- def set_action_category_dict(self, intra_extension_id, action_categories):
+ def set_action_category_dict(self, intra_extension_id, action_category_id, action_category_dict):
with sql.transaction() as session:
query = session.query(ActionCategory)
query = query.filter_by(intra_extension_id=intra_extension_id)
setattr(ref, attr, getattr(new_ref, attr))
return ref.to_dict()
- def add_action_category(self, intra_extension_id, action_category_id, action_category_name):
- with sql.transaction() as session:
- query = session.query(ActionCategory)
- query = query.filter_by(intra_extension_id=intra_extension_id)
- ref = query.first()
- if not ref:
- raise IntraExtensionUnknown()
- old_ref = ref.to_dict()
- action_categories = dict(old_ref["action_categories"])
- # TODO: action_categories[action_category_id] is a dict
- action_categories[action_category_id] = action_category_name
- new_ref = ActionCategory.from_dict(
- {
- "id": old_ref["id"],
- 'action_categories': action_categories,
- 'intra_extension_id': old_ref["intra_extension_id"]
- }
- )
- for attr in ActionCategory.attributes:
- if attr != 'id':
- setattr(ref, attr, getattr(new_ref, attr))
- return ref.to_dict()
-
def del_action_category(self, intra_extension_id, action_category_id):
with sql.transaction() as session:
query = session.query(ActionCategory)
ref = query.first()
session.delete(ref)
- def get_object_dict(self, intra_extension_id):
+ def get_objects_dict(self, intra_extension_id):
with sql.transaction() as session:
query = session.query(Object)
query = query.filter_by(intra_extension_id=intra_extension_id)
raise IntraExtensionUnknown()
return ref.to_dict()
- # TODO: to recheck
- def set_object_dict(self, intraa_extension_id, object_id):
+ def set_object_dict(self, intra_extension_id, object_id, object_dict):
with sql.transaction() as session:
query = session.query(Object)
query = query.filter_by(intra_extension_id=intraa_extension_id)
setattr(ref, attr, getattr(new_ref, attr))
return ref.to_dict()
- def add_object(self, intra_extension_id, object_id, object_name):
- with sql.transaction() as session:
- query = session.query(Object)
- query = query.filter_by(intra_extension_id=intra_extension_id)
- ref = query.first()
- if not ref:
- raise IntraExtensionUnknown()
- old_ref = ref.to_dict()
- objects = dict(old_ref["objects"])
- # TODO: objects[object_id] is a dict
- objects[object_id] = object_name
- new_ref = Object.from_dict(
- {
- "id": old_ref["id"],
- 'objects': objects,
- 'intra_extension_id': old_ref["intra_extension_id"]
- }
- )
- for attr in Object.attributes:
- if attr != 'id':
- setattr(ref, attr, getattr(new_ref, attr))
- return ref.to_dict()
-
def del_object(self, intra_extension_id, object_id):
with sql.transaction() as session:
query = session.query(Object)
if attr != 'id':
setattr(ref, attr, getattr(new_ref, attr))
- def get_action_dict(self, intra_extension_id):
+ def get_actions_dict(self, intra_extension_id):
with sql.transaction() as session:
query = session.query(Action)
query = query.filter_by(intra_extension_id=intra_extension_id)
raise IntraExtensionUnknown()
return ref.to_dict()
- # TODO: to recheck
- def set_action_dict(self, intra_extension_id, action_id):
+ def set_action_dict(self, intra_extension_id, action_id, action_dict):
with sql.transaction() as session:
query = session.query(Action)
query = query.filter_by(intra_extension_id=intra_extension_id)
setattr(ref, attr, getattr(new_ref, attr))
return ref.to_dict()
- def add_action(self, intra_extension_id, action_id, action_name):
- with sql.transaction() as session:
- query = session.query(Action)
- query = query.filter_by(intra_extension_id=intra_extension_id)
- ref = query.first()
- if not ref:
- raise IntraExtensionUnknown()
- old_ref = ref.to_dict()
- actions = dict(old_ref["actions"])
- # TODO: actions[action_id] is a dict
- actions[action_id] = action_name
- new_ref = Action.from_dict(
- {
- "id": old_ref["id"],
- 'actions': actions,
- 'intra_extension_id': old_ref["intra_extension_id"]
- }
- )
- for attr in Action.attributes:
- if attr != 'id':
- setattr(ref, attr, getattr(new_ref, attr))
- return ref.to_dict()
-
def del_action(self, intra_extension_id, action_id):
with sql.transaction() as session:
query = session.query(Action)
# Getter and Setter for object_category_scope
- def get_object_scope_dict(self, intra_extension_id, object_category_id):
+ def get_object_scopes_dict(self, intra_extension_id, object_category_id):
with sql.transaction() as session:
query = session.query(ObjectScope)
query = query.filter_by(intra_extension_id=intra_extension_id)
raise ObjectScopeUnknown()
return result
- def set_object_scope_dict(self, intra_extension_id, object_category_id, object_scope_id):
+ def set_object_scope_dict(self, intra_extension_id, object_category_id, object_scope_id, object_scope_dict):
with sql.transaction() as session:
query = session.query(ObjectScope)
query = query.filter_by(intra_extension_id=intra_extension_id)
session.add(new_ref)
return new_ref.to_dict()
- def add_object_scope(self, intra_extension_id, object_category_id, object_scope_id, object_scope_name):
- with sql.transaction() as session:
- query = session.query(ObjectScope)
- query = query.filter_by(intra_extension_id=intra_extension_id)
- ref = query.first()
- if not ref:
- raise IntraExtensionUnknown()
- old_ref = ref.to_dict()
- scope = dict(old_ref["object_scope"])
- if object_category_id not in scope:
- scope[object_category_id] = dict()
- scope[object_category_id][object_scope_id] = object_scope_name
- return self.set_object_scope_dict(intra_extension_id, object_category_id, scope[object_category_id])
-
def del_object_scope(self, intra_extension_id, object_category_id, object_scope_id):
with sql.transaction() as session:
query = session.query(ObjectScope)
# Getter and Setter for action_scope
- def get_action_scope_dict(self, intra_extension_id, action_category_id):
+ def get_action_scopes_dict(self, intra_extension_id, action_category_id):
with sql.transaction() as session:
query = session.query(ActionScope)
query = query.filter_by(intra_extension_id=intra_extension_id)
raise ActionScopeUnknown()
return result
- def set_action_scope_dict(self, intra_extension_id, action_category_id, action_scope_id):
+ def set_action_scope_dict(self, intra_extension_id, action_category_id, action_scope_id, action_scope_dict):
with sql.transaction() as session:
query = session.query(ActionScope)
query = query.filter_by(intra_extension_id=intra_extension_id)
session.add(new_ref)
return new_ref.to_dict()
- def add_action_scope(self, intra_extension_id, action_category_id, action_scope_id, action_scope_name):
- with sql.transaction() as session:
- query = session.query(ActionScope)
- query = query.filter_by(intra_extension_id=intra_extension_id)
- ref = query.first()
- if not ref:
- raise IntraExtensionUnknown()
- old_ref = ref.to_dict()
- scope = dict(old_ref["action_scope"])
- if action_category_id not in scope:
- scope[action_category_id] = dict()
- scope[action_category_id][action_scope_id] = action_scope_name
- return self.set_action_scope_dict(intra_extension_id, action_category_id, scope[action_category_id])
-
def del_action_scope(self, intra_extension_id, action_category_id, action_scope_id):
with sql.transaction() as session:
query = session.query(ActionScope)
# Getter and Setter for object_category_assignment
- def get_object_assignment_dict(self, intra_extension_id, object_id):
+ def get_object_assignment_list(self, intra_extension_id, object_id, object_category_id):
""" From a object_uuid, return a dictionary of (category: scope for that object)
:param intra_extension_id: intra extension UUID
_ref["object_assignment"][object_id] = dict()
return _ref
- def set_object_assignment_dict(self, intra_extension_id, object_id=None, object_assignment_dict={}):
+ def set_object_assignment_list(self, intra_extension_id, object_id, object_category_id, object_assignment_list=[]):
with sql.transaction() as session:
query = session.query(ObjectAssignment)
query = query.filter_by(intra_extension_id=intra_extension_id)
setattr(ref, attr, getattr(new_ref, attr))
return ref.to_dict()
- def add_object_assignment(self, intra_extension_id, object_id, object_category_id, object_scope_id):
+ def add_object_assignment_list(self, intra_extension_id, object_id, object_category_id, object_scope_id):
with sql.transaction() as session:
query = session.query(ObjectAssignment)
query = query.filter_by(intra_extension_id=intra_extension_id)
assignments[object_id][object_category_id] = list()
if object_scope_id not in assignments[object_id][object_category_id]:
assignments[object_id][object_category_id].append(object_scope_id)
- return self.set_object_assignment_dict(
+ return self.set_object_assignment_list(
intra_extension_id,
object_id,
assignments[object_id])
old_ref["object_assignment"][object_id].pop(object_category_id)
if not old_ref["object_assignment"][object_id]:
old_ref["object_assignment"].pop(object_id)
- self.set_object_assignment_dict(
+ self.set_object_assignment_list(
intra_extension_id,
object_id,
old_ref["object_assignment"][object_id])
# Getter and Setter for action_category_assignment
- def get_action_assignment_dict(self, intra_extension_id, action_id):
+ def get_action_assignment_list(self, intra_extension_id, action_id, action_category_id):
""" From a action_id, return a dictionary of (category: scope for that action)
:param intra_extension_id: intra extension UUID
_ref["action_assignment"][action_id] = dict()
return _ref
- def set_action_assignment_dict(self, intra_extension_id, action_id=None, action_assignment_dict={}):
+ def set_action_assignment_list(self, intra_extension_id, action_id, action_category_id, action_assignment_list=[]):
with sql.transaction() as session:
query = session.query(ActionAssignment)
query = query.filter_by(intra_extension_id=intra_extension_id)
setattr(ref, attr, getattr(new_ref, attr))
return ref.to_dict()
- def add_action_assignment(self, intra_extension_id, action_id, action_category_id, action_scope_id):
+ def add_action_assignment_list(self, intra_extension_id, action_id, action_category_id, action_scope_id):
with sql.transaction() as session:
query = session.query(ActionAssignment)
query = query.filter_by(intra_extension_id=intra_extension_id)
assignments[action_id][action_category_id] = list()
if action_scope_id not in assignments[action_id][action_category_id]:
assignments[action_id][action_category_id].append(action_scope_id)
- return self.set_action_assignment_dict(
+ return self.set_action_assignment_list(
intra_extension_id,
action_id,
assignments[action_id])
old_ref["action_assignment"][action_id].pop(action_category_id)
if not old_ref["action_assignment"][action_id]:
old_ref["action_assignment"].pop(action_id)
- self.set_action_assignment_dict(
+ self.set_action_assignment_list(
intra_extension_id,
action_id,
old_ref["action_assignment"][action_id])
setattr(ref, attr, getattr(new_ref, attr))
return self.get_rules_dict(intra_extension_id, sub_meta_rule_id)[rule_id]
- def del_rule_dict(self, intra_extension_id, sub_meta_rule_id, rule_id):
+ def del_rule(self, intra_extension_id, sub_meta_rule_id, rule_id):
with sql.transaction() as session:
query = session.query(Rule)
query = query.filter_by(rule_id=rule_id)
user_id = self._get_user_id_from_token(context.get('token_id'))
ie_id = kw.get('intra_extension_id', None)
object_category_id = kw.get("object_category_id", None)
- return self.admin_api.get_object_category_dict(user_id, ie_id, object_category_id)
+ return self.admin_api.get_object_categories_dict(user_id, ie_id, object_category_id)
@controller.protected()
def del_object_category(self, context, **kw):
user_id = self._get_user_id_from_token(context.get('token_id'))
ie_id = kw.get('intra_extension_id', None)
action_category_id = kw.get("action_category_id", None)
- return self.admin_api.get_action_category_dict(user_id, ie_id, action_category_id)
+ return self.admin_api.get_action_categories_dict(user_id, ie_id, action_category_id)
@controller.protected()
def del_action_category(self, context, **kw):
ie_id = kw.get("intra_extension_id", None)
object_dict = dict()
object_dict['name'] = kw.get("object_name", None)
- return self.admin_api.add_object(user_id, ie_id, object_dict)
+ object_dict['description'] = kw.get("object_description", None)
+ return self.admin_api.add_object_dict(user_id, ie_id, object_dict)
@controller.protected()
def get_object(self, context, **kw):
user_id = self._get_user_id_from_token(context.get('token_id'))
ie_id = kw.get("intra_extension_id", None)
object_id = kw.get("object_id", None)
- return self.admin_api.get_object_dict(user_id, ie_id, object_id)
+ return self.admin_api.get_objects_dict(user_id, ie_id, object_id)
@controller.protected()
def del_object(self, context, **kw):
ie_id = kw.get("intra_extension_id", None)
action_dict = dict()
action_dict['name'] = kw.get("action_name", None)
- return self.admin_api.add_action(user_id, ie_id, action_dict)
+ action_dict['description'] = kw.get("action_description", None)
+ return self.admin_api.add_action_dict(user_id, ie_id, action_dict)
@controller.protected()
def get_action(self, context, **kw):
user_id = self._get_user_id_from_token(context.get('token_id'))
ie_id = kw.get("intra_extension_id", None)
action_id = kw.get("action_id", None)
- return self.admin_api.get_action_dict(user_id, ie_id, action_id)
+ return self.admin_api.get_actions_dict(user_id, ie_id, action_id)
@controller.protected()
def del_action(self, context, **kw):
def get_object_scopes(self, context, **kw):
user_id = self._get_user_id_from_token(context.get('token_id'))
ie_id = kw.get("intra_extension_id", None)
- object_category_id = kw["object_category_id"]
- return self.admin_api.get_object_scope_dict(user_id, ie_id, object_category_id)
+ object_category_id = kw.get("object_category_id", None)
+ return self.admin_api.get_object_scopes_dict(user_id, ie_id, object_category_id)
@controller.protected()
def add_object_scope(self, context, **kw):
user_id = self._get_user_id_from_token(context.get('token_id'))
ie_id = kw.get("intra_extension_id", None)
- object_category_id = kw["object_category_id"]
- object_scope_name = kw["object_scope_name"]
- return self.admin_api.add_object_scope(
- user_id,
- ie_id,
- object_category_id,
- object_scope_name)
+ object_category_id = kw.get("object_category_id", None)
+ object_scope_dict = dict()
+ object_scope_dict['name'] = kw.get("object_scope_name", None)
+ object_scope_dict['description'] = kw.get("object_scope_description", None)
+ return self.admin_api.add_object_scope_dict(user_id, ie_id, object_category_id, object_scope_dict)
@controller.protected()
def get_object_scope(self, context, **kw):
user_id = self._get_user_id_from_token(context.get('token_id'))
ie_id = kw.get("intra_extension_id", None)
- object_category_id = kw["object_category_id"]
- object_scope_id = kw["object_scope_id"]
- return self.admin_api.get_object_category_scope(user_id, ie_id, object_category_id, object_scope_id)
+ object_category_id = kw.get("object_category_id", None)
+ object_scope_id = kw.get("object_scope_id", None)
+ return self.admin_api.get_object_scopes_dict(user_id, ie_id, object_category_id, object_scope_id)
@controller.protected()
def del_object_scope(self, context, **kw):
user_id = self._get_user_id_from_token(context.get('token_id'))
ie_id = kw.get("intra_extension_id", None)
- object_category_id = kw["object_category_id"]
- object_scope_id = kw["object_scope_id"]
- self.admin_api.del_object_scope(
- user_id,
- ie_id,
- object_category_id,
- object_scope_id)
+ object_category_id = kw.get("object_category_id", None)
+ object_scope_id = kw.get("object_scope_id", None)
+ self.admin_api.del_object_scope(user_id, ie_id, object_category_id, object_scope_id)
+
+ @controller.protected()
+ def set_object_scope(self, context, **kw):
+ user_id = self._get_user_id_from_token(context.get('token_id'))
+ ie_id = kw.get("intra_extension_id", None)
+ object_category_id = kw.get("object_category_id", None)
+ object_scope_id = kw.get("object_scope_id", None)
+ object_scope_dict = dict()
+ object_scope_dict['name'] = kw.get("object_scope_name", None)
+ object_scope_dict['description'] = kw.get("object_scope_description", None)
+ return self.admin_api.set_object_scope_dict(user_id, ie_id, object_category_id, object_scope_id, object_scope_dict)
@controller.protected()
def get_action_scopes(self, context, **kw):
user_id = self._get_user_id_from_token(context.get('token_id'))
ie_id = kw.get("intra_extension_id", None)
- action_category_id = kw["action_category_id"]
- return self.admin_api.get_action_scope_dict(user_id, ie_id, action_category_id)
+ action_category_id = kw.get("action_category_id", None)
+ return self.admin_api.get_action_scopes_dict(user_id, ie_id, action_category_id)
@controller.protected()
def add_action_scope(self, context, **kw):
user_id = self._get_user_id_from_token(context.get('token_id'))
ie_id = kw.get("intra_extension_id", None)
- action_category_id = kw["action_category_id"]
- action_scope_name = kw["action_scope_name"]
- return self.admin_api.add_action_scope(
- user_id,
- ie_id,
- action_category_id,
- action_scope_name)
+ action_category_id = kw.get("action_category_id", None)
+ action_scope_dict = dict()
+ action_scope_dict['name'] = kw.get("action_scope_name", None)
+ action_scope_dict['description'] = kw.get("action_scope_description", None)
+ return self.admin_api.add_action_scope_dict(user_id, ie_id, action_category_id, action_scope_dict)
@controller.protected()
def get_action_scope(self, context, **kw):
user_id = self._get_user_id_from_token(context.get('token_id'))
ie_id = kw.get("intra_extension_id", None)
- action_category_id = kw["action_category_id"]
- action_scope_id = kw["action_scope_id"]
- return self.admin_api.get_action_scope_dict(user_id, ie_id, action_category_id)[action_scope_id]
+ action_category_id = kw.get("action_category_id", None)
+ action_scope_id = kw.get("action_scope_id", None)
+ return self.admin_api.get_action_scopes_dict(user_id, ie_id, action_category_id, action_scope_id)
@controller.protected()
def del_action_scope(self, context, **kw):
user_id = self._get_user_id_from_token(context.get('token_id'))
ie_id = kw.get("intra_extension_id", None)
- action_category_id = kw["action_category_id"]
- action_scope_id = kw["action_scope_id"]
- self.admin_api.del_action_scope(
- user_id,
- ie_id,
- action_category_id,
- action_scope_id)
+ action_category_id = kw.get("action_category_id", None)
+ action_scope_id = kw.get("action_scope_id", None)
+ self.admin_api.del_action_scope(user_id, ie_id, action_category_id, action_scope_id)
+
+ @controller.protected()
+ def set_action_scope(self, context, **kw):
+ user_id = self._get_user_id_from_token(context.get('token_id'))
+ ie_id = kw.get("intra_extension_id", None)
+ action_category_id = kw.get("action_category_id", None)
+ action_scope_id = kw.get("action_scope_id", None)
+ action_scope_dict = dict()
+ action_scope_dict['name'] = kw.get("action_scope_name", None)
+ action_scope_dict['description'] = kw.get("action_scope_description", None)
+ return self.admin_api.set_action_scope_dict(user_id, ie_id, action_category_id, action_scope_id, action_scope_dict)
# Assignment functions
subject_id = kw.get("subject_id", None)
subject_category_id = kw.get("subject_category_id", None)
subject_scope_id = kw.get("subject_scope_id", None)
- return self.admin_api.add_subject_assignment_list(
- user_id,
- ie_id,
- subject_id,
- subject_category_id,
- subject_scope_id)
+ return self.admin_api.add_subject_assignment_list(user_id, ie_id, subject_id, subject_category_id, subject_scope_id)
@controller.protected()
def get_subject_assignment(self, context, **kw):
subject_id = kw.get("subject_id", None)
subject_category_id = kw.get("subject_category_id", None)
subject_scope_id = kw.get("subject_scope_id", None)
- self.admin_api.del_subject_assignment(
- user_id,
- ie_id,
- subject_id,
- subject_category_id,
- subject_scope_id)
-
- @controller.protected()
- def get_object_assignments(self, context, **kw):
- user_id = self._get_user_id_from_token(context.get('token_id'))
- ie_id = kw.get("intra_extension_id", None)
- object_id = kw["object_id"]
- return self.admin_api.get_object_assignment_dict(user_id, ie_id, object_id)
+ self.admin_api.del_subject_assignment(user_id, ie_id, subject_id, subject_category_id, subject_scope_id)
@controller.protected()
def add_object_assignment(self, context, **kw):
user_id = self._get_user_id_from_token(context.get('token_id'))
ie_id = kw.get("intra_extension_id", None)
- object_id = kw["object_id"]
- object_category_id = kw["object_category_id"]
- object_scope_id = kw["object_scope_id"]
- return self.admin_api.add_objecty_assignment(
- user_id,
- ie_id,
- object_id,
- object_category_id,
- object_scope_id)
+ object_id = kw.get("object_id", None)
+ object_category_id = kw.get("object_category_id", None)
+ object_scope_id = kw.get("object_scope_id", None)
+ return self.admin_api.add_objecty_assignment_list(user_id, ie_id, object_id, object_category_id, object_scope_id)
@controller.protected()
def get_object_assignment(self, context, **kw):
user_id = self._get_user_id_from_token(context.get('token_id'))
ie_id = kw.get("intra_extension_id", None)
- object_id = kw["object_id"]
- object_category_id = kw["object_category_id"]
- return self.admin_api.get_object_assignment_dict(user_id, ie_id, object_id, object_category_id)
+ object_id = kw.get("object_id", None)
+ object_category_id = kw.get("object_category_id", None)
+ return self.admin_api.get_object_assignment_list(user_id, ie_id, object_id, object_category_id)
@controller.protected()
def del_object_assignment(self, context, **kw):
user_id = self._get_user_id_from_token(context.get('token_id'))
ie_id = kw.get("intra_extension_id", None)
- object_id = kw["object_id"]
- object_category_id = kw["object_category_id"]
- object_scope_id = kw["object_scope_id"]
- self.admin_api.del_object_assignment(
- user_id,
- ie_id,
- object_id,
- object_category_id,
- object_scope_id)
-
- @controller.protected()
- def get_action_assignments(self, context, **kw):
- user_id = self._get_user_id_from_token(context.get('token_id'))
- ie_id = kw.get("intra_extension_id", None)
- action_id = kw["action_id"]
- return self.admin_api.get_action_assignment_dict(user_id, ie_id, action_id)
+ object_id = kw.get("object_id", None)
+ object_category_id = kw.get("object_category_id", None)
+ object_scope_id = kw.get("object_scope_id", None)
+ self.admin_api.del_object_assignment(user_id, ie_id, object_id, object_category_id, object_scope_id)
@controller.protected()
def add_action_assignment(self, context, **kw):
user_id = self._get_user_id_from_token(context.get('token_id'))
ie_id = kw.get("intra_extension_id", None)
- action_id = kw["action_id"]
- action_category_id = kw["action_category_id"]
- action_scope_id = kw["action_scope_id"]
- return self.admin_api.add_action_assignment(
- user_id,
- ie_id,
- action_id,
- action_category_id,
- action_scope_id)
+ action_id = kw.get("action_id", None)
+ action_category_id = kw.get("action_category_id", None)
+ action_scope_id = kw.get("action_scope_id", None)
+ return self.admin_api.add_action_assignment_list(user_id, ie_id, action_id, action_category_id, action_scope_id)
@controller.protected()
def get_action_assignment(self, context, **kw):
user_id = self._get_user_id_from_token(context.get('token_id'))
ie_id = kw.get("intra_extension_id", None)
- action_id = kw["action_id"]
- action_category_id = kw["action_category_id"]
- return self.admin_api.get_action_assignment_dict(user_id, ie_id, action_id, action_category_id)
+ action_id = kw.get("action_id", None)
+ action_category_id = kw.get("action_category_id", None)
+ return self.admin_api.get_action_assignment_list(user_id, ie_id, action_id, action_category_id)
@controller.protected()
def del_action_assignment(self, context, **kw):
user_id = self._get_user_id_from_token(context.get('token_id'))
ie_id = kw.get("intra_extension_id", None)
- action_id = kw["action_id"]
- action_category_id = kw["action_category_id"]
- action_scope_id = kw["action_scope_id"]
- self.admin_api.del_action_assignment(
- user_id,
- ie_id,
- action_id,
- action_category_id,
- action_scope_id)
+ action_id = kw.get("action_id", None)
+ action_category_id = kw.get("action_category_id", None)
+ action_scope_id = kw.get("action_scope_id", None)
+ self.admin_api.del_action_assignment(user_id, ie_id, action_id, action_category_id, action_scope_id)
# Metarule functions
@controller.protected()
authz_buffer['action_id'] = action_id
meta_data_dict = dict()
meta_data_dict["subject_categories"] = self.driver.get_subject_categories_dict(intra_extension_id)
- meta_data_dict["object_categories"] = self.driver.get_object_category_dict(intra_extension_id)
- meta_data_dict["action_categories"] = self.driver.get_action_category_dict(intra_extension_id)
+ meta_data_dict["object_categories"] = self.driver.get_object_categories_dict(intra_extension_id)
+ meta_data_dict["action_categories"] = self.driver.get_action_categories_dict(intra_extension_id)
subject_assignment_dict = dict()
for category in meta_data_dict["subject_categories"]:
subject_assignment_dict[category] = self.driver.get_subject_assignment_list(
intra_extension_id, subject_id)[category]
object_assignment_dict = dict()
for category in meta_data_dict["object_categories"]:
- object_assignment_dict[category] = self.driver.get_object_assignment_dict(
+ object_assignment_dict[category] = self.driver.get_object_assignment_list(
intra_extension_id, object_id)[category]
action_assignment_dict = dict()
for category in meta_data_dict["action_categories"]:
- action_assignment_dict[category] = self.driver.get_action_assignment_dict(
+ action_assignment_dict[category] = self.driver.get_action_assignment_list(
intra_extension_id, action_id)[category]
authz_buffer['subject_attributes'] = dict()
authz_buffer['object_attributes'] = dict()
)
# Note (dthom): object_category_assignment must be initialized because when there is no data in json
# we will not go through the for loop
- self.driver.set_object_assignment_dict(intra_extension_dict["id"])
+ self.driver.set_object_assignment_list(intra_extension_dict["id"])
for object in object_assignments:
- self.driver.set_object_assignment_dict(intra_extension_dict["id"], object, object_assignments[object])
+ self.driver.set_object_assignment_list(intra_extension_dict["id"], object, object_assignments[object])
action_assignments = dict()
for category_name, value in json_assignments["action_assignments"].iteritems():
)
# Note (dthom): action_category_assignment must be initialized because when there is no data in json
# we will not go through the for loop
- self.driver.set_action_assignment_dict(intra_extension_dict["id"])
+ self.driver.set_action_assignment_list(intra_extension_dict["id"])
for action in action_assignments:
- self.driver.set_action_assignment_dict(intra_extension_dict["id"], action, action_assignments[action])
+ self.driver.set_action_assignment_list(intra_extension_dict["id"], action, action_assignments[action])
def __load_metarule_file(self, intra_extension_dict, policy_dir):
:param intra_extension_id:
:return:
"""
- return self.driver.get_object_category_dict(intra_extension_id)
+ return self.driver.get_object_categories_dict(intra_extension_id)
@filter_args
@enforce(("read", "write"), "object_categories")
@enforce(("read", "write"), "object_scopes")
def add_object_category(self, user_id, intra_extension_id, object_category_name):
- object_category_dict = self.driver.get_object_category_dict(intra_extension_id)
+ object_category_dict = self.driver.get_object_categories_dict(intra_extension_id)
for object_category_id in object_category_dict:
if object_category_dict[object_category_id]["name"] is object_category_name:
raise ObjectCategoryNameExisting()
@filter_args
@enforce("read", "object_categories")
def get_object_category(self, user_id, intra_extension_id, object_category_id):
- object_category_dict = self.driver.get_object_category_dict(intra_extension_id)
+ object_category_dict = self.driver.get_object_categories_dict(intra_extension_id)
if object_category_id not in object_category_dict:
raise ObjectCategoryUnknown()
return object_category_dict[object_category_id]
@enforce(("read", "write"), "object_scopes")
@enforce(("read", "write"), "object_assignments")
def del_object_category(self, user_id, intra_extension_id, object_category_id):
- object_category_dict = self.driver.get_object_category_dict(intra_extension_id)
+ object_category_dict = self.driver.get_object_categories_dict(intra_extension_id)
if object_category_id not in object_category_dict:
raise ObjectCategoryUnknown()
# TODO (dthom): destroy category in scope
:param intra_extension_id:
:return:
"""
- return self.driver.get_action_category_dict(intra_extension_id)
+ return self.driver.get_action_categories_dict(intra_extension_id)
@filter_args
@enforce(("read", "write"), "action_categories")
@enforce(("read", "write"), "action_scopes")
def add_action_category(self, user_id, intra_extension_id, action_category_name):
- action_category_dict = self.driver.get_action_category_dict(intra_extension_id)
+ action_category_dict = self.driver.get_action_categories_dict(intra_extension_id)
for action_category_id in action_category_dict:
if action_category_dict[action_category_id]['name'] is action_category_name:
raise ActionCategoryNameExisting()
@filter_args
@enforce("read", "action_categories")
def get_action_category(self, user_id, intra_extension_id, action_category_id):
- action_category_dict = self.driver.get_action_category_dict(intra_extension_id)
+ action_category_dict = self.driver.get_action_categories_dict(intra_extension_id)
if action_category_id not in action_category_dict:
raise ActionCategoryUnknown()
- return self.driver.get_action_category_dict(intra_extension_id)[action_category_id]
+ return self.driver.get_action_categories_dict(intra_extension_id)[action_category_id]
@filter_args
@enforce(("read", "write"), "action_categories")
@enforce(("read", "write"), "action_category_scopes")
def del_action_category(self, user_id, intra_extension_id, action_category_id):
- action_category_dict = self.driver.get_action_category_dict(intra_extension_id)
+ action_category_dict = self.driver.get_action_categories_dict(intra_extension_id)
if action_category_id not in action_category_dict:
raise ActionCategoryUnknown()
# TODO (dthom): destroy category in scope
@filter_args
@enforce("read", "objects")
def get_object_dict(self, user_id, intra_extension_id):
- return self.driver.get_object_dict(intra_extension_id)
+ return self.driver.get_objects_dict(intra_extension_id)
@filter_args
@enforce(("read", "write"), "objects")
def add_object(self, user_id, intra_extension_id, object_name):
- object_dict = self.driver.get_object_dict(intra_extension_id)
+ object_dict = self.driver.get_objects_dict(intra_extension_id)
for object_id in object_dict:
if object_dict[object_id]["name"] is object_name:
raise ObjectNameExisting()
@filter_args
@enforce("read", "objects")
def get_object(self, user_id, intra_extension_id, object_id):
- object_dict = self.driver.get_object_dict(intra_extension_id)
+ object_dict = self.driver.get_objects_dict(intra_extension_id)
if object_id in object_dict:
raise ObjectUnknown()
return object_dict[object_id]
@filter_args
@enforce(("read", "write"), "objects")
def del_object(self, user_id, intra_extension_id, object_id):
- if object_id in self.driver.get_object_dict(intra_extension_id):
+ if object_id in self.driver.get_objects_dict(intra_extension_id):
raise ObjectUnknown()
# TODO (dthom): destroy item-related assignment
return self.driver.del_object(intra_extension_id, object_id)
@filter_args
@enforce("read", "actions")
def get_action_dict(self, user_id, intra_extension_id):
- return self.driver.get_action_dict(intra_extension_id)
+ return self.driver.get_actions_dict(intra_extension_id)
@filter_args
@enforce(("read", "write"), "actions")
def add_action(self, user_id, intra_extension_id, action_name):
- action_dict = self.driver.get_action_dict(intra_extension_id)
+ action_dict = self.driver.get_actions_dict(intra_extension_id)
for action_id in action_dict:
if action_dict[action_id]["name"] is action_name:
raise ActionNameExisting()
@filter_args
@enforce("read", "actions")
def get_action(self, user_id, intra_extension_id, action_id):
- action_dict = self.driver.get_action_dict(intra_extension_id)
+ action_dict = self.driver.get_actions_dict(intra_extension_id)
if action_id in action_dict:
raise ActionUnknown()
return action_dict[action_id]
@filter_args
@enforce(("read", "write"), "actions")
def del_action(self, user_id, intra_extension_id, action_id):
- if action_id in self.driver.get_action_dict(intra_extension_id):
+ if action_id in self.driver.get_actions_dict(intra_extension_id):
raise ActionUnknown()
# TODO (dthom): destroy item-related assignment
return self.driver.del_action(intra_extension_id, action_id)
@enforce("read", "object_category_scopes")
@enforce("read", "object_categories")
def get_object_scope_dict(self, user_id, intra_extension_id, object_category_id):
- if object_category_id not in self.driver.get_object_category_dict(intra_extension_id):
+ if object_category_id not in self.driver.get_object_categories_dict(intra_extension_id):
raise ObjectCategoryUnknown()
- return self.driver.get_object_scope_dict(intra_extension_id, object_category_id)
+ return self.driver.get_object_scopes_dict(intra_extension_id, object_category_id)
@filter_args
@enforce(("read", "write"), "object_scopes")
@enforce("read", "object_categories")
def add_object_scope(self, user_id, intra_extension_id, object_category_id, object_scope_name):
- if object_category_id not in self.driver.get_object_category_dict(intra_extension_id):
+ if object_category_id not in self.driver.get_object_categories_dict(intra_extension_id):
raise ObjectCategoryUnknown()
- object_scope_dict = self.driver.get_object_scope_dict(intra_extension_id, object_category_id)
+ object_scope_dict = self.driver.get_object_scopes_dict(intra_extension_id, object_category_id)
for _object_scope_id in object_scope_dict:
if object_scope_name is object_scope_dict[_object_scope_id]['name']:
raise ObjectScopeNameExisting()
@enforce("read", "object_scopes")
@enforce("read", "object_categories")
def get_object_scope(self, user_id, intra_extension_id, object_category_id, object_scope_id):
- if object_category_id not in self.driver.get_object_category_dict(intra_extension_id):
+ if object_category_id not in self.driver.get_object_categories_dict(intra_extension_id):
raise ObjectCategoryUnknown()
- object_scopte_dict = self.driver.get_object_scope_dict(intra_extension_id, object_category_id)
+ object_scopte_dict = self.driver.get_object_scopes_dict(intra_extension_id, object_category_id)
if object_scope_id not in object_scopte_dict:
raise ObjectScopeUnknown()
return object_scopte_dict[object_scope_id]
@enforce(("read", "write"), "object_scopes")
@enforce("read", "object_categories")
def del_object_scope(self, user_id, intra_extension_id, object_category_id, object_scope_id):
- if object_category_id not in self.driver.get_object_category_dict(intra_extension_id):
+ if object_category_id not in self.driver.get_object_categories_dict(intra_extension_id):
raise ObjectCategoryUnknown()
- if object_scope_id not in self.driver.get_object_scope_dict(intra_extension_id, object_category_id):
+ if object_scope_id not in self.driver.get_object_scopes_dict(intra_extension_id, object_category_id):
raise ObjectScopeUnknown()
# TODO (dthom): destroy scope-related assignment
# TODO (dthom): destroy scope-related rule
@enforce("read", "action_category_scopes")
@enforce("read", "action_categories")
def get_action_scope_dict(self, user_id, intra_extension_id, action_category_id):
- if action_category_id not in self.driver.get_object_category_dict(intra_extension_id):
+ if action_category_id not in self.driver.get_object_categories_dict(intra_extension_id):
raise ActionCategoryUnknown()
- return self.driver.get_action_scope_dict(intra_extension_id, action_category_id)
+ return self.driver.get_action_scopes_dict(intra_extension_id, action_category_id)
@filter_args
@enforce(("read", "write"), "action_scopes")
@enforce("read", "action_categories")
def add_action_scope(self, user_id, intra_extension_id, action_category_id, action_scope_name):
- if action_category_id not in self.driver.get_action_category_dict(intra_extension_id):
+ if action_category_id not in self.driver.get_action_categories_dict(intra_extension_id):
raise ActionCategoryUnknown()
- action_scope_dict = self.driver.get_action_scope_dict(intra_extension_id, action_category_id)
+ action_scope_dict = self.driver.get_action_scopes_dict(intra_extension_id, action_category_id)
for _action_scope_id in action_scope_dict:
if action_scope_name is action_scope_dict[_action_scope_id]['name']:
raise ActionScopeNameExisting()
@enforce("read", "action_scopes")
@enforce("read", "action_categories")
def get_action_scope(self, user_id, intra_extension_id, action_category_id, action_scope_id):
- if action_category_id not in self.driver.get_action_category_dict(intra_extension_id):
+ if action_category_id not in self.driver.get_action_categories_dict(intra_extension_id):
raise ActionCategoryUnknown()
- action_scopte_dict = self.driver.get_action_scope_dict(intra_extension_id, action_category_id)
+ action_scopte_dict = self.driver.get_action_scopes_dict(intra_extension_id, action_category_id)
if action_scope_id not in action_scopte_dict:
raise ActionScopeUnknown()
return action_scopte_dict[action_scope_id]
@enforce(("read", "write"), "action_scopes")
@enforce("read", "action_categories")
def del_action_scope(self, user_id, intra_extension_id, action_category_id, action_scope_id):
- if action_category_id not in self.driver.get_action_category_dict(intra_extension_id):
+ if action_category_id not in self.driver.get_action_categories_dict(intra_extension_id):
raise ActionCategoryUnknown()
- if action_scope_id not in self.driver.get_action_scope_dict(intra_extension_id, action_category_id):
+ if action_scope_id not in self.driver.get_action_scopes_dict(intra_extension_id, action_category_id):
raise ActionScopeUnknown()
# TODO (dthom): destroy scope-related assignment
# TODO (dthom): destroy scope-related rule
def get_object_assignment_dict(self, user_id, intra_extension_id, object_id):
if object_id not in self.get_object_dict(user_id, intra_extension_id):
raise ObjectUnknown()
- return self.driver.get_object_assignment_dict(intra_extension_id, object_id)
+ return self.driver.get_object_assignment_list(intra_extension_id, object_id)
@filter_args
@enforce(("read", "write"), "object_assignments")
@enforce("read", "objects")
@enforce("read", "object_categories")
def add_object_assignment(self, user_id, intra_extension_id, object_id, object_category_id, object_scope_id):
- if object_id not in self.driver.get_object_dict(intra_extension_id):
+ if object_id not in self.driver.get_objects_dict(intra_extension_id):
raise ObjectUnknown()
- elif object_category_id not in self.driver.get_object_category_dict(intra_extension_id):
+ elif object_category_id not in self.driver.get_object_categories_dict(intra_extension_id):
raise ObjectCategoryUnknown()
- elif object_scope_id not in self.driver.get_object_scope_dict(intra_extension_id, object_category_id):
+ elif object_scope_id not in self.driver.get_object_scopes_dict(intra_extension_id, object_category_id):
raise ObjectScopeUnknown()
- elif object_scope_id in self.driver.get_object_assignment_dict(intra_extension_id, object_id)[object_category_id]:
+ elif object_scope_id in self.driver.get_object_assignment_list(intra_extension_id, object_id)[object_category_id]:
raise ObjectAssignmentExisting()
- return self.driver.add_object_assignment(intra_extension_id, object_id, object_category_id, object_scope_id)
+ return self.driver.add_object_assignment_list(intra_extension_id, object_id, object_category_id, object_scope_id)
@filter_args
@enforce("read", "object_assignments")
@enforce("read", "objects")
@enforce("read", "object_categories")
def get_object_assignment(self, user_id, intra_extension_id, object_id, object_category_id):
- if object_id not in self.driver.get_object_dict(user_id, intra_extension_id):
+ if object_id not in self.driver.get_objects_dict(user_id, intra_extension_id):
raise ObjectUnknown()
- elif object_category_id not in self.driver.get_object_category_dict(intra_extension_id):
+ elif object_category_id not in self.driver.get_object_categories_dict(intra_extension_id):
raise ObjectCategoryUnknown()
- return self.driver.get_object_assignment_dict(intra_extension_id, object_id)[object_category_id]
+ return self.driver.get_object_assignment_list(intra_extension_id, object_id)[object_category_id]
@filter_args
@enforce(("read", "write"), "object_assignments")
@enforce("read", "object_categories")
@enforce("read", "object_scopes")
def del_object_assignment(self, user_id, intra_extension_id, object_id, object_category_id, object_scope_id):
- if object_id not in self.driver.get_object_dict(intra_extension_id):
+ if object_id not in self.driver.get_objects_dict(intra_extension_id):
raise ObjectUnknown()
- elif object_category_id not in self.driver.get_object_category_dict(intra_extension_id):
+ elif object_category_id not in self.driver.get_object_categories_dict(intra_extension_id):
raise ObjectCategoryUnknown()
- elif object_scope_id not in self.driver.get_object_scope_dict(intra_extension_id, object_category_id):
+ elif object_scope_id not in self.driver.get_object_scopes_dict(intra_extension_id, object_category_id):
raise ObjectScopeUnknown()
elif object_scope_id not in self.driver.get_subject_assignment_list(intra_extension_id, object_id)[object_category_id]:
raise ObjectAssignmentUnknown()
def get_action_assignment_dict(self, user_id, intra_extension_id, action_id):
if action_id not in self.get_action_dict(user_id, intra_extension_id):
raise ActionUnknown()
- return self.driver.get_action_assignment_dict(intra_extension_id, action_id)
+ return self.driver.get_action_assignment_list(intra_extension_id, action_id)
@filter_args
@enforce(("read", "write"), "action_assignments")
@enforce("read", "actions")
@enforce("read", "action_categories")
def add_action_assignment(self, user_id, intra_extension_id, action_id, action_category_id, action_scope_id):
- if action_id not in self.driver.get_action_dict(intra_extension_id):
+ if action_id not in self.driver.get_actions_dict(intra_extension_id):
raise ActionUnknown()
- elif action_category_id not in self.driver.get_action_category_dict(intra_extension_id):
+ elif action_category_id not in self.driver.get_action_categories_dict(intra_extension_id):
raise ActionCategoryUnknown()
- elif action_scope_id not in self.driver.get_action_scope_dict(intra_extension_id, action_category_id):
+ elif action_scope_id not in self.driver.get_action_scopes_dict(intra_extension_id, action_category_id):
raise ActionScopeUnknown()
- elif action_scope_id in self.driver.get_action_assignment_dict(intra_extension_id, action_id)[action_category_id]:
+ elif action_scope_id in self.driver.get_action_assignment_list(intra_extension_id, action_id)[action_category_id]:
raise ObjectAssignmentExisting()
- return self.driver.add_action_assignment(intra_extension_id, action_id, action_category_id, action_scope_id)
+ return self.driver.add_action_assignment_list(intra_extension_id, action_id, action_category_id, action_scope_id)
@filter_args
@enforce("read", "action_assignments")
@enforce("read", "actions")
@enforce("read", "action_categories")
def get_action_assignment(self, user_id, intra_extension_id, action_id, action_category_id):
- if action_id not in self.driver.get_action_dict(user_id, intra_extension_id):
+ if action_id not in self.driver.get_actions_dict(user_id, intra_extension_id):
raise ActionUnknown()
- elif action_category_id not in self.driver.get_action_category_dict(intra_extension_id):
+ elif action_category_id not in self.driver.get_action_categories_dict(intra_extension_id):
raise ActionCategoryUnknown()
- return self.driver.get_action_assignment_dict(intra_extension_id, action_id)[action_category_id]
+ return self.driver.get_action_assignment_list(intra_extension_id, action_id)[action_category_id]
@filter_args
@enforce(("read", "write"), "action_assignments")
@enforce("read", "action_categories")
@enforce("read", "action_scopes")
def del_action_assignment(self, user_id, intra_extension_id, action_id, action_category_id, action_scope_id):
- if action_id not in self.driver.get_action_dict(intra_extension_id):
+ if action_id not in self.driver.get_actions_dict(intra_extension_id):
raise ActionUnknown()
- elif action_category_id not in self.driver.get_action_category_dict(intra_extension_id):
+ elif action_category_id not in self.driver.get_action_categories_dict(intra_extension_id):
raise ActionCategoryUnknown()
- elif action_scope_id not in self.driver.get_action_scope_dict(intra_extension_id, action_category_id):
+ elif action_scope_id not in self.driver.get_action_scopes_dict(intra_extension_id, action_category_id):
raise ActionScopeUnknown()
- elif action_scope_id not in self.driver.get_action_assignment_dict(intra_extension_id, action_id)[action_category_id]:
+ elif action_scope_id not in self.driver.get_action_assignment_list(intra_extension_id, action_id)[action_category_id]:
raise ActionAssignmentUnknown()
return self.driver.del_action_assignment(intra_extension_id, action_id, action_category_id, action_scope_id)
subject_id = _subject_id
if not subject_id:
raise SubjectUnknown()
- objects_dict = self.driver.get_object_dict(intra_extension_id)
+ objects_dict = self.driver.get_objects_dict(intra_extension_id)
object_id = None
for _object_id in objects_dict:
if objects_dict[_object_id]['name'] is object_name:
object_id = _object_id
if not object_id:
raise ObjectUnknown()
- actions_dict = self.driver.get_action_dict(intra_extension_id)
+ actions_dict = self.driver.get_actions_dict(intra_extension_id)
action_id = None
for _action_id in actions_dict:
if actions_dict[_action_id] is action_name:
(uuid and uuid not in data_values.keys()):
raise SubjectUnknown()
elif data_name == self.OBJECT:
- data_values = self.get_object_dict(intra_extension_uuid)["objects"]
+ data_values = self.get_objects_dict(intra_extension_uuid)["objects"]
if (name and name not in extract_name(data_values)) or \
(uuid and uuid not in data_values.keys()):
raise ObjectUnknown()
elif data_name == self.ACTION:
- data_values = self.get_action_dict(intra_extension_uuid)["actions"]
+ data_values = self.get_actions_dict(intra_extension_uuid)["actions"]
if (name and name not in extract_name(data_values)) or \
(uuid and uuid not in data_values.keys()):
raise ActionUnknown()
(uuid and uuid not in data_values.keys()):
raise SubjectCategoryUnknown()
elif data_name == self.OBJECT_CATEGORY:
- data_values = self.get_object_category_dict(intra_extension_uuid)["object_categories"]
+ data_values = self.get_object_categories_dict(intra_extension_uuid)["object_categories"]
if (name and name not in extract_name(data_values)) or \
(uuid and uuid not in data_values.keys()):
raise ObjectCategoryUnknown()
elif data_name == self.ACTION_CATEGORY:
- data_values = self.get_action_category_dict(intra_extension_uuid)["action_categories"]
+ data_values = self.get_action_categories_dict(intra_extension_uuid)["action_categories"]
if (name and name not in extract_name(data_values)) or \
(uuid and uuid not in data_values.keys()):
raise ActionCategoryUnknown()
elif data_name == self.OBJECT_SCOPE:
if not category_uuid:
category_uuid = self.get_uuid_from_name(intra_extension_uuid, category_name, self.OBJECT_CATEGORY)
- data_values = self.get_object_scope_dict(intra_extension_uuid,
+ data_values = self.get_object_scopes_dict(intra_extension_uuid,
category_uuid)["object_category_scope"]
if (name and name not in extract_name(data_values)) or \
(uuid and uuid not in data_values.keys()):
elif data_name == self.ACTION_SCOPE:
if not category_uuid:
category_uuid = self.get_uuid_from_name(intra_extension_uuid, category_name, self.ACTION_CATEGORY)
- data_values = self.get_action_scope_dict(intra_extension_uuid,
+ data_values = self.get_action_scopes_dict(intra_extension_uuid,
category_uuid)["action_category_scope"]
if (name and name not in extract_name(data_values)) or \
(uuid and uuid not in data_values.keys()):
def del_subject_category(self, intra_extension_id, subject_category_id):
raise exception.NotImplemented() # pragma: no cover
- def get_object_category_dict(self, intra_extension_id):
+ def get_object_categories_dict(self, intra_extension_id):
"""Get a list of all object categories
:param intra_extension_id: IntraExtension UUID
"""
raise exception.NotImplemented() # pragma: no cover
- def set_object_category_dict(self, intra_extension_id, object_category_dict):
- """Set the list of all object categories
-
- :param intra_extension_id: IntraExtension UUID
- :type intra_extension_id: string
- :param object_category_dict: dict of object categories {"uuid1": "name1", "uuid2": "name2"}
- :type object_category_dict: dict
- :return: a dictionary containing all object categories {"uuid1": "name1", "uuid2": "name2"}
- """
- raise exception.NotImplemented() # pragma: no cover
-
- def add_object_category(self, intra_extension_id, object_category_id, object_category_name):
- """Add a object category
-
- :param intra_extension_id: IntraExtension UUID
- :type intra_extension_id: string
- :param object_category_id: the UUID of the object category
- :type object_category_id: string
- :param object_category_name: the name of the object category
- :type object_category_name: string
- :return: a dictionnary with the object catgory added {"uuid1": "name1"}
- """
+ def set_object_category_dict(self, intra_extension_id, object_category_id, object_category_dict):
raise exception.NotImplemented() # pragma: no cover
def del_object_category(self, intra_extension_id, object_category_id):
- """Remove one object category
-
- :param intra_extension_id: IntraExtension UUID
- :type intra_extension_id: string
- :param object_category_id: the UUID of object category to remove
- :type object_category_id: string
- :return: a dictionary containing all object categories {"uuid1": "name1", "uuid2": "name2"}
- """
- raise exception.NotImplemented() # pragma: no cover
-
- def get_action_category_dict(self, intra_extension_id):
- """Get a list of all action categories
-
- :param intra_extension_id: IntraExtension UUID
- :type intra_extension_id: string
- :return: a dictionary containing all action categories {"uuid1": "name1", "uuid2": "name2"}
- """
raise exception.NotImplemented() # pragma: no cover
- def set_action_category_dict(self, intra_extension_id, action_category_dict):
- """Set the list of all action categories
-
- :param intra_extension_id: IntraExtension UUID
- :type intra_extension_id: string
- :param action_category_dict: dict of action categories {"uuid1": "name1", "uuid2": "name2"}
- :type action_category_dict: dict
- :return: a dictionary containing all action categories {"uuid1": "name1", "uuid2": "name2"}
- """
+ def get_action_categories_dict(self, intra_extension_id):
raise exception.NotImplemented() # pragma: no cover
- def add_action_category(self, intra_extension_id, action_category_id, action_category_name):
- """Add a action category
-
- :param intra_extension_id: IntraExtension UUID
- :type intra_extension_id: string
- :param action_category_id: the UUID of the action category
- :type action_category_id: string
- :param action_category_name: the name of the action category
- :type action_category_name: string
- :return: a dictionnary with the action catgory added {"uuid1": "name1"}
- """
+ def set_action_category_dict(self, intra_extension_id, action_category_id, action_category_dict):
raise exception.NotImplemented() # pragma: no cover
def del_action_category(self, intra_extension_id, action_category_id):
- """Remove one action category
-
- :param intra_extension_id: IntraExtension UUID
- :type intra_extension_id: string
- :param action_category_id: the UUID of action category to remove
- :type action_category_id: string
- :return: a dictionary containing all action categories {"uuid1": "name1", "uuid2": "name2"}
- """
raise exception.NotImplemented() # pragma: no cover
# Perimeter functions
def get_subjects_dict(self, intra_extension_id):
- """Get the list of subject for that IntraExtension
-
- :param intra_extension_id: IntraExtension UUID
- :type intra_extension_id: string
- :return: a dictionary containing all subjects for that IntraExtension, eg. {"uuid1": "name1", "uuid2": "name2"}
- """
raise exception.NotImplemented() # pragma: no cover
def set_subject_dict(self, intra_extension_id, subject_id, subject_dict):
def del_subject(self, intra_extension_id, subject_id):
raise exception.NotImplemented() # pragma: no cover
- def get_object_dict(self, intra_extension_id):
- raise exception.NotImplemented() # pragma: no cover
-
- def set_object_dict(self, intra_extension_id, object_dict):
+ def get_objects_dict(self, intra_extension_id):
raise exception.NotImplemented() # pragma: no cover
- def add_object(self, intra_extension_id, object_id, object_name):
+ def set_object_dict(self, intra_extension_id, object_id, object_dict):
raise exception.NotImplemented() # pragma: no cover
def del_object(self, intra_extension_id, object_id):
raise exception.NotImplemented() # pragma: no cover
- def get_action_dict(self, intra_extension_id):
+ def get_actions_dict(self, intra_extension_id):
raise exception.NotImplemented() # pragma: no cover
- def set_action_dict(self, intra_extension_id, action_dict):
- raise exception.NotImplemented() # pragma: no cover
-
- def add_action(self, intra_extension_id, action_id, action_name):
+ def set_action_dict(self, intra_extension_id, action_id, action_dict):
raise exception.NotImplemented() # pragma: no cover
def del_action(self, intra_extension_id, action_id):
def del_subject_scope(self, intra_extension_id, subject_category_id, subject_scope_id):
raise exception.NotImplemented() # pragma: no cover
- def get_object_scope_dict(self, intra_extension_id, object_category_id):
- """Get a list of all object category scope
-
- :param intra_extension_id: IntraExtension UUID
- :type intra_extension_id: string
- :param object_category_id: the category UUID where the scope values are
- :type object_category_id: string
- :return: a dictionary containing all object category scope {"category1": {"scope_uuid1": "scope_name1}}
- """
- raise exception.NotImplemented() # pragma: no cover
-
- def set_object_scope_dict(self, intra_extension_id, object_category_id, object_scope_dict):
- """Set the list of all scope for that object category
-
- :param intra_extension_id: IntraExtension UUID
- :type intra_extension_id: string
- :param object_category_id: the UUID of the object category where this scope will be set
- :type object_category_id: string
- :return: a dictionary containing all scope {"scope_uuid1": "scope_name1, "scope_uuid2": "scope_name2}
- """
+ def get_object_scopes_dict(self, intra_extension_id, object_category_id):
raise exception.NotImplemented() # pragma: no cover
- def add_object_scope(self, intra_extension_id, object_category_id, object_scope_id, object_scope_name):
- """Add a object category
-
- :param intra_extension_id: IntraExtension UUID
- :type intra_extension_id: string
- :param object_category_id: the object category UUID where the scope will be added
- :type object_category_id: string
- :param object_scope_id: the UUID of the object category
- :type object_scope_id: string
- :param object_scope_name: the name of the object category
- :type object_scope_name: string
- :return: a dictionary containing the object category scope added {"category1": {"scope_uuid1": "scope_name1}}
- """
+ def set_object_scope_dict(self, intra_extension_id, object_category_id, object_scope_id, object_scope_dict):
raise exception.NotImplemented() # pragma: no cover
def del_object_scope(self, intra_extension_id, object_category_id, object_scope_id):
- """Remove one scope belonging to a object category
-
- :param intra_extension_id: IntraExtension UUID
- :type intra_extension_id: string
- :param object_category_id: the UUID of object categorywhere we can find the scope to remove
- :type object_category_id: string
- :param object_scope_id: the UUID of the scope to remove
- :type object_scope_id: string
- :return: None
- """
- raise exception.NotImplemented() # pragma: no cover
-
- def get_action_scope_dict(self, intra_extension_id, action_category_id):
- """Get a list of all action category scope
-
- :param intra_extension_id: IntraExtension UUID
- :type intra_extension_id: string
- :param action_category_id: the category UUID where the scope values are
- :type action_category_id: string
- :return: a dictionary containing all action category scope {"category1": {"scope_uuid1": "scope_name1}}
- """
raise exception.NotImplemented() # pragma: no cover
- def set_action_scope_dict(self, intra_extension_id, action_category_id, action_scope_id):
- """Set the list of all scope for that action category
-
- :param intra_extension_id: IntraExtension UUID
- :type intra_extension_id: string
- :param action_category_id: the UUID of the action category where this scope will be set
- :type action_category_id: string
- :return: a dictionary containing all scope {"scope_uuid1": "scope_name1, "scope_uuid2": "scope_name2}
- """
+ def get_action_scopes_dict(self, intra_extension_id, action_category_id):
raise exception.NotImplemented() # pragma: no cover
- def add_action_scope(self, intra_extension_id, action_category_id, action_scope_id, action_scope_name):
- """Add a action category
-
- :param intra_extension_id: IntraExtension UUID
- :type intra_extension_id: string
- :param action_category_id: the action category UUID where the scope will be added
- :type action_category_id: string
- :param action_scope_id: the UUID of the action category
- :type action_scope_id: string
- :param action_scope_name: the name of the action category
- :type action_scope_name: string
- :return: a dictionary containing the action category scope added {"category1": {"scope_uuid1": "scope_name1}}
- """
+ def set_action_scope_dict(self, intra_extension_id, action_category_id, action_scope_id, action_scope_dict):
raise exception.NotImplemented() # pragma: no cover
def del_action_scope(self, intra_extension_id, action_category_id, action_scope_id):
- """Remove one scope belonging to a action category
-
- :param intra_extension_id: IntraExtension UUID
- :type intra_extension_id: string
- :param action_category_id: the UUID of action categorywhere we can find the scope to remove
- :type action_category_id: string
- :param action_scope_id: the UUID of the scope to remove
- :type action_scope_id: string
- :return: None
- """
raise exception.NotImplemented() # pragma: no cover
# Assignment functions
def del_subject_assignment(self, intra_extension_id, subject_id, subject_category_id, subject_scope_id):
raise exception.NotImplemented() # pragma: no cover
- def get_object_assignment_dict(self, intra_extension_id, object_id):
+ def get_object_assignment_list(self, intra_extension_id, object_id, object_category_id):
raise exception.NotImplemented() # pragma: no cover
- def set_object_assignment_dict(self, intra_extension_id, object_id, object_assignment_dict):
+ def set_object_assignment_list(self, intra_extension_id, object_id, object_category_id, object_assignment_list):
raise exception.NotImplemented() # pragma: no cover
- def add_object_assignment(self, intra_extension_id, object_id, object_category_id, object_scope_id):
+ def add_object_assignment_list(self, intra_extension_id, object_id, object_category_id, object_scope_id):
raise exception.NotImplemented() # pragma: no cover
def del_object_assignment(self, intra_extension_id, object_id, object_category_id, object_scope_id):
raise exception.NotImplemented() # pragma: no cover
- def get_action_assignment_dict(self, intra_extension_id, action_id):
+ def get_action_assignment_list(self, intra_extension_id, action_id, action_category_id):
raise exception.NotImplemented() # pragma: no cover
- def set_action_assignment_dict(self, intra_extension_id, action_id, action_assignment_dict):
+ def set_action_assignment_list(self, intra_extension_id, action_id, action_category_id, action_assignment_list):
raise exception.NotImplemented() # pragma: no cover
- def add_action_assignment(self, intra_extension_id, action_id, action_category_id, action_scope_id):
+ def add_action_assignment_list(self, intra_extension_id, action_id, action_category_id, action_scope_id):
raise exception.NotImplemented() # pragma: no cover
def del_action_assignment(self, intra_extension_id, action_id, action_category_id, action_scope_id):
def set_rule_dict(self, intra_extension_id, sub_meta_rule_id, rule_id, rule_list):
raise exception.NotImplemented() # pragma: no cover
- def del_rule_dict(self, intra_extension_id, sub_meta_rule_id, rule_id):
+ def del_rule(self, intra_extension_id, sub_meta_rule_id, rule_id):
raise exception.NotImplemented() # pragma: no cover
class LogDriver(object):
Code Review / moon.git / commitdiff