Example #1
0
 def listColumnInfos(self):
     (key, reverse) = self._getSorting()
     columns = ( {'key': 'Type',
                  'title': _(u'Type'),
                  'width': '20',
                  'colspan': '2'}
               , {'key': 'getId',
                  'title': _(u'Name'),
                  'width': '360',
                  'colspan': None}
               , {'key': 'modified',
                  'title': _(u'Last Modified'),
                  'width': '180',
                  'colspan': None}
               , {'key': 'position',
                  'title': _(u'Position'),
                  'width': '80',
                  'colspan': None }
               )
     for column in columns:
         if key == column['key'] and not reverse and key != 'position':
             query = make_query(key=column['key'], reverse=1)
         else:
             query = make_query(key=column['key'])
         column['url'] = '%s?%s' % (self._getViewURL(), query)
     return tuple(columns)
Example #2
0
 def edit_control(self, title, description, **kw):
     context = self.context
     if title!=context.Title() or description != context.Description():
         context.edit(title=title, description=description)
         return True, _(u'Metadata changed.')
     else:
         return False, _(u'Nothing to change.')
def status_vocab(context):
    """Provides a list of workflow states"""
    ctool = getUtility(ICatalogTool)
    values = [SimpleTerm(u'', '', _(u"-- any --"))]
    values += [ SimpleTerm(v, str(v), _(decode(v)))
                for v in ctool.uniqueValuesFor('review_state') ]
    return SimpleVocabulary(values)
Example #4
0
def date_vocab(context):
    """Provides a list of dates for searching with"""
    mtool = getUtility(IMembershipTool)
    dates = [SimpleTerm(date(1970, 1, 1), date(1970, 1, 1), _(u'Ever'))]
    if not mtool.isAnonymousUser():
        member = mtool.getAuthenticatedMember()
        login_time = member.getProperty('last_login_time')
        if not hasattr(login_time, 'parts'):
            login_time = DateTime(login_time)
        login = date(*login_time.parts()[:3])
        dates.append(SimpleTerm(
            login, login, _(u'Last login'))
                     )

    today = date.today()
    dates.append(SimpleTerm(today - timedelta(days=1),
                            today - timedelta(days=1),
                            _(u'Yesterday')
                            )
                 )
    dates.append(SimpleTerm(today - timedelta(days=7),
                            today - timedelta(days=7),
                            _(u'Last week')
                            )
                 )
    dates.append(SimpleTerm(today - timedelta(days=31),
                            today - timedelta(days=31),
                            _(u'Last month')
                            )
                 )
    return SimpleVocabulary(dates)
Example #5
0
 def handle_delete(self, action, data):
     ids = self._get_ids(data)
     self.context.manage_delObjects(list(ids))
     if len(ids) == 1:
         self.status = _(u'Item deleted.')
     else:
         self.status = _(u'Items deleted.')
     return self._setRedirect('portal_types', 'object/contents')
Example #6
0
 def delete_control(self, ids, **kw):
     """Delete objects from a folder.
     """
     self.context.manage_delObjects(list(ids))
     if len(ids) == 1:
         return True, _(u'Item deleted.')
     else:
         return True, _(u'Items deleted.')
Example #7
0
 def handle_delete_success(self, action, data):
     """Delete the selected objects"""
     ids = self._get_ids()
     self.context.manage_delObjects(list(ids))
     if len(ids) == 1:
         self.status = _(u'Item deleted.')
     else:
         self.status = _(u'Items deleted.')
     return self._setRedirect('portal_types', 'object/folderContents')
Example #8
0
 def listBatchItems(self):
     members = []
     for item in self._getBatchObj():
         member = item
         member['home'] = self.mtool().getHomeUrl(item['id'],
                             verifyPermission=1)
         member['listed'] = member['listed'] and _(u"Yes") or _("No")
         members.append(member)
     return members
Example #9
0
 def description(self):
     if self.is_first_login:
         return _(u"This is the first time that you've logged in to "
                  u"${portal_title}. Before you start exploring you need "
                  u"to change your original password. This will ensure "
                  u"that the password we sent you via email cannot be "
                  u"used in a malicious manner.",
                  mapping={'portal_title': self.portal_title})
     else:
         return _(u'Please use the form below to change your password.')
Example #10
0
 def listBatchItems(self):
     members = []
     for member in self._getBatchObj():
         member_home = self.mtool.getHomeUrl(member['id'],
                                             verifyPermission=1)
         member_listed = member['listed'] and _(u'Yes') or _(u'No')
         members.append({'id': member['id'],
                         'home': member_home,
                         'listed': member_listed})
     return tuple(members)
Example #11
0
 def copy_control(self, ids, **kw):
     """Copy objects from a folder to the clipboard.
     """
     try:
         self.context.manage_copyObjects(ids, self.request)
         if len(ids) == 1:
             return True, _(u'Item copied.')
         else:
             return True, _(u'Items copied.')
     except CopyError:
         return False, _(u'CopyError: Copy failed.')
Example #12
0
 def handle_paste(self, action, data):
     try:
         result = self.context.manage_pasteObjects(self.request['__cp'])
         if len(result) == 1:
             self.status = _(u'Item pasted.')
         else:
             self.status = _(u'Items pasted.')
     except CopyError, error:
         self.status = _(u'CopyError: Paste failed.')
         self.request['RESPONSE'].expireCookie('__cp', 
                 path='%s' % (self.request['BASEPATH1'] or "/"))
Example #13
0
 def handle_copy(self, action, data):
     """Copy the selected objects to the clipboard"""
     ids = self._get_ids(data)
     try:
         self.context.manage_copyObjects(ids, self.request)
         if len(ids) == 1:
             self.status = _(u'Item copied.')
         else:
             self.status = _(u'Items copied.')
     except CopyError:
         self.status = _(u'CopyError: Copy failed.')
     return self._setRedirect('portal_types', 'object/new_contents')
Example #14
0
    def navigation_next(self):
        batch_obj = self._getBatchObj().next
        if batch_obj is None:
            return None

        length = len(batch_obj)
        url = self._getNavigationURL(batch_obj.first)
        if length == 1:
            title = _(u'Next item')
        else:
            title = _(u'Next ${count} items', mapping={'count': length})
        return {'title': title, 'url': url}
Example #15
0
 def cut_control(self, ids, **kw):
     """Cut objects from a folder and copy to the clipboard.
     """
     try:
         self.context.manage_cutObjects(ids, self.request)
         if len(ids) == 1:
             return True, _(u'Item cut.')
         else:
             return True, _(u'Items cut.')
     except CopyError:
         return False, _(u'CopyError: Cut failed.')
     except zExceptions_Unauthorized:
         return False, _(u'Unauthorized: Cut failed.')
Example #16
0
 def paste_control(self, **kw):
     """Paste objects to a folder from the clipboard.
     """
     try:
         result = self.context.manage_pasteObjects(self.request['__cp'])
         if len(result) == 1:
             return True, _(u'Item pasted.')
         else:
             return True, _(u'Items pasted.')
     except CopyError:
         return False, _(u'CopyError: Paste failed.')
     except zExceptions_Unauthorized:
         return False, _(u'Unauthorized: Paste failed.')
Example #17
0
 def handle_cut(self, action, data):
     """Cut the selected objects and put them in the clipboard"""
     ids = self._get_ids(data)
     try:
         self.context.manage_cutObjects(ids, self.request)
         if len(ids) == 1:
             self.status = _(u'Item cut.')
         else:
             self.status = _(u'Items cut.')
     except CopyError:
         self.status = _(u'CopyError: Cut failed.')
     except zExceptions_Unauthorized:
         self.status = _(u'Unauthorized: Cut failed.')
     return self._setRedirect('portal_types', 'object/new_contents')    
Example #18
0
 def bottom_control(self, ids, **kw):
     subset_ids = [ obj.getId()
                    for obj in self.context.listFolderContents() ]
     try:
         attempt = self.context.moveObjectsToBottom(ids,
                                                    subset_ids=subset_ids)
         if attempt == 1:
             return True, _(u'Item moved to bottom.')
         elif attempt > 1:
             return True, _(u'Items moved to bottom.')
         else:
             return False, _(u'Nothing to change.')
     except ValueError:
         return False, _(u'ValueError: Move failed.')
