def EnableCustomRisks(survey):
    """In order to allow the user to add custom risks, we create a new special
    module (marked with ICustomRisksModule) in which they may be created.
    """
    appconfig = component.getUtility(IAppConfig)
    if not asBool(appconfig["euphorie"].get("allow_user_defined_risks")):
        return 0
    if "custom-risks" in survey.keys():
        # We don't want to create the custom risks module twice.
        return 0
    args = dict(
        container=survey,
        type="euphorie.module",
        id="custom-risks",
        title=_(u"title_other_risks", default=u"Added risks (by you)"),
        safe_id=False,
        description=_(
            u"description_other_risks", default=u"In case you have identified "
            u"risks not included in the tool, you are able to add them now:"),
        optional=True,
        question=_(
            u"question_other_risks", default=u"<p>Would you now like to add "
            u"your own defined risks to this tool?</p><p><strong>Important:"
            u"</strong> In order to avoid duplicating risks, we strongly "
            u"recommend you to go first through all the previous modules, if "
            u"you have not done it yet.</p><p>If you don't need to add risks, "
            u"please select 'No.'</p>"),
    )
    try:
        module = api.content.create(**args)
    except api.exc.InvalidParameterError:
        args['id'] = "custom-risks-"+str(random.randint(0, 99999999))
        module = api.content.create(**args)
    alsoProvides(module, ICustomRisksModule)
    return args['id']

def set_browserlayer(request):
    """Set the BrowserLayer for the request.

    We have to set the browserlayer manually, since importing the profile alone
    doesn't do it in tests.
    """
    alsoProvides(request, IPlonesocialNetworkLayer)

 def __call__(self):
     alsoProvides(self.request, IDisableCSRFProtection)
     data = self.read_json()
     response_data = {
         'github_members': {},
         'github_stats': {},
         'stackoverflow': {},
         'pypi': {},
         'twitter': {},
         'community': {},
     }
     members = api.user.get_users()
     self.add_github_member_related_data(
         members,
         data,
         response_data['github_members']
     )
     self.add_stackoverflow_data(
         members,
         data,
         response_data['stackoverflow']
     )
     self.add_twitter_data(
         members,
         data,
         response_data['twitter']
     )
     self.add_github_overall_stats(data, response_data['github_stats'])
     # Disable pypi stats since they always return 0
     # self.add_pypi_stats(data, response_data['pypi'])
     self.add_community_stats(data, response_data['community'])
     return self.json_success(response_data)

    def test_portlet_inheritance(self):
        portal = self.layer['portal']
        folder = portal.folder2
        request = folder.REQUEST
        view = folder.restrictedTraverse('@@plone')
        alsoProvides(view, IViewView)
        self.assertTrue(IViewView.providedBy(view))
        viewlet_manager = queryMultiAdapter(
            (folder, request, view),
            IContentProvider,
            'plone.abovecontentbody')
        viewlet = queryMultiAdapter(
            (folder, request, view, viewlet_manager),
            IViewlet,
            'collective.calltoaction')
        self.assertTrue(viewlet is not None)
        viewlet.update()
        # The portlet from the test fixture is blocked.
        self.assertEqual(len(viewlet.data), 0)

        # Show the action globally.  This ignores portlet inheritance.
        registry = getUtility(IRegistry)
        settings = registry.forInterface(
            ICollectiveCalltoactionSettings, check=False)
        self.assertFalse(settings.show_global)
        settings.show_global = True

        # Now we should see the portlet
        viewlet.update()
        self.assertEqual(len(viewlet.data), 1)

    def _create_site_with_request(self):
        request = Dummy(getPreferredLanguages=lambda: [])
        alsoProvides(request, IUserPreferredLanguages)
        site = Dummy(REQUEST=request,
                     getSiteManager=getGlobalSiteManager)

        return site

    def test_multiple_selection(self):
        """The pattern_options key maximumSelectionSize shouldn't be
        set when the field allows multiple selections"""
        from plone.app.widgets.dx import RelatedItemsFieldWidget
        from zope.schema.interfaces import ISource
        from zope.schema.vocabulary import VocabularyRegistry

        context = Mock(absolute_url=lambda: 'fake_url')
        context.portal_properties.site_properties\
            .getProperty.return_value = ['SomeType']
        field = List(
            __name__='selectfield',
            value_type=Choice(vocabulary='foobar')
        )
        widget = RelatedItemsFieldWidget(field, self.request)
        widget.context = context

        vocab = Mock()
        alsoProvides(vocab, ISource)
        with mock.patch.object(VocabularyRegistry, 'get', return_value=vocab):
            widget.update()
            base_args = widget._base_args()
        patterns_options = base_args['pattern_options']
        self.assertFalse('maximumSelectionSize' in patterns_options)
        self.assertEqual(
            patterns_options['vocabularyUrl'],
            '/@@getVocabulary?name=foobar&field=selectfield',
            )

    def test_export_with_missing_schema_does_not_error(self):

        xml = """\
<registry>
  <record name="test.export.simple" interface="non.existant.ISchema" field="blah">
    <field type="plone.registry.field.TextLine">
      <default>N/A</default>
      <title>Simple record</title>
    </field>
    <value>Sample value</value>
  </record>
</registry>"""

        self.registry.records['test.export.simple'] = \
            Record(field.TextLine(title=u"Simple record", default=u"N/A"), value=u"Sample value")

        # Note: These are nominally read-only!
        self.registry.records['test.export.simple'].field.interfaceName = 'non.existant.ISchema'
        self.registry.records['test.export.simple'].field.fieldName = 'blah'

        alsoProvides(self.registry.records['test.export.simple'], IInterfaceAwareRecord)

        context = DummyExportContext(self.site)
        exportRegistry(context)

        self.assertEquals('registry.xml', context._wrote[0][0])
        self.assertXmlEquals(xml, context._wrote[0][1])

    def testViewlet(self):
        viewlets = self._get_viewlets(self.portal, 'plone.htmlhead.links')
        self.assertFalse(VIEWLET_NAME in viewlets.keys())

        alsoProvides(self.portal, IOpengraphable)
        viewlets = self._get_viewlets(self.portal, 'plone.htmlhead.links')
        self.assertTrue(VIEWLET_NAME in viewlets.keys())

    def test_converter_RelationList(self):
        from plone.app.z3cform.converters import RelatedItemsDataConverter
        from z3c.relationfield.interfaces import IRelationList
        field = List()
        alsoProvides(field, IRelationList)
        brain1 = Mock(getObject=Mock(return_value='obj1'), UID='id1')
        brain2 = Mock(getObject=Mock(return_value='obj2'), UID='id2')
        portal_catalog = Mock(return_value=[brain1, brain2])
        widget = Mock(separator=';')
        converter = RelatedItemsDataConverter(field, widget)

        self.assertEqual(converter.toWidgetValue(None), None)
        with mock.patch(
            'plone.app.z3cform.converters.IUUID',
            side_effect=['id1', 'id2']
        ):
            self.assertEqual(
                converter.toWidgetValue(['obj1', 'obj2']), 'id1;id2')

        self.assertEqual(converter.toFieldValue(None), None)
        with mock.patch(
                'plone.app.z3cform.converters.getToolByName',
                return_value=portal_catalog):
            self.assertEqual(
                converter.toFieldValue('id1;id2'), ['obj1', 'obj2'])

    def __call__(self):
        alsoProvides(self, IViewView)
        manager = queryMultiAdapter(
            (self.context, self.request, self),
            IViewletManager, name='plone.belowcontent'
        )
        viewlet = queryMultiAdapter(
            (self.context, self.request, self, manager),
            IViewlet, name='plone.comments'
        )
        if viewlet is not None:
            viewlet.form = TileCommentForm
            viewlet.update()

            if isinstance(viewlet.form, TileCommentForm):
                viewlet.form.action = self.url

            # Fix submit redirect from tile to context
            if 'location' in self.request.response.headers:
                location = self.request.response.getHeader('location')
                self.request.response.redirect(''.join([
                    self.context.absolute_url(), '#', location.split('#')[-1]
                ]))
            return protect(u'<html><body>%s</body></html>' % viewlet.render())
        else:
            return u'<html><body></body></html>'

 def __call__(self, *args, **kw):
     obj = self._callable(*args, **kw)
     if self.provides:
         alsoProvides(obj, self.provides)
     obj.title = kw.pop("title", self.title)
     obj.description = kw.pop("description", self.description)
     return obj

