Python DateTime.rfc822方法代码示例

# 需要导入模块: from DateTime import DateTime [as 别名]
# 或者: from DateTime.DateTime import rfc822 [as 别名]
 def set_cookie(self, key, value, expires=None, path='/',
                across_domain_cookie_=False, RESPONSE=None,
                **kw):
     """ set a cookie in REQUEST 
     
     'across_domain_cookie_' sets the cookie across all subdomains
     eg. www.mobilexpenses.com and mobile.mobilexpenses.com etc.
     This rule will only apply if the current domain name plus sub domain
     contains at least two dots.
     """
     if expires is None:
         then = DateTime()+365
         then = then.rfc822()
     elif isinstance(expires, int):
         then = DateTime()+expires
         then = then.rfc822()
     elif type(expires)==DateTimeType:
         # convert it to RFC822()
         then = expires.rfc822()
     else:
         then = expires
         
     if across_domain_cookie_ and not kw.get('domain'):
         
         # set kw['domain'] = '.domainname.com' if possible
         cookie_domain = self._getCookieDomain()
         if cookie_domain:
             kw['domain'] = cookie_domain
             
     if RESPONSE is None:
         RESPONSE = self.REQUEST.RESPONSE
         
     RESPONSE.setCookie(key, value, 
                        expires=then, path=path, **kw)

# 需要导入模块: from DateTime import DateTime [as 别名]
# 或者: from DateTime.DateTime import rfc822 [as 别名]
    def testRFC822(self):
        # rfc822 conversion
        dt = DateTime('2002-05-02T08:00:00+00:00')
        self.assertEqual(dt.rfc822(), 'Thu, 02 May 2002 08:00:00 +0000')

        dt = DateTime('2002-05-02T08:00:00+02:00')
        self.assertEqual(dt.rfc822(), 'Thu, 02 May 2002 08:00:00 +0200')

        dt = DateTime('2002-05-02T08:00:00-02:00')
        self.assertEqual(dt.rfc822(), 'Thu, 02 May 2002 08:00:00 -0200')

        # Checking that conversion from local time is working.
        dt = DateTime()
        dts = dt.rfc822().split(' ')
        times = dts[4].split(':')
        _isDST = time.localtime(time.time())[8]
        if _isDST:
            offset = time.altzone
        else:
            offset = time.timezone
        self.assertEqual(dts[0], dt.aDay() + ',')
        self.assertEqual(int(dts[1]), dt.day())
        self.assertEqual(dts[2], dt.aMonth())
        self.assertEqual(int(dts[3]), dt.year())
        self.assertEqual(int(times[0]), dt.h_24())
        self.assertEqual(int(times[1]), dt.minute())
        self.assertEqual(int(times[2]), int(dt.second()))
        self.assertEqual(dts[5], "%+03d%02d" % divmod((-offset / 60), 60))

# 需要导入模块: from DateTime import DateTime [as 别名]
# 或者: from DateTime.DateTime import rfc822 [as 别名]
    def dictFromBrain(self, brain, editableEvents=[]):
        if type(brain.end) != DateTime:
            brainend = DateTime(brain.end)
            brainstart = DateTime(brain.start)
        else:
            brainend = brain.end
            brainstart = brain.start

        if brain.UID in editableEvents:
            editable = True
        else:
            editable = False

        if brainend - brainstart > 1.0:
            allday = True
        else:
            allday = False

        if getattr(brain, 'SFAllDay', None) in [False,True]:
            allday = brain.SFAllDay

        copycut = ''
        if self.copyDict and brain.getPath() == self.copyDict['url']:
            copycut = self.copyDict['op'] == 1 and ' event_cutted' or ' event_copied'
        typeClass = ' type-'+brain.portal_type
        colorDict = getColorIndex(self.context, self.request, brain=brain)
        colorIndex = colorDict.get('class', '')
        color = colorDict.get('color', '')
        extraClass = self.getBrainExtraClass(brain)
        HANDLE_RECURRENCE = HAS_RECURRENCE_SUPPORT and self.request.get('start') and self.request.get('end')
        if HANDLE_RECURRENCE:
            event = brain.getObject()
            start = DateTime(self.request.get('start'))
            end = DateTime(self.request.get('end'))
            occurences = IRecurrence(event).occurrences(limit_start=start, limit_end=end)
            occurenceClass = ' occurence'
        else:
            occurences = [(brainstart.rfc822(), brainend.rfc822())]
            occurenceClass = ''
        events = []
        for occurence_start, occurence_end in occurences:
            events.append({
                "id": "UID_%s" % (brain.UID),
                "title": brain.Title,
                "description": brain.Description,
                "start": HANDLE_RECURRENCE and occurence_start.isoformat() or occurence_start,
                "end": HANDLE_RECURRENCE and occurence_end.isoformat() or occurence_end,
                "url": brain.getURL(),
                "editable": editable,
                "allDay": allday,
                "className": "contextualContentMenuEnabled state-" + str(brain.review_state) + (editable and " editable" or "")+copycut+typeClass+colorIndex+extraClass+occurenceClass,
                "color": color})
        return events

