def delete_action(wf, context): # pylint: disable=invalid-name,unused-argument """Delete draft version, and parent if single version""" versions = IWorkflowVersions(context) versions.remove_version(IWorkflowState(context).version_id) if not versions.get_last_versions(): document = get_parent(versions, IDocument) folder = get_parent(document, IDocumentFolder) del folder[document.__name__]
def handle_added_engine(event): """Register new SQLAlchemy engine when added""" sm = get_parent(event.newParent, ISiteRoot) # pylint: disable=invalid-name if sm is not None: sm.getSiteManager().registerUtility(event.object, IAlchemyEngineUtility, name=event.object.name or '')
def handle_removed_engine(event): """Un-register an SQLAlchemy engine when deleted""" sm = get_parent(event.oldParent, ISiteRoot) # pylint: disable=invalid-name if sm is not None: sm.getSiteManager().unregisterUtility(event.object, IAlchemyEngineUtility, name=event.object.name or '')
def send_report(task, report, status, target, registry=None): # pylint: disable=unused-argument """Send mail report to given target""" if not IMailNotification.providedBy(target): return scheduler = get_parent(task, IScheduler) try: mailer_name = scheduler.report_mailer except (TypeError, AttributeError, ComponentLookupError): return mailer = queryUtility(IMailer, mailer_name) if mailer is not None: report_source = scheduler.report_source if status == TASK_STATUS_ERROR: subject = "[SCHEDULER !ERROR!] {}".format(task.name) elif status == TASK_STATUS_WARNING: subject = "[SCHEDULER WARNING] {}".format(task.name) else: subject = "[scheduler] {}".format(task.name) for email in target.target_email or (): message = Message(subject=subject, sender=report_source, recipients=(email, ), body=report.getvalue()) mailer.send(message)
def notify_user_activation(user, request=None): """Send mail for user activation""" security = query_utility(ISecurityManager) settings = INotificationSettings(security) if not settings.enable_notifications: # pylint: disable=assignment-from-no-return LOGGER.info("Security notifications disabled, no message sent...") return mailer = settings.get_mailer() # pylint: disable=assignment-from-no-return if mailer is None: LOGGER.warning("Can't find mailer utility, no notification message sent!") return if request is None: request = check_request() translate = request.localizer.translate i18n_settings = II18n(settings) message_text, template_name = None, None if user.self_registered: # pylint: disable=assignment-from-no-return message_text = i18n_settings.query_attribute('registration_template', request=request) if not message_text: template_name = 'templates/register-message.pt' elif user.wait_confirmation: # pylint: disable=assignment-from-no-return message_text = i18n_settings.query_attribute('confirmation_template', request=request) if not message_text: template_name = 'templates/register-info.pt' site = get_parent(request.context, ISite) if message_text is not None: message_text = message_text.format(**user.to_dict()) elif template_name is not None: message_text = render(template_name, request=request, value={ 'user': user, 'site': site, 'settings': settings }) html_body = render('templates/register-body.pt', request=request, value={ 'user': user, 'site': site, 'settings': settings, 'message': message_text }) message = Message( subject=translate(_("{prefix}Please confirm registration")).format( prefix="{prefix} ".format(prefix=settings.subject_prefix) if settings.subject_prefix else ''), sender='{name} <{email}>'.format(name=settings.sender_name, email=settings.sender_email), recipients=("{firstname} {lastname} <{email}>".format(firstname=user.firstname, lastname=user.lastname, email=user.email),), html=Attachment(data=html_body, content_type='text/html; charset=utf-8', disposition='inline', transfer_encoding='quoted-printable'), body=Attachment(data=html_to_text(html_body), content_type='text/plain; charset=utf-8', disposition='inline', transfer_encoding='quoted-printable')) mailer.send(message)
def title(self): """Title getter""" translate = self.request.localizer.translate scheduler = query_utility(IScheduler) task = get_parent(self.context, ITask) return '<small>{}</small><br />{}'.format( get_object_label(scheduler, self.request, self), translate(_("Task: {}")).format(task.name))
def skin_parent(self): """Get parent of current skin, which can be self if not inherited""" if (not self._inherit_skin) and self.skin: return self parent = get_parent(self, ISkinnable, allow_context=False) if parent is not None: return parent.skin_parent return None
def internal_id(self): """Task internal ID getter""" if self._internal_id is None: site = get_parent(self, ISite) sm = site.getSiteManager() # pylint: disable=invalid-name,too-many-function-args,assignment-from-no-return intids = sm.queryUtility(IIntIds) if intids is not None: self._internal_id = intids.register(self) return self._internal_id
def render(self, changes): """AJAX result renderer""" if not changes: return None scheduler = get_parent(self.context, IScheduler) return { 'callbacks': [ get_json_table_row_add_callback(scheduler, self.request, SchedulerTasksTable, changes) ] }
def render(self, changes): """AJAX form renderer""" if not changes: return None manager = get_parent(self.context, IAlchemyManager) return { 'callbacks': [ get_json_table_row_add_callback(manager, self.request, AlchemyManagerEnginesTable, changes) ] }
def render(self, changes): """AJAX result renderer""" if changes is None: return None task = get_parent(self.context, ITask) return { 'status': 'success', 'message': self.request.localizer.translate(self.view.success_message), 'callbacks': [ get_json_table_row_refresh_callback(task, self.request, TaskNotificationsTable, self.context) ] }
def _get_viewlets(self): viewlets = [] content = get_parent(self.context, IWorkflowManagedContent) wf = get_utility(IWorkflow, name=content.workflow_name) # pylint: disable=invalid-name if wf is None: return viewlets info = IWorkflowInfo(self.context) for transition_id in info.get_manual_transition_ids(): transition = wf.get_transition_by_id(transition_id) menu = TransitionMenuItem(self.context, self.request, self.view, self, transition) viewlets.append((transition_id, menu)) return sorted(viewlets, key=lambda x: x[1].weight)
def delete_document(self, oid, request=None): """Delete document or version""" if not oid: return None document = self.get_document(oid) if document is None: raise HTTPNotFound() if request is None: request = check_request() if not request.has_permission(MANAGE_DOCUMENT_PERMISSION, context=document): raise HTTPForbidden() folder = get_parent(document, IDocumentFolder) del folder[document.oid] return document
def remove_version(self, version_id, state='deleted', comment=None, principal=None, request=None): # pylint: disable=too-many-arguments """Remove version with given ID""" if str(version_id) not in self: return # update version state version = self[str(version_id)] wf_state = IWorkflowState(version) if comment: if request is None: request = check_request() translate = request.localizer.translate workflow = get_utility( IWorkflow, name=get_parent(self, IWorkflowManagedContent).workflow_name) item = WorkflowHistoryItem( date=datetime.utcnow(), source_version=wf_state.version_id, source_state=translate( workflow.states.getTerm(wf_state.state).title), target_state=translate(workflow.states.getTerm(state).title), principal=request.principal.id, comment=comment) wf_state.history.append(item) # pylint: disable=no-member wf_state.state = state if principal is not None: wf_state.state_principal = principal # remove given version state = self.state_by_version[version_id] versions = self.versions_by_state[state] versions.remove(version_id) if versions: self.versions_by_state[state] = versions else: del self.versions_by_state[state] del self.state_by_version[version_id] self.deleted[version_id] = self[str(version_id)] del self[str(version_id)]
def __init__(self, context): terms = [] translate = check_request().localizer.translate negotiator = query_utility(INegotiator) if negotiator is not None: terms.append( SimpleTerm(negotiator.server_language, title=translate( BASE_LANGUAGES.get( negotiator.server_language)))) manager = get_parent(context, II18nManager) if manager is not None: for lang in manager.languages: # pylint: disable=not-an-iterable if (negotiator is None) or (lang != negotiator.server_language): terms.append( SimpleTerm(lang, title=translate( BASE_LANGUAGES.get(lang) or _("<unknown>")))) super(I18nContentLanguages, self).__init__(terms)
def is_published(self, check_parent=True): """Check if content is published""" # check is parent is also published... if check_parent: parent = get_parent(self.__parent__, IWorkflowPublicationSupport, allow_context=False) if (parent is not None ) and not IWorkflowPublicationInfo(parent).is_published(): return False # associated workflow? workflow = IWorkflow(self.__parent__, None) if (workflow is not None) and not workflow.visible_states: return False # check content versions versions = IWorkflowVersions(self.__parent__, None) if (versions is not None) and not versions.get_versions( workflow.visible_states): return False now = tztime(datetime.utcnow()) return (self.publication_effective_date is not None) and \ (self.publication_effective_date <= now) and \ ((self.publication_expiration_date is None) or (self.publication_expiration_date >= now))
def resources(self): """Get custom skin resources""" request = self.request main_resources = request.registry.queryMultiAdapter( (self.context, request, self.view), IResources) if main_resources is not None: main_resource = main_resources.resources[-1] library = main_resource.library parent_resources = (main_resource,) skin_parent = get_parent(request.context, ISkinnable).skin_parent # include custom CSS files custom_css = skin_parent.custom_stylesheet # pylint: disable=no-member if custom_css: dc = IZopeDublinCore(custom_css, None) # pylint: disable=invalid-name modified = dc.modified if dc is not None else datetime.utcnow() # pylint: disable=no-member custom_css_url = absolute_url(custom_css, request, query={'_': modified.timestamp()}) resource = library.known_resources.get(custom_css_url) if resource is None: resource = ExternalResource(library, custom_css_url, resource_type='css', depends=parent_resources) yield resource # include custom JS files custom_js = skin_parent.custom_script # pylint: disable=no-member if custom_js: dc = IZopeDublinCore(custom_js, None) # pylint: disable=invalid-name modified = dc.modified if dc is not None else datetime.utcnow() # pylint: disable=no-member custom_js_url = absolute_url(custom_js, request, query={'_': modified.timestamp()}) resource = library.known_resources.get(custom_js_url) if resource is None: resource = ExternalResource(library, custom_js_url, resource_type='js', depends=parent_resources, bottom=True) yield resource
def get_value(self, obj): task = get_parent(obj, ITask) return task.name
def parent(self): """Workflow managed content getter""" return get_parent(self.context, IWorkflowManagedContent)
def parent(self): """Get current parent""" return get_parent(self.__parent__, self.target_interface, allow_context=False)
def workflow_version_workflow_factory(context): """Workflow content version workflow factory""" content = get_parent(context, IWorkflowManagedContent) return queryUtility(IWorkflow, name=content.workflow_name)
def oid(self): """Get parent OID""" document = get_parent(self, IDocument) return document.oid
def workflow(self): """Workflow property getter""" content = get_parent(self.context, IWorkflowManagedContent) return get_utility(IWorkflow, name=content.workflow_name)
def workflow_version_versions_factory(context): """Workflow versions factory for version""" parent = get_parent(context, IWorkflowManagedContent) if parent is not None: return IWorkflowVersions(parent) return None
def wf_content_workflow_adapter(context): """Content workflow adapter""" content = get_parent(context, IContent) return getUtility(IWorkflow, name=content.workflow_name)
def can_inherit_skin(self): """Can we inherit skin from parent?""" return get_parent(self, ISkinnable, allow_context=False) is not None
def transition(self): """Transition property getter""" parent = get_parent(self.context, IWorkflowManagedContent) workflow = query_utility(IWorkflow, name=parent.workflow_name) return workflow.get_transition_by_id( self.request.params.get('workflow.widgets.transition_id'))
def title(self): """Title getter""" return get_parent(self.context, ITask).name