cubicweb: comparison hooks/syncschema.py

equal deleted inserted replaced

-:06daf13195d4
+:107ba1c45227
 rdef = self.entity.reverse_constrained_by[0]
 session = self.session
 # when the relation is added in the same transaction, the constraint
 # object is created by the operation adding the attribute or relation,
 # so there is nothing to do here
-if rdef.eid in session.transaction_data.get('neweids', ()):
+if session.added_in_transaction(rdef.eid):
 return
 subjtype, rtype, objtype = session.schema.schema_by_eid(rdef.eid)
 cstrtype = self.entity.type
 oldcstr = rtype.constraint_by_type(subjtype, objtype, cstrtype)
 newcstr = CONSTRAINTS[cstrtype].deserialize(self.entity.value)
 def precommit_event(self):
 rdef = self.entity.reverse_constrained_by[0]
 # when the relation is added in the same transaction, the constraint
 # object is created by the operation adding the attribute or relation,
 # so there is nothing to do here
-if rdef.eid in self.session.transaction_data.get('neweids', ()):
+if session.added_in_transaction(rdef.eid):
 self.cancelled = True
 return
 subjtype, rtype, objtype = self.session.schema.schema_by_eid(rdef.eid)
 self.prepare_constraints(subjtype, rtype, objtype)
 cstrtype = self.entity.type
 self.perm, erschema.type, self.expr)
 return
 erschema.set_rqlexprs(self.perm, rqlexprs)
-# deletion hooks ###############################################################
+class SyncSchemaHook(hook.Hook):
+__abstract__ = True
-class DelCWETypeHook(hook.Hook):
+category = 'syncschema'
+# CWEType hooks ################################################################
+class DelCWETypeHook(SyncSchemaHook):
 """before deleting a CWEType entity:
 * check that we don't remove a core entity type
 * cascade to delete related CWAttribute and CWRelation entities
 * instantiate an operation to delete the entity type on commit
 """
 __id__ = 'syncdelcwetype'
-__select__ = hook.Hook.__select__ & entity_implements('CWEType')
+__select__ = SyncSchemaHook.__select__ & entity_implements('CWEType')
-category = 'syncschema'
 events = ('before_delete_entity',)
 def __call__(self):
 # final entities can't be deleted, don't care about that
 name = self.entity.name
 if newname.lower() != oldname.lower():
 SourceDbCWETypeRename(self.cw_req, oldname=oldname, newname=newname)
 MemSchemaCWETypeRename(self.cw_req, oldname=oldname, newname=newname)
 entity['name'] = newname
-class DelCWRTypeHook(hook.Hook):
+# CWRType hooks ################################################################
+class DelCWRTypeHook(SyncSchemaHook):
 """before deleting a CWRType entity:
 * check that we don't remove a core relation type
 * cascade to delete related CWAttribute and CWRelation entities
 * instantiate an operation to delete the relation type on commit
 """
 __id__ = 'syncdelcwrtype'
-__select__ = hook.Hook.__select__ & entity_implements('CWRType')
+__select__ = SyncSchemaHook.__select__ & entity_implements('CWRType')
-category = 'syncschema'
 events = ('before_delete_entity',)
 def __call__(self):
 name = self.entity.name
 if name in CORE_ETYPES:
 raise ValidationError(self.entity.eid, {None: self.cw_req._('can\'t be deleted')})
 # delete relation definitions using this relation type
 MemSchemaCWRTypeUpdate(self.cw_req, rschema=rschema, values=newvalues)
 SourceDbCWRTypeUpdate(self.cw_req, rschema=rschema, values=newvalues,
 entity=entity)
+# relation_type hooks ##########################################################
-class AfterDelRelationTypeHook(hook.Hook):
+class AfterDelRelationTypeHook(SyncSchemaHook):
 """before deleting a CWAttribute or CWRelation entity:
 * if this is a final or inlined relation definition, instantiate an
 operation to drop necessary column, else if this is the last instance
 of a non final relation, instantiate an operation to drop necessary
 table
 * instantiate an operation to delete the relation definition on commit
 * delete the associated relation type when necessary
 """
 __id__ = 'syncdelrelationtype'
-__select__ = hook.Hook.__select__ & hook.match_rtype('relation_type')
+__select__ = SyncSchemaHook.__select__ & hook.match_rtype('relation_type')
-category = 'syncschema'
 events = ('after_delete_relation',)
 def __call__(self):
 session = self.cw_req
 subjschema, rschema, objschema = session.schema.schema_by_eid(self.eidfrom)
 if lastrel and not rteid in pendings:
 execute('DELETE CWRType X WHERE X eid %(x)s', {'x': rteid}, 'x')
 MemSchemaRDefDel(session, (subjschema, rschema, objschema))
-class AfterAddCWAttributeHook(hook.Hook):
+# CWAttribute / CWRelation hooks ###############################################
+class AfterAddCWAttributeHook(SyncSchemaHook):
 __id__ = 'syncaddcwattribute'
-__select__ = hook.Hook.__select__ & entity_implements('CWAttribute')
+__select__ = SyncSchemaHook.__select__ & entity_implements('CWAttribute')
-category = 'syncschema'
 events = ('after_add_entity',)
 def __call__(self):
 SourceDbCWAttributeAdd(self.cw_req, entity=self.entity)
 class AfterAddCWRelationHook(AfterAddCWAttributeHook):
 __id__ = 'syncaddcwrelation'