# 需要导入模块: from DateTime import DateTime [as 别名]
# 或者: from DateTime.DateTime import rfc822 [as 别名]
 def setAuthCookie(self, resp, cookie_name, cookie_value):
     """ this method overrides the default setAuthCookie so that we can
     set the cookie for a longer time. """
     kw = {}
     req = getattr(self, 'REQUEST', None)
     if req is not None and req.get('SERVER_URL', '').startswith('https:'):
         # Ask the client to send back the cookie only in SSL mode
         kw['secure'] = 'y'
         
     if req.get('remember_login_days'):
         days = int(req.get('remember_login_days'))
         then = DateTime() + days
         kw['expires'] = then.rfc822()
         resp.setCookie('use_remember_login_days', '1', 
                        path=self.getCookiePath(), **kw)
     else:
         resp.setCookie('use_remember_login_days', '0', 
                        path=self.getCookiePath(), **kw)
         
     resp.setCookie(cookie_name, cookie_value,
                    path=self.getCookiePath(), **kw)
         
     resp.setCookie('__issuetracker_logout_page', 
                    self.absolute_url()+'/logout', # that's how it's defined in CookieCrumbler
                    path=self.getCookiePath(), **kw)

# 需要导入模块: from DateTime import DateTime [as 别名]
# 或者: from DateTime.DateTime import rfc822 [as 别名]
    def setAuthCookie(self, resp, cookie_name, cookie_value):
        """ this method overrides the default setAuthCookie so that we can
        set the cookie for a longer time. """
        kw = {}
        req = getattr(self, 'REQUEST', None)
        if req is not None and req.get('SERVER_URL', '').startswith('https:'):
            # Ask the client to send back the cookie only in SSL mode
            kw['secure'] = 'y'

        if req.get('remember_login_days'):
            days = int(req.get('remember_login_days'))
            then = DateTime() + days
            kw['expires'] = then.rfc822()
            resp.setCookie('use_remember_login_days', '1',
                           path=self.getCookiePath(), **kw)
        else:
            resp.setCookie('use_remember_login_days', '0',
                           path=self.getCookiePath(), **kw)
            
        resp.setCookie(cookie_name, cookie_value,
                       path=self.getCookiePath(), **kw)
        
        logout_url_start = self.absolute_url()
        
        if self.REQUEST.SESSION.get('cc_in_path'):
            # that means the user authenticated in a different root
            # to where the openid instance is located
            cc_in_path = self.REQUEST.SESSION.get('cc_in_path')
            assert cc_in_path.startswith('/')
            context = aq_parent(aq_inner(self)).unrestrictedTraverse(cc_in_path.split('/')[1:])
            logout_url_start = context.absolute_url() + '/%s' % self.getId()

        resp.setCookie('__issuetracker_logout_page',
                       logout_url_start+'/logout', # that's how it's defined in CookieCrumbler
                       path=self.getCookiePath(), **kw)

# 需要导入模块: from DateTime import DateTime [as 别名]
# 或者: from DateTime.DateTime import rfc822 [as 别名]
    def __call__(self):
        """ Return csv content as http response or return info IStatusMessage
        """

        csv_content = self.all_activities_csv()

        if csv_content is not None:
            now = DateTime()
            nice_filename = '%s_%s' % ('activities_', now.strftime('%Y%m%d'))
            self.request.response.setHeader("Content-Disposition",
                                            "attachment; filename=%s.csv" % 
                                             nice_filename)
            self.request.response.setHeader("Content-Type", "text/csv")
            self.request.response.setHeader("Content-Length", len(csv_content))
            self.request.response.setHeader('Last-Modified',
                                            DateTime.rfc822(DateTime()))
            self.request.response.setHeader("Cache-Control", "no-store")
            self.request.response.setHeader("Pragma", "no-cache")
            self.request.response.write(csv_content)
        else:
            msg = _('No activities exist')
            IStatusMessage(self.request).addStatusMessage(msg,"info")

        # redirect to show the info message
        self.request.response.redirect(
                '/'.join(self.context.getPhysicalPath()))

        return csv_content