Example #19
0
File: form.py Project: goschtl/zope
 def _handle_success(self, action, data):
     # normalize set and datetime
     for k, v in data.iteritems():
         if isinstance(v, Set):
             data[k] = set(v)
         elif isinstance(v, datetime) and v.tzname() is None:
             data[k] = parseDatetimetz(str(v))
     if form.applyChanges(self.context, self.form_fields, data,
                          self.adapters):
         self.context.reindexObject()
         obj_type = translate(self.context.Type(), self.context)
         self.status = _(u'${obj_type} changed.',
                         mapping={'obj_type': obj_type})
     else:
         self.status = _(u'Nothing to change.')
Example #20
0
File: form.py Project: goschtl/zope
 def label(self):
     obj_type_id = self.widgets['portal_type']._getFormValue()
     # look it up to get an i18n message object with correct i18n domain
     ttool = self._getTool('portal_types')
     fti = ttool.getTypeInfo(obj_type_id)
     obj_type = translate(fti.Title(), self.context)
     return _(u'Add ${obj_type}', mapping={'obj_type': obj_type})
Example #21
0
    def mailPassword(self, forgotten_userid, REQUEST):
        """ Email a forgotten password to a member.

        o Raise an exception if user ID is not found.
        """
        mtool = getUtility(IMembershipTool)
        member = mtool.getMemberById(forgotten_userid)

        if member is None:
            raise ValueError(_(u'The username you entered could not be '
                               u'found.'))

        email = self._getValidEmailAddress(member)

        # Rather than have the template try to use the mailhost, we will
        # render the message ourselves and send it from here (where we
        # don't need to worry about 'UseMailHost' permissions).
        if getattr(self, 'REQUEST', None) is None:
            context = RequestContainer(REQUEST=REQUEST)
            for item in reversed(aq_chain(self)):
                context = aq_base(item).__of__(context)
        else:
            context = self
        method = context.password_email
        kw = {'member': member, 'password': member.getPassword()}

        if getattr(aq_base(method), 'isDocTemp', 0):
            mail_text = method(self, REQUEST, **kw)
        else:
            mail_text = method(**kw)

        host = getUtility(IMailHost)
        host.send(mail_text)

        return context.mail_password_response(self, REQUEST)
Example #22
0
File: form.py Project: goschtl/zope
    def add(self, obj):
        container = self.context
        portal_type = self.ti.getId()

        # check allowed (sometimes redundant, but better safe than sorry)
        if not self.ti.isConstructionAllowed(container):
            raise AccessControl_Unauthorized('Cannot create %s' % portal_type)

        #check container constraints
        ttool = self._getTool('portal_types')
        container_ti = ttool.getTypeInfo(container)
        if container_ti is not None and \
                not container_ti.allowType(portal_type):
            raise ValueError('Disallowed subobject type: %s' % portal_type)

        name = INameChooser(container).chooseName(obj.getId(), obj)
        obj.id = name
        container._setObject(name, obj)
        obj = container._getOb(name)

        obj_type = translate(obj.Type(), container)
        self.status = _(u'${obj_type} added.', mapping={'obj_type': obj_type})
        self._finished_add = True
        self._added_obj = obj
        return obj
Example #23
0
def type_vocab(context):
    """Provides a list of portal types"""
    ttool =  getUtility(ITypesTool)
    types = ttool.listTypeInfo()
    terms = [SimpleTerm(None, None, _(u"-- any --"))]
    terms += [SimpleTerm(t.getId(), t.getId(), t.Title()) for t in types]
    return SimpleVocabulary(terms)
Example #24
0
    def mailPassword(self, forgotten_userid, REQUEST):
        """ Email a forgotten password to a member.

        o Raise an exception if user ID is not found.
        """
        # XXX: this method violates the rules for tools/utilities:
        # it depends on a non-utility tool
        membership = getToolByName(self, 'portal_membership')
        member = membership.getMemberById(forgotten_userid)

        if member is None:
            raise ValueError(_(u'The username you entered could not be '
                               u'found.'))

        email = self._getValidEmailAddress(member)

        # Rather than have the template try to use the mailhost, we will
        # render the message ourselves and send it from here (where we
        # don't need to worry about 'UseMailHost' permissions).
        method = self.password_email
        kw = {'member': member, 'password': member.getPassword()}

        if getattr(aq_base(method), 'isDocTemp', 0):
            mail_text = method(self, REQUEST, **kw)
        else:
            mail_text = method(**kw)

        host = getUtility(IMailHost)
        host.send( mail_text )

        return self.mail_password_response( self, REQUEST )
Example #25
0
def subject_vocab(context):
    """Provides a list of subject keywords"""
    ctool = getUtility(ICatalogTool)
    values = [SimpleTerm(None, None, _(u"-- any --"))]
    values += [SimpleTerm(v, v, v)
               for v in ctool.uniqueValuesFor('Subject')]
    return SimpleVocabulary(values)
Example #26
0
    def edit(self, text_format, text, file='', safety_belt=''):
        """ Update the document.

        To add webDav support, we need to check if the content is locked, and if
        so return ResourceLockedError if not, call _edit.

        Note that this method expects to be called from a web form, and so
        disables header processing
        """
        self.failIfLocked()
        if not self._safety_belt_update(safety_belt=safety_belt):
            msg = _(u'Intervening changes from elsewhere detected. '
                    u'Please refetch the document and reapply your changes. '
                    u'(You may be able to recover your version using the '
                    u"browser 'back' button, but will have to apply them to "
                    u'a freshly fetched copy.)')
            raise EditingConflict(msg)
        if file and (type(file) is not type('')):
            contents=file.read()
            if contents:
                text = contents
        if html_headcheck(text) and text_format.lower() != 'plain':
            text = bodyfinder(text)
        self.setFormat(text_format)
        self._edit(text)
        self.reindexObject()
Example #27
0
    def edit_control(self, allow_discussion, title=None, subject=None,
                     description=None, contributors=None, effective_date=None,
                     expiration_date=None, format=None, language=None,
                     rights=None, **kw):
        context = self.context
        dtool = self._getTool('portal_discussion')

        if title is None:
            title = context.Title()

        if subject is None:
            subject = context.Subject()
        else:
            subject = self._tuplify(subject)

        if description is None:
            description = context.Description()

        if contributors is None:
            contributors = context.Contributors()
        else:
            contributors = self._tuplify(contributors)

        if effective_date is None:
            effective_date = context.EffectiveDate()

        if expiration_date is None:
            expiration_date = context.expires()

        if format is None:
            format = context.Format()

        if language is None:
            language = context.Language()

        if rights is None:
            rights = context.Rights()

        if allow_discussion == 'default':
            allow_discussion = None
        elif allow_discussion == 'off':
            allow_discussion = False
        elif allow_discussion == 'on':
            allow_discussion = True
        dtool.overrideDiscussionFor(context, allow_discussion)

        try:
            context.editMetadata( title=title
                                , description=description
                                , subject=subject
                                , contributors=contributors
                                , effective_date=effective_date
                                , expiration_date=expiration_date
                                , format=format
                                , language=language
                                , rights=rights
                                )
            return True, _(u'Metadata changed.')
        except ResourceLockedError, errmsg:
            return False, errmsg
Example #28
0
 def handle_bottom(self, action, data):
     ids = self._get_ids(data)
     subset_ids = [ obj.getId()
                    for obj in self.context.listFolderContents() ]
     try:
         attempt = self.context.moveObjectsToBottom(ids,
                                                    subset_ids=subset_ids)
         if attempt == 1:
             self.status = _(u'Item moved to bottom.')
         elif attempt > 1:
             self.status = _(u'Items moved to bottom.')
         else:
             self.status = _(u'Nothing to change.')
     except ValueError:
         self.status = _(u'ValueError: Move failed.')
     return self._setRedirect('portal_types', 'object/contents')