-__select__ = hook.Hook.__select__ & entity_implements('CWRelation')
+__select__ = SyncSchemaHook.__select__ & entity_implements('CWRelation')
 def __call__(self):
 SourceDbCWRelationAdd(self.cw_req, entity=self.entity)
-class AfterUpdateCWRDefHook(hook.Hook):
+class AfterUpdateCWRDefHook(SyncSchemaHook):
 __id__ = 'syncaddcwattribute'
-__select__ = hook.Hook.__select__ & entity_implements('CWAttribute', 'CWRelation')
+__select__ = SyncSchemaHook.__select__ & entity_implements('CWAttribute',
-category = 'syncschema'
+'CWRelation')
 events = ('after_update_entity',)
 def __call__(self):
 entity = self.entity
-if entity.eid in self.cw_req.transaction_data.get('pendingeids', ()):
+if self.cw_req.deleted_in_transaction(entity.eid):
 return
 desttype = entity.otype.name
 rschema = self.cw_req.schema[entity.rtype.name]
 newvalues = {}
 for prop in rschema.rproperty_defs(desttype):
 rschema=rschema, values=newvalues)
 # constraints synchronization hooks ############################################
-class AfterAddCWConstraintHook(hook.Hook):
+class AfterAddCWConstraintHook(SyncSchemaHook):
 __id__ = 'syncaddcwconstraint'
-__select__ = hook.Hook.__select__ & entity_implements('CWConstraint')
+__select__ = SyncSchemaHook.__select__ & entity_implements('CWConstraint')
-category = 'syncschema'
 events = ('after_add_entity', 'after_update_entity')
 def __call__(self):
 MemSchemaCWConstraintAdd(self.cw_req, entity=self.entity)
 SourceDbCWConstraintAdd(self.cw_req, entity=self.entity)
-class AfterAddConstrainedByHook(hook.Hook):
+class AfterAddConstrainedByHook(SyncSchemaHook):
 __id__ = 'syncdelconstrainedby'
-__select__ = hook.Hook.__select__ & hook.match_rtype('constrainted_by')
+__select__ = SyncSchemaHook.__select__ & hook.match_rtype('constrainted_by')
-category = 'syncschema'
 events = ('after_add_relation',)
 def __call__(self):
-if self.eidfrom in self.cw_req.transaction_data.get('neweids', ()):
+if self.cw_req.added_in_transaction(self.eidfrom):
 self.cw_req.transaction_data.setdefault(self.eidfrom, []).append(self.eidto)
 class BeforeDeleteConstrainedByHook(AfterAddConstrainedByHook):
 __id__ = 'syncdelconstrainedby'
 events = ('before_delete_relation',)
 def __call__(self):
-if self.eidfrom in self.cw_req.transaction_data.get('pendingeids', ()):
+if self.cw_req.deleted_in_transaction(self.eidfrom):
 return
 schema = self.cw_req.schema
 entity = self.cw_req.entity_from_eid(self.eidto)
 subjtype, rtype, objtype = schema.schema_by_eid(self.eidfrom)
 try:
 # permissions synchronization hooks ############################################
-class AfterAddPermissionHook(hook.Hook):
+class AfterAddPermissionHook(SyncSchemaHook):
 """added entity/relation *_permission, need to update schema"""
 __id__ = 'syncaddperm'
-__select__ = hook.Hook.__select__ & hook.match_rtype(
+__select__ = SyncSchemaHook.__select__ & hook.match_rtype(
 'read_permission', 'add_permission', 'delete_permission',
 'update_permission')
-category = 'syncschema'
 events = ('after_add_relation',)
 def __call__(self):
 perm = self.rtype.split('_', 1)[0]
 if self.cw_req.describe(self.eidto)[0] == 'CWGroup':
 """
 __id__ = 'syncdelperm'
 events = ('before_delete_relation',)
 def __call__(self):
-if self.eidfrom in self.cw_req.transaction_data.get('pendingeids', ()):
+if self.cw_req.deleted_in_transaction(self.eidfrom):
 return
 perm = self.rtype.split('_', 1)[0]
 if self.cw_req.describe(self.eidto)[0] == 'CWGroup':
 MemSchemaPermCWGroupDel(self.cw_req, perm, self.eidfrom, self.eidto)
 else: # RQLExpression
 expr = self.cw_req.entity_from_eid(self.eidto).expression
 MemSchemaPermRQLExpressionDel(self.cw_req, perm, self.eidfrom, expr)
-class ModifySpecializesHook(hook.Hook):
+class ModifySpecializesHook(SyncSchemaHook):
 __id__ = 'syncspecializes'
-__select__ = hook.Hook.__select__ & hook.match_rtype('specializes')
+__select__ = SyncSchemaHook.__select__ & hook.match_rtype('specializes')
-category = 'syncschema'
 events = ('after_add_relation', 'after_delete_relation')
 def __call__(self):
 # registering a schema operation will trigger a call to
 # repo.set_schema() on commit which will in turn rebuild

changeset 2841	107ba1c45227
parent 2835	04034421b072
child 2847	c2ee28f4d4b1