def approve_version(self):
"""Aprove the current unapproved version.
"""
# self._update_publication_status()
if self._unapproved_version == empty_version:
raise VersioningError(
_('There is no unapproved version to approve.'), self)
if self._approved_version != empty_version:
raise VersioningError(_('There already is an approved version.'),
self)
if self._unapproved_version[1] is None:
raise VersioningError(
_('Cannot approve version without publication datetime.'),
self)
self._approved_version = self._unapproved_version
self._unapproved_version = empty_version
version = self._getOb(self._approved_version[0])
status = IRequestForApprovalStatus(version)
status.validate()
notify(events.ContentApprovedEvent(version, status))
# We may be published now
self._update_publication_status()
def request_version_approval(self, message):
"""Request approval for the current unapproved version
Raises VersioningError, if there is no such version,
or it is already approved.
Returns None otherwise
"""
version_id = self.get_unapproved_version()
if version_id is None:
raise VersioningError(_("This content doesn't require approval."),
self)
version = self._getOb(version_id)
status = IRequestForApprovalStatus(version)
if status.pending:
raise VersioningError(
_('The version is already requested for approval.'), self)
status.comment('request', message)
notify(events.ContentRequestApprovalEvent(version, status))
def test_request_approval_approved(self):
versioning = self.root.versioning
# Cannot ask approval if there is no version to approve
self.assertRaises(Versioning.VersioningError,
versioning.request_version_approval,
'Request message')
self.assertEqual(versioning.is_approval_requested(), False)
versioning.create_version('0', DateTime() + 10, None)
with assertTriggersEvents('ContentRequestApprovalEvent'):
versioning.request_version_approval('Request test message')
self.assertEqual(versioning.is_approval_requested(), True)
self.assertEqual(versioning.get_public_version(), None)
self.assertEqual(versioning.get_approved_version(), None)
self.assertEqual(versioning.get_unapproved_version(), '0')
status = IRequestForApprovalStatus(versioning._getOb('0'))
self.assertEqual(len(status.messages), 1)
self.assertEqual(status.pending, True)
message = status.messages[0]
self.assertEqual(message.user_id, 'manager')
self.assertEqual(message.status, 'request')
self.assertEqual(message.message, 'Request test message')
self.assertNotEqual(message.date, None)
# Cannot ask approval two times
self.assertRaises(Versioning.VersioningError,
versioning.request_version_approval,
'Request message')
with assertTriggersEvents('ContentApprovedEvent'):
versioning.approve_version()
self.assertEqual(versioning.is_approval_requested(), False)
self.assertEqual(versioning.get_public_version(), None)
self.assertEqual(versioning.get_approved_version(), '0')
self.assertEqual(versioning.get_unapproved_version(), None)
self.assertEqual(len(status.messages), 2)
self.assertEqual(status.pending, False)
response_message = status.messages[1]
self.assertEqual(response_message.user_id, 'manager')
self.assertEqual(response_message.status, 'approve')
self.assertEqual(response_message.message, None)
self.assertNotEqual(response_message.date, None)
# It is approved, cannot ask to approve it again
self.assertRaises(Versioning.VersioningError,
versioning.request_version_approval,
'Request message')
def is_approval_requested(self):
"""Check if there exists an unapproved version
which has a request for approval.
"""
version_id = self.get_unapproved_version()
if version_id is None:
return False
version = self._getOb(version_id)
status = IRequestForApprovalStatus(version)
return status.pending
def reject_version_approval(self, message):
"""Reject a previous request for approval
Implementation should raise VersioningError, if the
currently unapproved version has no request for approval yet,
or if there is no unapproved version.
"""
version_id = self.get_unapproved_version()
if version_id is None:
raise VersioningError(_("This content doesn't require approval."),
self)
version = self._getOb(version_id)
status = IRequestForApprovalStatus(version)
if not status.pending:
raise VersioningError(
_("No request for approval is pending for this content."),
self)
status.comment('reject', message)
notify(events.ContentApprovalRequestRefusedEvent(version, status))
def create_copy(self, version_id=None):
"""Create new version of public version.
"""
if self.get_approved_version() is not None:
raise VersioningError(
_('An approved version is already available.'),
self)
if self.get_unapproved_version() is not None:
raise VersioningError(
_('An new version is already available.'),
self)
expiration_time = None
if version_id is None:
# get id of public version to copy
version_id, ignored_time, expiration_time = self._public_version
# if there is no public version, get id of last closed version
# (which should always be there)
if version_id is None:
if self._previous_versions:
version_id, ignored_time, expiration_time = \
self._previous_versions[-1]
if version_id is None:
raise VersioningError(
_(u"There is no version to create a version form."),
self)
if expiration_time is not None and not expiration_time.isFuture():
# Reset expiration time if it is in the past.
expiration_time = None
# Copy given version
new_version_id = self.get_new_version_id()
self.manage_clone(self._getOb(version_id), new_version_id)
# The version might have been copied. Clear its data.
version = self._getOb(new_version_id)
IRequestForApprovalStatus(version).reset()
# Register it
self.create_version(new_version_id, None, expiration_time)
def test_request_approval_withdraw(self):
versioning = self.root.versioning
# Cannot ask/cancel approval if there is no version to approve
self.assertRaises(Versioning.VersioningError,
versioning.withdraw_version_approval,
'Withdraw message')
versioning.create_version('0', DateTime() + 10, None)
with assertTriggersEvents('ContentRequestApprovalEvent'):
versioning.request_version_approval('Request message')
self.assertEqual(versioning.get_public_version(), None)
self.assertEqual(versioning.get_approved_version(), None)
self.assertEqual(versioning.get_unapproved_version(), '0')
status = IRequestForApprovalStatus(versioning._getOb('0'))
self.assertEqual(len(status.messages), 1)
self.assertEqual(status.pending, True)
with assertTriggersEvents('ContentApprovalRequestWithdrawnEvent'):
versioning.withdraw_version_approval('Withdraw message')
self.assertEqual(versioning.get_public_version(), None)
self.assertEqual(versioning.get_approved_version(), None)
self.assertEqual(versioning.get_unapproved_version(), '0')
self.assertEqual(len(status.messages), 2)
self.assertEqual(status.pending, False)
response_message = status.messages[1]
self.assertEqual(response_message.user_id, 'manager')
self.assertEqual(response_message.status, 'withdraw')
self.assertEqual(response_message.message, 'Withdraw message')
self.assertNotEqual(response_message.date, None)
# Cannot withdraw version twice
self.assertRaises(Versioning.VersioningError,
versioning.withdraw_version_approval,
'Withdraw message')