Example #29
0
 def handle_delete(self, action, data):
     """Delete selected members"""
     mtool = getUtility(IMembershipTool)
     mtool.deleteMembers(self._get_ids())
     self.status = _(u"Selected members deleted.")
     self._setRedirect('portal_actions', "global/manage_members",
                       '{0}.b_start'.format(self.prefix))
Example #30
0
 def handle_sort_order(self, action, data):
     """Set the sort options for the folder."""
     key = data['position']
     reverse = data.get('reverse', 0)
     self.context.setDefaultSorting(key, reverse)
     self.status = _(u"Sort order changed")
     return self._setRedirect('portal_types', 'object/new_contents')
Example #31
0
options = {}

title = form.get('title', context.Title())
text = form.get('text', '')
options['is_preview'] = is_preview
options['title'] = title
options['text'] = text
options['cooked_text'] = structured_text(text)

if is_preview:
    hidden_vars = [{
        'name': n,
        'value': v
    } for n, v in html_marshal(title=title, text=text)]
else:
    hidden_vars = []
buttons = []
target = atool.getActionInfo('object/reply', context)['url']
buttons.append({'name': 'add', 'value': _(u'Add')})
if is_preview:
    buttons.append({'name': 'edit', 'value': _(u'Edit')})
else:
    buttons.append({'name': 'preview', 'value': _(u'Preview')})
options['form'] = {
    'action': target,
    'listHiddenVarInfos': tuple(hidden_vars),
    'listButtonInfos': tuple(buttons)
}

return context.discussion_reply_template(**decode(options, script))
Example #32
0
 def label(self):
     obj_type = translate(self.context.Type(), self.context)
     return _(u'Edit ${obj_type}', mapping={'obj_type': obj_type})
##parameters=ids, **kw
##
from Products.CMFDefault.utils import Message as _

subset_ids = [obj.getId() for obj in context.listFolderContents()]
try:
    attempt = context.moveObjectsToTop(ids, subset_ids=subset_ids)
    if attempt == 1:
        return context.setStatus(True, _(u'Item moved to top.'))
    elif attempt > 1:
        return context.setStatus(True, _(u'Items moved to top.'))
    else:
        return context.setStatus(False, _(u'Nothing to change.'))
except ValueError:
    return context.setStatus(False, _(u'ValueError: Move failed.'))
from Products.CMFDefault.SyndicationTool import SyndicationTool
from Products.CMFDefault.utils import Message as _


class SyndicationInformation(SimpleItem):
    #DEPRECATED
    """
    Existing implementation creates a full SimpleItem which is not directly
    editable
    """

    id='syndication_information'
    meta_type='SyndicationInformation'

available_periods = (
    (u'hourly', 'hourly', _(u'Hourly')),
    (u'daily', 'daily', _(u'Daily')),
    (u'weekly', 'weekly', _(u'Weekly')),
    (u'monthly', 'monthly', _(u'Monthly')),
    (u'yearly', 'yearly', _(u'Yearly')))


