def _data(self):
        # facultiesList = faculties(None).by_value.keys()
        news = []
        news_filtered = []
        context = aq_inner(self.context)
        portal_state = getMultiAdapter((context, self.request), name='plone_portal_state')
        path = portal_state.navigation_root_path()
        limit = self.data.count
        state = self.data.state

        portal = getSite()
        current_user = api.user.get_current()
        userid = current_user.id

        soup_tags = get_soup('user_subscribed_tags', portal)
        tags_soup = [r for r in soup_tags.query(Eq('id', userid))]
        if tags_soup:
            tags = tags_soup[0].attrs['tags']
            news += self.get_news(context, state, path, limit, tags)
            for newObject in news:
                if newObject not in news_filtered and newObject['subject'] is not ():
                    news_filtered.append(newObject)

            newsSorted = sorted(news_filtered, key=lambda new: new['date'], reverse=True)
            return newsSorted
        else:
            return []

def get_safe_member_by_id(username):
    """Gets user info from the repoze.catalog based user properties catalog.
       This is a safe implementation for getMemberById portal_membership to
       avoid useless searches to the LDAP server. It gets only exact matches (as
       the original does) and returns a dict. It DOES NOT return a Member
       object.
    """
    portal = api.portal.get()
    soup = get_soup('user_properties', portal)
    username = username.lower()
    records = [r for r in soup.query(Eq('id', username))]
    if records:
        properties = {}
        for attr in records[0].attrs:
            if records[0].attrs.get(attr, False):
                properties[attr] = records[0].attrs[attr]

        # Make sure that the key 'fullname' is returned anyway for it's used in
        # the wild without guards
        if 'fullname' not in properties:
            properties['fullname'] = ''

        return properties
    else:
        # No such member: removed?  We return something useful anyway.
        return {'username': username, 'description': '', 'language': '',
                'home_page': '', 'name_or_id': username, 'location': '',
                'fullname': ''}

    def test_group_sync(self):
        sync_view = getMultiAdapter((self.portal, self.request), name='syncldapgroups')
        sync_view.render()

        soup = get_soup('ldap_groups', self.portal)

        self.assertTrue(len(soup.data.keys()) > 0)

    def render(self):
        portal = getSite()
        current_user = api.user.get_current()
        userid = current_user.id
        tag = self.request.form['tag']
        soup_tags = get_soup('user_subscribed_tags', portal)
        exist = [r for r in soup_tags.query(Eq('id', userid))]

        if not exist:
            record = Record()
            record.attrs['id'] = userid
            record.attrs['tags'] = [tag]
            soup_tags.add(record)
        else:
            subscribed = [True for utag in exist[0].attrs['tags'] if utag == tag]
            if subscribed:
                exist[0].attrs['tags'].remove(tag)
            else:
                exist[0].attrs['tags'].append(tag)
        soup_tags.reindex()

        if IPloneSiteRoot.providedBy(self.context):
            self.request.response.redirect(self.context.absolute_url() + '/alltags')
        else:
            self.request.response.redirect(self.context.absolute_url())

    def __call__(self):
        soup = get_soup(self.soup_name, self.context)
        aaData = list()
        length, lazydata = self.query(soup)
        columns = self.columns
        colnames = [_['id'] for _ in columns]
        # todo json response header einbaun

        def record2list(record):
            result = list()
            for colname in colnames:
                coldef = self.column_def(colname)
                renderer = coldef.get('renderer')
                if renderer:
                    value = renderer(colname, record)
                else:
                    value = record.attrs.get(colname, '')
                result.append(value)
            return result
        for lazyrecord in self.slice(lazydata):
            aaData.append(record2list(lazyrecord()))
        data = {
            "sEcho": int(self.request.form['sEcho']),
            "iTotalRecords": soup.storage.length.value,
            "iTotalDisplayRecords": length,
            "aaData": aaData,
        }
        self.request.response.setHeader("Content-type", "application/json")
        return json.dumps(data)

 def initialize(self):
     """ setup the storage
     """
     alsoProvides(self.root, ISoupRoot)
     locator = StorageLocator(self.root)
     locator.storage(self.id)
     self._soup = get_soup(self.id, self.root)

