def __call__(self, *args, **kw):
context = self.context
request = self.request
request.set('disable_border', 1)
# following two only on Plone 4+
request.set('disable_plone.leftcolumn', 1)
request.set('disable_plone.rightcolumn', 1)
self.error = False
token = request.form.get('token')
path = request.form.get('path')
comment = request.form.get('comment', None)
doc = context.unrestrictedTraverse(path)
conf = IAnnotations(doc).get('share-tokens')
if conf.get('reject') and conf.get('reject')==token and not comment.strip():
# comment when rejecting is required
context.plone_utils.addPortalMessage(_(u'When rejecting, a motivation is required'),
type='error')
request.response.redirect(request.form.get('came_from') or context.absolute_url())
return
try:
self.result = ConsumePowerTokenView.__call__(self, comment=comment, **kw)[0]
except PowerTokenSecurityError:
self.result = None
self.error = True
return self.index()
class BasicProfile(object):
implements(IBasicProfile)
adapts(IPrincipal)
def __init__(self, principal):
self.annotations = IAnnotations(principal)
self.principal = principal
@setproperty
def name(self, v):
self.annotations['name'] = v
# for principalfolder search
ip = internal_principal(self.principal.id)
ip.title = v
@getproperty
def name(self):
return self.annotations.get('name', self.principal.title)
@setproperty
def email(self, v):
self.annotations['email'] = v
@getproperty
def email(self):
return self.annotations.get('email', u'')
def test_ParentsAreCorrectlyUpdatedOnMove(self):
# first create some projects and sub-projects using the _createProjectsAndTestAnnotationsEvolution
(project1, subproject1, subSubproject1, subSubproject2, project1Annotations, subproject1Annotations,
subSubproject1Annotations, subSubproject2Annotations) = self._createProjectsAndTestAnnotationsEvolution()
project2 = self.portal.projectspace['project-2']
project2Annotations = IAnnotations(project2)
# we change initial state
self.pw.doActionFor(project2, "set_to_be_scheduled")
params = {'title': 'Subproject 2',
'priority': 'priority-2',
}
subproject2 = createContentInContainer(project2, 'project', **params)
# we change initial state
self.pw.doActionFor(subproject2, "set_to_be_scheduled")
subproject2Annotations = IAnnotations(subproject2)
# verifying content
self.assertEquals(len(project1Annotations[CBIAK].keys()), 3)
self.assertEquals(len(subproject1Annotations[CBIAK].keys()), 2)
self.assertDictEqual(project2Annotations.get(CBIAK, {}), {})
self.assertDictEqual(subproject2Annotations.get(CBIAK, {}), {})
# we move last level
api.content.move(subSubproject2, subproject2)
self.assertEquals(len(project1Annotations[CBIAK].keys()), 2)
self.assertEquals(len(subproject1Annotations[CBIAK].keys()), 1)
self.assertEquals(len(project2Annotations[CBIAK].keys()), 1)
self.assertEquals(len(subproject2Annotations[CBIAK].keys()), 1)
# we move intermediate level
api.content.move(subproject1, project2)
self.assertEquals(len(project1Annotations[CBIAK].keys()), 0)
self.assertEquals(len(subproject1Annotations[CBIAK].keys()), 1)
self.assertEquals(len(project2Annotations[CBIAK].keys()), 3)
self.assertEquals(len(subproject2Annotations[CBIAK].keys()), 1)
def __call__(self, *args, **kw):
context = self.context
request = self.request
request.set('disable_border', 1)
# following two only on Plone 4+
request.set('disable_plone.leftcolumn', 1)
request.set('disable_plone.rightcolumn', 1)
self.error = False
token = request.form.get('token')
path = request.form.get('path')
comment = request.form.get('comment', None)
doc = context.unrestrictedTraverse(path)
conf = IAnnotations(doc).get('share-tokens')
if conf.get('reject') and conf.get(
'reject') == token and not comment.strip():
# comment when rejecting is required
context.plone_utils.addPortalMessage(
_(u'When rejecting, a motivation is required'), type='error')
request.response.redirect(
request.form.get('came_from') or context.absolute_url())
return
try:
self.result = ConsumePowerTokenView.__call__(self,
comment=comment,
**kw)[0]
except PowerTokenSecurityError:
self.result = None
self.error = True
return self.index()
class BasicProfile(object):
implements(IBasicProfile)
adapts(IPrincipal)
def __init__(self, principal):
self.annotations = IAnnotations(principal)
self.principal = principal
@setproperty
def name(self, v):
self.annotations['name'] = v
# for principalfolder search
ip = internal_principal(self.principal.id)
ip.title = v
@getproperty
def name(self):
return self.annotations.get('name', self.principal.title)
@setproperty
def email(self, v):
self.annotations['email'] = v
@getproperty
def email(self):
return self.annotations.get('email', u'')
def __call__(self):
disable_edit_bar()
annotations = IAnnotations(self.context)
self.source_document = uuidToObject(annotations.get(PDF_SAVE_SOURCE_UUID_KEY))
self.version_id = annotations.get(PDF_SAVE_SOURCE_VERSION_KEY)
self.destination_document = self.context
self.destination = self.context.get_parent_dossier()
self.trigger_conversion()
return self.template()
def _initialize(self, create=False):
if self.storage is not None:
return
storage = IAnnotations(self.context)
if storage.get(ANNOTATIONS_KEY, None) is None:
storage[ANNOTATIONS_KEY] = dict.PersistentDict()
storage[ANNOTATIONS_KEY]['notifications'] = IOBTree()
storage[ANNOTATIONS_KEY]['user'] = OOBTree()
storage[ANNOTATIONS_KEY]['intid'] = 1
self.storage = storage.get(ANNOTATIONS_KEY, None)
def __call__(self):
disable_edit_bar()
annotations = IAnnotations(self.context)
self.source_document = uuidToObject(
annotations.get(PDF_SAVE_SOURCE_UUID_KEY))
self.version_id = annotations.get(PDF_SAVE_SOURCE_VERSION_KEY)
self.destination_document = self.context
self.destination = self.context.get_parent_dossier()
self.trigger_conversion()
return self.template()
class MegaphoneRenderer(BrowserView):
"""
This is a view of a Megaphone action which renders the letter based on the
request form variables and the template stored in an annotation on the
form folder.
"""
def __init__(self, context, request):
self.context = context
self.request = request
self.data = IAnnotations(context).get(ANNOTATION_KEY, PersistentDict())
def render_letter(self, request=None):
if request is None:
request = self.request
transformer = getToolByName(self.context, 'portal_transforms')
template = self.data.get('template', '${sender_body}')
return transformer(
'web_intelligent_plain_text_to_html',
_dreplace(template, self.context, request)
)
def render_plaintext_letter(self):
template = self.data.get('template', '${sender_body}')
return _dreplace(template, self.context, self.request).encode('utf8')
def render_all_letters(self):
letters = []
for request in recipient_multiplexer(self.context, self.request):
letters.append(self.render_letter(request=request))
return letters
def render_thankyou(self):
transformer = getToolByName(self.context, 'portal_transforms')
template = self.data.get('thankyou_template', '')
return transformer(
'web_intelligent_plain_text_to_html',
_dreplace(template, self.context, self.request)
)
def render_recipient_source_snippets(self):
out = []
for _, source in getAdapters((self.context, self.request), IRecipientSource):
out.append(source.render_form())
return ''.join(out)
def render_recipients_list(self):
recipients = []
for _, source in getAdapters((self.context, self.request), IRecipientSource):
for recipient in source.lookup():
recipients.append(recipient_label(recipient))
return recipients
def get_slid(self):
"""slideshare slideshowid or redirect to upload"""
annotations = IAnnotations(self.context)
sl_id = annotations.get(KEY, None)
if sl_id:
return sl_id
else:
if IATFile.providedBy(self.context):
if self.context.getContentType() in SLIDES_MIMETYPES:
self.request.response.redirect(
self.context.absolute_url() +
'/@@slideshare_post.html')
else:
msg = _(u"This file does not seem to be a presentation")
IStatusMessage(self.request).addStatusMessage(msg,
type='error')
elif IATLink.providedBy(self.context):
urlob = urlparse(self.context.getRemoteUrl())
if urlob.hostname == 'www.slideshare.net':
self.request.response.redirect(
self.context.absolute_url() +
'/@@slideshare_getid.html')
else:
msg = _(u"This is not a valid slideshare URL")
IStatusMessage(self.request).addStatusMessage(msg,
type='error')
def patched_getScale(self, instance, scale):
""" return scaled and aq-wrapped version for given image data """
field = self.context
available = field.getAvailableSizes(instance)
if scale in available or scale is None:
image = self.retrieveScale(instance, scale=scale)
if not image: # create the scale if it doesn't exist
width, height = available[scale]
data = self.createScale(instance, scale, width, height)
if data is not None:
self.storeScale(instance, scale, **data)
image = self.retrieveScale(instance, scale=scale)
# retrieve scale width and height from annotation for image that has
# missing info, this happens when we get the svg scale
if image and not image.width:
width, height = available[scale]
annotations = IAnnotations(instance)
scale_annotations = annotations.get('plone.scale')
filename = image.getFilename()
for value in scale_annotations.values():
scale_key = value.get('key')
scale_height = scale_key[1][1]
scale_width = scale_key[2][1]
if scale_height == height and scale_width == width and \
filename == value.get('filename'):
image.width = value.get('width')
image.height = value.get('height')
break
if image is not None and not isinstance(image, basestring):
return image
return None
def __init__(self, context):
self.ideal_wrapper = getUtility(IMollieIdeal)
annotations = IAnnotations(context)
self._metadata = annotations.get(IDEAL_PAYMENT_ANNOTATION_KEY, None)
if self._metadata is None:
self._metadata = PersistentMapping()
annotations[IDEAL_PAYMENT_ANNOTATION_KEY] = self._metadata
def get_statuses(self, create_if_missing=False):
"""Get the mapping of delivery statuses by transport.
"""
ann = IAnnotations(self.disposition)
if TRANSPORT_STATUSES_KEY not in ann and create_if_missing:
ann[TRANSPORT_STATUSES_KEY] = PersistentMapping()
return ann.get(TRANSPORT_STATUSES_KEY, {})
def saveJobProgress(event):
""" Save job progress
"""
portal = getToolByName(event.object, 'portal_url').getPortalObject()
portal_anno = IAnnotations(portal)
annotation = portal_anno.get('async_move_jobs')
annotation_job = annotation.setdefault(event.job_id, {})
if event.operation == 'initialize':
annotation_job['sub_progress'] = {}
operation_type = getattr(event, 'operation_type', 'Moved')
annotation_job['title'] = "%s below objects within: %s" % (
operation_type, event.object.absolute_url()
)
for oid, title in event.oblist_id:
annotation_job['sub_progress'][oid] = {}
annotation_job['sub_progress'][oid]['progress'] = 0
annotation_job['sub_progress'][oid]['title'] = title
if event.operation == 'sub_progress':
obj_id = event.obj_id
annotation_job.setdefault('sub_progress', {})
annotation_job['sub_progress'].setdefault(obj_id, {})
annotation_job['sub_progress'][obj_id]['progress'] = event.progress
if event.operation == 'progress':
annotation_job['progress'] = event.progress
def disable_behaviors(obj, behaviors, ifaces):
""" Disable behaviors on an object.
:param obj: The Dexterity content object to disable behaviors on.
:type obj: object
:param behaviors: Behaviors to be disabled on the object. This is a list of
dotted names of behavior schema interfaces.
:type behaviors: list
:param ifaces: Behavior marker interfaces belonging to the behaviors to be
disabled. This is a list of interface classes.
:type ifaces: class
Use it like so:
>>> from plone.app.event.dx.interfaces import IDXEvent
>>> disable_behaviors(obj, ['plone.app.event.dx.behaviors.IEventBasic',],
... [IDXEvent,])
"""
annotations = IAnnotations(obj)
instance_behaviors = annotations.get(KEY, ())
instance_behaviors = filter(lambda x: x not in behaviors,
instance_behaviors)
annotations[KEY] = instance_behaviors
for iface in ifaces:
noLongerProvides(obj, iface)
obj.reindexObject(idxs=('object_provides'))
def after_resolve_jobs_pending(self):
"""This flag tracks whether these jobs have already been executed for
a resolved dossier, or are still pending (because they have been
deferred to a nightly job).
"""
ann = IAnnotations(self.context)
return ann.get(AFTER_RESOLVE_JOBS_PENDING_KEY, False)
def is_available(self, obj, data_type='preview'):
if data_type == 'pdf':
annotations = IAnnotations(obj)
if annotations.get(PDF_VERSION_KEY):
return True
else:
return False
def handle(self):
"""
Looks up the handle in the context's annotation.
Returns None if not found.
"""
annotations = IAnnotations(self.context)
return annotations.get(KEY, None)
class NotificationConfiglet(BrowserView):
template = ViewPageTemplateFile('configlet.pt')
def __call__(self, delete=None):
self.storage = IAnnotations(self.context)
if delete and self.storage.has_key(STORAGE_KEY) and self.storage[STORAGE_KEY].has_key(delete):
del self.storage[STORAGE_KEY][delete]
statusmessages = IStatusMessage(self.request)
statusmessages.addStatusMessage(_('message_deleted', default='Notification template deleted'), type='info')
return self.template()
@memoize
def templates(self):
if not self.storage.has_key(STORAGE_KEY):
return []
templates_raw = self.storage.get(STORAGE_KEY)
vocabulary = availableWorkflows(self.context)
templates = []
for name, template in templates_raw.items():
template = {'name': name,
'template': template}
try:
term = vocabulary.getTermByToken(name)
template.update(dict(title=(term.title or term.token)))
except:
pass
templates.append(template)
return templates
def test_customstyles_are_stored_in_btree(self):
adapter = ICustomStyles(self.portal)
adapter.set('css.body-background', 'blue')
annotations = IAnnotations(self.portal)
self.assertEquals(OOBTree,
type(annotations.get(CUSTOMSTYLES_ANNOTATION_KEY)))
def _default_stylebook(self):
if not getattr(self, '_default', None):
if not [o.getId() for o in self.stylebooks()]:
return None
anno = IAnnotations(self.context).get(ANNO_KEY, {})
self._default = anno.get('default_stylebook', None)
return self._default
def update_opengraphable_objects(context, new_ct):
g_marker = queryUtility(IOpengraphMarkerUtility)
if not g_marker:
return
options = IAnnotations(context)
ct = getToolByName(context, 'portal_catalog')
olds_pt = options.get('old_content_types', [])
if new_ct == olds_pt:
return
adds = []
for new in new_ct:
if new in olds_pt:
olds_pt.remove(new)
else:
adds.append(new)
nb_items, bad_items = g_marker.update(context, adds, olds_pt)
updated = u'%d %s' % (nb_items, _(u'objects updated.'))
if not bad_items:
message = updated
else:
message = u'%s, %d %s: %s' % (updated,
len(bad_items),
_(u'update(s) on object(s) failed'),
','.join(bad_items), )
pu = getToolByName(context, 'plone_utils')
pu.addPortalMessage(message)
def _annotation_storage(self, create_if_missing=False):
annotations = IAnnotations(self.context)
# Avoid writes on read
if REMINDER_ANNOTATIONS_KEY not in annotations and create_if_missing:
annotations[REMINDER_ANNOTATIONS_KEY] = PersistentDict()
return annotations.get(REMINDER_ANNOTATIONS_KEY, {})
def after_resolve_jobs_pending(self):
"""This flag tracks whether these jobs have already been executed for
a resolved dossier, or are still pending (because they have been
deferred to a nightly job).
"""
ann = IAnnotations(self.context)
return ann.get(AFTER_RESOLVE_JOBS_PENDING_KEY, False)
def disable_behaviors(obj, behaviors, ifaces):
""" Disable behaviors on an object.
:param obj: The Dexterity content object to disable behaviors on.
:type obj: object
:param behaviors: Behaviors to be disabled on the object. This is a list of
dotted names of behavior schema interfaces.
:type behaviors: list
:param ifaces: Behavior marker interfaces belonging to the behaviors to be
disabled. This is a list of interface classes.
:type ifaces: class
Use it like so:
>>> from plone.app.event.dx.interfaces import IDXEvent
>>> disable_behaviors(obj, ['plone.app.event.dx.behaviors.IEventBasic',],
... [IDXEvent,])
"""
annotations = IAnnotations(obj)
instance_behaviors = list(annotations.get(KEY, []))
instance_behaviors = filter(lambda x: x not in behaviors,
instance_behaviors)
annotations[KEY] = instance_behaviors
for iface in ifaces:
noLongerProvides(obj, iface)
# TODO UNTESTED:
obj.reindexObject(idxs=('object_provides'))
def __init__(self, context):
self.context = self.__parent__ = context # see PvWh book site 269
annotations = IAnnotations(context)
mapping = annotations.get(EntryNavAnnotations_KEY)
if mapping is None:
mapping = annotations[EntryNavAnnotations_KEY] = PersistentDict({'name': '', 'order': 0})
self.mapping = mapping
def has_metadata_changed_been_filled():
site = getSite()
annotations = IAnnotations(site)
if METADATA_CHANGED_FILLED_KEY not in annotations:
# This is a newly setup deployment or one where the first upgrade has not been run.
return True
return bool(annotations.get(METADATA_CHANGED_FILLED_KEY))
def _getHandle(self, context):
"""
Helper method looking up the handle in the context's annotation.
Returns None if not existing.
"""
annotations = IAnnotations(context)
return annotations.get(KEY, None)
def get_users_statistics_reports(site):
""" Get existing reports saved in annotations
"""
annotations = IAnnotations(site)
reports = annotations.get(USERS_STATISTICS_KEY, None)
return reports
def _getHandle(self, context):
"""
Helper method looking up the handle in the context's annotation.
Returns None if not existing.
"""
annotations = IAnnotations(context)
return annotations.get(KEY, None)
def get_users_statistics_reports(site):
""" Get existing reports saved in annotations
"""
annotations = IAnnotations(site)
reports = annotations.get(USERS_STATISTICS_KEY, None)
return reports
def get_table_filters():
"""get_table_filters."""
site = getSite()
anno = IAnnotations(site)
matrix = anno.get('matrix_1', {})
return matrix.get('select_categories', {})
def disable_behaviors(obj, behaviors, ifaces, reindex=True):
""" Disable behaviors on an object.
:param obj: The Dexterity content object to disable behaviors on.
:type obj: object
:param behaviors: Behaviors to be disabled on the object. This is a list of
dotted names of behavior schema interfaces.
:type behaviors: list or tuple
:param ifaces: Behavior marker interfaces belonging to the behaviors to be
disabled. This is a list of interface classes.
:type ifaces: class
:param reindex: Flag whether to reindex object after modification
:type reindex: bool
Use it like so:
>>> from plone.app.event.dx.interfaces import IDXEvent
>>> disable_behaviors(obj, ['plone.app.event.dx.behaviors.IEventBasic',],
... [IDXEvent,])
"""
annotations = IAnnotations(obj)
instance_behaviors = annotations.get(ANNOTATION_KEY, ())
instance_behaviors = filter(lambda x: x not in behaviors,
instance_behaviors)
annotations[ANNOTATION_KEY] = instance_behaviors
for iface in ifaces:
noLongerProvides(obj, iface)
if reindex:
obj.reindexObject(idxs=('object_provides'))
def cleanup_convert_figure_jobs(context):
""" Cleanup Async jobs saved on EEAFIgureFile
"""
ctool = getToolByName(context, 'portal_catalog')
brains = ctool.unrestrictedSearchResults(portal_type=['EEAFigureFile'])
logger.info('Removing async jobs')
count = 0
for brain in brains:
try:
doc = brain.getObject()
if getattr(doc, '_convertjob', None):
del doc._convertjob
try:
anno = IAnnotations(doc)
except TypeError:
continue
convert_job = anno.get('convert_figure_job')
if convert_job and not isinstance(convert_job, dict):
del anno['convert_figure_job']
else:
continue
logger.info('Removing async for %s', brain.getURL())
count += 1
if count % 100 == 0:
logger.info('INFO: Transaction committed to zodb %s', count)
transaction.commit()
except Exception, err:
logger.warn('Couldn\'t remove async for %s', brain.getURL())
# ctool.uncatalog_object(brain.getPath())
logger.exception(err)
continue
def handle(self):
"""
Looks up the handle in the context's annotation.
Returns None if not found.
"""
annotations = IAnnotations(self.context)
return annotations.get(KEY, None)
def test_setData_stores_data(self):
annotations = IAnnotations(self.layer['portal'])
self.assertIsNone(annotations.get(ANNOTATION_KEY))
component = getAdapter(self.layer['portal'], IDataCollector,
name='ftw.servicenavigation')
component.setData(EXAMPLE_DATA)
self.assertEqual(EXAMPLE_DATA, annotations[ANNOTATION_KEY])
def instance_behaviors_of(obj):
"""Return applied instance behavior names of object.
:param obj: The Dexterity content object to enable behaviors on.
:type obj: object
"""
annotations = IAnnotations(obj)
return annotations.get(ANNOTATION_KEY, ())
def get_payment_data(self):
adapted = IAnnotations(self.context)
payment_code = self.request.SESSION.get(MIPAGO_PAYMENT_CODE, None)
if payment_code is not None:
payments = adapted.get(ANNOTATION_KEY, {})
return payments.get(payment_code, None)
return None
def store(self, conf):
self.check_permission(conf)
annotations = IAnnotations(self.context)
storage = annotations.get(SL_ANNOTATION_KEY, None)
if storage:
storage.update(make_resursive_persistent(conf))
else:
annotations[SL_ANNOTATION_KEY] = make_resursive_persistent(conf)
def post(self, **kwargs):
""" POST
"""
newids = self.request.get('new_ids')
newtitles = self.request.get('new_titles', '')
paths = self.request.get('paths', '')
if 'form.button.Cancel' in kwargs:
return self._redirect(_(u"Rename cancelled"), redirect_to='')
elif 'form.button.rename' in kwargs:
return self.original_action(action='rename')
elif 'form.button.async_rename' in kwargs:
return self.index()
worker = getUtility(IAsyncService)
queue = worker.getQueues()['']
email = api.user.get_current().getProperty('email')
try:
job = worker.queueJobInQueue(
queue, (ASYNCMOVE_QUEUE,),
async_rename,
self.context,
new_ids=newids,
new_titles=newtitles,
paths=paths,
success_event=AsyncRenameSuccess,
fail_event=AsyncRenameFail,
email=email
)
job_id = u64(job._p_oid)
context = self.context
wrapper = IContextWrapper(context)(
folder_move_from=context.absolute_url(1),
folder_move_to=', '.join(newids),
folder_move_objects=', '.join(paths),
asyncmove_email=email,
async_operation_type='rename',
email=email
)
notify(AsyncOperationAdded(wrapper))
anno = IAnnotations(self.context)
anno['async_move_job'] = job_id
portal = getToolByName(self, 'portal_url').getPortalObject()
portal_anno = IAnnotations(portal)
if not portal_anno.get('async_move_jobs'):
portal_anno['async_move_jobs'] = OOBTree()
message_type = 'info'
message = _(u"Item added to the queue. "
u"We will notify you by email at '%s' when the job is "
u"completed" % email)
except Exception, err:
logger.exception(err)
message_type = 'error'
message = u"Failed to add items to the sync queue"
def uninstall(context):
if context.readDataFile('raptus.notification.uninstall.txt') is None:
return
portal = context.getSite()
# Remove notification storage to prevent broken object errors after removal
storage = IAnnotations(portal)
if storage.get(ANNOTATIONS_KEY, None) is not None:
del storage[ANNOTATIONS_KEY]
def test_setData_stores_data(self):
annotations = IAnnotations(self.layer['portal'])
self.assertIsNone(annotations.get(ANNOTATION_KEY))
component = getAdapter(self.layer['portal'],
IDataCollector,
name='ftw.servicenavigation')
component.setData(EXAMPLE_DATA)
self.assertEqual(EXAMPLE_DATA, annotations[ANNOTATION_KEY])
def test_save_pdf_under_form_created_document_annotations(self, browser):
self.login(self.regular_user, browser)
browser.open(self.document, view='save_pdf_under')
browser.forms.get('form').find_field("Destination").fill(self.empty_dossier)
with self.observe_children(self.empty_dossier) as children:
browser.click_on("Save")
self.assertEqual(len(children["added"]), 1)
created_document = children["added"].pop()
annotations = IAnnotations(created_document)
self.assertEqual(IUUID(self.document),
annotations.get(PDF_SAVE_SOURCE_UUID_KEY))
self.assertEqual('conversion-demanded',
annotations.get(PDF_SAVE_STATUS_KEY))
self.assertIsNotNone(annotations.get(PDF_SAVE_TOKEN_KEY))
self.assertEqual(self.regular_user.getId(),
annotations.get(PDF_SAVE_OWNER_ID_KEY))
def async_move(context, success_event, fail_event, **kwargs):
""" Async job
"""
newid = kwargs.get('newid', '')
email = kwargs.get('email', '')
anno = IAnnotations(context)
job_id = anno.get('async_move_job')
if not newid:
wrapper = IContextWrapper(context)(
error=u'Invalid newid'
)
notify(fail_event(wrapper))
raise CopyError(eNoItemsSpecified)
try:
_op, mdatas = _cb_decode(newid)
except:
raise CopyError(eInvalid)
oblist = []
app = context.getPhysicalRoot()
for mdata in mdatas:
m = loadMoniker(mdata)
try:
ob = m.bind(app)
except ConflictError:
raise
except:
raise CopyError(eNotFound)
oblist.append(ob)
wrapper = IContextWrapper(context)(
folder_move_from=oblist and aq_parent(
aq_inner(oblist[0])).absolute_url(),
folder_move_to=context.absolute_url(),
folder_move_objects=', '.join([obj.getId() for obj in oblist]),
asyncmove_email=email
)
try:
manage_pasteObjects_no_events(context, cb_copy_data=newid)
except Exception, err:
logger.exception(err)
wrapper.error = err.message
wrapper.job_id = job_id
notify(fail_event(wrapper))
raise CopyError(MessageDialog(
title='Error',
message=err.message,
action='manage_main',
))
def __get__(self, inst, cls=None):
if inst is None:
return getObjectSpecification(cls)
request = getRequest()
annotations = IAnnotations(request)
# Return cached spec from request
if inst.__parent__ is not None and inst.__name__ is not None:
digest = inst.__parent__.schema_digest
key = '.'.join([self.__class__.__name__, digest, inst.__name__])
spec = annotations.get(key)
if spec is not None:
return spec
spec = getattr(inst, '__provides__', None)
if spec is None:
spec = implementedBy(cls)
model = load_model(
aq_base(inst.__parent__).schema,
cache_key=inst.__parent__.schema_digest,
)
schemata = []
for schema in [
model.schemata[name] for name in model.schemata
if name == u'' or IS_TRANSLATION.match(name)
]:
try:
field = schema[inst.__name__]
except AttributeError:
continue
try:
schemata.append(field.schema)
except AttributeError:
schemata.append(field.value_type.schema)
schemata.append(spec)
spec = Implements(*schemata)
# Cache spec into request
annotations[key] = spec
else:
spec = getattr(inst, '__provides__', None)
if spec is None:
spec = implementedBy(cls)
# Set by FlowSubmissionDataFactory
schemata = [inst._v_initial_schema, spec]
spec = Implements(*schemata)
return spec
def __get__(self, inst, cls=None):
if inst is None:
return getObjectSpecification(cls)
request = getRequest()
annotations = IAnnotations(request)
try:
digest = inst.schema_digest
except AttributeError:
spec = getattr(inst, '__provides__', None)
if spec is None:
return implementedBy(cls)
else:
return spec
# Return cached spec from request
if not getattr(self, '__recursion__', False):
spec = annotations.get(self.__class__.__name__ + '.' + digest)
if spec is not None:
return spec
spec = getattr(inst, '__provides__', None)
if spec is None:
spec = implementedBy(cls)
model = load_model(inst.schema, cache_key=inst.schema_digest)
schemata = [
model.schemata[name] for name in model.schemata
if name in [u'', u'++add++']
or IS_TRANSLATION.match(name.split(u'++add++')[0])
]
schemata.append(spec)
if getattr(self, '__recursion__', False):
return Implements(*schemata)
self.__recursion__ = True
dynamically_provided = []
try:
assignable = IBehaviorAssignable(inst, None)
if assignable is not None:
for behavior_registration in assignable.enumerateBehaviors():
if behavior_registration.marker:
dynamically_provided.append(
behavior_registration.marker, )
finally:
del self.__recursion__
schemata.extend(dynamically_provided)
spec = Implements(*schemata)
# Cache spec into request
annotations[self.__class__.__name__ + '.' + digest] = spec
return spec
def post(self, **kwargs):
""" POST
"""
newids = self.request.get('new_ids')
newtitles = self.request.get('new_titles', '')
paths = self.request.get('paths', '')
if 'form.button.Cancel' in kwargs:
return self._redirect(_(u"Rename cancelled"), redirect_to='')
elif 'form.button.rename' in kwargs:
return self.original_action(action='rename')
elif 'form.button.async_rename' in kwargs:
return self.index()
worker = getUtility(IAsyncService)
queue = worker.getQueues()['']
email = api.user.get_current().getProperty('email')
try:
job = worker.queueJobInQueue(queue, (ASYNCMOVE_QUEUE, ),
async_rename,
self.context,
new_ids=newids,
new_titles=newtitles,
paths=paths,
success_event=AsyncRenameSuccess,
fail_event=AsyncRenameFail,
email=email)
job_id = u64(job._p_oid)
context = self.context
wrapper = IContextWrapper(context)(
folder_move_from=context.absolute_url(1),
folder_move_to=', '.join(newids),
folder_move_objects=', '.join(paths),
asyncmove_email=email,
async_operation_type='rename',
email=email)
notify(AsyncOperationAdded(wrapper))
anno = IAnnotations(self.context)
anno['async_move_job'] = job_id
portal = getToolByName(self, 'portal_url').getPortalObject()
portal_anno = IAnnotations(portal)
if not portal_anno.get('async_move_jobs'):
portal_anno['async_move_jobs'] = OOBTree()
message_type = 'info'
message = _(u"Item added to the queue. "
u"We will notify you by email at '%s' when the job is "
u"completed" % email)
except Exception, err:
logger.exception(err)
message_type = 'error'
message = u"Failed to add items to the sync queue"
def actionSubmit(self, action, data):
annotations = IAnnotations(self.context)
if annotations.get(KEY):
annotations[KEY] = None
msg = _(u"Slideshare id removed")
IStatusMessage(self.request).addStatusMessage(msg, type='info')
else:
msg = _(u"object does not have a slideshare id")
IStatusMessage(self.request).addStatusMessage(msg, type='error')
self.context.setLayout(self.context.getDefaultLayout())
self.request.response.redirect(self.next_url)
def get_job_annotation(self, job):
""" Get job annotation
"""
portal = getToolByName(self.context, 'portal_url').getPortalObject()
portal_anno = IAnnotations(portal)
async_job_status = portal_anno.get('async_move_jobs')
if async_job_status:
job_id = u64(job._p_oid)
annotation_job = async_job_status.get(job_id)
return annotation_job
return None
def is_available(self, data_type='preview'):
if data_type == 'pdf':
annotations = IAnnotations(self.context)
if annotations.get(PDF_VERSION_KEY):
return True
if self.get_number_of_pages(img_type=data_type) > 0:
return True
else:
if is_autoconv_enabled() and hasattr(self.context, 'REQUEST'):
queueConversionJob(self.context, self.context.REQUEST)
return False
def get_job_annotation(self, job):
""" Get job annotation
"""
portal = getToolByName(self.context, 'portal_url').getPortalObject()
portal_anno = IAnnotations(portal)
async_job_status = portal_anno.get('async_move_jobs')
if async_job_status:
job_id = u64(job._p_oid)
annotation_job = async_job_status.get(job_id)
return annotation_job
return None
def addRefreshViewletCommands(event):
view = event.view
context = view.context
request = view.request
annotations = IAnnotations(request)
viewletByClass = annotations.get('viewletByClass', [])
if viewletByClass:
for name, manager in getAdapters(
(context, request, view, ), IViewletManager):
for name, viewlet in getAdapters(
(context, request, view, manager), IViewlet):
maybeRenderViewlet(viewlet, viewletByClass)
def load(self):
annotations = IAnnotations(self.context)
default_state = deepcopy(self._default_page_config())
page_state = deepcopy(annotations.get(
SL_ANNOTATION_KEY,
make_resursive_persistent(default_state)))
for slotname in default_state:
if not page_state.get(slotname):
page_state[slotname] = default_state[slotname]
return page_state
def __init__(self, context):
self.__parent__ = context
self._context = context
annotations = IAnnotations(self._context)
map = annotations.get(self.key)
if map is None:
self._byrow = {}
self._bycol = {}
else:
self._byrow = map._byrow
self._bycol = map._bycol
self.map = map