class ISyndicationInfo(ISyndicationInfo):

    period = Choice(
        title=_(u"Update period"),
        vocabulary=SimpleVocabulary.fromTitleItems(available_periods),
    )

    frequency = Int(
        title=_(u"Update frequency"),
Example #35
0
            self.request.form['text'] = scrubHTML(text)
            return True
        except IllegalHTML, errmsg:
            return False, errmsg

    def validateTextFile(self, file='', **kw):
        try:
            upload = file.read()
        except AttributeError:
            return True
        else:
            if upload:
                self.request.form['text'] = upload
                return True
            else:
                return True

    # controllers

    def edit_control(self, text_format, text, SafetyBelt='', **kw):
        context = self.context
        if text_format != context.text_format or \
                text != context.EditableBody():
            try:
                context.edit(text_format, text, safety_belt=SafetyBelt)
                return True, _(u'Document changed.')
            except (ResourceLockedError, EditingConflict), errmsg:
                return False, errmsg
        else:
            return False, _(u'Nothing to change.')
Example #36
0
class ContentsView(BatchFormMixin, EditFormBase):
    """Folder contents view"""

    template = ViewPageTemplateFile('folder_contents.pt')
    rename_template = ViewPageTemplateFile('folder_rename.pt')

    object_actions = form.Actions(
        form.Action(name='select_for_rename',
                    label=_(u'Rename...'),
                    validator='validate_items',
                    condition='show_select_for_rename',
                    success='handle_select_for_rename_success',
                    failure='handle_failure'),
        form.Action(name='cut',
                    label=_(u'Cut'),
                    condition='show_basic',
                    validator='validate_items',
                    success='handle_cut_success',
                    failure='handle_failure'),
        form.Action(name='copy',
                    label=_(u'Copy'),
                    condition='show_basic',
                    validator='validate_items',
                    success='handle_copy_success',
                    failure='handle_failure'),
        form.Action(name='paste',
                    label=_(u'Paste'),
                    condition='show_paste',
                    success='handle_paste_success',
                    failure='handle_failure'),
        form.Action(name='delete',
                    label=_(u'Delete'),
                    condition='show_delete',
                    validator='validate_items',
                    success='handle_delete_success',
                    failure='handle_failure'))

    delta_actions = form.Actions(
        form.Action(name='up',
                    label=_(u'Up'),
                    condition='is_orderable',
                    validator='validate_items',
                    success='handle_up_success',
                    failure='handle_failure'),
        form.Action(name='down',
                    label=_(u'Down'),
                    condition='is_orderable',
                    validator='validate_items',
                    success='handle_down_success',
                    failure='handle_failure'))

    absolute_actions = form.Actions(
        form.Action(name='top',
                    label=_(u'Top'),
                    condition='is_orderable',
                    validator='validate_items',
                    success='handle_top_success',
                    failure='handle_failure'),
        form.Action(name='bottom',
                    label=_(u'Bottom'),
                    condition='is_orderable',
                    validator='validate_items',
                    success='handle_bottom_success',
                    failure='handle_failure'))

    sort_actions = form.Actions(
        form.Action(name='sort_order',
                    label=_(u'Set as Default Sort'),
                    condition='can_sort_be_changed',
                    success='handle_sort_order_success',
                    failure='handle_failure'))

    rename_actions = form.Actions(
        form.Action(name='rename',
                    label=_(u'Rename'),
                    validator='validate_items',
                    success='handle_rename_success',
                    failure='handle_rename_failure'),
        form.Action(name='cancel',
                    label=_(u'Cancel'),
                    validator='handle_cancel_validate',
                    success='handle_cancel_success'))

    actions = (object_actions + delta_actions + absolute_actions +
               sort_actions + rename_actions)
    form_fields = form.FormFields()
    delta_field = form.FormFields(IDeltaItem)
    description = u''

    @property
    def label(self):
        return _(u'Folder Contents: ${obj_title}',
                 mapping={'obj_title': self.title()})

    @memoize
    def listBatchItems(self):
        """List batched items.
        """
        show_checkboxes = self._checkPermission(ViewManagementScreens)
        contents = []
        b_start = self._getBatchStart()
        key, _reverse = self._get_sorting()
        for idx, item in enumerate(self._getBatchObj()):
            content = ContentProxy(item)
            content.checkbox = show_checkboxes
            if key == 'position':
                content.position = b_start + idx + 1
            else:
                content.position = '...'
            contents.append(content)
        return tuple(contents)

    @memoize
    def listSelectedItems(self):
        ids = self._get_ids()
        contents = []
        for item in self._getBatchObj():
            if not item.getId() in ids:
                continue
            if not item.cb_isMoveable():
                continue
            contents.append(ContentProxy(item))
        return tuple(contents)

    @memoize
    @decode
    def up_info(self):
        """Link to the contens view of the parent object"""
        up_obj = aq_parent(aq_inner(self.context))
        mtool = getUtility(IMembershipTool)
        allowed = mtool.checkPermission(ListFolderContents, up_obj)
        if allowed:
            if IDynamicType.providedBy(up_obj):
                up_url = up_obj.getActionInfo('object/folderContents')['url']
                return {
                    'icon': '%s/UpFolder_icon.gif' % self._getPortalURL(),
                    'id': up_obj.getId(),
                    'url': up_url
                }
            else:
                return {'icon': '', 'id': 'Root', 'url': ''}
        else:
            return {}

    def setUpWidgets(self, ignore_request=False):
        """Create widgets for the folder contents."""
        super(ContentsView, self).setUpWidgets(ignore_request)
        self.widgets = form.setUpWidgets(self.delta_field,
                                         self.prefix,
                                         self.context,
                                         self.request,
                                         ignore_request=ignore_request)

    @memoize
    def _get_sorting(self):
        """How should the contents be sorted"""
        data = self._getNavigationVars()
        key = data.get('sort_key')
        if key:
            return (key, data.get('reverse', 0))
        else:
            return self.context.getDefaultSorting()

    @memoize
    def column_headings(self):
        key, reverse = self._get_sorting()
        columns = ({
            'sort_key': 'Type',
            'title': _(u'Type'),
            'class': 'contents_type_col',
            'colspan': '2'
        }, {
            'sort_key': 'getId',
            'title': _(u'Name'),
            'class': 'contents_name_col'
        }, {
            'sort_key': 'modified',
            'title': _(u'Last Modified'),
            'class': 'contents_modified_col'
        }, {
            'sort_key': 'position',
            'title': _(u'Position'),
            'class': 'contents_position_col'
        })
        for column in columns:
            paras = {'form.sort_key': column['sort_key']}
            if key == column['sort_key'] \
            and not reverse and key != 'position':
                paras['form.reverse'] = 1
            query = urllib.urlencode(paras)
            column['url'] = '%s?%s' % (self._getViewURL(), query)
        return tuple(columns)

    @memoize
    def _get_items(self):
        key, reverse = self._get_sorting()
        items = self.context.contentValues()
        return sort(items, ((key, 'cmp', reverse and 'desc' or 'asc'), ))

    @memoize
    def _get_ids(self):
        """Identify objects that have been selected"""
        ids = self.request.form.get('{0}.select_ids'.format(self.prefix), [])
        if isinstance(ids, basestring):
            ids = [ids]
        return [str(id) for id in ids]

    @memoize
    def _get_new_ids(self):
        ids = self.request.form.get('{0}.new_ids'.format(self.prefix), [])
        if isinstance(ids, basestring):
            ids = [ids]
        return [str(id) for id in ids]

    #Action conditions
    @memoize
    def show_basic(self, action=None):
        if not self._checkPermission(ViewManagementScreens):
            return False
        return bool(self._get_items())

    @memoize
    def show_delete(self, action=None):
        if not self.show_basic():
            return False
        return self._checkPermission(DeleteObjects)

    @memoize
    def show_paste(self, action=None):
        """Any data in the clipboard"""
        if not self._checkPermission(ViewManagementScreens):
            return False
        if not self._checkPermission(AddPortalContent):
            return False
        return bool(self.context.cb_dataValid())

    @memoize
    def show_select_for_rename(self, action=None):
        if not self.show_basic():
            return False
        if not self._checkPermission(AddPortalContent):
            return False
        return self.context.allowedContentTypes()

    @memoize
    def can_sort_be_changed(self, action=None):
        """Returns true if the default sort key may be changed
            may be sorted for display"""
        if not self._checkPermission(ViewManagementScreens):
            return False
        if not self._checkPermission(ManageProperties):
            return False
        return not self._get_sorting() == self.context.getDefaultSorting()

    @memoize
    def is_orderable(self, action=None):
        """Returns true if the displayed contents can be
            reorded."""
        if not self._checkPermission(ViewManagementScreens):
            return False
        if not self._checkPermission(ManageProperties):
            return False
        key, _reverse = self._get_sorting()
        return key == 'position' and len(self._get_items()) > 1

    #Action validators
    def validate_items(self, action=None, data=None):
        """Check whether any items have been selected for
        the requested action."""
        errors = self.validate(action, data)
        if errors:
            return errors
        if self._get_ids() == []:
            errors.append(_(u"Please select one or more items first."))
        return errors

    #Action handlers

    def handle_select_for_rename_success(self, action, data):
        """Redirect to rename template.
        """
        return self.rename_template()

    def handle_cut_success(self, action, data):
        """Cut the selected objects and put them in the clipboard"""
        ids = self._get_ids()
        try:
            self.context.manage_cutObjects(ids, self.request)
            if len(ids) == 1:
                self.status = _(u'Item cut.')
            else:
                self.status = _(u'Items cut.')
        except CopyError:
            self.status = _(u'CopyError: Cut failed.')
            return self.handle_failure(action, data, ())
        except zExceptions_Unauthorized:
            return self.handle_failure(action, data, ())
            self.status = _(u'Unauthorized: Cut failed.')
        return self._setRedirect('portal_types', 'object/folderContents')

    def handle_copy_success(self, action, data):
        """Copy the selected objects to the clipboard"""
        ids = self._get_ids()
        try:
            self.context.manage_copyObjects(ids, self.request)
            if len(ids) == 1:
                self.status = _(u'Item copied.')
            else:
                self.status = _(u'Items copied.')
        except CopyError:
            self.status = _(u'CopyError: Copy failed.')
            return self.handle_failure(action, data, ())
        return self._setRedirect('portal_types', 'object/folderContents')

    def handle_paste_success(self, action, data):
        """Paste the objects from the clipboard into the folder"""
        try:
            result = self.context.manage_pasteObjects(self.request['__cp'])
            if len(result) == 1:
                self.status = _(u'Item pasted.')
            else:
                self.status = _(u'Items pasted.')
        except CopyError:
            self.request['RESPONSE'].expireCookie(
                '__cp', path='%s' % (self.request['BASEPATH1'] or "/"))
            self.status = _(u'CopyError: Paste failed.')
        except ValueError:
            self.status = _(u'ValueError: Paste failed.')
            return self.handle_failure(action, data, ())
        except zExceptions_Unauthorized:
            self.status = _(u'Unauthorized: Paste failed.')
            return self.handle_failure(action, data, ())
        return self._setRedirect('portal_types', 'object/folderContents')

    def handle_delete_success(self, action, data):
        """Delete the selected objects"""
        ids = self._get_ids()
        self.context.manage_delObjects(list(ids))
        if len(ids) == 1:
            self.status = _(u'Item deleted.')
        else:
            self.status = _(u'Items deleted.')
        return self._setRedirect('portal_types', 'object/folderContents')

    def handle_up_success(self, action, data):
        """Move the selected objects up the selected number of places"""
        ids = self._get_ids()
        delta = data.get('delta', 1)
        subset_ids = [obj.getId() for obj in self.context.listFolderContents()]
        try:
            attempt = self.context.moveObjectsUp(ids,
                                                 delta,
                                                 subset_ids=subset_ids)
            if attempt == 1:
                self.status = _(u'Item moved up.')
            elif attempt > 1:
                self.status = _(u'Items moved up.')
            else:
                self.status = self.noChangesMessage
        except ValueError:
            self.status = _(u'ValueError: Move failed.')
            return self.handle_failure(action, data, ())
        return self._setRedirect('portal_types', 'object/folderContents')

    def handle_down_success(self, action, data):
        """Move the selected objects down the selected number of places"""
        ids = self._get_ids()
        delta = data.get('delta', 1)
        subset_ids = [obj.getId() for obj in self.context.listFolderContents()]
        try:
            attempt = self.context.moveObjectsDown(ids,
                                                   delta,
                                                   subset_ids=subset_ids)
            if attempt == 1:
                self.status = _(u'Item moved down.')
            elif attempt > 1:
                self.status = _(u'Items moved down.')
            else:
                self.status = self.noChangesMessage
        except ValueError:
            self.status = _(u'ValueError: Move failed.')
            return self.handle_failure(action, data, ())
        return self._setRedirect('portal_types', 'object/folderContents')

    def handle_top_success(self, action, data):
        """Move the selected objects to the top of the page"""
        ids = self._get_ids()
        subset_ids = [obj.getId() for obj in self.context.listFolderContents()]
        try:
            attempt = self.context.moveObjectsToTop(ids, subset_ids=subset_ids)
            if attempt == 1:
                self.status = _(u'Item moved to top.')
            elif attempt > 1:
                self.status = _(u'Items moved to top.')
            else:
                self.status = self.noChangesMessage
        except ValueError:
            self.status = _(u'ValueError: Move failed.')
            return self.handle_failure(action, data, ())
        return self._setRedirect('portal_types', 'object/folderContents')

    def handle_bottom_success(self, action, data):
        """Move the selected objects to the bottom of the page"""
        ids = self._get_ids()
        subset_ids = [obj.getId() for obj in self.context.listFolderContents()]
        try:
            attempt = self.context.moveObjectsToBottom(ids,
                                                       subset_ids=subset_ids)
            if attempt == 1:
                self.status = _(u'Item moved to bottom.')
            elif attempt > 1:
                self.status = _(u'Items moved to bottom.')
            else:
                self.status = self.noChangesMessage
        except ValueError:
            self.status = _(u'ValueError: Move failed.')
            return self.handle_failure(action, data, ())
        return self._setRedirect('portal_types', 'object/folderContents')

    def handle_sort_order_success(self, action, data):
        """Set the sort options for the folder."""
        self.context.setDefaultSorting(*self._get_sorting())
        self.status = _(u'Default sort order changed.')
        return self._setRedirect('portal_types', 'object/folderContents')

    def handle_rename_success(self, action, data):
        """Rename objects in a folder.
        """
        ids = self._get_ids()
        new_ids = self._get_new_ids()
        if not ids == new_ids:
            try:
                self.context.manage_renameObjects(ids, new_ids)
                if len(ids) == 1:
                    self.status = _(u'Item renamed.')
                else:
                    self.status = _(u'Items renamed.')
            except CopyError:
                self.status = _(u'CopyError: Rename failed.')
                return self.handle_rename_failure(action, data, ())
        else:
            self.status = self.noChangesMessage
        return self._setRedirect(
            'portal_types', 'object/folderContents',
            '{0}.b_start, {0}.sort_key, {0}.reverse'.format(self.prefix))

    def handle_cancel_success(self, action, data):
        return self._setRedirect(
            'portal_types', 'object/folderContents',
            '{0}.b_start, {0}.sort_key, {0}.reverse'.format(self.prefix))

    def handle_rename_failure(self, action, data, errors):
        super(ContentsView, self).handle_failure(action, data, errors)
        return self.rename_template()
Example #37
0
 def label(self):
     obj_type = translate(self.ti.Title(), self.context)
     return _(u'Add ${obj_type}', mapping={'obj_type': obj_type})
Example #38
0
##parameters=type_name='', **kw
##
from Products.CMFDefault.utils import MessageID as _

if type_name:
    return context.setStatus(True)
else:
    return context.setStatus(False, _('Please select a content type.'))
Example #39
0
##parameters=password, confirm, domains=None, **kw
##title=Action to change password
##
from Products.CMFCore.utils import getToolByName
from Products.CMFDefault.utils import Message as _

mtool = getToolByName(script, 'portal_membership')
rtool = getToolByName(script, 'portal_registration')

result = rtool.testPasswordValidity(password, confirm)
if result:
    return context.setStatus(False, result)

member = mtool.getAuthenticatedMember()
mtool.setPassword(password, domains, REQUEST=context.REQUEST)
if member.getProperty('last_login_time') == DateTime('1999/01/01'):
    member.setProperties(last_login_time='2000/01/01')

mtool.credentialsChanged(password, context.REQUEST)

return context.setStatus(True, _(u'Password changed.'))
Example #40
0
##parameters=change_type
##title=Set local roles
##
from Products.CMFCore.utils import getToolByName
from Products.CMFDefault.utils import Message as _

mtool = getToolByName(script, 'portal_membership')

if change_type == 'add':
    mtool.setLocalRoles(obj=context,
                        member_ids=context.REQUEST.get('member_ids', ()),
                        member_role=context.REQUEST.get('member_role', ''))
else:
    mtool.deleteLocalRoles(obj=context,
                           member_ids=context.REQUEST.get('member_ids', ()))

context.setStatus(True, _(u'Local Roles changed.'))
context.setRedirect(context, 'object/localroles')
Example #41
0
##parameters=change='', change_and_view=''
##
from Products.CMFDefault.utils import MessageID as _

form = context.REQUEST.form
if change and \
        context.file_edit_control(**form) and \
        context.setRedirect(context, 'object/edit'):
    return
elif change_and_view and \
        context.file_edit_control(**form) and \
        context.setRedirect(context, 'object/view'):
    return

options = {}

buttons = []
target = context.getActionInfo('object/edit')['url']
buttons.append({'name': 'change', 'value': _('Change')})
buttons.append({'name': 'change_and_view', 'value': _('Change and View')})
options['form'] = {'action': target, 'listButtonInfos': tuple(buttons)}

return context.file_edit_template(**options)
Example #42
0
class ContentsView(ContentEditFormBase):
    """Folder contents view for camaoCmsMasterPages"""

    actions = form.Actions(
        form.Action(name='rename',
                    label=_(u'Rename'),
                    validator='check_items',
                    success='handle_rename'),
        form.Action(name='cut',
                    label=_(u'Cut'),
                    validator='check_items',
                    success='handle_cut'),
        form.Action(name='copy',
                    label=_(u'Copy'),
                    validator='check_items',
                    success='handle_copy'),
        form.Action(name='paste',
                    label=_(u'Paste'),
                    condition='check_clipboard_data',
                    success='handle_paste'),
        form.Action(name='delete',
                    label=_(u'Delete'),
                    validator='check_items',
                    success='handle_delete'),
        form.Action(name='up',
                    label=_(u'Up'),
                    validator='check_items',
                    success='handle_up'),
        form.Action(name='down',
                    label=_(u'Down'),
                    validator='check_items',
                    success='handle_down'),
        form.Action(name='top',
                    label=_(u'Top'),
                    validator='check_items',
                    success='handle_top'),
        form.Action(name='bottom',
                    label=_(u'Bottom'),
                    validator='check_items',
                    success='handle_bottom'))

    template = ViewPageTemplateFile('templates/contents.pt')

    errors = ()

    def __init__(self, *args, **kw):
        super(ContentsView, self).__init__(*args, **kw)
        self.form_fields = form.FormFields()
        self.contents = self.context.contentValues()

        for item in self.contents:
            for n, f in schema.getFieldsInOrder(IFolderItem):
                field = form.FormField(f, n, item.id)
                self.form_fields += form.FormFields(field)

    def is_orderable(self):
        """Returns true if folder contents may be reordered"""
        pass

    def is_sortable(self):
        """Returns true if the folder contents view may be sorted for display"""
        pass

    def setUpWidgets(self, ignore_request=False):
        data = {}
        for i in self.contents:
            data['%s.name' % i.id] = i.id
        self.widgets = form.setUpDataWidgets(self.form_fields,
                                             self.prefix,
                                             self.context,
                                             self.request,
                                             data=data,
                                             ignore_request=ignore_request)

    def layout_fields(self):
        """Return the widgets for the form in the interface field order"""
        fields = []

        for index, item in enumerate(self.contents):
            field = {'ModificationDate': item.ModificationDate()}
            field['select'] = self.widgets['%s.select' % item.getId()]
            field['name'] = self.widgets['%s.name' % item.getId()]
            field['url'] = item.absolute_url()
            field['title'] = item.TitleOrId()
            field['icon'] = item.icon
            field['position'] = index + 1
            fields.append(field.copy())
        return fields

    def _get_ids(self, data):
        """Strip prefixes from ids that have been selected"""
        ids = [k.split(".")[0] for k, v in data.items() if v == True]
        return ids

    def check_items(self, action, data):
        """Check whether any items have been selected for the requested action."""
        errors = form.getWidgetsData(self.widgets, 'form', data)
        if len(self._get_ids(data)) == 0:
            return [_(u"Please select one or more items first.")]

    def check_clipboard_data(self, action):
        return bool(self.context.cb_dataValid())

    def handle_new(self, action, data):
        return self._setRedirect('portal_types', 'object/new')

    def handle_rename(self, action, data):
        ids = self._get_ids(data)
        new_ids = [str(data['%s.name' % k]) for k in ids]
        self.status = _(u'Item renamed.')
        self.context.manage_renameObjects(ids, new_ids)
        return self._setRedirect('portal_types', 'object/contents')

    def handle_cut(self, action, data):
        ids = self._get_ids(data)

        try:
            self.context.manage_cutObjects(ids, self.request)
            if len(ids) == 1:
                self.status = _(u'Item cut.')
            else:
                self.status = _(u'Items cut.')
        except CopyError:
            self.status = _(u'CopyError: Cut failed.')
        except zExceptions_Unauthorized:
            self.status = _(u'Unauthorized: Cut failed.')
        return self._setRedirect('portal_types', 'object/contents')

    def handle_copy(self, action, data):
        ids = self._get_ids(data)

        try:
            self.context.manage_copyObjects(ids, self.request)
            if len(ids) == 1:
                self.status = _(u'Item copied.')
            else:
                self.status = _(u'Items copied.')
        except CopyError:
            self.status = _(u'CopyError: Copy failed.')
        return self._setRedirect('portal_types', 'object/contents')

    def handle_paste(self, action, data):
        try:
            result = self.context.manage_pasteObjects(self.request['__cp'])
            if len(result) == 1:
                self.status = _(u'Item pasted.')
            else:
                self.status = _(u'Items pasted.')
        except CopyError, error:
            self.status = _(u'CopyError: Paste failed.')
            self.request['RESPONSE'].expireCookie(
                '__cp', path='%s' % (self.request['BASEPATH1'] or "/"))

        except zExceptions_Unauthorized:
            self.status = _(u'Unauthorized: Paste failed.')
Example #43
0
options = {}

c = context.aq_explicit
raw_items = [getattr(c, id) for id in ids if hasattr(c, id)]
raw_items = [item for item in raw_items if item.cb_isMoveable()]
items = []
for item in raw_items:
    item_icon = item.getIcon(1)
    items.append({
        'icon': item_icon and ('%s/%s' % (portal_url, item_icon)) or '',
        'id': item.getId(),
        'title': item.Title(),
        'type': item.Type() or None
    })
options['batch'] = {'listItemInfos': tuple(items)}

target = context.getActionInfo('object/rename_items')['url']
hidden_vars = []
for name, value in html_marshal(**default_kw):
    hidden_vars.append({'name': name, 'value': value})
buttons = []
buttons.append({'name': 'rename', 'value': _('Rename')})
buttons.append({'name': 'cancel', 'value': _('Cancel')})
options['form'] = {
    'action': target,
    'listHiddenVarInfos': tuple(hidden_vars),
    'listButtonInfos': tuple(buttons)
}

return context.folder_rename_template(**options)
Example #44
0
 def label(self):
     return _(u'Folder Contents: ${obj_title}',
              mapping={'obj_title': self.title()})
Example #45
0
            del kw[k]
    elif k in ('created',):
        if v['query'] == epoch and v['range'] == 'min':
            del kw[k]
        else:
            # work around problems with DateTime in records
            kw[k] = v.copy()
    elif k in ('go', 'go.x', 'go.y', 'b_start'):
            del kw[k]
items = ctool.searchResults(kw)
batch_obj = Batch(items, 25, b_start, orphan=1)

items = [ {'description': item.Description,
           'icon': item.getIconURL,
           'title': item.Title,
           'type': item.Type,
           'date': item.Date,
           'url': item.getURL()+'/view'}
          for item in batch_obj ]

length = batch_obj.sequence_length
summary = { 'length': length and thousands_commas(length) or '',
            'type': (length == 1) and _(u'item') or _(u'items'),
            'match': kw.get('SearchableText') }
navigation = context.getBatchNavigation(batch_obj, target, **kw)
options['batch'] = { 'summary': summary,
                     'listItemInfos': tuple(items),
                     'navigation': navigation }

return context.search_results_template(**decode(options, script))
Example #46
0
 def check_items(self, action, data):
     """Check whether any items have been selected for the requested action."""
     errors = form.getWidgetsData(self.widgets, 'form', data)
     if len(self._get_ids(data)) == 0:
         return [_(u"Please select one or more items first.")]
Example #47
0
 def handle_sort_order_success(self, action, data):
     """Set the sort options for the folder."""
     self.context.setDefaultSorting(*self._get_sorting())
     self.status = _(u'Default sort order changed.')
     return self._setRedirect('portal_types', 'object/folderContents')
Example #48
0
##parameters=member_id, password, member_email, send_password=False, **kw
##title=Add a member
##
from Products.CMFCore.utils import getToolByName
from Products.CMFDefault.permissions import ManageUsers
from Products.CMFDefault.utils import MessageID as _

mtool = getToolByName(script, 'portal_membership')
ptool = getToolByName(script, 'portal_properties')
rtool = getToolByName(script, 'portal_registration')

try:
    rtool.addMember(id=member_id,
                    password=password,
                    properties={
                        'username': member_id,
                        'email': member_email
                    })
except ValueError, errmsg:
    return context.setStatus(False, errmsg)
else:
    if ptool.getProperty('validate_email') or send_password:
        rtool.registeredNotify(member_id)
    if mtool.checkPermission(ManageUsers, mtool):
        return context.setStatus(True, _('Member registered.'))
    else:
        return context.setStatus(False, _('Success!'))
Example #49
0
##parameters=**kw
##title=Paste objects to a folder from the clipboard
##
from Products.CMFDefault.exceptions import CopyError
from Products.CMFDefault.exceptions import zExceptions_Unauthorized
from Products.CMFDefault.utils import Message as _

try:
    result = context.manage_pasteObjects(context.REQUEST['__cp'])
    if len(result) == 1:
        return context.setStatus(True, _(u'Item pasted.'))
    else:
        return context.setStatus(True, _(u'Items pasted.'))
except CopyError:
    return context.setStatus(False, _(u'CopyError: Paste failed.'))
except zExceptions_Unauthorized:
    return context.setStatus(False, _(u'Unauthorized: Paste failed.'))
Example #50
0
    'Products.CMFCore.interfaces.IMembershipTool')
