From e23e30ea41726f334ee46ee6698ef75e7bf1d001 Mon Sep 17 00:00:00 2001 From: WuKong Date: Fri, 17 Jul 2015 15:27:50 +0200 Subject: review backends Change-Id: Ic82081a421e672a3fff0559f5fbd82736316803e Signed-off-by: WuKong --- keystone-moon/keystone/contrib/moon/algorithms.py | 12 +- .../keystone/contrib/moon/backends/sql.py | 1152 ++++++++++---------- keystone-moon/keystone/contrib/moon/core.py | 42 +- 3 files changed, 622 insertions(+), 584 deletions(-) (limited to 'keystone-moon/keystone/contrib') diff --git a/keystone-moon/keystone/contrib/moon/algorithms.py b/keystone-moon/keystone/contrib/moon/algorithms.py index 49690f64..fe35b7ee 100644 --- a/keystone-moon/keystone/contrib/moon/algorithms.py +++ b/keystone-moon/keystone/contrib/moon/algorithms.py @@ -37,14 +37,14 @@ rule_dict = [ def inclusion(authz_buffer, sub_meta_rule_dict, rule_list): _cat = [] for subject_cat in sub_meta_rule_dict['subject_categories']: - if subject_cat in authz_buffer['subject_attributes']: - _cat.append(authz_buffer['subject_attributes'][subject_cat]) + if subject_cat in authz_buffer['subject_assignments']: + _cat.append(authz_buffer['subject_assignments'][subject_cat]) for action_cat in sub_meta_rule_dict['action_categories']: - if action_cat in authz_buffer['action_attributes']: - _cat.append(authz_buffer['action_attributes'][action_cat]) + if action_cat in authz_buffer['action_assignments']: + _cat.append(authz_buffer['action_assignments'][action_cat]) for object_cat in sub_meta_rule_dict['object_categories']: - if object_cat in authz_buffer['object_attributes']: - _cat.append(authz_buffer['object_attributes'][object_cat]) + if object_cat in authz_buffer['object_assignments']: + _cat.append(authz_buffer['object_assignments'][object_cat]) for _element in itertools.product(*_cat): if list(_element) in rule_list: diff --git a/keystone-moon/keystone/contrib/moon/backends/sql.py b/keystone-moon/keystone/contrib/moon/backends/sql.py index 4da0f1c8..b328112c 100644 --- a/keystone-moon/keystone/contrib/moon/backends/sql.py +++ b/keystone-moon/keystone/contrib/moon/backends/sql.py @@ -17,14 +17,12 @@ from keystone.contrib.moon import IntraExtensionDriver from keystone.contrib.moon import TenantDriver # from keystone.contrib.moon import InterExtensionDriver -from keystone.contrib.moon.exception import TenantException, TenantListEmpty - CONF = config.CONF LOG = log.getLogger(__name__) class IntraExtension(sql.ModelBase, sql.DictBase): - __tablename__ = 'intra_extension' + __tablename__ = 'intra_extensions' attributes = ['id', 'name', 'model', 'description'] id = sql.Column(sql.String(64), primary_key=True) name = sql.Column(sql.String(64), nullable=False) @@ -40,12 +38,12 @@ class IntraExtension(sql.ModelBase, sql.DictBase): return dict(six.iteritems(self)) -class Subject(sql.ModelBase, sql.DictBase): - __tablename__ = 'subject' - attributes = ['id', 'subjects', 'intra_extension_uuid'] +class SubjectCategory(sql.ModelBase, sql.DictBase): + __tablename__ = 'subject_categories' + attributes = ['id', 'subject_category', 'intra_extension_id'] id = sql.Column(sql.String(64), primary_key=True) - subjects = sql.Column(sql.JsonBlob(), nullable=True) - intra_extension_uuid = sql.Column(sql.ForeignKey("intra_extension.id"), nullable=False) + subject_category = sql.Column(sql.JsonBlob(), nullable=True) + intra_extension_id = sql.Column(sql.ForeignKey("intra_extensions.id"), nullable=False) @classmethod def from_dict(cls, d): @@ -56,12 +54,12 @@ class Subject(sql.ModelBase, sql.DictBase): return dict(six.iteritems(self)) -class Object(sql.ModelBase, sql.DictBase): - __tablename__ = 'object' - attributes = ['id', 'objects', 'intra_extension_uuid'] +class ObjectCategory(sql.ModelBase, sql.DictBase): + __tablename__ = 'object_categories' + attributes = ['id', 'object_category', 'intra_extension_id'] id = sql.Column(sql.String(64), primary_key=True) - objects = sql.Column(sql.JsonBlob(), nullable=True) - intra_extension_uuid = sql.Column(sql.ForeignKey("intra_extension.id"), nullable=False) + object_category = sql.Column(sql.JsonBlob(), nullable=True) + intra_extension_id = sql.Column(sql.ForeignKey("intra_extensions.id"), nullable=False) @classmethod def from_dict(cls, d): @@ -72,12 +70,12 @@ class Object(sql.ModelBase, sql.DictBase): return dict(six.iteritems(self)) -class Action(sql.ModelBase, sql.DictBase): - __tablename__ = 'action' - attributes = ['id', 'actions', 'intra_extension_uuid'] +class ActionCategory(sql.ModelBase, sql.DictBase): + __tablename__ = 'action_categories' + attributes = ['id', 'action_category', 'intra_extension_id'] id = sql.Column(sql.String(64), primary_key=True) - actions = sql.Column(sql.JsonBlob(), nullable=True) - intra_extension_uuid = sql.Column(sql.ForeignKey("intra_extension.id"), nullable=False) + action_category = sql.Column(sql.JsonBlob(), nullable=True) + intra_extension_id = sql.Column(sql.ForeignKey("intra_extensions.id"), nullable=False) @classmethod def from_dict(cls, d): @@ -88,12 +86,12 @@ class Action(sql.ModelBase, sql.DictBase): return dict(six.iteritems(self)) -class SubjectCategory(sql.ModelBase, sql.DictBase): - __tablename__ = 'subject_category' - attributes = ['id', 'subject_categories', 'intra_extension_uuid'] +class Subject(sql.ModelBase, sql.DictBase): + __tablename__ = 'subjects' + attributes = ['id', 'subject', 'intra_extension_id'] id = sql.Column(sql.String(64), primary_key=True) - subject_categories = sql.Column(sql.JsonBlob(), nullable=True) - intra_extension_uuid = sql.Column(sql.ForeignKey("intra_extension.id"), nullable=False) + subject = sql.Column(sql.JsonBlob(), nullable=True) + intra_extension_id = sql.Column(sql.ForeignKey("intra_extensions.id"), nullable=False) @classmethod def from_dict(cls, d): @@ -104,12 +102,12 @@ class SubjectCategory(sql.ModelBase, sql.DictBase): return dict(six.iteritems(self)) -class ObjectCategory(sql.ModelBase, sql.DictBase): - __tablename__ = 'object_category' - attributes = ['id', 'object_categories', 'intra_extension_uuid'] +class Object(sql.ModelBase, sql.DictBase): + __tablename__ = 'objects' + attributes = ['id', 'object', 'intra_extension_id'] id = sql.Column(sql.String(64), primary_key=True) - object_categories = sql.Column(sql.JsonBlob(), nullable=True) - intra_extension_uuid = sql.Column(sql.ForeignKey("intra_extension.id"), nullable=False) + object = sql.Column(sql.JsonBlob(), nullable=True) + intra_extension_id = sql.Column(sql.ForeignKey("intra_extensions.id"), nullable=False) @classmethod def from_dict(cls, d): @@ -120,12 +118,12 @@ class ObjectCategory(sql.ModelBase, sql.DictBase): return dict(six.iteritems(self)) -class ActionCategory(sql.ModelBase, sql.DictBase): - __tablename__ = 'action_category' - attributes = ['id', 'action_categories', 'intra_extension_uuid'] +class Action(sql.ModelBase, sql.DictBase): + __tablename__ = 'actions' + attributes = ['id', 'action', 'intra_extension_id'] id = sql.Column(sql.String(64), primary_key=True) - action_categories = sql.Column(sql.JsonBlob(), nullable=True) - intra_extension_uuid = sql.Column(sql.ForeignKey("intra_extension.id"), nullable=False) + action = sql.Column(sql.JsonBlob(), nullable=True) + intra_extension_id = sql.Column(sql.ForeignKey("intra_extensions.id"), nullable=False) @classmethod def from_dict(cls, d): @@ -136,12 +134,13 @@ class ActionCategory(sql.ModelBase, sql.DictBase): return dict(six.iteritems(self)) -class SubjectCategoryScope(sql.ModelBase, sql.DictBase): - __tablename__ = 'subject_category_scope' - attributes = ['id', 'subject_category_scope', 'intra_extension_uuid'] +class SubjectScope(sql.ModelBase, sql.DictBase): + __tablename__ = 'subject_scopes' + attributes = ['id', 'subject_scope', 'intra_extension_id', 'subject_category_id'] id = sql.Column(sql.String(64), primary_key=True) - subject_category_scope = sql.Column(sql.JsonBlob(), nullable=True) - intra_extension_uuid = sql.Column(sql.ForeignKey("intra_extension.id"), nullable=False) + subject_scope = sql.Column(sql.JsonBlob(), nullable=True) + intra_extension_id = sql.Column(sql.ForeignKey("intra_extensions.id"), nullable=False) + subject_category_id = sql.Column(sql.ForeignKey("subject_categories.id"), nullable=False) @classmethod def from_dict(cls, d): @@ -152,12 +151,13 @@ class SubjectCategoryScope(sql.ModelBase, sql.DictBase): return dict(six.iteritems(self)) -class ObjectCategoryScope(sql.ModelBase, sql.DictBase): - __tablename__ = 'object_category_scope' - attributes = ['id', 'object_category_scope', 'intra_extension_uuid'] +class ObjectScope(sql.ModelBase, sql.DictBase): + __tablename__ = 'object_scopes' + attributes = ['id', 'object_scope', 'intra_extension_id', 'object_category_id'] id = sql.Column(sql.String(64), primary_key=True) - object_category_scope = sql.Column(sql.JsonBlob(), nullable=True) - intra_extension_uuid = sql.Column(sql.ForeignKey("intra_extension.id"), nullable=False) + object_scope = sql.Column(sql.JsonBlob(), nullable=True) + intra_extension_id = sql.Column(sql.ForeignKey("intra_extensions.id"), nullable=False) + object_category_id = sql.Column(sql.ForeignKey("object_categories.id"), nullable=False) @classmethod def from_dict(cls, d): @@ -168,12 +168,13 @@ class ObjectCategoryScope(sql.ModelBase, sql.DictBase): return dict(six.iteritems(self)) -class ActionCategoryScope(sql.ModelBase, sql.DictBase): - __tablename__ = 'action_category_scope' - attributes = ['id', 'action_category_scope', 'intra_extension_uuid'] +class ActionScope(sql.ModelBase, sql.DictBase): + __tablename__ = 'action_scopes' + attributes = ['id', 'action_scope', 'intra_extension_id', 'action_category'] id = sql.Column(sql.String(64), primary_key=True) - action_category_scope = sql.Column(sql.JsonBlob(), nullable=True) - intra_extension_uuid = sql.Column(sql.ForeignKey("intra_extension.id"), nullable=False) + action_scope = sql.Column(sql.JsonBlob(), nullable=True) + intra_extension_id = sql.Column(sql.ForeignKey("intra_extensions.id"), nullable=False) + action_category_id = sql.Column(sql.ForeignKey("action_categories.id"), nullable=False) @classmethod def from_dict(cls, d): @@ -184,12 +185,13 @@ class ActionCategoryScope(sql.ModelBase, sql.DictBase): return dict(six.iteritems(self)) -class SubjectCategoryAssignment(sql.ModelBase, sql.DictBase): - __tablename__ = 'subject_category_assignment' - attributes = ['id', 'subject_category_assignments', 'intra_extension_uuid'] +class SubjectAssignment(sql.ModelBase, sql.DictBase): + __tablename__ = 'subject_assignments' + attributes = ['id', 'subject_assignment', 'intra_extension_id', 'subject_id'] id = sql.Column(sql.String(64), primary_key=True) - subject_category_assignments = sql.Column(sql.JsonBlob(), nullable=True) - intra_extension_uuid = sql.Column(sql.ForeignKey("intra_extension.id"), nullable=False) + subject_assignment = sql.Column(sql.JsonBlob(), nullable=True) + intra_extension_id = sql.Column(sql.ForeignKey("intra_extensions.id"), nullable=False) + subject_id = sql.Column(sql.ForeignKey("subjects.id"), nullable=False) @classmethod def from_dict(cls, d): @@ -200,12 +202,13 @@ class SubjectCategoryAssignment(sql.ModelBase, sql.DictBase): return dict(six.iteritems(self)) -class ObjectCategoryAssignment(sql.ModelBase, sql.DictBase): - __tablename__ = 'object_category_assignment' - attributes = ['id', 'object_category_assignments', 'intra_extension_uuid'] +class ObjectAssignment(sql.ModelBase, sql.DictBase): + __tablename__ = 'object_assignments' + attributes = ['id', 'object_assignment', 'intra_extension_id', 'object_id'] id = sql.Column(sql.String(64), primary_key=True) - object_category_assignments = sql.Column(sql.JsonBlob(), nullable=True) - intra_extension_uuid = sql.Column(sql.ForeignKey("intra_extension.id"), nullable=False) + 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) @classmethod def from_dict(cls, d): @@ -216,12 +219,13 @@ class ObjectCategoryAssignment(sql.ModelBase, sql.DictBase): return dict(six.iteritems(self)) -class ActionCategoryAssignment(sql.ModelBase, sql.DictBase): - __tablename__ = 'action_category_assignment' - attributes = ['id', 'action_category_assignments', 'intra_extension_uuid'] +class ActionAssignment(sql.ModelBase, sql.DictBase): + __tablename__ = 'action_assignments' + attributes = ['id', 'action_assignment', 'intra_extension_id', 'action_id'] id = sql.Column(sql.String(64), primary_key=True) - action_category_assignments = sql.Column(sql.JsonBlob(), nullable=True) - intra_extension_uuid = sql.Column(sql.ForeignKey("intra_extension.id"), nullable=False) + 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) @classmethod def from_dict(cls, d): @@ -232,13 +236,28 @@ class ActionCategoryAssignment(sql.ModelBase, sql.DictBase): return dict(six.iteritems(self)) -class MetaRule(sql.ModelBase, sql.DictBase): - __tablename__ = 'metarule' - attributes = ['id', 'sub_meta_rules', 'aggregation', 'intra_extension_uuid'] +class AggregationAlgorithm(sql.ModelBase, sql.DictBase): + __tablename__ = 'aggregation_algorithm' + attributes = ['id', 'aggregation_algorithm_id', 'intra_extension_id'] id = sql.Column(sql.String(64), primary_key=True) - sub_meta_rules = sql.Column(sql.JsonBlob(), nullable=True) - aggregation = sql.Column(sql.Text(), nullable=True) - intra_extension_uuid = sql.Column(sql.ForeignKey("intra_extension.id"), nullable=False) + aggregation_algorithm_id = sql.Column(sql.Text(), nullable=True) + intra_extension_id = sql.Column(sql.ForeignKey("intra_extensions.id"), nullable=False) + + @classmethod + def from_dict(cls, d): + new_d = d.copy() + return cls(**new_d) + + def to_dict(self): + return dict(six.iteritems(self)) + + +class SubMetaRule(sql.ModelBase, sql.DictBase): + __tablename__ = 'sub_meta_rules' + attributes = ['id', 'sub_meta_rule', 'intra_extension_id'] + id = sql.Column(sql.String(64), primary_key=True) + sub_meta_rule = sql.Column(sql.JsonBlob(), nullable=True) + intra_extension_id = sql.Column(sql.ForeignKey("intra_extensions.id"), nullable=False) @classmethod def from_dict(cls, d): @@ -250,11 +269,12 @@ class MetaRule(sql.ModelBase, sql.DictBase): class Rule(sql.ModelBase, sql.DictBase): - __tablename__ = 'rule' - attributes = ['id', 'rules', 'intra_extension_uuid'] + __tablename__ = 'rules' + attributes = ['id', 'rule', 'intra_extension_id', 'sub_meta_rule_id'] id = sql.Column(sql.String(64), primary_key=True) - rules = sql.Column(sql.JsonBlob(), nullable=True) - intra_extension_uuid = sql.Column(sql.ForeignKey("intra_extension.id"), nullable=False) + rule = sql.Column(sql.JsonBlob(), nullable=True) + intra_extension_id = sql.Column(sql.ForeignKey("intra_extensions.id"), nullable=False) + sub_meta_rule_id = sql.Column(sql.ForeignKey("sub_meta_rules.id"), nullable=False) @classmethod def from_dict(cls, d): @@ -298,23 +318,25 @@ __all_objects__ = ( SubjectCategory, ObjectCategory, ActionCategory, - SubjectCategoryScope, - ObjectCategoryScope, - ActionCategoryScope, - SubjectCategoryAssignment, - ObjectCategoryAssignment, - ActionCategoryAssignment, - MetaRule, + SubjectScope, + ObjectScope, + ActionScope, + SubjectAssignment, + ObjectAssignment, + ActionAssignment, + AggregationAlgorithm, + SubMetaRule, Rule, ) class IntraExtensionConnector(IntraExtensionDriver): + # Tenant functions + def get_intra_extension_dict(self): with sql.transaction() as session: query = session.query(IntraExtension.id) intraextensions = query.all() - # return intraextensions return [intraextension[0] for intraextension in intraextensions] def set_intra_extension(self, intra_id, intra_extension): @@ -325,10 +347,10 @@ class IntraExtensionConnector(IntraExtensionDriver): session.add(ie_ref) return IntraExtension.to_dict(ie_ref) - def get_intra_extension(self, uuid): + def get_intra_extension(self, intra_extension_id): with sql.transaction() as session: query = session.query(IntraExtension) - query = query.filter_by(id=uuid) + query = query.filter_by(id=intra_extension_id) ref = query.first() if not ref: raise exception.NotFound @@ -340,1081 +362,1091 @@ class IntraExtensionConnector(IntraExtensionDriver): # Must delete all references to that IntraExtension for _object in __all_objects__: query = session.query(_object) - query = query.filter_by(intra_extension_uuid=intra_extension_id) + query = query.filter_by(intra_extension_id=intra_extension_id) _ref = query.first() if _ref: session.delete(_ref) session.flush() session.delete(ref) - # Getter and setter for name - - def get_name(self, uuid): - intra_extension = self.get_intra_extension(uuid) + def get_intra_extension_name(self, intra_extension_id): + intra_extension = self.get_intra_extension(intra_extension_id) return intra_extension["name"] - def set_name(self, uuid, name): + def set_intra_extension_name(self, intra_extension_id, intra_extension_name): raise exception.NotImplemented() # pragma: no cover - # Getter and setter for model - - def get_model(self, uuid): - intra_extension = self.get_intra_extension(uuid) + def get_intra_extension_model(self, intra_extension_id): + intra_extension = self.get_intra_extension(intra_extension_id) return intra_extension["model"] - def set_model(self, uuid, model): + def set_intra_extension_model(self, intra_extension_id, intra_extension_model): raise exception.NotImplemented() # pragma: no cover - # Getter and setter for description - - def get_description(self, uuid): - intra_extension = self.get_intra_extension(uuid) + def get_intra_extension_description(self, intra_extension_id): + intra_extension = self.get_intra_extension(intra_extension_id) return intra_extension["description"] - def set_description(self, uuid, args): + def set_intra_extension_description(self, intra_extension_id, intra_extension_description): raise exception.NotImplemented() # pragma: no cover - # Perimeter + # Getter and Setter for subject_category - def get_subject_dict(self, extension_uuid): + def get_subject_category_dict(self, intra_extension_id): with sql.transaction() as session: - query = session.query(Subject) - query = query.filter_by(intra_extension_uuid=extension_uuid) + query = session.query(SubjectCategory) + query = query.filter_by(intra_extension_id=intra_extension_id) ref = query.first() if not ref: raise IntraExtensionUnknown() return ref.to_dict() - def set_subject_dict(self, extension_uuid, subject_uuid): + # TODO: review the code + def set_subject_category_dict(self, intra_extension_id, subject_category_id, subject_category_dict): with sql.transaction() as session: - query = session.query(Subject) - query = query.filter_by(intra_extension_uuid=extension_uuid) + query = session.query(SubjectCategory) + query = query.filter_by(intra_extension_id=intra_extension_id) ref = query.first() - new_ref = Subject.from_dict( + if not ref: + raise IntraExtensionUnknown() + old_ref = ref.to_dict() + new_ref = SubjectCategory.from_dict( { - "id": uuid4().hex, - 'subjects': subject_uuid, - 'intra_extension_uuid': extension_uuid + "id": subject_category_id, + 'subject_category': subject_category_dict, + 'intra_extension_id': intra_extension_id } ) - if not ref: - session.add(new_ref) - ref = new_ref - else: - for attr in Subject.attributes: - if attr != 'id': - setattr(ref, attr, getattr(new_ref, attr)) + for attr in SubjectCategory.attributes: + if attr != 'id': + setattr(ref, attr, getattr(new_ref, attr)) return ref.to_dict() - def add_subject(self, extension_uuid, subject_uuid, subject_name): + # TODO: review the code + def add_subject_category(self, intra_extension_id, subject_category_id, subject_category_name): with sql.transaction() as session: - query = session.query(Subject) - query = query.filter_by(intra_extension_uuid=extension_uuid) + query = session.query(SubjectCategory) + query = query.filter_by(intra_extension_id=intra_extension_id) ref = query.first() - if not ref: - raise IntraExtensionUnknown() - old_ref = ref.to_dict() - subjects = dict(old_ref["subjects"]) - subjects[subject_uuid] = subject_name - new_ref = Subject.from_dict( + subject_category_dict = { + 'name': subject_category_name, + 'description': None + } + new_ref = SubjectCategory.from_dict( { - "id": old_ref["id"], - 'subjects': subjects, - 'intra_extension_uuid': old_ref["intra_extension_uuid"] + "id": subject_category_id, + 'subject_category': subject_category_dict, + 'intra_extension_id': intra_extension_id } ) - for attr in Subject.attributes: - if attr != 'id': - setattr(ref, attr, getattr(new_ref, attr)) + if not ref: + session.add(new_ref) + ref = new_ref + else: + for attr in SubjectCategory.attributes: + if attr != 'id': + setattr(ref, attr, getattr(new_ref, attr)) return ref.to_dict() - def del_subject(self, extension_uuid, subject_uuid): + def del_subject_category(self, intra_extension_id, subject_category_id): with sql.transaction() as session: - query = session.query(Subject) - query = query.filter_by(intra_extension_uuid=extension_uuid) + query = session.query(SubjectCategory) + query = query.filter_by(intra_extension_id=intra_extension_id) ref = query.first() if not ref: raise IntraExtensionUnknown() else: old_ref = ref.to_dict() - subjects = dict(old_ref["subjects"]) + subject_category_dict = dict(old_ref["subject_category"]) try: - subjects.pop(subject_uuid) + subject_category_dict.pop(subject_category_id) except KeyError: - LOG.error("KeyError in remove_subject {} | {}".format(subject_uuid, subjects)) + pass else: - new_ref = Subject.from_dict( + new_ref = SubjectCategory.from_dict( { "id": old_ref["id"], - 'subjects': subjects, - 'intra_extension_uuid': old_ref["intra_extension_uuid"] + 'subject_categories': subject_category_dict, + 'intra_extension_id': old_ref["intra_extension_id"] } ) - for attr in Subject.attributes: + for attr in SubjectCategory.attributes: if attr != 'id': setattr(ref, attr, getattr(new_ref, attr)) + return ref.to_dict() - def get_object_dict(self, extension_uuid): + # Getter and Setter for object_category + + def get_object_category_dict(self, intra_extension_id): with sql.transaction() as session: - query = session.query(Object) - query = query.filter_by(intra_extension_uuid=extension_uuid) + query = session.query(ObjectCategory) + query = query.filter_by(intra_extension_id=intra_extension_id) ref = query.first() if not ref: raise IntraExtensionUnknown() return ref.to_dict() - def set_object_dict(self, extension_uuid, object_uuid): + # TODO: to recheck + def set_object_category_dict(self, intra_extension_id, object_categories): with sql.transaction() as session: - query = session.query(Object) - query = query.filter_by(intra_extension_uuid=extension_uuid) + query = session.query(ObjectCategory) + query = query.filter_by(intra_extension_id=intra_extension_id) ref = query.first() - new_ref = Object.from_dict( + new_ref = ObjectCategory.from_dict( { "id": uuid4().hex, - 'objects': object_uuid, - 'intra_extension_uuid': extension_uuid + 'object_categories': object_categories, + 'intra_extension_id': intra_extension_id } ) if not ref: session.add(new_ref) ref = new_ref else: - for attr in Object.attributes: + for attr in ObjectCategory.attributes: if attr != 'id': setattr(ref, attr, getattr(new_ref, attr)) return ref.to_dict() - def add_object(self, extension_uuid, object_uuid, object_name): + def add_object_category(self, intra_extension_id, object_category_id, object_category_name): with sql.transaction() as session: - query = session.query(Object) - query = query.filter_by(intra_extension_uuid=extension_uuid) + 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() - objects = dict(old_ref["objects"]) - objects[object_uuid] = object_name - new_ref = Object.from_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"], - 'objects': objects, - 'intra_extension_uuid': old_ref["intra_extension_uuid"] + 'object_categories': object_categories, + 'intra_extension_id': old_ref["intra_extension_id"] } ) - for attr in Object.attributes: + for attr in ObjectCategory.attributes: if attr != 'id': setattr(ref, attr, getattr(new_ref, attr)) return ref.to_dict() - def del_object(self, extension_uuid, object_uuid): + def del_object_category(self, intra_extension_id, object_category_id): with sql.transaction() as session: - query = session.query(Object) - query = query.filter_by(intra_extension_uuid=extension_uuid) + query = session.query(ObjectCategory) + query = query.filter_by(intra_extension_id=intra_extension_id) ref = query.first() if not ref: raise IntraExtensionUnknown() else: old_ref = ref.to_dict() - objects = dict(old_ref["objects"]) + object_categories = dict(old_ref["object_categories"]) try: - objects.pop(object_uuid) + object_categories.pop(object_category_id) except KeyError: - LOG.error("KeyError in remove_object {} | {}".format(object_uuid, objects)) + pass else: - new_ref = Object.from_dict( + new_ref = ObjectCategory.from_dict( { "id": old_ref["id"], - 'objects': objects, - 'intra_extension_uuid': old_ref["intra_extension_uuid"] + 'object_categories': object_categories, + 'intra_extension_id': old_ref["intra_extension_id"] } ) - for attr in Object.attributes: + for attr in ObjectCategory.attributes: if attr != 'id': setattr(ref, attr, getattr(new_ref, attr)) + return ref.to_dict() - def get_action_dict(self, extension_uuid): + # Getter and Setter for action_category + + def get_action_category_dict(self, intra_extension_id): with sql.transaction() as session: - query = session.query(Action) - query = query.filter_by(intra_extension_uuid=extension_uuid) + query = session.query(ActionCategory) + query = query.filter_by(intra_extension_id=intra_extension_id) ref = query.first() if not ref: raise IntraExtensionUnknown() return ref.to_dict() - def set_action_dict(self, extension_uuid, action_uuid): + # TODO: to recheck + def set_action_category_dict(self, intra_extension_id, action_categories): with sql.transaction() as session: - query = session.query(Action) - query = query.filter_by(intra_extension_uuid=extension_uuid) + query = session.query(ActionCategory) + query = query.filter_by(intra_extension_id=intra_extension_id) ref = query.first() - new_ref = Action.from_dict( + new_ref = ActionCategory.from_dict( { "id": uuid4().hex, - 'actions': action_uuid, - 'intra_extension_uuid': extension_uuid + 'action_categories': action_categories, + 'intra_extension_id': intra_extension_id } ) if not ref: session.add(new_ref) ref = new_ref else: - for attr in Action.attributes: + for attr in ActionCategory.attributes: if attr != 'id': setattr(ref, attr, getattr(new_ref, attr)) return ref.to_dict() - def add_action(self, extension_uuid, action_uuid, action_name): + def add_action_category(self, intra_extension_id, action_category_id, action_category_name): with sql.transaction() as session: - query = session.query(Action) - query = query.filter_by(intra_extension_uuid=extension_uuid) + 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() - actions = dict(old_ref["actions"]) - actions[action_uuid] = action_name - new_ref = Action.from_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"], - 'actions': actions, - 'intra_extension_uuid': old_ref["intra_extension_uuid"] + 'action_categories': action_categories, + 'intra_extension_id': old_ref["intra_extension_id"] } ) - for attr in Action.attributes: + for attr in ActionCategory.attributes: if attr != 'id': setattr(ref, attr, getattr(new_ref, attr)) return ref.to_dict() - def del_action(self, extension_uuid, action_uuid): + def del_action_category(self, intra_extension_id, action_category_id): with sql.transaction() as session: - query = session.query(Action) - query = query.filter_by(intra_extension_uuid=extension_uuid) + query = session.query(ActionCategory) + query = query.filter_by(intra_extension_id=intra_extension_id) ref = query.first() if not ref: raise IntraExtensionUnknown() else: old_ref = ref.to_dict() - actions = dict(old_ref["actions"]) + action_categories = dict(old_ref["action_categories"]) try: - actions.pop(action_uuid) + action_categories.pop(action_category_id) except KeyError: - LOG.error("KeyError in remove_action {} | {}".format(action_uuid, actions)) + pass else: - new_ref = Action.from_dict( + new_ref = ActionCategory.from_dict( { "id": old_ref["id"], - 'actions': actions, - 'intra_extension_uuid': old_ref["intra_extension_uuid"] + 'action_categories': action_categories, + 'intra_extension_id': old_ref["intra_extension_id"] } ) - for attr in Action.attributes: + for attr in ActionCategory.attributes: if attr != 'id': setattr(ref, attr, getattr(new_ref, attr)) + return ref.to_dict() - # Getter and Setter for subject_category + # Perimeter - def get_subject_category_dict(self, extension_uuid): + def get_subject_dict(self, intra_extension_id): with sql.transaction() as session: - query = session.query(SubjectCategory) - query = query.filter_by(intra_extension_uuid=extension_uuid) + query = session.query(Subject) + query = query.filter_by(intra_extension_id=intra_extension_id) ref = query.first() if not ref: raise IntraExtensionUnknown() return ref.to_dict() - def set_subject_category_dict(self, extension_uuid, subject_categories): + # TODO: to recheck + def set_subject_dict(self, intra_extension_id, subject_id): with sql.transaction() as session: - query = session.query(SubjectCategory) - query = query.filter_by(intra_extension_uuid=extension_uuid) + query = session.query(Subject) + query = query.filter_by(intra_extension_id=intra_extension_id) ref = query.first() - new_ref = SubjectCategory.from_dict( + new_ref = Subject.from_dict( { "id": uuid4().hex, - 'subject_categories': subject_categories, - 'intra_extension_uuid': extension_uuid + 'subjects': subject_id, + 'intra_extension_id': intra_extension_id } ) if not ref: session.add(new_ref) ref = new_ref else: - for attr in SubjectCategory.attributes: + for attr in Subject.attributes: if attr != 'id': setattr(ref, attr, getattr(new_ref, attr)) return ref.to_dict() - def add_subject_category(self, extension_uuid, subject_category_uuid, subject_category_name): + def add_subject(self, intra_extension_id, subject_id, subject_name): with sql.transaction() as session: - query = session.query(SubjectCategory) - query = query.filter_by(intra_extension_uuid=extension_uuid) + query = session.query(Subject) + query = query.filter_by(intra_extension_id=intra_extension_id) ref = query.first() if not ref: raise IntraExtensionUnknown() old_ref = ref.to_dict() - subject_categories = dict(old_ref["subject_categories"]) - subject_categories[subject_category_uuid] = subject_category_name - new_ref = SubjectCategory.from_dict( + subjects = dict(old_ref["subjects"]) + # TODO: subjects[subject_id] is a dict + subjects[subject_id] = subject_name + new_ref = Subject.from_dict( { "id": old_ref["id"], - 'subject_categories': subject_categories, - 'intra_extension_uuid': old_ref["intra_extension_uuid"] + 'subjects': subjects, + 'intra_extension_id': old_ref["intra_extension_id"] } ) - for attr in SubjectCategory.attributes: + for attr in Subject.attributes: if attr != 'id': setattr(ref, attr, getattr(new_ref, attr)) return ref.to_dict() - def del_subject_category(self, extension_uuid, subject_category_uuid): + def del_subject(self, intra_extension_id, subject_id): with sql.transaction() as session: - query = session.query(SubjectCategory) - query = query.filter_by(intra_extension_uuid=extension_uuid) + query = session.query(Subject) + query = query.filter_by(intra_extension_id=intra_extension_id) ref = query.first() if not ref: raise IntraExtensionUnknown() else: old_ref = ref.to_dict() - subject_categories = dict(old_ref["subject_categories"]) + subjects = dict(old_ref["subjects"]) try: - subject_categories.pop(subject_category_uuid) + subjects.pop(subject_id) except KeyError: - pass + LOG.error("KeyError in remove_subject {} | {}".format(subject_id, subjects)) else: - new_ref = SubjectCategory.from_dict( + new_ref = Subject.from_dict( { "id": old_ref["id"], - 'subject_categories': subject_categories, - 'intra_extension_uuid': old_ref["intra_extension_uuid"] + 'subjects': subjects, + 'intra_extension_id': old_ref["intra_extension_id"] } ) - for attr in SubjectCategory.attributes: + for attr in Subject.attributes: if attr != 'id': setattr(ref, attr, getattr(new_ref, attr)) - return ref.to_dict() - # Getter and Setter for object_category - - def get_object_category_dict(self, extension_uuid): + def get_object_dict(self, intra_extension_id): with sql.transaction() as session: - query = session.query(ObjectCategory) - query = query.filter_by(intra_extension_uuid=extension_uuid) + query = session.query(Object) + query = query.filter_by(intra_extension_id=intra_extension_id) ref = query.first() if not ref: raise IntraExtensionUnknown() return ref.to_dict() - def set_object_category_dict(self, extension_uuid, object_categories): + # TODO: to recheck + def set_object_dict(self, intraa_extension_id, object_id): with sql.transaction() as session: - query = session.query(ObjectCategory) - query = query.filter_by(intra_extension_uuid=extension_uuid) + query = session.query(Object) + query = query.filter_by(intra_extension_id=intraa_extension_id) ref = query.first() - new_ref = ObjectCategory.from_dict( + new_ref = Object.from_dict( { "id": uuid4().hex, - 'object_categories': object_categories, - 'intra_extension_uuid': extension_uuid + 'objects': object_id, + 'intra_extension_id': intraa_extension_id } ) if not ref: session.add(new_ref) ref = new_ref else: - for attr in ObjectCategory.attributes: + for attr in Object.attributes: if attr != 'id': setattr(ref, attr, getattr(new_ref, attr)) return ref.to_dict() - def add_object_category(self, extension_uuid, object_category_uuid, object_category_name): + def add_object(self, intra_extension_id, object_id, object_name): with sql.transaction() as session: - query = session.query(ObjectCategory) - query = query.filter_by(intra_extension_uuid=extension_uuid) + 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() - object_categories = dict(old_ref["object_categories"]) - object_categories[object_category_uuid] = object_category_name - new_ref = ObjectCategory.from_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"], - 'object_categories': object_categories, - 'intra_extension_uuid': old_ref["intra_extension_uuid"] + 'objects': objects, + 'intra_extension_id': old_ref["intra_extension_id"] } ) - for attr in ObjectCategory.attributes: + for attr in Object.attributes: if attr != 'id': setattr(ref, attr, getattr(new_ref, attr)) return ref.to_dict() - def del_object_category(self, extension_uuid, object_category_uuid): + def del_object(self, intra_extension_id, object_id): with sql.transaction() as session: - query = session.query(ObjectCategory) - query = query.filter_by(intra_extension_uuid=extension_uuid) + query = session.query(Object) + query = query.filter_by(intra_extension_id=intra_extension_id) ref = query.first() if not ref: raise IntraExtensionUnknown() else: old_ref = ref.to_dict() - object_categories = dict(old_ref["object_categories"]) + objects = dict(old_ref["objects"]) try: - object_categories.pop(object_category_uuid) + objects.pop(object_id) except KeyError: - pass + LOG.error("KeyError in remove_object {} | {}".format(object_id, objects)) else: - new_ref = ObjectCategory.from_dict( + new_ref = Object.from_dict( { "id": old_ref["id"], - 'object_categories': object_categories, - 'intra_extension_uuid': old_ref["intra_extension_uuid"] + 'objects': objects, + 'intra_extension_id': old_ref["intra_extension_id"] } ) - for attr in ObjectCategory.attributes: + for attr in Object.attributes: if attr != 'id': setattr(ref, attr, getattr(new_ref, attr)) - return ref.to_dict() - - # Getter and Setter for action_category - def get_action_category_dict(self, extension_uuid): + def get_action_dict(self, intra_extension_id): with sql.transaction() as session: - query = session.query(ActionCategory) - query = query.filter_by(intra_extension_uuid=extension_uuid) + query = session.query(Action) + query = query.filter_by(intra_extension_id=intra_extension_id) ref = query.first() if not ref: raise IntraExtensionUnknown() return ref.to_dict() - def set_action_category_dict(self, extension_uuid, action_categories): + # TODO: to recheck + def set_action_dict(self, intra_extension_id, action_id): with sql.transaction() as session: - query = session.query(ActionCategory) - query = query.filter_by(intra_extension_uuid=extension_uuid) + query = session.query(Action) + query = query.filter_by(intra_extension_id=intra_extension_id) ref = query.first() - new_ref = ActionCategory.from_dict( + new_ref = Action.from_dict( { "id": uuid4().hex, - 'action_categories': action_categories, - 'intra_extension_uuid': extension_uuid + 'actions': action_id, + 'intra_extension_id': intra_extension_id } ) if not ref: session.add(new_ref) ref = new_ref else: - for attr in ActionCategory.attributes: + for attr in Action.attributes: if attr != 'id': setattr(ref, attr, getattr(new_ref, attr)) return ref.to_dict() - def add_action_category(self, extension_uuid, action_category_uuid, action_category_name): + def add_action(self, intra_extension_id, action_id, action_name): with sql.transaction() as session: - query = session.query(ActionCategory) - query = query.filter_by(intra_extension_uuid=extension_uuid) + 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() - action_categories = dict(old_ref["action_categories"]) - action_categories[action_category_uuid] = action_category_name - new_ref = ActionCategory.from_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"], - 'action_categories': action_categories, - 'intra_extension_uuid': old_ref["intra_extension_uuid"] + 'actions': actions, + 'intra_extension_id': old_ref["intra_extension_id"] } ) - for attr in ActionCategory.attributes: + for attr in Action.attributes: if attr != 'id': setattr(ref, attr, getattr(new_ref, attr)) return ref.to_dict() - def del_action_category(self, extension_uuid, action_category_uuid): + def del_action(self, intra_extension_id, action_id): with sql.transaction() as session: - query = session.query(ActionCategory) - query = query.filter_by(intra_extension_uuid=extension_uuid) + query = session.query(Action) + query = query.filter_by(intra_extension_id=intra_extension_id) ref = query.first() if not ref: raise IntraExtensionUnknown() else: old_ref = ref.to_dict() - action_categories = dict(old_ref["action_categories"]) + actions = dict(old_ref["actions"]) try: - action_categories.pop(action_category_uuid) + actions.pop(action_id) except KeyError: - pass + LOG.error("KeyError in remove_action {} | {}".format(action_id, actions)) else: - new_ref = ActionCategory.from_dict( + new_ref = Action.from_dict( { "id": old_ref["id"], - 'action_categories': action_categories, - 'intra_extension_uuid': old_ref["intra_extension_uuid"] + 'actions': actions, + 'intra_extension_id': old_ref["intra_extension_id"] } ) - for attr in ActionCategory.attributes: + for attr in Action.attributes: if attr != 'id': setattr(ref, attr, getattr(new_ref, attr)) - return ref.to_dict() - # Getter and Setter for subject_category_value_scope + # Getter and Setter for subject_scope - def get_subject_category_scope_dict(self, extension_uuid, subject_category): + def get_subject_scope_dict(self, intra_extension_id, subject_category_id): with sql.transaction() as session: - query = session.query(SubjectCategoryScope) - query = query.filter_by(intra_extension_uuid=extension_uuid) + query = session.query(SubjectScope) + query = query.filter_by( + intra_extension_id=intra_extension_id, + subject_category_id=subject_category_id) ref = query.first() if not ref: raise IntraExtensionUnknown() result = copy.deepcopy(ref.to_dict()) - if subject_category not in result["subject_category_scope"].keys(): + if subject_category_id not in result["subject_scopes"].keys(): raise SubjectScopeUnknown() return result - def set_subject_scope_dict(self, extension_uuid, subject_category, scope): + def set_subject_scope_dict(self, intra_extension_id, subject_category_id, subject_scope_id): with sql.transaction() as session: - query = session.query(SubjectCategoryScope) - query = query.filter_by(intra_extension_uuid=extension_uuid) + query = session.query(SubjectScope) + query = query.filter_by(intra_extension_id=intra_extension_id) ref = query.first() if not ref: - new_ref = SubjectCategoryScope.from_dict( + new_ref = SubjectScope.from_dict( { "id": uuid4().hex, - 'subject_category_scope': {subject_category: scope}, - 'intra_extension_uuid': extension_uuid + 'subject_scope': {subject_category_id: subject_scope_id}, + 'intra_extension_id': intra_extension_id } ) session.add(new_ref) else: tmp_ref = ref.to_dict() - tmp_ref['subject_category_scope'].update({subject_category: scope}) + tmp_ref['subject_scope'].update({subject_category_id: subject_scope_id}) session.delete(ref) - new_ref = SubjectCategoryScope.from_dict(tmp_ref) + new_ref = SubjectScope.from_dict(tmp_ref) session.add(new_ref) return new_ref.to_dict() - def add_subject_scope(self, extension_uuid, subject_category, scope_uuid, scope_name): + def add_subject_scope(self, intra_extension_id, subject_category_id, subject_scope_id, subject_scope_name): with sql.transaction() as session: - query = session.query(SubjectCategoryScope) - query = query.filter_by(intra_extension_uuid=extension_uuid) + query = session.query(SubjectScope) + query = query.filter_by(intra_extension_id=intra_extension_id) ref = query.first() if not ref: raise IntraExtensionUnknown() old_ref = ref.to_dict() - scope = copy.deepcopy(old_ref["subject_category_scope"]) - if subject_category not in scope.keys(): - scope[subject_category] = dict() - scope[subject_category][scope_uuid] = scope_name - return self.set_subject_scope_dict(extension_uuid, subject_category, scope[subject_category]) + scope = copy.deepcopy(old_ref["subject_scope"]) + if subject_category_id not in scope.keys(): + scope[subject_category_id] = dict() + scope[subject_category_id][subject_scope_id] = subject_scope_name + return self.set_subject_scope_dict(intra_extension_id, subject_category_id, scope[subject_category_id]) - def del_subject_scope(self, extension_uuid, subject_category, scope_uuid): + def del_subject_scope(self, intra_extension_id, subject_category_id, subject_scope_id): with sql.transaction() as session: - query = session.query(SubjectCategoryScope) - query = query.filter_by(intra_extension_uuid=extension_uuid) + query = session.query(SubjectScope) + 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["subject_category_scope"]) - if subject_category not in scope: + scope = dict(old_ref["subject_scope"]) + if subject_category_id not in scope: return try: - scope[subject_category].pop(scope_uuid) + scope[subject_category_id].pop(subject_scope_id) except KeyError: return - new_ref = SubjectCategoryScope.from_dict( + new_ref = SubjectScope.from_dict( { "id": old_ref["id"], - 'subject_category_scope': scope, - 'intra_extension_uuid': old_ref["intra_extension_uuid"] + 'subject_scope': scope, + 'intra_extension_id': old_ref["intra_extension_id"] } ) - for attr in SubjectCategoryScope.attributes: + for attr in SubjectScope.attributes: if attr != 'id': setattr(ref, attr, getattr(new_ref, attr)) return ref.to_dict() # Getter and Setter for object_category_scope - def get_object_scope_dict(self, extension_uuid, object_category): + def get_object_scope_dict(self, intra_extension_id, object_category_id): with sql.transaction() as session: - query = session.query(ObjectCategoryScope) - query = query.filter_by(intra_extension_uuid=extension_uuid) + query = session.query(ObjectScope) + query = query.filter_by(intra_extension_id=intra_extension_id) ref = query.first() if not ref: raise IntraExtensionUnknown() result = copy.deepcopy(ref.to_dict()) - if object_category not in result["object_category_scope"].keys(): + if object_category_id not in result["object_scopes"].keys(): raise ObjectScopeUnknown() return result - def set_object_scope_dict(self, extension_uuid, object_category, scope): + def set_object_scope_dict(self, intra_extension_id, object_category_id, object_scope_id): with sql.transaction() as session: - query = session.query(ObjectCategoryScope) - query = query.filter_by(intra_extension_uuid=extension_uuid) + query = session.query(ObjectScope) + query = query.filter_by(intra_extension_id=intra_extension_id) ref = query.first() if not ref: - new_ref = ObjectCategoryScope.from_dict( + new_ref = ObjectScope.from_dict( { "id": uuid4().hex, - 'object_category_scope': {object_category: scope}, - 'intra_extension_uuid': extension_uuid + 'object_scope': {object_category_id: object_scope_id}, + 'intra_extension_id': intra_extension_id } ) session.add(new_ref) else: tmp_ref = ref.to_dict() - tmp_ref['object_category_scope'].update({object_category: scope}) + tmp_ref['object_scope'].update({object_category_id: object_scope_id}) session.delete(ref) - new_ref = ObjectCategoryScope.from_dict(tmp_ref) + new_ref = ObjectScope.from_dict(tmp_ref) session.add(new_ref) return new_ref.to_dict() - def add_object_scope(self, extension_uuid, object_category, scope_uuid, scope_name): + 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(ObjectCategoryScope) - query = query.filter_by(intra_extension_uuid=extension_uuid) + 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_category_scope"]) - if object_category not in scope: - scope[object_category] = dict() - scope[object_category][scope_uuid] = scope_name - return self.set_object_scope_dict(extension_uuid, object_category, scope[object_category]) + 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, extension_uuid, object_category, scope_uuid): + def del_object_scope(self, intra_extension_id, object_category_id, object_scope_id): with sql.transaction() as session: - query = session.query(ObjectCategoryScope) - query = query.filter_by(intra_extension_uuid=extension_uuid) + 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_category_scope"]) - if object_category not in scope: + scope = dict(old_ref["object_scope"]) + if object_category_id not in scope: return try: - scope[object_category].pop(scope_uuid) + scope[object_category_id].pop(object_scope_id) except KeyError: return - new_ref = ObjectCategoryScope.from_dict( + new_ref = ObjectScope.from_dict( { "id": old_ref["id"], - 'object_category_scope': scope, - 'intra_extension_uuid': old_ref["intra_extension_uuid"] + 'object_scope': scope, + 'intra_extension_id': old_ref["intra_extension_id"] } ) - for attr in ObjectCategoryScope.attributes: + for attr in ObjectScope.attributes: if attr != 'id': setattr(ref, attr, getattr(new_ref, attr)) return ref.to_dict() - # Getter and Setter for action_category_scope + # Getter and Setter for action_scope - def get_action_scope_dict(self, extension_uuid, action_category): + def get_action_scope_dict(self, intra_extension_id, action_category_id): with sql.transaction() as session: - query = session.query(ActionCategoryScope) - query = query.filter_by(intra_extension_uuid=extension_uuid) + query = session.query(ActionScope) + query = query.filter_by(intra_extension_id=intra_extension_id) ref = query.first() if not ref: raise IntraExtensionUnknown() result = copy.deepcopy(ref.to_dict()) - if action_category not in result["action_category_scope"].keys(): + if action_category_id not in result["action_scope"].keys(): raise ActionScopeUnknown() return result - def set_action_scope_dict(self, extension_uuid, action_category, scope): + def set_action_scope_dict(self, intra_extension_id, action_category_id, action_scope_id): with sql.transaction() as session: - query = session.query(ActionCategoryScope) - query = query.filter_by(intra_extension_uuid=extension_uuid) + query = session.query(ActionScope) + query = query.filter_by(intra_extension_id=intra_extension_id) ref = query.first() if not ref: - new_ref = ActionCategoryScope.from_dict( + new_ref = ActionScope.from_dict( { "id": uuid4().hex, - 'action_category_scope': {action_category: scope}, - 'intra_extension_uuid': extension_uuid + 'action_scope': {action_category_id: action_scope_id}, + 'intra_extension_id': intra_extension_id } ) session.add(new_ref) else: tmp_ref = ref.to_dict() - tmp_ref['action_category_scope'].update({action_category: scope}) + tmp_ref['action_scope'].update({action_category_id: action_scope_id}) session.delete(ref) - new_ref = ActionCategoryScope.from_dict(tmp_ref) + new_ref = ActionScope.from_dict(tmp_ref) session.add(new_ref) return new_ref.to_dict() - def add_action_scope(self, extension_uuid, action_category, scope_uuid, scope_name): + 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(ActionCategoryScope) - query = query.filter_by(intra_extension_uuid=extension_uuid) + 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_category_scope"]) - if action_category not in scope: - scope[action_category] = dict() - scope[action_category][scope_uuid] = scope_name - return self.set_action_scope_dict(extension_uuid, action_category, scope[action_category]) + 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, extension_uuid, action_category, scope_uuid): + def del_action_scope(self, intra_extension_id, action_category_id, action_scope_id): with sql.transaction() as session: - query = session.query(ActionCategoryScope) - query = query.filter_by(intra_extension_uuid=extension_uuid) + 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_category_scope"]) - if action_category not in scope: + scope = dict(old_ref["action_scope"]) + if action_category_id not in scope: return try: - scope[action_category].pop(scope_uuid) + scope[action_category_id].pop(action_scope_id) except KeyError: return - new_ref = ActionCategoryScope.from_dict( + new_ref = ActionScope.from_dict( { "id": old_ref["id"], - 'action_category_scope': scope, - 'intra_extension_uuid': old_ref["intra_extension_uuid"] + 'action_scope': scope, + 'intra_extension_id': old_ref["intra_extension_id"] } ) - for attr in ActionCategoryScope.attributes: + for attr in ActionScope.attributes: if attr != 'id': setattr(ref, attr, getattr(new_ref, attr)) return ref.to_dict() # Getter and Setter for subject_category_assignment - def get_subject_assignment_dict(self, extension_uuid, subject_uuid): + def get_subject_assignment_dict(self, intra_extension_id, subject_id): """ From a subject_uuid, return a dictionary of (category: scope for that subject) - :param extension_uuid: intra extension UUID - :param subject_uuid: subject UUID + :param intra_extension_id: intra extension UUID + :param subject_id: subject UUID :return: a dictionary of (keys are category nd values are scope for that subject) """ with sql.transaction() as session: - query = session.query(SubjectCategoryAssignment) - query = query.filter_by(intra_extension_uuid=extension_uuid) + query = session.query(SubjectAssignment) + query = query.filter_by(intra_extension_id=intra_extension_id) ref = query.first() if not ref: - raise IntraExtensionUnknown("get_subject_category_assignment_dict") + raise IntraExtensionUnknown() _ref = ref.to_dict() - if subject_uuid in _ref["subject_category_assignments"]: - _backup_dict = _ref["subject_category_assignments"][subject_uuid] - _ref["subject_category_assignments"] = dict() - _ref["subject_category_assignments"][subject_uuid] = _backup_dict + if subject_id in _ref["subject_assignment"]: + _backup_dict = _ref["subject_assignment"][subject_id] + _ref["subject_assignment"] = dict() + _ref["subject_assignment"][subject_id] = _backup_dict else: - _ref["subject_category_assignments"] = dict() - _ref["subject_category_assignments"][subject_uuid] = dict() + _ref["subject_assignment"] = dict() + _ref["subject_assignment"][subject_id] = dict() return _ref - def set_subject_assignment_dict(self, extension_uuid, subject_uuid=None, assignment_dict={}): + def set_subject_assignment_dict(self, intra_extension_id, subject_id=None, subject_assignment_dict={}): with sql.transaction() as session: - query = session.query(SubjectCategoryAssignment) - query = query.filter_by(intra_extension_uuid=extension_uuid) + query = session.query(SubjectAssignment) + query = query.filter_by(intra_extension_id=intra_extension_id) ref = query.first() - if type(assignment_dict) is not dict: + if type(subject_assignment_dict) is not dict: raise IntraExtensionError() - for value in assignment_dict.values(): + for value in subject_assignment_dict.values(): if type(value) is not list: raise IntraExtensionError(str(value)) - if not subject_uuid: - subject_category_assignments = {} + if not subject_id: + subject_assignments = {} else: - subject_category_assignments = {subject_uuid: assignment_dict} - new_ref = SubjectCategoryAssignment.from_dict( + subject_assignments = {subject_id: subject_assignment_dict} + new_ref = SubjectAssignment.from_dict( { "id": uuid4().hex, - 'subject_category_assignments': subject_category_assignments, - 'intra_extension_uuid': extension_uuid + 'subject_assignment': subject_assignments, + 'intra_extension_id': intra_extension_id } ) if not ref: session.add(new_ref) ref = new_ref else: - new_ref.subject_category_assignments[subject_uuid] = assignment_dict - for attr in SubjectCategoryAssignment.attributes: + new_ref.subject_assignments[subject_id] = subject_assignment_dict + for attr in SubjectAssignment.attributes: if attr != 'id': setattr(ref, attr, getattr(new_ref, attr)) return ref.to_dict() - def add_subject_assignment(self, extension_uuid, subject_uuid, category_uuid, scope_uuid): + def add_subject_assignment(self, intra_extension_id, subject_id, subject_category_id, subject_scope_id): with sql.transaction() as session: - query = session.query(SubjectCategoryAssignment) - query = query.filter_by(intra_extension_uuid=extension_uuid) + query = session.query(SubjectAssignment) + query = query.filter_by(intra_extension_id=intra_extension_id) ref = query.first() if not ref: raise IntraExtensionUnknown() - assignments = ref.to_dict()['subject_category_assignments'] - if subject_uuid not in assignments: - assignments[subject_uuid] = dict() - if category_uuid not in assignments[subject_uuid]: - assignments[subject_uuid][category_uuid] = list() - if scope_uuid not in assignments[subject_uuid][category_uuid]: - assignments[subject_uuid][category_uuid].append(scope_uuid) + assignment = ref.to_dict()['subject_assignment'] + if subject_id not in assignment: + assignment[subject_id] = dict() + if subject_category_id not in assignment[subject_id]: + assignment[subject_id][subject_category_id] = list() + if subject_scope_id not in assignment[subject_id][subject_category_id]: + assignment[subject_id][subject_category_id].append(subject_scope_id) return self.set_subject_assignment_dict( - extension_uuid, - subject_uuid, - assignments[subject_uuid]) + intra_extension_id, + subject_id, + assignment[subject_id]) - def del_subject_assignment(self, extension_uuid, subject_uuid, category_uuid, scope_uuid): + def del_subject_assignment(self, intra_extension_id, subject_id, subject_category_id, subject_scope_id): with sql.transaction() as session: - query = session.query(SubjectCategoryAssignment) - query = query.filter_by(intra_extension_uuid=extension_uuid) + query = session.query(SubjectAssignment) + query = query.filter_by(intra_extension_id=intra_extension_id) ref = query.first() if not ref: raise IntraExtensionUnknown() old_ref = ref.to_dict() - if subject_uuid in old_ref["subject_category_assignments"]: - if category_uuid in old_ref["subject_category_assignments"][subject_uuid]: - old_ref["subject_category_assignments"][subject_uuid][category_uuid].remove(scope_uuid) - if not old_ref["subject_category_assignments"][subject_uuid][category_uuid]: - old_ref["subject_category_assignments"][subject_uuid].pop(category_uuid) - if not old_ref["subject_category_assignments"][subject_uuid]: - old_ref["subject_category_assignments"].pop(subject_uuid) + if subject_id in old_ref["subject_assignment"]: + if subject_category_id in old_ref["subject_assignment"][subject_id]: + old_ref["subject_assignment"][subject_id][subject_category_id].remove(subject_scope_id) + if not old_ref["subject_assignment"][subject_id][subject_category_id]: + old_ref["subject_assignment"][subject_id].pop(subject_category_id) + if not old_ref["subject_assignment"][subject_id]: + old_ref["subject_assignment"].pop(subject_id) try: self.set_subject_assignment_dict( - extension_uuid, - subject_uuid, - old_ref["subject_category_assignments"][subject_uuid]) + intra_extension_id, + subject_id, + old_ref["subject_assignment"][subject_id]) except KeyError: self.set_subject_assignment_dict( - extension_uuid, - subject_uuid, + intra_extension_id, + subject_id, {}) # Getter and Setter for object_category_assignment - def get_object_assignment_dict(self, extension_uuid, object_uuid): + def get_object_assignment_dict(self, intra_extension_id, object_id): """ From a object_uuid, return a dictionary of (category: scope for that object) - :param extension_uuid: intra extension UUID - :param object_uuid: object UUID + :param intra_extension_id: intra extension UUID + :param object_id: object UUID :return: a dictionary of (keys are category nd values are scope for that object) """ with sql.transaction() as session: - query = session.query(ObjectCategoryAssignment) - query = query.filter_by(intra_extension_uuid=extension_uuid) + query = session.query(ObjectAssignment) + query = query.filter_by(intra_extension_id=intra_extension_id) ref = query.first() if not ref: raise IntraExtensionUnknown() _ref = ref.to_dict() - if object_uuid in _ref["object_category_assignments"]: - _backup_dict = _ref["object_category_assignments"][object_uuid] - _ref["object_category_assignments"] = dict() - _ref["object_category_assignments"][object_uuid] = _backup_dict + if object_id in _ref["object_assignment"]: + _backup_dict = _ref["object_assignment"][object_id] + _ref["object_assignment"] = dict() + _ref["object_assignment"][object_id] = _backup_dict else: - _ref["object_category_assignments"] = dict() - _ref["object_category_assignments"][object_uuid] = dict() + _ref["object_assignment"] = dict() + _ref["object_assignment"][object_id] = dict() return _ref - def set_object_assignment_dict(self, extension_uuid, object_uuid=None, assignment_dict={}): + def set_object_assignment_dict(self, intra_extension_id, object_id=None, object_assignment_dict={}): with sql.transaction() as session: - query = session.query(ObjectCategoryAssignment) - query = query.filter_by(intra_extension_uuid=extension_uuid) + query = session.query(ObjectAssignment) + query = query.filter_by(intra_extension_id=intra_extension_id) ref = query.first() - if type(assignment_dict) is not dict: + if type(object_assignment_dict) is not dict: raise IntraExtensionError() - for value in assignment_dict.values(): + for value in object_assignment_dict.values(): if type(value) is not list: raise IntraExtensionError(str(value)) - new_ref = ObjectCategoryAssignment.from_dict( + new_ref = ObjectAssignment.from_dict( { "id": uuid4().hex, - 'object_category_assignments': {object_uuid: assignment_dict}, - 'intra_extension_uuid': extension_uuid + 'object_assignment': {object_id: object_assignment_dict}, + 'intra_extension_id': intra_extension_id } ) if not ref: session.add(new_ref) ref = new_ref else: - new_ref.object_category_assignments[object_uuid] = assignment_dict - for attr in ObjectCategoryAssignment.attributes: + new_ref.object_assignment[object_id] = object_assignment_dict + for attr in ObjectAssignment.attributes: if attr != 'id': setattr(ref, attr, getattr(new_ref, attr)) return ref.to_dict() - def add_object_assignment(self, extension_uuid, object_uuid, category_uuid, scope_uuid): + def add_object_assignment(self, intra_extension_id, object_id, object_category_id, object_scope_id): with sql.transaction() as session: - query = session.query(ObjectCategoryAssignment) - query = query.filter_by(intra_extension_uuid=extension_uuid) + query = session.query(ObjectAssignment) + query = query.filter_by(intra_extension_id=intra_extension_id) ref = query.first() if not ref: raise IntraExtensionUnknown() - assignments = ref.to_dict()['object_category_assignments'] - if object_uuid not in assignments: - assignments[object_uuid] = dict() - if category_uuid not in assignments[object_uuid]: - assignments[object_uuid][category_uuid] = list() - if scope_uuid not in assignments[object_uuid][category_uuid]: - assignments[object_uuid][category_uuid].append(scope_uuid) + assignments = ref.to_dict()['object_assignment'] + if object_id not in assignments: + assignments[object_id] = dict() + if object_category_id not in assignments[object_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( - extension_uuid, - object_uuid, - assignments[object_uuid]) + intra_extension_id, + object_id, + assignments[object_id]) - def del_object_assignment(self, extension_uuid, object_uuid, category_uuid, scope_uuid): + def del_object_assignment(self, intra_extension_id, object_id, object_category_id, object_scope_id): with sql.transaction() as session: - query = session.query(ObjectCategoryAssignment) - query = query.filter_by(intra_extension_uuid=extension_uuid) + query = session.query(ObjectAssignment) + query = query.filter_by(intra_extension_id=intra_extension_id) ref = query.first() if not ref: raise IntraExtensionUnknown() old_ref = ref.to_dict() - if object_uuid in old_ref["object_category_assignments"]: - if category_uuid in old_ref["object_category_assignments"][object_uuid]: - old_ref["object_category_assignments"][object_uuid][category_uuid].remove(scope_uuid) - if not old_ref["object_category_assignments"][object_uuid][category_uuid]: - old_ref["object_category_assignments"][object_uuid].pop(category_uuid) - if not old_ref["object_category_assignments"][object_uuid]: - old_ref["object_category_assignments"].pop(object_uuid) + if object_id in old_ref["object_assignment"]: + if object_category_id in old_ref["object_assignment"][object_id]: + old_ref["object_assignment"][object_id][object_category_id].remove(object_scope_id) + if not old_ref["object_assignment"][object_id][object_category_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( - extension_uuid, - object_uuid, - old_ref["object_category_assignments"][object_uuid]) + intra_extension_id, + object_id, + old_ref["object_assignment"][object_id]) # Getter and Setter for action_category_assignment - def get_action_assignment_dict(self, extension_uuid, action_uuid): - """ From a action_uuid, return a dictionary of (category: scope for that action) + def get_action_assignment_dict(self, intra_extension_id, action_id): + """ From a action_id, return a dictionary of (category: scope for that action) - :param extension_uuid: intra extension UUID - :param action_uuid: action UUID + :param intra_extension_id: intra extension UUID + :param action_id: action UUID :return: a dictionary of (keys are category nd values are scope for that action) """ with sql.transaction() as session: - query = session.query(ActionCategoryAssignment) - query = query.filter_by(intra_extension_uuid=extension_uuid) + query = session.query(ActionAssignment) + query = query.filter_by(intra_extension_id=intra_extension_id) ref = query.first() if not ref: raise IntraExtensionUnknown() _ref = ref.to_dict() - if action_uuid in _ref["action_category_assignments"]: - _backup_dict = _ref["action_category_assignments"][action_uuid] - _ref["action_category_assignments"] = dict() - _ref["action_category_assignments"][action_uuid] = _backup_dict + if action_id in _ref["action_assignment"]: + _backup_dict = _ref["action_assignment"][action_id] + _ref["action_assignment"] = dict() + _ref["action_assignment"][action_id] = _backup_dict else: - _ref["action_category_assignments"] = dict() - _ref["action_category_assignments"][action_uuid] = dict() + _ref["action_assignment"] = dict() + _ref["action_assignment"][action_id] = dict() return _ref - def set_action_assignment_dict(self, extension_uuid, action_uuid=None, assignment_dict={}): + def set_action_assignment_dict(self, intra_extension_id, action_id=None, action_assignment_dict={}): with sql.transaction() as session: - query = session.query(ActionCategoryAssignment) - query = query.filter_by(intra_extension_uuid=extension_uuid) + query = session.query(ActionAssignment) + query = query.filter_by(intra_extension_id=intra_extension_id) ref = query.first() - if type(assignment_dict) is not dict: + if type(action_assignment_dict) is not dict: raise IntraExtensionError() - for value in assignment_dict.values(): + for value in action_assignment_dict.values(): if type(value) is not list: raise IntraExtensionError(str(value)) - new_ref = ActionCategoryAssignment.from_dict( + new_ref = ActionAssignment.from_dict( { "id": uuid4().hex, - 'action_category_assignments': {action_uuid: assignment_dict}, - 'intra_extension_uuid': extension_uuid + 'action_assignment': {action_id: action_assignment_dict}, + 'intra_extension_id': intra_extension_id } ) if not ref: session.add(new_ref) ref = new_ref else: - new_ref.action_category_assignments[action_uuid] = assignment_dict - for attr in ActionCategoryAssignment.attributes: + new_ref.action_assignment[action_id] = action_assignment_dict + for attr in ActionAssignment.attributes: if attr != 'id': setattr(ref, attr, getattr(new_ref, attr)) return ref.to_dict() - def add_action_assignment(self, extension_uuid, action_uuid, category_uuid, scope_uuid): + def add_action_assignment(self, intra_extension_id, action_id, action_category_id, action_scope_id): with sql.transaction() as session: - query = session.query(ActionCategoryAssignment) - query = query.filter_by(intra_extension_uuid=extension_uuid) + query = session.query(ActionAssignment) + query = query.filter_by(intra_extension_id=intra_extension_id) ref = query.first() if not ref: raise IntraExtensionUnknown() - assignments = ref.to_dict()['action_category_assignments'] - if action_uuid not in assignments: - assignments[action_uuid] = dict() - if category_uuid not in assignments[action_uuid]: - assignments[action_uuid][category_uuid] = list() - if scope_uuid not in assignments[action_uuid][category_uuid]: - assignments[action_uuid][category_uuid].append(scope_uuid) + assignments = ref.to_dict()['action_assignment'] + if action_id not in assignments: + assignments[action_id] = dict() + if action_category_id not in assignments[action_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( - extension_uuid, - action_uuid, - assignments[action_uuid]) + intra_extension_id, + action_id, + assignments[action_id]) - def del_action_assignment(self, extension_uuid, action_uuid, category_uuid, scope_uuid): + def del_action_assignment(self, intra_extension_id, action_id, action_category_id, action_scope_id): with sql.transaction() as session: - query = session.query(ActionCategoryAssignment) - query = query.filter_by(intra_extension_uuid=extension_uuid) + query = session.query(ActionAssignment) + query = query.filter_by(intra_extension_id=intra_extension_id) ref = query.first() if not ref: raise IntraExtensionUnknown() old_ref = ref.to_dict() - if action_uuid in old_ref["action_category_assignments"]: - if category_uuid in old_ref["action_category_assignments"][action_uuid]: - old_ref["action_category_assignments"][action_uuid][category_uuid].remove(scope_uuid) - if not old_ref["action_category_assignments"][action_uuid][category_uuid]: - old_ref["action_category_assignments"][action_uuid].pop(category_uuid) - if not old_ref["action_category_assignments"][action_uuid]: - old_ref["action_category_assignments"].pop(action_uuid) + if action_id in old_ref["action_assignment"]: + if action_category_id in old_ref["action_assignment"][action_id]: + old_ref["action_assignment"][action_id][action_category_id].remove(action_scope_id) + if not old_ref["action_assignment"][action_id][action_category_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( - extension_uuid, - action_uuid, - old_ref["action_category_assignments"][action_uuid]) + intra_extension_id, + action_id, + old_ref["action_assignment"][action_id]) # Getter and Setter for meta_rule - def get_meta_rule_dict(self, extension_uuid): + def get_sub_meta_rule_dict(self, intra_extension_id): with sql.transaction() as session: - query = session.query(MetaRule) - query = query.filter_by(intra_extension_uuid=extension_uuid) + query = session.query(SubMetaRule) + query = query.filter_by(intra_extension_id=intra_extension_id) ref = query.first() if not ref: raise IntraExtensionUnknown() return ref.to_dict() - def set_meta_rule_dict(self, extension_uuid, meta_rule_dict): + def set_sub_meta_rule_dict(self, intra_extension_id, sub_meta_rule_dict): with sql.transaction() as session: - query = session.query(MetaRule) - query = query.filter_by(intra_extension_uuid=extension_uuid) + query = session.query(SubMetaRule) + query = query.filter_by(intra_extension_id=intra_extension_id) ref = query.first() - meta_rule_dict["id"] = uuid4().hex - meta_rule_dict["intra_extension_uuid"] = extension_uuid - new_ref = MetaRule.from_dict(meta_rule_dict) + sub_meta_rule_dict["id"] = uuid4().hex + sub_meta_rule_dict["intra_extension_id"] = intra_extension_id + new_ref = SubMetaRule.from_dict(sub_meta_rule_dict) if not ref: session.add(new_ref) ref = new_ref else: - for attr in MetaRule.attributes: + for attr in SubMetaRule.attributes: if attr != 'id': setattr(ref, attr, getattr(new_ref, attr)) return ref.to_dict() # Getter and Setter for rules - def get_rule_dict(self, extension_uuid): + def get_rule_dict(self, intra_extension_id): with sql.transaction() as session: query = session.query(Rule) - query = query.filter_by(intra_extension_uuid=extension_uuid) + query = query.filter_by(intra_extension_id=intra_extension_id) ref = query.first() if not ref: raise IntraExtensionUnknown() return ref.to_dict() - def set_rule_dict(self, extension_uuid, rule_dict): + def set_rule_dict(self, intra_extension_id, rule_dict): with sql.transaction() as session: query = session.query(Rule) - query = query.filter_by(intra_extension_uuid=extension_uuid) + query = query.filter_by(intra_extension_id=intra_extension_id) ref = query.first() rules = dict() rules["id"] = uuid4().hex - rules["intra_extension_uuid"] = extension_uuid - rules["rules"] = rule_dict + rules["intra_extension_id"] = intra_extension_id + rules["rule"] = rule_dict new_ref = Rule.from_dict(rules) if not ref: session.add(new_ref) @@ -1434,11 +1466,15 @@ class TenantConnector(TenantDriver): # query = query.filter_by(uuid=tenant_uuid) # ref = query.first().to_dict() tenants = query.all() - if not tenants: - raise TenantListEmpty() return {tenant.id: Tenant.to_dict(tenant) for tenant in tenants} - # return [Tenant.to_dict(tenant) for tenant in tenants] + def add_tenant(self, tenant_id, tenant_name, intra_authz_ext_id, intra_admin_ext_id): + pass + + def del_tenant(self, tenant_id): + pass + + # TODO: def set_tenant(self, tenant_id, tenant_name, intra_authz_ext_id, intra_admin_ext_id) def set_tenant_dict(self, tenant): with sql.transaction() as session: uuid = tenant.keys()[0] @@ -1474,15 +1510,15 @@ class TenantConnector(TenantDriver): # __tablename__ = 'inter_extension' # attributes = [ # 'id', -# 'requesting_intra_extension_uuid', -# 'requested_intra_extension_uuid', +# 'requesting_intra_extension_id', +# 'requested_intra_extension_id', # 'virtual_entity_uuid', # 'genre', # 'description', # ] # id = sql.Column(sql.String(64), primary_key=True) -# requesting_intra_extension_uuid = sql.Column(sql.String(64)) -# requested_intra_extension_uuid = sql.Column(sql.String(64)) +# requesting_intra_extension_id = sql.Column(sql.String(64)) +# requested_intra_extension_id = sql.Column(sql.String(64)) # virtual_entity_uuid = sql.Column(sql.String(64)) # genre = sql.Column(sql.String(64)) # description = sql.Column(sql.Text()) diff --git a/keystone-moon/keystone/contrib/moon/core.py b/keystone-moon/keystone/contrib/moon/core.py index b92238f2..74e3404d 100644 --- a/keystone-moon/keystone/contrib/moon/core.py +++ b/keystone-moon/keystone/contrib/moon/core.py @@ -187,7 +187,10 @@ class TenantManager(manager.Manager): :return: dict """ # TODO: check user right with user_id in SuperExtension - return self.driver.get_tenant_dict() + tenant_dict = self.driver.get_tenant_dict() + if not tenant_dict: + raise TenantDictEmpty() + return tenant_dict def add_tenant(self, user_id, tenant_name, intra_authz_ext_id, intra_admin_ext_id): # TODO: check user right with user_id in SuperExtension @@ -229,7 +232,6 @@ class TenantManager(manager.Manager): if tenant_id not in tenant_dict: raise TenantUnknown() return self.driver.set_tenant( - self, tenant_id, tenant_name, tenant_dict[tenant_id]['intra_authz_ext_id'], @@ -308,14 +310,14 @@ class IntraExtensionManager(manager.Manager): 'subject_uuid': xxx, 'object_uuid': yyy, 'action_uuid': zzz, - 'subject_attributes': { + 'subject_assignments': { 'subject_category1': [], 'subject_category2': [], ... 'subject_categoryn': [] }, - 'object_attributes': {}, - 'action_attributes': {}, + 'object_assignments': {}, + 'action_assignments': {}, } """ authz_buffer = dict() @@ -323,30 +325,30 @@ class IntraExtensionManager(manager.Manager): authz_buffer['object_id'] = object_id authz_buffer['action_id'] = action_id meta_data_dict = dict() - meta_data_dict["subject_categories"] = self.driver.get_subject_category_dict(intra_extension_id)["subject_categories"] - meta_data_dict["object_categories"] = self.driver.get_object_category_dict(intra_extension_id)["object_categories"] - meta_data_dict["action_categories"] = self.driver.get_action_category_dict(intra_extension_id)["action_categories"] + meta_data_dict["subject_categories"] = self.driver.get_subject_category_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) subject_assignment_dict = dict() for category in meta_data_dict["subject_categories"]: subject_assignment_dict[category] = self.driver.get_subject_assignment_dict( - intra_extension_id, category)["subject_category_assignments"] + 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( - intra_extension_id, category)["object_category_assignments"] + 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( - intra_extension_id, category)["action_category_assignments"] + intra_extension_id, action_id)[category] authz_buffer['subject_attributes'] = dict() authz_buffer['object_attributes'] = dict() authz_buffer['action_attributes'] = dict() for _subject_category in meta_data_dict['subject_categories']: - authz_buffer['subject_attributes'][_subject_category] = subject_assignment_dict[_subject_category] + authz_buffer['subject_assignments'][_subject_category] = subject_assignment_dict[_subject_category] for _object_category in meta_data_dict['object_categories']: - authz_buffer['object_attributes'][_object_category] = object_assignment_dict[_object_category] + authz_buffer['object_assignments'][_object_category] = object_assignment_dict[_object_category] for _action_category in meta_data_dict['action_categories']: - authz_buffer['action_attributes'][_action_category] = action_assignment_dict[_action_category] + authz_buffer['action_assignments'][_action_category] = action_assignment_dict[_action_category] return authz_buffer def authz(self, intra_extension_id, subject_id, object_id, action_id): @@ -369,7 +371,7 @@ class IntraExtensionManager(manager.Manager): authz_buffer = self.__get_authz_buffer(intra_extension_id, subject_id, object_id, action_id) decision_buffer = dict() - meta_rule_dict = self.driver.get_meta_rule_dict(intra_extension_id) + meta_rule_dict = self.driver.get_sub_meta_rule_dict(intra_extension_id) for sub_meta_rule_id in meta_rule_dict['sub_meta_rules']: if meta_rule_dict['sub_meta_rules'][sub_meta_rule_id]['algorithm'] == 'inclusion': @@ -592,7 +594,7 @@ class IntraExtensionManager(manager.Manager): "aggregation": json_metarule["aggregation"], "sub_meta_rules": metarule } - self.driver.set_meta_rule_dict(intra_extension_dict["id"], submetarules) + self.driver.set_sub_meta_rule_dict(intra_extension_dict["id"], submetarules) def __load_rule_file(self, intra_extension_dict, policy_dir): @@ -602,7 +604,7 @@ class IntraExtensionManager(manager.Manager): intra_extension_dict["rule"] = {"rule": copy.deepcopy(json_rules)} # Translate value from JSON file to UUID for Database rules = dict() - sub_meta_rules = self.driver.get_meta_rule_dict(intra_extension_dict["id"]) + sub_meta_rules = self.driver.get_sub_meta_rule_dict(intra_extension_dict["id"]) for relation in json_rules: # print(relation) # print(self.get_sub_meta_rule_relations("admin", ie["id"])) @@ -1831,7 +1833,7 @@ class IntraExtensionDriver(object): """ raise exception.NotImplemented() # pragma: no cover - def set_subject_category_dict(self, intra_extension_id, subject_category_dict): + def set_subject_category_dict(self, intra_extension_id, subject_category_id, subject_category_dict): """Set the list of all subject categories :param intra_extension_id: IntraExtension UUID @@ -2409,7 +2411,7 @@ class IntraExtensionDriver(object): # Meta_rule functions - def get_meta_rule_dict(self, extension_uuid): + def get_sub_meta_rule_dict(self, extension_uuid): """Get the Meta rule :param extension_uuid: IntraExtension UUID @@ -2431,7 +2433,7 @@ class IntraExtensionDriver(object): """ raise exception.NotImplemented() # pragma: no cover - def set_meta_rule_dict(self, extension_uuid, meta_rule_dict): + def set_sub_meta_rule_dict(self, extension_uuid, meta_rule_dict): """Set the Meta rule :param extension_uuid: IntraExtension UUID -- cgit 1.2.3-korg