def restoreTo(self, sParentId, trans):
"""
Restores the deleted object to the specified container.
@param sParentId: The ID of the container in which
the item will be restored
@type sParentId: str
@param trans: A valid transaction handle
@return: None
"""
## TODO: check if oDeleted exists
oDeleted = _db.getDeletedItem(self._deletedId, trans)
oParent = _db.getItem(sParentId, trans)
if not(oDeleted.getContentclass() in oParent.containment):
raise exceptions.ContainmentError, \
'The target container does not accept ' + \
'objects of type "%s".' % oDeleted.getContentclass()
# try to restore original item
self._restore(oDeleted, oParent, trans)
self.delete(trans, False)
# update container
oParent._addItemReference(oDeleted)
_db.putItem(oParent, trans)
def getDeletedItem(self):
"""
Use this method to get the item that was logically deleted.
@return: the deleted item
@rtype: type
"""
oDeleted = _db.getDeletedItem(self._deletedId)
return(oDeleted)
def on_create(item, attr, trans):
if item._isDeleted and attr.cascadeDelete and attr.value:
from porcupine.systemObjects import DeletedItem
oItemRef = _db.getDeletedItem(attr.value, trans)
parent = _db.getItem(oItemRef._parentid, trans)
# update container
parent._addItemReference(oItemRef)
_db.putItem(parent, trans)
deletedItem = DeletedItem(oItemRef, trans)
deletedItem._undelete(oItemRef, trans)
Relator1EventHandler.on_update(item, attr, None, trans)
def delete(self, trans, _removeDeleted=True):
"""
Deletes the deleted object permanently.
@param trans: A valid transaction handle
@param _removeDeleted: Leave as is
@return: None
"""
Removeable.delete(self, trans)
if _removeDeleted:
# we got a direct call. remove deleted item
## TODO: check if oDeleted exists
oDeleted = _db.getDeletedItem(self._deletedId, trans)
_db.removeDeletedItem(oDeleted, trans)
def _undelete(self, deletedItem, trans):
"""
Undeletes a logically deleted item.
Returns: None
"""
_db.handle_update(deletedItem, None, trans)
deletedItem._isDeleted = False
if deletedItem.isCollection:
lstChildren = deletedItem._items.values() + deletedItem._subfolders.values()
for sID in lstChildren:
oChild = _db.getDeletedItem(sID, trans)
self._undelete(oChild, trans)
_db.putItem(deletedItem, trans)
def on_delete(item, attr, trans, bPermanent):
lstValue = attr.value
if not item._isDeleted:
from porcupine import datatypes
if lstValue and attr.respectsReferences:
raise exceptions.ReferentialIntegrityError, (
'Cannot delete object "%s" ' % item.displayName.value +
'because it is being referenced by other objects.')
# remove references
for sID in lstValue:
ref_item = _db.getItem(sID, trans)
if ref_item.getContentclass() in attr.relCc:
oAttrRef = getattr(ref_item, attr.relAttr)
if isinstance(oAttrRef, datatypes.RelatorN):
try:
oAttrRef.value.remove(item._id)
except ValueError:
pass
elif isinstance(oAttrRef, datatypes.Relator1):
oAttrRef.value = ''
_db.putItem(ref_item, trans)
else:
attr.value.remove(sID)
if attr.cascadeDelete:
oParent = _db.getItem(oItemRef._parentid, trans)
try:
oParent._removeItemReference(oItemRef)
_db.putItem(oParent, trans)
except KeyError:
pass
if attr.cascadeDelete:
for sID in lstValue:
if item._isDeleted:
oItemRef = _db.getDeletedItem(sID, trans)
else:
oItemRef = _db.getItem(sID, trans)
if bPermanent:
oItemRef._delete(trans)
else:
oItemRef._recycle(trans)
def delete(self, trans, _removeDeleted=True):
"""
Deletes the deleted object permanently.
@param trans: A valid transaction handle
@param _removeDeleted: Leave as is
@return: None
"""
Removeable.delete(self, trans)
if _removeDeleted:
# we got a direct call. remove deleted item
## TODO: check if oDeleted exists
oDeleted = _db.getDeletedItem(self._deletedId, trans)
_db.removeDeletedItem(oDeleted, trans)
else:
# we got a call from "restore" or "restoreTo"
# do not replay in case of txn abort
del trans.actions[-1]
def restore(self, trans):
"""
Restores the deleted item to its original location, if
it still exists.
@param trans: A valid transaction handle
@return: None
@raise L{porcupine.exceptions.ObjectNotFound}:
If the original location no longer exists.
"""
## TODO: check if oDeleted exists
oDeleted = _db.getDeletedItem(self._deletedId, trans)
oOriginalParent = _db.getItem(oDeleted._parentid, trans)
# update container
oOriginalParent._addItemReference(oDeleted)
_db.putItem(oOriginalParent, trans)
# try to restore original item
self._restore(oDeleted, oOriginalParent, trans)
self.delete(trans, False)
def on_create(cls, item, attr, trans):
if item._isDeleted:
attr.value = [_db.getDeletedItem(sID, trans)
for sID in attr.value]
CompositionEventHandler.on_update(item, attr, None, trans)