# 需要导入模块: from DateTime import DateTime [as 别名]
# 或者: from DateTime.DateTime import rfc822 [as 别名]
    def __call__(self):
        """ Return csv content as http response or return info IStatusMessage
        """

        csv_content = self.logged_requests_csv()

        if csv_content is not None:
            now = DateTime()
            nice_filename = '%s_%s' % ('requestlog_', now.strftime('%Y%m%d'))

            self.request.response.setHeader("Content-Disposition",
                                            "attachment; filename=%s.csv" % 
                                             nice_filename)
            self.request.response.setHeader("Content-Type", "text/csv")
            self.request.response.setHeader("Content-Length", len(csv_content))
            self.request.response.setHeader('Last-Modified',
                                            DateTime.rfc822(DateTime()))
            self.request.response.setHeader("Cache-Control", "no-store")
            self.request.response.setHeader("Pragma", "no-cache")
            self.request.response.write(csv_content)
        else:
            msg = _('No log entries exist')
            IStatusMessage(self.request).addStatusMessage(msg,"info")

        return csv_content

# 需要导入模块: from DateTime import DateTime [as 别名]
# 或者: from DateTime.DateTime import rfc822 [as 别名]
    def _handlePost(self, REQUEST=None):
        regs = [self.context.registrations[a]
                    for a in REQUEST.form
                     if a != 'submit' \
                        and a[:4] != 'cert' \
                        and REQUEST.form[a] == 'on']

        certinfo = {}
        for key in ['certtitle', 'certsubtitle', 'certprenamedesc',
                    'certpostnamedesc', 'certawardtitle', 'certdate',
                    'certsigdesc', 'certborder']:
            if key not in REQUEST.form or REQUEST.form[key] == None:
                certinfo[key] = ''
            else:
                certinfo[key] = REQUEST.form[key]

        urltool = getToolByName(self.context, 'portal_url')
        portal = urltool.getPortalObject()
        portal_url = portal.absolute_url()

        pdf = generateCertificate(regs,
                                  portal_url,
                                  True,
                                  context=self.context,
                                  **certinfo)

        REQUEST.response.setHeader('Content-Disposition',
                                   'attachment; filename=%s' % pdf['filename'])
        REQUEST.response.setHeader('Content-Type', 'application/pdf')
        REQUEST.response.setHeader('Content-Length', len(pdf['file']))
        REQUEST.response.setHeader('Last-Modified',
                                   DateTime.rfc822(DateTime()))
        REQUEST.response.setHeader('Cache-Control', 'no-store')
        REQUEST.response.setHeader('Pragma', 'no-cache')
        REQUEST.response.write(pdf['file'])

