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 set_approved_version_publication_datetime(self, dt):
"""Set publication datetime for approved.
"""
if self._approved_version == empty_version:
raise VersioningError(_('No approved version.'), self)
if dt is None:
raise VersioningError(_('Must specify publication datetime.'), self)
version_id, publication_datetime, expiration_datetime = \
self._approved_version
self._approved_version = version_id, dt, expiration_datetime
# may become published, update publication status
self._update_publication_status()
def get_status(self):
"""Returns the status of a version as a string
return value can be one of the following strings:
unapproved
pending
approved
published
last_closed
closed
"""
versionid = self.version.id
if self.content.get_unapproved_version() == versionid:
if self.content.is_approval_requested():
return 'pending'
return 'unapproved'
elif self.content.get_approved_version() == versionid:
return 'approved'
elif self.content.get_public_version() == versionid:
return 'published'
else:
if self.content._previous_versions:
if self.content._previous_versions[-1][0] == versionid:
return 'last_closed'
else:
for (vid, vpt, vet) in self.content._previous_versions:
if vid == versionid:
return 'closed'
raise VersioningError(
_('No such version ${version}', mapping={'version': versionid}),
self.content)
def set_unapproved_version_expiration_datetime(self, dt):
"""Set expiration datetime, or None for no expiration.
"""
if self._unapproved_version == empty_version:
raise VersioningError(_('No unapproved version.'), self)
version_id, publication_datetime, expiration_datetime = \
self._unapproved_version
self._unapproved_version = version_id, publication_datetime, dt
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 set_public_version_expiration_datetime(self, dt):
"""Set expiration datetime, or None for no expiration.
"""
if self._public_version == empty_version:
raise VersioningError(_('No public version.'), self)
version_id, publication_datetime, expiration_datetime = \
self._public_version
self._public_version = version_id, publication_datetime, dt
# may become expired, update publication status
self._update_publication_status()
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 delete(self):
"""Delete the version
"""
versionid = self.version.id
if self.content.get_approved_version() == versionid:
raise VersioningError(_("Version is approved."), self.content,
self.version)
if self.content.get_public_version() == versionid:
raise VersioningError(_("Version is published."), self.content,
self.version)
if self.content.get_unapproved_version() == versionid:
self.content._unapproved_version = (None, None, None)
else:
for version in self.content._previous_versions:
if version[0] == versionid:
self.content._previous_versions.remove(version)
break
self.content.manage_delObjects([versionid])
return True
def set_next_version_expiration_datetime(self, dt):
"""Set expiration datetime of next version.
"""
if self._approved_version[0]:
version_id, publication_datetime, expiration_datetime = \
self._approved_version
self._approved_version = version_id, publication_datetime, dt
elif self._unapproved_version[0]:
version_id, publication_datetime, expiration_datetime = \
self._unapproved_version
self._unapproved_version = version_id, publication_datetime, dt
else:
raise VersioningError(_('No next version.'), self)
def unapprove_version(self):
"""Unapprove an approved but not yet public version.
"""
# self._update_publication_status()
if self._approved_version == empty_version:
raise VersioningError(_("This content is not approved."), self)
if self._unapproved_version != empty_version:
raise VersioningError(
_(
('Should never happen: unapproved version ${unapproved} found while '
'approved version ${approved} exists at the same time.'),
mapping={
'unapproved': self._unapproved_version[0],
'approved': self._approved_version[0]
}), self)
self._unapproved_version = self._approved_version
self._approved_version = empty_version
version = self._getOb(self._unapproved_version[0])
notify(events.ContentUnApprovedEvent(version))
def approve(self, time=None):
if self.context.get_unapproved_version() is None:
raise VersioningError(
_("There is no unapproved version to approve."),
self.context)
if time is not None:
if isinstance(time, datetime):
time = DateTime(time)
self.context.set_unapproved_version_publication_datetime(time)
elif self.context.get_unapproved_version_publication_datetime() is None:
self.context.set_unapproved_version_publication_datetime(DateTime())
self.context.approve_version()
return True
def close_version(self):
"""Close public version.
"""
if self._public_version == empty_version:
raise VersioningError(_("There is no public version to close."),
self)
previous_versions = self._previous_versions or []
previous_versions.append(self._public_version)
self._public_version = empty_version
self._previous_versions = previous_versions
version = self._getOb(self._previous_versions[-1][0])
notify(events.ContentClosedEvent(version))
def publish(self):
# Do the same job than approve, but works on closed content as
# well.
if not self.context.get_unapproved_version():
if self.context.is_published():
raise VersioningError(
_("There is no unapproved version to approve."),
self.context)
self.context.create_copy()
current = self.context.get_unapproved_version_publication_datetime()
if current is None or current.isFuture():
# If the publication date is in the future, set it correct to now.
self.context.set_unapproved_version_publication_datetime(DateTime())
self.context.approve_version()
return True
def make_editable(self):
"""Make the version editable.
"""
current_version = self.content.get_unapproved_version()
if current_version is not None:
# move the current editable version to _previous_versions
if self.content.is_approval_requested():
raise VersioningError(
_('A version is already waiting approval.'), self)
version_tuple = self.content._unapproved_version
if self.content._previous_versions is None:
self.content._previous_versions = []
self.content._previous_versions.append(version_tuple)
self.content._unapproved_version = (None, None, None)
self.content.create_copy(version_id=self.version.id)
return True