def _fixup_zope_interface():
    # Make sure the provided and implementedBy objects
    # can be iterated.
    # Note that we DO NOT use the _iteratorChecker, but instead
    # we use NoProxy to be sure that the results (of iteration or not) are not
    # proxied. On Python 2, these objects are builtin and don't go through the
    # checking process at all, much like BTrees, so NoProxy is necessary for
    # compatibility. On Python 3, prior to this, iteration was simply not allowed.
    from zope.interface import providedBy
    from zope.interface import alsoProvides

    class I1(Interface):
        pass

    class I2(Interface):
        pass

    @implementer(I1)
    class O(object):
        pass

    o = O()


    # This will be athe zope.interface.implementedBy from the class
    # a zope.interface.declarations.Implements
    _default_checkers[type(providedBy(o))] = NoProxy

    alsoProvides(o, I2)
    # This will be the zope.interface.Provides from the instance
    _default_checkers[type(providedBy(o))] = NoProxy

 def process(self):        
     alsoProvides(self.request, IDisableCSRFProtection)
     """ do main work here """
     context = api.content.get(path='/library/ws/resources')
     
     computer_id = self.request.form.get('computerId','')
     print computer_id
     print idnormalizer.normalize(computer_id)
     available = True 
     if int(self.request.form.get('status', -1)) <= 0:
         available = False
     
     brains = api.content.find(context=context, portal_type='polklibrary.type.computeravailability.models.resource', id=idnormalizer.normalize(computer_id))
     if brains:
         obj = brains[0].getObject()
         obj.activated = available
         obj.reindexObject()
         self._data['status'] = 'Updated'
     else:
         obj = api.content.create(
                     type='polklibrary.type.computeravailability.models.resource',
                     title=computer_id,
                     container=context,
                 )
         obj.activated = available
         obj.resources = u"PC"  # Default since most are
         api.content.transition(obj=obj, transition='publish')
         obj.reindexObject()
         self._data['status'] = 'Created'