ptool = getUtilityByInterfaceName(
    'Products.CMFCore.interfaces.IPropertiesTool')
stool = getUtilityByInterfaceName('Products.CMFCore.interfaces.ISkinsTool')

if stool.updateSkinCookie():
    skinname = context.getSkinNameFromRequest(context.REQUEST)
    context.changeSkin(skinname, context.REQUEST)

options = {}

isAnon = mtool.isAnonymousUser()
if isAnon:
    context.REQUEST.RESPONSE.expireCookie('__ac', path='/')
    options['is_anon'] = True
    options['title'] = _(u'Login failure')
    options['admin_email'] = ptool.getProperty('email_from_address')
else:
    mtool.createMemberArea()
    member = mtool.getAuthenticatedMember()
    now = context.ZopeTime()
    last_login = member.getProperty('login_time')
    never_logged_in = str(last_login).startswith('2000/01/01')
    if never_logged_in and ptool.getProperty('validate_email'):
        member.setProperties(last_login_time='1999/01/01', login_time=now)
        target = atool.getActionInfo('user/change_password')['url']
        context.REQUEST.RESPONSE.redirect(target)
        return
    member.setProperties(last_login_time=last_login, login_time=now)
    came_from = context.REQUEST.get('came_from', None)
    if came_from:
Example #51
0
##parameters=include_root=1
##title=Return breadcrumbs
##
from Products.CMFCore.utils import getToolByInterfaceName
from Products.CMFDefault.utils import Message as _