# 需要导入模块: from DateTime import DateTime [as 别名]
# 或者: from DateTime.DateTime import rfc822 [as 别名]
    def __call__(self):
        """ Post the zipfile to the remote url as set up in the configlet.
        """

        zip_data = self.zip_csv()
        
        # get settings
        registry = getUtility(IRegistry)
        settings = registry.forInterface(ITARMIIRemoteServerSettings)

        # make sure that a server has been specified
        if settings.server_url != None:
            parts = urlparse.urlparse(settings.server_url)
        else:
            msg = _('Upload Server not specified in settings')
            IStatusMessage(self.request).addStatusMessage(msg,"error")
            # redirect to show the error message
            return self.request.response.redirect(
                   '/'.join(self.context.getPhysicalPath()))

        # send zip data to server
        h = httplib.HTTP(parts.netloc) # ignore leading '//'
        h.putrequest('POST', parts.path)
        now = DateTime()
        body = '\r\n' + zip_data

        memberid = os.environ['TEACHERDATA_USER']
        passwd = os.environ['TEACHERDATA_PASS']
        authstr = "%s:%s" % (memberid, passwd)

        nice_filename = '%s_%s' % ('tarmii_logs_', now.strftime('%Y%m%d'))
        h.putheader('Authorization', 'Basic ' + base64.b64encode(authstr))
        h.putheader("Content-Disposition", "attachment; filename=%s.zip" %
                                            nice_filename)
        h.putheader('Content-Type', 'application/octet-stream')
        h.putheader('Content-Length', str(len(body)))
        h.putheader('Last-Modified', DateTime.rfc822(DateTime()))
        h.endheaders()

        h.send(body)
        errcode, errmsg, headers = h.getreply()

        if errcode == 200:
            # if upload successful, set date in registry
            dt = DateTime().asdatetime().replace(tzinfo=None)
            settings.last_successful_upload = \
                datetime(dt.year, dt.month, dt.day, dt.hour, dt.minute)
            msg = str(errcode) + ' : ' +_('File sent to server')
            IStatusMessage(self.request).addStatusMessage(msg,"info")
        else:
            msg = str(errcode) + ' : ' + _('File not sent successfully')
            IStatusMessage(self.request).addStatusMessage(msg,"error")
            log = logging.getLogger('tarmii.theme.uploadtoserver')
            log.error(msg)

        # redirect to show the error message
        return self.request.response.redirect(
               '/'.join(self.context.getPhysicalPath()))

# 需要导入模块: from DateTime import DateTime [as 别名]
# 或者: from DateTime.DateTime import rfc822 [as 别名]
    def __call__(self):
        """ Export all learners from a classlist into a CSV file, do nothing if 
            the class is empty.
        """

        csv_content = None
        # It is safe to do this at the moment, because the view is bound
        # to IClasslist.
        contentFilter = {'portal_type': 'upfront.classlist.content.learner'}
        contentFilter['sort_on'] = "id"
        contentFilter['sort_order'] = "ascending"
        learners = self.context.getFolderContents(contentFilter,
                                                  full_objects=True)
        learner_csv = StringIO()

        if learners is not None and len(learners) > 0:
            writer = csv.DictWriter(learner_csv,
                                fieldnames=['code', 'name', 'gender',
                                            'language'],
                                restval='',
                                extrasaction='ignore',
                                dialect='excel',
                                quoting=csv.QUOTE_ALL
                               )

            for learner in learners:
                ldict={'code': learner.id,
                       'name': learner.name,
                       'gender': learner.gender,
                       'language': learner.home_language.to_object.title, 
                      }
                writer.writerow(ldict)
            
            csv_content = learner_csv.getvalue()
            learner_csv.close()

            now = DateTime()
            nice_filename = 'classlist-%s' % self.context.title

            self.request.response.setHeader("Content-Disposition",
                                            "attachment; filename=%s.xls" % 
                                             nice_filename)
            self.request.response.setHeader("Content-Type", "text/csv")
            self.request.response.setHeader("Content-Length", len(csv_content))
            self.request.response.setHeader('Last-Modified',
                                            DateTime.rfc822(DateTime()))
            self.request.response.setHeader("Cache-Control", "no-store")
            self.request.response.setHeader("Pragma", "no-cache")

            self.request.response.write(csv_content)
        else:
            msg = _('The classlist has no learners')
            IStatusMessage(self.request).addStatusMessage(msg,"info")

        self.request.response.redirect(
                '/'.join(self.context.getPhysicalPath()))

        return csv_content

# 需要导入模块: from DateTime import DateTime [as 别名]
# 或者: from DateTime.DateTime import rfc822 [as 别名]
    def dictFromBrain(self, brain, args):
        eventsFilter = queryAdapter( self.context, ISolgemaFullcalendarEditableFilter )
        editpaths = eventsFilter.filterEvents(args)
        member = self.context.portal_membership.getAuthenticatedMember()
        memberid = member.id

        #Scheduler changes
        if brain.getObject().portal_type == "collective.dexterity.appointments.timeslot" or brain.getObject().portal_type == "collective.dexterity.appointments.person":
            start = DateTime(brain.getObject().start)
            end = DateTime(brain.getObject().end)
        else:
            start = brain.start
            end = brain.end

        #End Scheduler changes

        if memberid in brain.Creator:
            editable = True
        else:
            editable = False
        if brain.getURL() in editpaths:
            editable = True
        else:
            editable = False
        if end - start > 1.0:
            allday = True
        else:
            allday = False
        if getattr(brain, 'SFAllDay', None) in [False,True]:
            allday = brain.SFAllDay
        copycut = ''
        if self.copyDict and brain.getPath() == self.copyDict['url']:
            copycut = self.copyDict['op'] == 1 and ' event_cutted' or ' event_copied'
        typeClass = ' type-'+brain.portal_type
        colorIndex = getColorIndex(self.context, self.request, brain=brain)
        extraClass = self.getExtraClass(brain)
        return {"id": "UID_%s" % (brain.UID), 
                "title": brain.Title, 
                "description": brain.Description,
                "start": start.rfc822(),
                "end": end.rfc822(),
                "url": brain.getURL(),
                "editable": editable,
                "allDay": allday, 
                "className": "contextualContentMenuEnabled state-" + str(brain.review_state) + (editable and " editable" or "")+copycut+typeClass+colorIndex+extraClass}