def do_transition_for_booking(booking, transition, order_data, event=False):
    """do any transition for a given single booking

    this mixes main state and salaried!
    """
    # XXX: currently we need to delete attribute before setting to a new
    #      value in order to persist change. fix in appropriate place.
    if transition == interfaces.SALARIED_TRANSITION_SALARIED:
        del booking.attrs['salaried']
        booking.attrs['salaried'] = interfaces.SALARIED_YES
    elif transition == interfaces.SALARIED_TRANSITION_OUTSTANDING:
        del booking.attrs['salaried']
        booking.attrs['salaried'] = interfaces.SALARIED_NO
    elif transition == interfaces.STATE_TRANSITION_RENEW:
        del booking.attrs['state']
        booking.attrs['state'] = interfaces.STATE_NEW
        # fix stock item available
        order_data.decrease_stock([booking])
    elif transition == interfaces.STATE_TRANSITION_PROCESS:
        del booking.attrs['state']
        booking.attrs['state'] = interfaces.STATE_PROCESSING
    elif transition == interfaces.STATE_TRANSITION_FINISH:
        del booking.attrs['state']
        booking.attrs['state'] = interfaces.STATE_FINISHED
    elif transition == interfaces.STATE_TRANSITION_CANCEL:
        del booking.attrs['state']
        booking.attrs['state'] = interfaces.STATE_CANCELLED
        # fix stock item available
        order_data.increase_stock([booking])
    else:
        raise ValueError(u"invalid transition: %s" % transition)
    bookings_soup = get_soup('bda_plone_orders_bookings', order_data.context)
    bookings_soup.reindex(records=[booking])

 def rebuild_soup(self):
     sid = self.request.form.get("id")
     if not sid:
         return self.redirect_base("No soup id given")
     soup = get_soup(sid, self.context)
     soup.rebuild()
     msg = "%s rebuilt." % sid
     return self.redirect_base(msg)

 def clear_soup(self):
     sid = self.request.form.get('id')
     if not sid:
         return self.redirect_base('No soup id given!') 
     soup = get_soup(sid, self.context)
     soup.clear()
     msg = '%s cleared.' % sid
     return self.redirect_base(msg)

 def rebuild_length(self):
     sid = self.request.form.get("id")
     if not sid:
         return self.redirect_base("No soup id given")
     soup = get_soup(sid, self.context)
     newlen = len(soup.storage.data)
     soup.storage.length.set(newlen)
     transaction.commit()
     return self.redirect_base(u"Length of storage %s is %s" % (sid, newlen))

    def getMyTags(self):
        portal = getSite()
        current_user = api.user.get_current()
        userid = current_user.id

        soup_tags = get_soup('user_subscribed_tags', portal)
        tags_soup = [r for r in soup_tags.query(Eq('id', userid))]

        return tags_soup[0].attrs['tags'] if tags_soup else []