ptool = getToolByInterfaceName('Products.CMFCore.interfaces.IPropertiesTool')
utool = getToolByInterfaceName('Products.CMFCore.interfaces.IURLTool')
portal_url = utool()
result = []

if include_root:
    result.append( { 'id'      : _(u'root')
                   , 'title'   : ptool.title()
                   , 'url'     : portal_url
                   }
                 )

relative = utool.getRelativeContentPath(context)
portal = utool.getPortalObject()

for i in range( len( relative ) ):
    now = relative[ :i+1 ]
    obj = portal.restrictedTraverse( now )
    if not now[ -1 ] == 'talkback':
        result.append( { 'id'      : now[ -1 ]
                       , 'title'   : obj.Title()
                       , 'url'     : portal_url + '/' + '/'.join(now)
                       }
                    )
##parameters=ids=(), **kw
##
from Products.CMFDefault.utils import Message as _

if ids:
    return context.setStatus(True)
else:
    return context.setStatus(
        False, _(u'Please select one or more members '
                 u'first.'))
Example #53
0
 def handle_validate(self, action, data):
     if self.context.wl_isLocked():
         return (_(u'This resource is locked via webDAV.'), )
     return None
Example #54
0
class ContentAddFormBase(_EditFormMixin, PageAddForm):

    adapts(IFolderish, ICMFDefaultSkin, ITypeInformation)
    implementsOnly(IPageForm)

    security = ClassSecurityInfo()
    security.declareObjectPrivate()

    actions = form.Actions(
        form.Action(name='add',
                    label=form._('Add'),
                    condition=form.haveInputWidgets,
                    success='handle_add',
                    failure='handle_failure'),
        form.Action(name='cancel',
                    label=_(u'Cancel'),
                    success='handle_cancel_success',
                    failure='handle_cancel_failure'))

    def __init__(self, context, request, ti):
        self.context = context
        self.request = request
        self.ti = ti

    security.declareProtected(AddPortalContent, '__call__')

    def __call__(self):
        container = self.context
        portal_type = self.ti.getId()

        # check allowed (sometimes redundant, but better safe than sorry)
        if not self.ti.isConstructionAllowed(container):
            raise AccessControl_Unauthorized('Cannot create %s' % portal_type)

        # check container constraints
        ttool = self._getTool('portal_types')
        container_ti = ttool.getTypeInfo(container)
        if container_ti is not None and \
                not container_ti.allowType(portal_type):
            raise ValueError('Disallowed subobject type: %s' % portal_type)

        return super(ContentAddFormBase, self).__call__()

    @property
    def label(self):
        obj_type = translate(self.ti.Title(), self.context)
        return _(u'Add ${obj_type}', mapping={'obj_type': obj_type})

    @property
    def description(self):
        return self.ti.Description()

    #same as in form.AddFormBase but without action decorator
    def handle_add(self, action, data):
        self.createAndAdd(data)

    def handle_cancel_success(self, action, data):
        return self._setRedirect('portal_types',
                                 ('object/folderContents', 'object/view'))

    def handle_cancel_failure(self, action, data, errors):
        self.status = None
        return self._setRedirect('portal_types',
                                 ('object/folderContents', 'object/view'))

    def create(self, data):
        id = data.pop('id', '') or ''
        factory = getUtility(IFactory, self.ti.factory)
        obj = factory(id=id, **data)
        obj._setPortalTypeName(self.ti.getId())
        return obj

    def add(self, obj):
        container = self.context

        name = INameChooser(container).chooseName(obj.getId(), obj)
        obj.id = name
        container._setObject(name, obj)
        obj = container._getOb(name)

        obj_type = translate(obj.Type(), container)
        self.status = _(u'${obj_type} added.', mapping={'obj_type': obj_type})
        self._finished_add = True
        self._added_obj = obj
        return obj

    def nextURL(self):
        obj = self._added_obj

        message = translate(self.status, self.context)
        if isinstance(message, unicode):
            message = message.encode(self._getBrowserCharset())
        return '%s/%s?%s' % (obj.absolute_url(), self.ti.immediate_view,
                             make_query(portal_status_message=message))