# 需要导入模块: from DateTime import DateTime [as 别名]
# 或者: from DateTime.DateTime import rfc822 [as 别名]
 def _saveSkippablePaths(self, paths):
     """ save the list to a cookie """
     assert isinstance(paths, list)
     value = '|'.join(paths)
     key = COOKIEKEY_SKIPPABLE_PATHS
     then = DateTime()+300
     then = then.rfc822()
     self.REQUEST.RESPONSE.setCookie(key, value, path='/',
                                     expires=then)

# 需要导入模块: from DateTime import DateTime [as 别名]
# 或者: from DateTime.DateTime import rfc822 [as 别名]
    def changesettings_web(self):
	""" take things from self.REQUEST """
	request = self.REQUEST
	
	# Check email
	email = request.get('email', self.getEmail()).strip()
	if not Utils.ValidEmailAddress(email):
	    m = "%s is not a valid email address"%email
	    raise "InvalidEmailAddress", m
	
	# Check dayskip
	dayskip = int(request.get('dayskip', self.getDayskip()))
	if dayskip < 1 or dayskip > 30:
	    m = "Dayskip must be between (and including) 1 and 30"
	    raise "InvalidDayskip", m
    
	# Check meta_types
	meta_types = request.get('meta_types', self.getMetatypes())
	if not same_type(meta_types, []):
	    meta_types = [meta_types]
	meta_types = [x.strip() for x in meta_types]
	possible_meta_types = self.aq_parent.getAllMetatypes()
	checked_meta_types = []
	for meta_type in meta_types:
	    if meta_type in possible_meta_types:
		checked_meta_types.append(meta_type)
	if not checked_meta_types:
	    m = "No recognized types selected"
	    raise "NoMetatypes", m
	
	# Check name
	name = request.get('name', self.getName()).strip()
	
	response = request.RESPONSE
	then = DateTime() + 300
	then = then.rfc822()
	
	if not request.get('__blogcomment_name','') and name:
	    response.setCookie('__blogcomment_name', name,
	                       path='/', expires=then)
			       
	# Now save the changes
	self.email = email
	self.dayskip = dayskip
	self.meta_types = meta_types
	self.name = name
	    
	return self.change_settings_set(self, request)

# 需要导入模块: from DateTime import DateTime [as 别名]
# 或者: from DateTime.DateTime import rfc822 [as 别名]
    def test__call__(self):

        # prepare the zip contents
        # users csv will exist because there is one user in the system
        users = self.portal.restrictedTraverse("@@export-user-profiles")
        # zip data
        in_memory_zip = StringIO()
        zf = zipfile.ZipFile(in_memory_zip, mode="w")
        zf.writestr("users.csv", users.user_profiles_csv())
        zf.close()
        in_memory_zip.seek(0)
        test_zip_data = in_memory_zip.read()

        view = self.portal.restrictedTraverse("@@download-teacher-data")
        self.request.RESPONSE.stdout = StringIO()
        view()
        self.request.RESPONSE.stdout.seek(0)

        now = DateTime()
        filename = "%s_%s" % ("tarmii_logs_", now.strftime("%Y%m%d"))
        date_time = DateTime.rfc822(DateTime())

        csv_ref = (
            "Status: 200 OK\r\n"
            + "X-Powered-By: Zope (www.zope.org), "
            + "Python (www.python.org)\r\n"
            + "Content-Length: 161\r\n"
            + "Content-Disposition: attachment; filename="
            + filename
            + ".zip\r\n"
            + "Last-Modified: "
            + date_time
            + "\r\n"
            + "Pragma: no-cache\r\n"
            + "Cache-Control: no-store\r\n"
            + "Content-Type: application/octet-stream\r\n"
            + "\r\n"
            + test_zip_data
        )

        self.request.RESPONSE.stdout.seek(0)
        self.assertEqual(self.request.RESPONSE.stdout.read(), csv_ref)
        print "done"

