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