Example #55
0
class ContentsView(BatchViewBase, _EditFormMixin, PageForm):
    """Folder contents view"""
    
    template = ViewPageTemplateFile('templates/folder_contents.pt')
    prefix = 'form'
    
    object_actions = form.Actions(
        form.Action(
            name='rename',
            label=_(u'Rename'),
            validator='validate_items',
            condition='has_subobjects',
            success='handle_rename'),
        form.Action(
            name='cut',
            label=_(u'Cut'),
            condition='has_subobjects',
            validator='validate_items',
            success='handle_cut'),
        form.Action(
            name='copy',
            label=_(u'Copy'),
            condition='has_subobjects',
            validator='validate_items',
            success='handle_copy'),
        form.Action(
            name='paste',
            label=_(u'Paste'),
            condition='check_clipboard_data',
            success='handle_paste'),
        form.Action(
            name='delete',
            label=_(u'Delete'),
            condition='has_subobjects',
            validator='validate_items',
            success='handle_delete')
            )
            
    delta_actions = form.Actions(
        form.Action(
            name='up',
            label=_(u'Up'),
            condition='is_orderable',
            validator='validate_items',
            success='handle_up'),
        form.Action(
            name='down',
            label=_(u'Down'),
            condition='is_orderable',
            validator='validate_items',
            success='handle_down')
            )
            
    absolute_actions = form.Actions(
        form.Action(
            name='top',
            label=_(u'Top'),
            condition='is_orderable',
            validator='validate_items',
            success='handle_top'),
        form.Action(
            name='bottom',
            label=_(u'Bottom'),
            condition='is_orderable',
            validator='validate_items',
            success='handle_bottom')
            )

    sort_actions = form.Actions(
        form.Action(
            name='sort_order',
            label=_(u'Set as Default Sort'),
            condition='can_sort_be_changed',
            validator='validate_items',
            success='handle_top')
            )
            
    actions = object_actions + delta_actions + absolute_actions + sort_actions
    errors = ()
    
    def __init__(self, *args, **kw):
        super(ContentsView, self).__init__(*args, **kw)
        self.form_fields = form.FormFields()
        self.delta_field = form.FormFields(IDeltaItem)
        self.contents = self.context.contentValues()        
                
    def content_fields(self):
        """Create content field objects only for batched items"""
        for item in self._getBatchObj():
            for name, field in schema.getFieldsInOrder(IFolderItem):
                field = form.FormField(field, name, item.id)
                self.form_fields += form.FormFields(field)

    @memoize
    @decode
    def up_info(self):
        """Link to the contens view of the parent object"""
        up_obj = self.context.aq_inner.aq_parent
        mtool = self._getTool('portal_membership')
        allowed = mtool.checkPermission(ListFolderContents, up_obj)
        if allowed:
            if IDynamicType.providedBy(up_obj):
                up_url = up_obj.getActionInfo('object/folderContents')['url']
                return {'icon': '%s/UpFolder_icon.gif' % self._getPortalURL(),
                        'id': up_obj.getId(),
                        'url': up_url}
            else:
                return {'icon': '',
                        'id': 'Root',
                        'url': ''}
        else:
            return {}
        
    def setUpWidgets(self, ignore_request=False):
        """Create widgets for the folder contents."""
        super(ContentsView, self).setUpWidgets(ignore_request)
        data = {}
        self.content_fields()
        for i in self._getBatchObj():
            data['%s.name' % i.id] = i.getId()
        self.widgets = form.setUpDataWidgets(
                self.form_fields, self.prefix, self.context,
                self.request, data=data, ignore_request=ignore_request)
        self.widgets += form.setUpWidgets(
                self.delta_field, self.prefix, self.context,
                self.request, ignore_request=ignore_request)
                
    @memoize
    def _get_sorting(self):
        """How should the contents be sorted"""
        data = self._getHiddenVars()
        key = data.get('sort_key')
        if key:
            return (key, data.get('reverse', 0))
        else:
            return self.context.getDefaultSorting()
            
    @memoize
    def _is_default_sorting(self,):
        return self._get_sorting() == self.context.getDefaultSorting()
        
    @memoize
    def column_headings(self):
        key, reverse = self._get_sorting()
        columns = ( {'sort_key': 'Type',
                     'title': _(u'Type'),
                     'colspan': '2'}
                  , {'sort_key': 'getId',
                     'title': _(u'Name')}
                  , {'sort_key': 'modified',
                     'title': _(u'Last Modified')}
                  , {'sort_key': 'position',
                     'title': _(u'Position')}
                  )
        for column in columns:
            paras = {'form.sort_key':column['sort_key']}
            if key == column['sort_key'] \
            and not reverse and key != 'position':
                paras['form.reverse'] = 1
            query = urllib.urlencode(paras)
            column['url'] = '%s?%s' % (self._getViewURL(), query)
        return tuple(columns)
        
    @memoize
    def _get_items(self):
        key, reverse = self._get_sorting()
        items = self.contents
        return sequence.sort(items,
                             ((key, 'cmp', reverse and 'desc' or 'asc'),))
    
    @memoize
    def listBatchItems(self):
        """Return the widgets for the form in the interface field order"""
        batch_obj = self._getBatchObj()
        b_start = self._getBatchStart()
        key, reverse = self._get_sorting()
        fields = []

        for idx, item in enumerate(batch_obj):
            field = {'ModificationDate':item.ModificationDate()}
            field['select'] = self.widgets['%s.select' % item.getId()]
            field['name'] = self.widgets['%s.name' % item.getId()]
            field['url'] = item.absolute_url()
            field['title'] = item.TitleOrId()
            field['icon'] = item.icon
            field['position'] = (key == 'position') \
                                and str(b_start + idx + 1) \
                                or '...'
            field['type'] = item.Type() or None
            fields.append(field.copy())
        return fields
                
    def _get_ids(self, data):
        """Identify objects that have been selected"""
        ids = [k[:-7] for k, v in data.items()
                 if v is True and k.endswith('.select')]
        return ids

    #Action conditions
    @memoize
    def has_subobjects(self, action=None):
        """Return false if the user cannot rename subobjects"""
        return bool(self.contents)
    
    @memoize
    def check_clipboard_data(self, action=None):
        """Any data in the clipboard"""
        return bool(self.context.cb_dataValid())
    
    @memoize
    def can_sort_be_changed(self, action=None):
        """Returns true if the default sort key may be changed 
            may be sorted for display"""
        items_move_allowed = self._checkPermission(ManageProperties)
        return items_move_allowed and not \
            self._get_sorting() == self.context.getDefaultSorting()

    @memoize
    def is_orderable(self, action=None):
        """Returns true if the displayed contents can be
            reorded."""
        (key, reverse) = self._get_sorting()        
        return key == 'position' and len(self.contents) > 1
    
    #Action validators
    def validate_items(self, action=None, data=None):
        """Check whether any items have been selected for 
        the requested action."""
        super(ContentsView, self).validate(action, data)
        if self._get_ids(data) == []:
            return [_(u"Please select one or more items first.")]
        else:
            return []
            
    #Action handlers
    def handle_rename(self, action, data):
        """Redirect to rename view passing the ids of objects to be renamed"""
        # currently redirects to a PythonScript
        # should be replaced with a dedicated form
        self.request.form['ids'] = self._get_ids(data)
        keys = ",".join(self._getHiddenVars().keys() + ['ids'])
        # keys = 'b_start, ids, key, reverse'
        return self._setRedirect('portal_types', 'object/rename_items', keys)
        
    def handle_cut(self, action, data):
        """Cut the selected objects and put them in the clipboard"""
        ids = self._get_ids(data)
        try:
            self.context.manage_cutObjects(ids, self.request)
            if len(ids) == 1:
                self.status = _(u'Item cut.')
            else:
                self.status = _(u'Items cut.')
        except CopyError:
            self.status = _(u'CopyError: Cut failed.')
        except zExceptions_Unauthorized:
            self.status = _(u'Unauthorized: Cut failed.')
        return self._setRedirect('portal_types', 'object/contents')    

    def handle_copy(self, action, data):
        """Copy the selected objects to the clipboard"""
        ids = self._get_ids(data)
        try:
            self.context.manage_copyObjects(ids, self.request)
            if len(ids) == 1:
                self.status = _(u'Item copied.')
            else:
                self.status = _(u'Items copied.')
        except CopyError:
            self.status = _(u'CopyError: Copy failed.')
        return self._setRedirect('portal_types', 'object/contents')
    
    def handle_paste(self, action, data):
        """Paste the objects from the clipboard into the folder"""
        try:
            result = self.context.manage_pasteObjects(self.request['__cp'])
            if len(result) == 1:
                self.status = _(u'Item pasted.')
            else:
                self.status = _(u'Items pasted.')
        except CopyError, error:
            self.status = _(u'CopyError: Paste failed.')
            self.request['RESPONSE'].expireCookie('__cp', 
                    path='%s' % (self.request['BASEPATH1'] or "/"))

        except zExceptions_Unauthorized:
            self.status = _(u'Unauthorized: Paste failed.')