# 需要导入模块: from DateTime import DateTime [as 别名]
# 或者: from DateTime.DateTime import rfc822 [as 别名]
class OptOutDashboardView(BrowserView):
    """Personal dashboard for opt-out preferences"""
    
    def __init__(self, context, request):
        self.context = context
        self.request = request
        self.general_cookie_consent = None
        self.nextYear = DateTime() + 365
        request.set('disable_border', True)

    def __call__(self, *args, **kwargs):
        if 'form.submitted' in self.request.form:
            self._save_changes()
            IStatusMessage(self.request).addStatusMessage(_(u"Changes saved"), "info")
            self.request.response.redirect("%s/@@%s" % (self.context.absolute_url(),
                                                        self.__name__),)
        return self.index()

    def _save_changes(self):
        request = self.request
        form = request.form
        if not form.get('accept_cookies'):
            # Cookie policy rejected: set all of the opt-out cookies
            optout_all(request, 'true', update=True)
            self.setOneYearCookie(config.COOKIECONSENT_NAME, 'false')
            return
        # Cookies consent given: let's save also opt-out cookies
        self.setOneYearCookie(config.COOKIECONSENT_NAME, 'true')
        for optout in self.settings().optout_configuration:
            value = 'true' if form.get('app_%s' % optout.app_id)=='true' else 'false'
            for cookie in optout.cookies:
                self.setOneYearCookie("%s-optout" % cookie, value)

    def setOneYearCookie(self, name, value):
        setCookie(self.request.response, name, value, expires=self.nextYear.rfc822())

    def _i18n_alternative(self, app_id, id):
        oo_i18n_id = u"%s_optout_%s" % (app_id, id)
        oo_item = translate(_(oo_i18n_id), context=self.request)
        if unicode(oo_item)==oo_i18n_id:
            return app_id
        return oo_item

    @memoize
    def settings(self):
        registry = queryUtility(IRegistry)
        return registry.forInterface(ICookieConsentSettings, check=False)

    def optouts(self):
        settings = self.settings()
        request = self.request
        cookies = request.cookies
        portal_state = getMultiAdapter((self.context, request), name=u'plone_portal_state')
        current_language = portal_state.language()
        self.general_cookie_consent = cookies.get(config.COOKIECONSENT_NAME, False)=='true'

        results = []
        for oo_conf in settings.optout_configuration:
            optout = {}
            optout['id'] = oo_conf.app_id

            # i18n
            if len(oo_conf.texts)==0:
                optout['title'] = self._i18n_alternative(oo_conf.app_id, u'title')
                optout['description'] = self._i18n_alternative(oo_conf.app_id, u'description')
            else:
                for i, app_text_content in enumerate(oo_conf.texts):
                    if current_language==app_text_content.lang:
                        optout['title'] = app_text_content.app_title if app_text_content.app_title else self._i18n_alternative(oo_conf.app_id, u'title')
                        raw_i18n_desc = app_text_content.app_description if app_text_content.app_description else self._i18n_alternative(oo_conf.app_id, u'description')
                        optout['description'] = '<br />'.join(raw_i18n_desc.strip().splitlines())
                        break
                else:
                    # no lang found: use the first one as default
                    default_conf = oo_conf.texts[0]
                    optout['title'] = default_conf.app_title if default_conf.app_title else self._i18n_alternative(oo_conf.app_id, u'title')
                    raw_i18n_desc = default_conf.app_description if default_conf.app_description else self._i18n_alternative(oo_conf.app_id, u'description')
                    optout['description'] = '<br />'.join(raw_i18n_desc.strip().splitlines())

            # check cookies: to enable the radio as "deny" we care about at least of one cookie
            negative_cookies = [c for c in oo_conf.cookies \
                    if not cookies.get("%s-optout" % c, None) or cookies["%s-optout" % c]=='false']
            optout['cookie'] = False if negative_cookies else True
            results.append(optout)
        return results