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