def remove_user_from_catalog(username):
    portal = api.portal.get()
    soup = get_soup('user_properties', portal)
    exists = [r for r in soup.query(Eq('id', username))]
    if exists:
        user_record = exists[0]
        del soup[user_record]

    if IAMULEARN:
        extender_name = api.portal.get_registry_record('genweb.controlpanel.core.IGenwebCoreControlPanelSettings.user_properties_extender')
        # Make sure that, in fact we have such a extender in place
        if extender_name in [a[0] for a in getUtilitiesFor(ICatalogFactory)]:
            extended_soup = get_soup(extender_name, portal)
            exist = []
            exist = [r for r in extended_soup.query(Eq('id', username))]
            if exist:
                extended_user_record = exist[0]
                del extended_soup[extended_user_record]

    def test_delete_community(self):
        login(self.portal, 'ulearn.testuser1')
        community = self.create_test_community()
        gwuuid = IGWUUID(community).get()
        api.content.delete(obj=community)

        soup = get_soup('communities_acl', self.portal)
        records = [r for r in soup.query(Eq('gwuuid', gwuuid))]

        self.assertFalse(records)

    def get_editacl(self, community):
        # The user has role Manager

        gwuuid = community.gwuuid
        portal = api.portal.get()
        soup = get_soup('communities_acl', portal)

        records = [r for r in soup.query(Eq('gwuuid', gwuuid))]
        editacl = dict(users=records[0].attrs['acl'].get('users', ''),
                       groups=records[0].attrs['acl'].get('groups', ''))
        return editacl

    def render(self):
        query = self.request.form.get('q', '')
        if query:
            portal = api.portal.get()
            soup = get_soup('ldap_groups', portal)
            normalized_query = query.replace('.', ' ') + '*'

            results = [dict(id=r.attrs.get('id')) for r in soup.query(Eq('searchable_id', normalized_query))]
            return json.dumps(dict(results=results))
        else:
            return json.dumps(dict(id='No results yet.'))

    def test_community_creation_closed(self):
        nom = u'community-test'
        description = 'Blabla'
        image = None
        community_type = 'Closed'
        twitter_hashtag = 'helou'

        login(self.portal, 'ulearn.testuser1')

        self.portal.invokeFactory('ulearn.community', 'community-test',
                                 title=nom,
                                 description=description,
                                 image=image,
                                 community_type=community_type,
                                 twitter_hashtag=twitter_hashtag)

        community = self.portal['community-test']

        logout()

        # Test for the acl registry
        soup = get_soup('communities_acl', self.portal)
        # By the gwuuid
        records = [r for r in soup.query(Eq('gwuuid', IGWUUID(community).get()))]
        self.assertEqual(len(records), 1)
        self.assertEqual(records[0].attrs.get('gwuuid', ''), IGWUUID(community).get())
        self.assertEqual(records[0].attrs.get('path', ''), '/'.join(community.getPhysicalPath()))
        self.assertEqual(records[0].attrs.get('hash', ''), sha1(community.absolute_url()).hexdigest())
        self.assertEqual(records[0].attrs.get('acl', '').get('users', [])[0]['role'], u'owner')
        self.assertEqual(records[0].attrs.get('acl', '').get('users', [])[0]['id'], u'ulearn.testuser1')

        # Test for internal objects
        self.assertEqual(community.objectIds(), ['documents', 'events', 'discussion'])

        # Test for photo folder
        self.assertEqual(community['documents'].objectIds(), ['media', ])

        # Test for subscribed users
        self.assertTrue(u'ulearn.testuser1' in self.get_max_subscribed_users(community))

        # Test for Plone permissions/local roles
        self.assertTrue('Reader' not in community.get_local_roles_for_userid(userid='AuthenticatedUsers'))
        self.assertTrue('Editor' in community.get_local_roles_for_userid(userid='ulearn.testuser1'))
        self.assertTrue('Owner' in community.get_local_roles_for_userid(userid='ulearn.testuser1'))
        self.assertTrue('Reader' in community.get_local_roles_for_userid(userid='ulearn.testuser1'))

        # Test the initial MAX properties
        max_community_info = self.get_max_context_info(community)
        self.assertEqual('helou', max_community_info.get(u'twitterHashtag', ''))
        self.assertFalse(max_community_info.get(u'notifications', False))
        self.assertTrue(u'[COMMUNITY]' in max_community_info.get('tags', []))

        for key in CLOSED_PERMISSIONS:
            self.assertEqual(max_community_info['permissions'].get(key, ''), CLOSED_PERMISSIONS[key])

    def isTagFollowed(self, category):
        portal = getSite()
        current_user = api.user.get_current()
        userid = current_user.id

        soup_tags = get_soup('user_subscribed_tags', portal)
        tags_soup = [r for r in soup_tags.query(Eq('id', userid))]
        if tags_soup:
            tags = tags_soup[0].attrs['tags']
            return True if category in tags else False
        else:
            return False

    def is_community_manager(self, community):
        # The user has role Manager
        if self.is_role_manager:
            return True

        gwuuid = community.gwuuid
        portal = api.portal.get()
        soup = get_soup('communities_acl', portal)

        records = [r for r in soup.query(Eq('gwuuid', gwuuid))]
        if records:
            return self.username in [a['id'] for a in records[0].attrs['acl']['users'] if a['role'] == u'owner']

        def get_data_acces_community_user():
            """ Returns the date of user access to the community.
            """
            user_community = user + '_' + community.id
            portal = api.portal.get()

            soup_access = get_soup('user_community_access', portal)
            exist = [r for r in soup_access.query(Eq('user_community', user_community))]
            if not exist:
                return DateTime()
            else:
                return exist[0].attrs['data_access']

    def render(self):
        portal = api.portal.get()
        soup = get_soup('uuid_preserver', portal)
        pc = api.portal.get_tool('portal_catalog')
        results = pc.searchResults()

        for result in results:
            record = Record()
            record.attrs['uuid'] = result.UID
            record.attrs['path'] = result.getPath()
            soup.add(record)
            logger.warning('Preserving {}: {}'.format(result.getPath(), result.UID))