Example #56
0
 def successMessage(self):
     obj_type = translate(self.context.Type(), self.context)
     return _(u'${obj_type} changed.', mapping={'obj_type': obj_type})
Example #57
0
##parameters=member=None, password='******'
##
from Products.CMFCore.utils import getToolByInterfaceName
from Products.CMFDefault.utils import decode
from Products.CMFDefault.utils import makeEmail
from Products.CMFDefault.utils import Message as _

atool = getToolByInterfaceName('Products.CMFCore.interfaces.IActionsTool')
ptool = getToolByInterfaceName('Products.CMFCore.interfaces.IPropertiesTool')
utool = getToolByInterfaceName('Products.CMFCore.interfaces.IURLTool')
portal_url = utool()


options = {}
options['password'] = password

headers = {}
headers['Subject'] = _(u'${portal_title}: Membership reminder',
                      mapping={'portal_title': decode(ptool.title(), script)})
headers['From'] = '%s <%s>' % (ptool.getProperty('email_from_name'),
                               ptool.getProperty('email_from_address'))
headers['To'] = '<%s>' % (member and member.email or '*****@*****.**')

mtext = context.password_email_template(**decode(options, script))
return makeEmail(mtext, script, headers)
Example #58
0
 def summary_type(self):
     length = self._getBatchObj().sequence_length
     return (length == 1) and _(u'item') or _(u'items')
Example #59
0
 def handle_rename(self, action, data):
     ids = self._get_ids(data)
     new_ids = [str(data['%s.name' % k]) for k in ids]
     self.status = _(u'Item renamed.')
     self.context.manage_renameObjects(ids, new_ids)
     return self._setRedirect('portal_types', 'object/contents')
Example #60
0
class ContentEditFormBase(_EditFormMixin, PageForm):

    actions = form.Actions(
        form.Action(name='change',
                    label=_(u'Change'),
                    validator='handle_validate',
                    success='handle_change_success',
                    failure='handle_failure'),
        form.Action(name='change_and_view',
                    label=_(u'Change and View'),
                    validator='handle_validate',
                    success='handle_change_and_view_success',
                    failure='handle_failure'))

    description = u''

    def setUpWidgets(self, ignore_request=False):
        self.adapters = {}
        self.widgets = form.setUpEditWidgets(self.form_fields,
                                             self.prefix,
                                             self.context,
                                             self.request,
                                             adapters=self.adapters,
                                             ignore_request=ignore_request)

    @property
    def label(self):
        obj_type = translate(self.context.Type(), self.context)
        return _(u'Edit ${obj_type}', mapping={'obj_type': obj_type})

    @property
    def successMessage(self):
        obj_type = translate(self.context.Type(), self.context)
        return _(u'${obj_type} changed.', mapping={'obj_type': obj_type})

    noChangesMessage = _(u'Nothing to change.')

    def handle_validate(self, action, data):
        if self.context.wl_isLocked():
            return (_(u'This resource is locked via webDAV.'), )
        return None

    def applyChanges(self, data):
        content = self.context
        changes = form.applyData(content, self.form_fields, data,
                                 self.adapters)
        # ``changes`` is a dictionary; if empty, there were no changes
        if changes:
            content.reindexObject()
        return changes

    def _handle_success(self, action, data):
        # normalize set and datetime
        for k, v in data.iteritems():
            if isinstance(v, Set):
                data[k] = set(v)
            elif isinstance(v, datetime) and v.tzname() is None:
                data[k] = parseDatetimetz(str(v))
        changes = self.applyChanges(data)
        if changes:
            self.status = self.successMessage
        else:
            self.status = self.noChangesMessage
        return changes

    def handle_change_success(self, action, data):
        self._handle_success(action, data)
        return self._setRedirect('portal_types', 'object/edit')

    def handle_change_and_view_success(self, action, data):
        self._handle_success(action, data)
        return self._setRedirect('portal_types', 'object/view')