def set_browserlayer(request):
    """Set the BrowserLayer for the request.

    We have to set the browserlayer manually, since importing the profile alone
    doesn't do it in tests.
    """
    alsoProvides(request, IProductShopExtensionLayer)

 def update(self):
     """ Update form - see interfaces.IForm """
     self.formMaybeForceSSL()
     super(EasyFormForm, self).update()
     self.template = self.form_template
     if self.request.method == 'POST' and \
             not self.context.thanksPageOverride:
         data, errors = self.extractData()
         if errors:
             return
         data = self.updateServerSideData(data)
         self.thanksPage = True
         self.template = self.thank_you_template
         if self.context.showFields:
             self.fields = self.setThanksFields(self.base_fields)
             for group in self.groups:
                 group.fields = self.setThanksFields(
                     self.base_groups.get(group.label))
         self.mode = DISPLAY_MODE
         # we need to update the widgets in display mode again
         super(EasyFormForm, self).update()
         prologue = self.context.thanksPrologue
         epilogue = self.context.thanksEpilogue
         self.thanksPrologue = prologue and dollar_replacer(
             prologue.output, data)
         self.thanksEpilogue = epilogue and dollar_replacer(
             epilogue.output, data)
         alsoProvides(self.request, IEasyFormThanksPage)

def apply_request_layer_by_url(event):
    """Apply a request layer by URL.

    This subscriber applies a request-layer on the ``request`` object
    based on the request to allow layer-based component registration
    of user interface elements.
    
    NOTE: only one layer is applied -- the first one to match.
    """
    request = event.request
    #path = "/".join(reversed(request.getTraversalStack()))
    path = url.get_destination_url_path(request)
    path_info = request.get("PATH_INFO")
    log.debug(" [apply_request_layer_by_url] path=%s path_info=%s" % (
                                                            path, path_info))
    for condition, layer in mapping_on_path:
        if condition.match(path) is not None:
            log.debug("Adding %s layer to request for path <%s>" % (layer, path))
            interface.alsoProvides(request, layer)
            break # only apply first matching layer
    else: # there was no break, no mapping_on_path layer added
        # !+IResourceNonLayer(mr, nov-2010) almost never passes thru here
        for condition, layer in mapping_on_path_info:
            if condition.match(path_info) is not None:
                log.debug("Adding %s layer to request for path_info <%s>" % (
                                                            layer, path_info))
                interface.alsoProvides(request, layer)
                break

 def factory(self):
     #base = cachedItemMixin()
     #base._key = self.key()
     ci = type('SimpleItemMapperCachedItem', (cachedItemMixin,), {key:None for key in self.mapper.keys()})()
     ci._key = self.key()
     alsoProvides(ci, ICachedItem)
     return ci

 def __call__(self):
     """Sync a single user profile with external property providers"""
     alsoProvides(self.request, IDisableCSRFProtection)
     userprofile = self.context
     IUserProfileManager(userprofile).sync()
     api.portal.show_message(message=_("External property sync complete."), request=self.request)
     return self.request.response.redirect(userprofile.absolute_url())

 def setUp(self):
     self.portal = self.layer['portal']
     self.request = self.layer['request']
     alsoProvides(self.request, IBrowserLayer)
     with api.env.adopt_roles(['Manager']):
         self.journal = api.content.create(
             self.portal, 'Journal', 'journal')

 def test_viewlet(self):
     request = self.folder.REQUEST
     view = self.folder.restrictedTraverse('@@plone')
     alsoProvides(view, IViewView)
     self.assertTrue(IViewView.providedBy(view))
     viewlet_manager = queryMultiAdapter(
         (self.folder, request, view),
         IContentProvider,
         'plone.abovecontentbody')
     viewlet = queryMultiAdapter(
         (self.folder, request, view, viewlet_manager),
         IViewlet,
         'collective.calltoaction')
     self.assertTrue(viewlet is not None)
     viewlet.update()
     # We expect data from the portlet assignment in
     # profiles/testfixture/portlets.xml.
     self.assertEqual(len(viewlet.data), 1)
     portlet = viewlet.data[0]
     self.assertIn('assignment', portlet.keys())
     self.assertIn('html', portlet.keys())
     assignment = portlet['assignment']
     self.assertEqual(assignment.milli_seconds_until_overlay, 1000)
     portlet_html = portlet['html']
     self.assertIn('portletCallToAction', portlet_html)
     self.assertIn('portletCallToAction', portlet_html)
     viewlet_html = viewlet.render()
     self.assertIn(portlet_html, viewlet_html)
     self.assertIn('data-timeout="1000"', viewlet_html)