def set_data(self, data):
        assert self.folder
        assert self.form_fields
        assert self.versionForChange
        assert self.auditor
        assert data

        nvId = new_version_id()
        while nvId in self.folder.objectIds():
            nvId = new_version_id()
        newVersion = new_version(self.folder, nvId)
        fields = self.form_fields.omit('id', 'parentVersion',
          'editor', 'creationDate')
        form.applyChanges(newVersion, fields, data)
        newVersion.parentVersion = to_ascii(self.versionForChange.id)
        userInfo = createObject('groupserver.LoggedInUser',
          self.folder)
        newVersion.editor = to_unicode_or_bust(userInfo.id)

        i, s = self.get_auditDatums(self.versionForChange,
          newVersion)
        self.auditor.info(EDIT_CONTENT, i, s)

        # Handle publishing here
        if data['published']:
            self.folder.published_revision = newVersion.id
        self.status = '%s %s' % \
          ('Published' if data['published'] else 'Changed',
           data['title'])
        assert self.status

 def create(self, data):
     query = createObject(u"collective.cmisquery.CMISQuery")
     content = self.context.add(query)
     # We need to add the content before editing it, in order to
     # have a working reference: we would get not yet overwise.
     applyChanges(content, self.form_fields, data)
     return content

    def createAndAdd(self, data):
        domain_model = self.domain_model
        # create the object, inspect data for constructor args
        try:
            ob = createInstance(domain_model, data)
        except TypeError:
            ob = domain_model()

        # apply any context values
        self.finishConstruction(ob)

        # apply extra form values
        form.applyChanges(ob, self.form_fields, data, self.adapters)

        # save the object, id is generated by db on flush
        self.context[""] = ob

        # flush so we have database id
        bungeni.alchemist.Session().flush()

        # fire an object created event
        notify(ObjectCreatedEvent(ob))

        # signal to add form machinery to go to next url
        self._finished_add = True

        mapper = orm.object_mapper(ob)

        # TODO single primary key (need changes to base container)
        oid = mapper.primary_key_from_instance(ob)

        # retrieve the object with location and security information
        return self.context[oid]

    def handle_create_shipment( self, action, data ):
        items = self.selection_column.getSelected( self.line_items, self.request )
        if not items:
            self.status = _(u"Please Select Items to Ship")
            return
        
        o_shipment = shipment.Shipment()
        
        order = self.context._object
        # this gets attached normally via the warehouse
        # event subscriber, we do it lazy here for existing orders
        if getattr( order, 'shipments', None) is None:
            order.shipments = shipment.OrderShipments()

        # modify shipment with supplied form fields
        adapters = { IShipment : o_shipment }
        form.applyChanges( None, self.form_fields, data, adapters )

        # store shipment
        sid = str( len( order.shipments ) + 1 )
        order.shipments[ sid ] = o_shipment

        # populate shipment with items
        for i in items:
            o_shipment[ i.item_id ] = i.clone()
            i.fulfillment_workflow.fireTransition('ship')

        # attempt to transition order
        self.transitionOrder()

        # clear manager item cache and fetch
        self.status = _(u"Shipment Created")
        self.update()

    def createAndAdd(self, data):
        # use aq_inner, or else the obj will be wrapped in this view,
        # will screw up acquired security settings (esp. local roles)
        context = aq_inner(self.context)
        plone_utils = getToolByName(context, 'plone_utils')
        list_id = plone_utils.normalizeString(data['title'])

        context.invokeFactory(self.portal_type, list_id)
        list_ob = context._getOb(list_id)

        old_list_type = list_ob.list_type.list_marker
        new_list_type = data.get('list_type').list_marker

        form.applyChanges(list_ob, self.form_fields, data)

        # ensure correct role is set for users
        self._assign_local_roles_to_managers(list_ob)
        
        # XXX this ObjectCreatedEvent event would normally come before
        # the ObjectAddedEvent
        notify(zope.app.event.objectevent.ObjectCreatedEvent(list_ob))
        notify(ListTypeChanged(list_ob, old_list_type, new_list_type))
        self._finished_add = True

        status = IStatusMessage(self.request)
        status.addStatusMessage(_('Mailing list added.'), type=u'info')

        self._next_url = list_ob.absolute_url()

        return list_ob

 def submit(self, action, data):
     """
     """
     wvconfig = IWeblogConfiguration(self.context)
     form.applyChanges(wvconfig, self.form_fields, data)
     msg = _(u'Configuration saved.')
     IStatusMessage(self.request).addStatusMessage(msg, type='info')

 def create(self, data):
     """ Create
     """
     name = INameChooser(self.context).chooseName(data.get('title', ''),
                                                  None)
     ob = AnalyticsReport(id=name)
     applyChanges(ob, self.form_fields, data)
     return ob

 def add_profile_attributes(self, userInfo, data):
     addFields = AddFields(self.context)
     enforce_schema(userInfo.user, addFields.profileInterface)
     f = form.Fields(addFields.adminInterface, render_context=False)
     fields = f.select(*addFields.profileFieldIds)
     for field in fields:
         field.interface = addFields.profileInterface
     form.applyChanges(userInfo.user, fields, data)

    def create(self, data):
        ob = NewsItem()

        title = data.get('title', 'stire')
        uid = INameChooser(self.context).chooseName(title, ob)
        setattr(ob, '_tmp_id', uid)
        applyChanges(ob, self.form_fields, data)
        return ob

    def add_profile_attributes(self, userInfo, data):
        enforce_schema(userInfo.user, self.inviteFields.profileInterface)
        fields = self.form_fields.select(*self.inviteFields.profileFieldIds)
        for field in fields:
            field.interface = self.inviteFields.profileInterface

        form.applyChanges(userInfo.user, fields, data)
        # wpb: Why not use self.set_delivery?
        set_digest(userInfo, self.groupInfo, data)

 def handle_change(self, action, data):
     ctx = get_the_actual_instance_from_zope(self.context)
     form.applyChanges(ctx, self.form_fields, data)
     auditor = ChangeAuditor(ctx)
     auditor.info(CHANGE, str(len(data['introduction'])))
     self.status = _(
         'change-success',
         'The introduction text that appears on '
         '<a href="/">the site homepage</a> has been '
         'changed.')

 def handle_add_warehouse( self, action, data ):
     adapters = { interfaces.IWarehouse : warehouse.Warehouse(),
                  interfaces.IAddress   : Address() }
                  
     form.applyChanges( self.context, self.form_fields, data, adapters )
     
     container = component.getUtility( interfaces.IWarehouseContainer )
     w = adapters[ interfaces.IWarehouse ]
     w.location = adapters[ interfaces.IAddress ]
     container[ w.name ] = w
     self.request.response.redirect('@@pgp-view-warehouse?wid=%s'% w.name )

 def handle_edit_save_and_view(self, action, data):
     """Saves the  document and redirects to its view page"""
     for key in data.keys():
         if isinstance(data[key], str): 
             data[key] = unescape(data[key])
 	form.applyChanges(self.context, self.form_fields, data)
     if not self._next_url:
         self._next_url = ui_utils.url.absoluteURL(
             self.context, self.request) + \
             '?portal_status_message= Saved'
     self.request.response.redirect(self._next_url)

 def handle_edit_action(self, action, data):
     CheckAuthenticator(self.request)
     if not self.available():
         self.status = _(u'text_not_allowed_manage_server',
                         default=u'You are not allowed to manage the Zope server.')
         return
     form.applyChanges(self.context, self.form_fields, data, self.adapters)
     value = data.get('days', None)
     # skip the actual pack method in tests
     if value is not None and isinstance(value, int) and value >= 0:
         context = aq_inner(self.context)
         cpanel = context.unrestrictedTraverse('/Control_Panel')
         cpanel.manage_pack(days=value, REQUEST=None)
     self.status = _(u'Packed the database.')

    def actual_handle_set(self, action, data):
        groupsToJoin = None
        if 'joinable_groups' in data.keys():
            groupsToJoin = data.pop('joinable_groups')

        fields = self.form_fields.omit('joinable_groups')
        for field in fields:
            field.interface = self.registerInterface
        form.applyChanges(self.context, fields, data)

        if groupsToJoin and self.user_has_verified_email:
            self.join_groups(groupsToJoin)
        elif groupsToJoin:
            self.invite_groups(groupsToJoin)

    def handle_change(self, action, data):

        if data['replyTo'] != self.replyTo:
            self.replyTo = data['replyTo']
            del(data['replyTo'])

        form.applyChanges(self.context, self.form_fields, data)
        self.set_subject_prefix(data['short_name'])
        groupLink = '<a href="{groupUrl}">{groupName}</a>.'.format(
            groupUrl=self.groupInfo.relative_url(),
            groupName=self.groupInfo.name)
        self.status = _('changed-status',
                        'Changed the properties of ${groupLink}.',
                        mapping={'groupLink': groupLink})

    def save_action(self, action, data):
        """Update the context and redirect to its overview page."""
        config = getUtility(IPublisherConfigSet).getByDistribution(self.context)
        if config is None:
            config = getUtility(IPublisherConfigSet).new(
                distribution=self.context,
                root_dir=data["root_dir"],
                base_url=data["base_url"],
                copy_base_url=data["copy_base_url"],
            )
        else:
            form.applyChanges(config, self.form_fields, data, self.adapters)

        self.request.response.addInfoNotification("Your changes have been applied.")
        self.next_url = canonical_url(self.context)

    def handle_invite(self, action, data):
        form.applyChanges(self.context, self.form_fields, data)

        auditor = Auditor(self.siteInfo, self.groupInfo)
        admin = createObject('groupserver.LoggedInUser', self.context)
        l = '{0}'.format(len(data['aboutText'])) \
            if data['aboutText'] else '0'
        auditor.info(CHANGE_ABOUT, admin, l)

        self.status = _(
            'change-status-success',
            'The About tab on the homepage for '
            '<a href="${groupUrl}">${groupName}</a> has been changed.',
            mapping={'groupUrl': self.groupInfo.relativeURL,
                     'groupName': self.groupInfo.name})

    def set_data(self, data):
        assert self.context
        assert self.form_fields

        alteredFields = []
        for datum in getFieldsInOrder(self.interface):
            if datum[0] in data:
                if data[datum[0]] != getattr(self.context, datum[0]):
                    alteredFields.append(datum[0])

        # Create the content folder and object and apply changes.
        folder = GSContentPage(self.context, mode='add', id=data['id'])
        if folder.status['error']:
            retval = u'%s' % folder.status['msg']

        changed = form.applyChanges(folder, self.form_fields, data)

        # All good, so redirect to the edit page.
        if changed:
            url = '%s/edit_page.html' % folder.context.absolute_url(0)
            self.request.response.redirect(url)
            return
        else:
            retval = u'Problem creating page'

        assert retval
        assert type(retval) == unicode
        self.status = retval

    def handle_save_action(self, action, data):
        if form.applyChanges(self.context, self.form_fields, data,
                             self.adapters):
            zope.event.notify(
                zope.lifecycleevent.ObjectModifiedEvent(self.context))
            zope.event.notify(ploneformbase.EditSavedEvent(self.context))
            self.status = "Changes saved"
        else:
            zope.event.notify(ploneformbase.EditCancelledEvent(self.context))
            self.status = "No changes"

        settings = PageSliderSettings(self.context)
        slides = settings.slides
        index = data.get('index', -1)
        value = {
            'html': data['slide'],
            'overlay': data['overlay'],
            'on_hover': data['on_hover']
        }

        if index == -1:
            slides.append(value)
            index = len(slides) - 1
        else:
            slides[index] = value

        settings.slides = slides

        url = getMultiAdapter((self.context, self.request),
                              name='absolute_url')() + "/@@slider-settings"
        self.request.response.redirect(url)