def test_add_first(self): from collective.bookmarks.storage import Bookmarks from repoze.catalog.query import Eq import math import time import uuid bookmarks = Bookmarks() data = { "owner": "kim stanley", "uid": uuid.uuid4(), "group": "", "payload": {}, "created": math.floor(time.time()), } result = bookmarks.add(data["owner"], data["uid"], data["group"], data["payload"]) self.assertIsNotNone(result) record = bookmarks._fetch_one( Eq("owner", data["owner"]) & Eq("uid", data["uid"]) & Eq("group", data["group"])) self.assertIn("created", record.attrs) record.attrs["created"] = data["created"] self.assertEqual(data, bookmarks._dictify(record))
def test_fetch_one_too_many(self): from collective.bookmarks.storage import Bookmarks from repoze.catalog.query import Eq from souper.soup import Record import uuid bookmarks = Bookmarks() data = {"owner": "kim stanley", "uid": uuid.uuid4(), "group": ""} record1 = Record() record1.attrs["owner"] = data["owner"] record1.attrs["uid"] = data["uid"] record1.attrs["group"] = data["group"] record2 = Record() record2.attrs["owner"] = data["owner"] record2.attrs["uid"] = data["uid"] record2.attrs["group"] = data["group"] bookmarks._soup.add(record1) bookmarks._soup.add(record2) with self.assertRaises(ValueError): bookmarks._fetch_one( Eq("owner", data["owner"]) & Eq("uid", data["uid"]) & Eq("group", data["group"]))
def test_update_existing(self): from collective.bookmarks.storage import Bookmarks from repoze.catalog.query import Eq import uuid bookmarks = Bookmarks() data = { "owner": "kim stanley", "uid": uuid.uuid4(), "group": "", "payload": {} } bookmarks.add(data["owner"], data["uid"], data["group"], data["payload"]) new_payload = {"foo": "bar"} result = bookmarks.update(data["owner"], data["uid"], data["group"], new_payload) self.assertIsNotNone(result) record = bookmarks._fetch_one( Eq("owner", data["owner"]) & Eq("uid", data["uid"]) & Eq("group", data["group"])) self.assertEqual(record.attrs["payload"], new_payload)
def parse_query(query): result = [] for name, value in query.items(): if name in ('Type', 'portal_type'): new_value = [] if type(value) not in (list, tuple): value = [value] for v in value: if v in _type_name_mapping: new_value.append(_type_name_mapping[v]) value = new_value if IImage in value: result.append(Any('mimetype', _image_mimetypes)) query = Any('interfaces', value) elif name == 'path': split = value.split('::') if len(split) == 2: path = split[0] depth = split[1] else: path = value depth = 1 query = Eq(name, { 'query': path, 'depth': int(depth) }) elif name in _index_mapping: name = _index_mapping[name] query = Eq(name, value) else: query = Eq(name, value) result.append(query) return result
def add(self, owner: str, uid: uuid.UUID, group: str, queryparams: str, payload: dict) -> typing.Union[int, None]: """add new entry. uniqueness is given by triple of owner, uid, group and queryparams. returns None if such a triple already exists returns record_id if successful added """ # check existing if (self._fetch_one( Eq("owner", owner) & Eq("uid", uid) & Eq("group", group) & Eq("queryparams", queryparams)) is not None): return None record = Record() record.attrs["owner"] = owner record.attrs["uid"] = uid record.attrs["group"] = group record.attrs["queryparams"] = queryparams record.attrs["payload"] = payload record.attrs["created"] = json_compatible(datetime.utcnow()) if self._soup.add(record): return self._dictify(record)
def agenda_data_json(context, request): if not request.is_participant: return {} query = Eq('path', resource_path(context)) & Eq('type_name', 'AgendaItem') # Sanitize to avoid exceptions? state = request.POST.get('state') if state not in _OPEN_STATES and not request.is_moderator: raise HTTPForbidden('State query not allowed') tag = request.session.get('voteit.ai_selected_tag', '') if tag and tag in request.meeting.tags: query &= Any('tags', [tag.lower()]) results = [] hide_type_count = request.session.get('voteit.agenda.hide_type_count', False) if state: query &= Eq('workflow_state', state) count, docids = request.root.catalog.query(query) for ai in request.resolve_docids(docids, perm=None): ai_res = {'title': ai.title, 'name': ai.__name__} if not hide_type_count: ai_res['contents'] = count_types(request, ai) if state is None: ai_res['state'] = ai.get_workflow_state() results.append(ai_res) return {'ais': results, 'hide_type_count': hide_type_count}
def day_entries(request, context, day=None, userid=_marker): """ :param request: :param context: Fetch everything within this contexts path (may be root) :param group: Group entries together within tasks :param day: Limit within this day :type day: date :param userid: User to fetch for. None means all :return: OrderedDict with Task uid as key and time entry objects in a list as value. """ if userid == _marker: userid = request.authenticated_userid #FIXME: Fetch exactly one day and all entries for that day. Sort according to Tasks #min_created = utcnow() - timedelta(days=days) query = Eq('path', resource_path(context)) &\ Eq('type_name', 'TimeEntry') # Gt('created', timegm(min_created.timetuple())) if userid: query &= Any('creator', [userid]) docids = request.root.catalog.query(query, sort_index='created', reverse=True)[1] results = OrderedDict() for obj in request.resolve_docids(docids): items = results.setdefault(obj.__parent__.uid, []) items.append(obj) return results
def report(self): unbilled_time_query = Eq('type_name', 'TimeEntry') & Eq( 'path', resource_path(self.context)) unbilled_count, unbilled_time_entries = self.request.root.catalog.query( unbilled_time_query) total_time = timedelta() for time_entry in self.request.resolve_docids(unbilled_time_entries): total_time += time_entry.timedelta return {'total_time': total_time}
def guard_proposals_that_are_part_of_a_poll(request, context): query = Eq('path', resource_path(request.agenda_item)) & Eq( 'type_name', 'Poll') docids = request.root.catalog.query(query)[1] found = [] for poll in request.resolve_docids(docids, perm=None): if context.uid in poll.proposals: found.append(poll) return found
def count_tags(self, context, request, base_tag, num): results = {} query = Eq('path', resource_path(context)) & Eq('type_name', 'Proposal') query &= NotAny('workflow_state', ['retracted', 'unhandled']) cquery = request.root.catalog.query for i in range(1, num+1): tag = "%s-%s" % (base_tag, i) res = cquery(query & Any('tags', [tag]))[0] results[tag] = res.total return results
def polls_menu(context, request, va, **kw): api = kw['api'] if api.meeting is None: return '' query = Eq('content_type', 'Poll' ) & Eq('path', resource_path(api.meeting)) & Eq('workflow_state', 'ongoing') response = {} response['api'] = api response['menu_title'] = va.title response['open_polls'] = bool(api.root.catalog.query(query)[0]) response['url'] = request.resource_url(api.meeting, 'meeting_poll_menu') return render('templates/polls/polls_menu.pt', response, request = request)
def test_fetch_one_non_existing(self): from collective.bookmarks.storage import Bookmarks from repoze.catalog.query import Eq import uuid bookmarks = Bookmarks() result = bookmarks._fetch_one( Eq("owner", "harry") & Eq("uid", uuid.uuid4()) & Eq("group", "cool stuff")) self.assertIs(result, None)
def test_directory_self_updates_on_user_creation(self): api.user.create(email='*****@*****.**', username='******', properties=dict(fullname='Test Directory User', location='Barcelona', ubicacio='NX', telefon='44002, 54390')) portal = api.portal.get() soup = get_soup('user_properties', portal) exist = [r for r in soup.query(Eq('username', 'testdirectory'))] self.assertEqual('44002, 54390', exist[0].attrs['telefon']) exist = [r for r in soup.query(Eq('fullname', 'Test*'))] self.assertEqual(u'Test Directory User', exist[0].attrs['fullname'])
def find_tos(self, filter_agreed=True): query = Eq("type_name", "TOS") & Eq("wf_state", "enabled") docids = self.request.root.catalog.query(query)[1] for tos in self.request.resolve_docids(docids, perm=None): # The language aspect if tos.lang and tos.lang != self.request.localizer.locale_name: continue if filter_agreed: if tos.uid not in self.agreed_tos: yield tos else: yield tos
def test_directory_self_updates_on_user_creation_with_unicode(self): api.user.create(email='*****@*****.**', username='******', properties=dict(fullname=u'Víctor', location=u'Barcelona', email=u'*****@*****.**')) portal = api.portal.get() soup = get_soup('user_properties', portal) exist = [r for r in soup.query(Eq('username', 'testdirectory'))] self.assertEqual('*****@*****.**', exist[0].attrs['email']) exist = [r for r in soup.query(Eq('fullname', u'Ví*'))] self.assertEqual(u'Víctor', exist[0].attrs['fullname'])
def check_ongoing_poll(context): """ Check if a poll is ongoing, return number of ongoing polls """ meeting = find_interface(context, IMeeting) assert IMeeting.providedBy(meeting) root = find_root(meeting) query = ( Eq("type_name", "Poll") & Eq("path", resource_path(meeting)) & Eq("workflow_state", "ongoing") ) res = root.catalog.query(query)[0] return res.total
def by_owner( self, owner: str, group: typing.Union[str, None] = None) -> typing.Iterator[dict]: """get all bookmarks of an owner, optional filtered by group return dictified data """ query = Eq("owner", owner) if group is not None: query &= Eq("group", group) for lazy_record in self._soup.lazy(query): yield self._dictify(lazy_record())
def motion_states_checkbox_widget(node, kw): request = kw["request"] context = kw["context"] wfs = get_workflows(request.registry) motion_workflow = wfs["motion_workflow"] values = [] query = Eq("path", resource_path(context)) & Eq("type_name", "Motion") for (state, title) in motion_workflow.states.items(): title = request.localizer.translate(title) title += ( " (%s)" % request.root.catalog.query(query & Eq("wf_state", state))[0].total ) values.append((state, title)) return deform.widget.CheckboxChoiceWidget(values=values)
def query(self, soup): soup.reindex() # fetch user vendor uids vendor_uids = get_vendor_uids_for() # filter by given vendor uid or user vendor uids vendor_uid = self.request.form.get('vendor') if vendor_uid: vendor_uid = uuid.UUID(vendor_uid) # raise if given vendor uid not in user vendor uids if vendor_uid not in vendor_uids: raise Unauthorized query = Any('vendor_uid', [vendor_uid]) else: query = Any('vendor_uid', vendor_uids) # filter by customer if given customer = self.request.form.get('customer') if customer: query = query & Eq('creator', customer) # filter by search term if given term = self.request.form['sSearch'].decode('utf-8') if term: query = query & Contains(self.search_text_index, term) # Show only tickets that are paid query = query & Eq('salaried', 'yes') if not IPloneSiteRoot.providedBy(self.context): buyable_uids = self._get_buyables_in_context() query = query & Any('buyable_uids', buyable_uids) # query orders and return result sort = self.sort() try: res = soup.lazy(query, sort_index=sort['index'], reverse=sort['reverse'], with_size=True) length = res.next() except: length = 0 pass return length, res
def query(self, soup): # fetch user vendor uids vendor_uids = get_vendor_uids_for() # filter by given vendor uid or user vendor uids vendor_uid = self.request.form.get('vendor') if vendor_uid: vendor_uid = uuid.UUID(vendor_uid) # raise if given vendor uid not in user vendor uids if vendor_uid not in vendor_uids: raise Unauthorized query = Any('vendor_uids', [vendor_uid]) else: query = Any('vendor_uids', vendor_uids) # filter by customer if given customer = self.request.form.get('customer') if customer: query = query & Eq('creator', customer) # Filter by state if given state = self.request.form.get('state') if state: query = query & Eq('state', state) # Filter by salaried if given salaried = self.request.form.get('salaried') if salaried: query = query & Eq('salaried', salaried) # filter by search term if given term = self.request.form['sSearch'].decode('utf-8') if term: # append * for proper fulltext search term += '*' query = query & Contains(self.search_text_index, term) # get buyable uids for given context, get all buyables on site root # use explicit IPloneSiteRoot to make it play nice with lineage if not IPloneSiteRoot.providedBy(self.context): buyable_uids = self._get_buyables_in_context() query = query & Any('buyable_uids', buyable_uids) # query orders and return result sort = self.sort() res = soup.lazy(query, sort_index=sort['index'], reverse=sort['reverse'], with_size=True) length = res.next() return length, res
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 query2(self, soup): # fetch user vendor uids vendor_uids = get_vendor_uids_for() # filter by given vendor uid or user vendor uids vendor_uid = self.request.form.get('vendor') if vendor_uid: vendor_uid = uuid.UUID(vendor_uid) # raise if given vendor uid not in user vendor uids if vendor_uid not in vendor_uids: raise Unauthorized query = Any('vendor_uids', [vendor_uid]) else: query = Any('vendor_uids', vendor_uids) # filter by customer if given customer = self.request.form.get('customer') if customer: query = query & Eq('creator', customer) # filter by search term if given term = self.request.form['sSearch'].decode('utf-8') if term: query = query & Contains(self.search_text_index, term) # query orders and return result sort = self.sort() res = soup.lazy(query, sort_index=sort['index'], reverse=sort['reverse'], with_size=True) length = res.next() return length, res
def render(self): portal = getSite() current_user = api.user.get_current() userid = current_user.id search_items = self.request.form['items'] search_items = search_items.split(',') in_list = False soup_searches = get_soup('user_news_searches', portal) exist = [r for r in soup_searches.query(Eq('id', userid))] if exist: acl_record = exist[0] total_searches = acl_record.attrs['searches'] for search in exist[0].attrs['searches']: for i, item in enumerate(search_items): if item not in search: break if i == len(search_items) - 1: if len(search_items) < len(search): break else: in_list = True if in_list: total_searches.remove(search_items) acl_record.attrs['searches'] = total_searches soup_searches.reindex(records=[acl_record])
def evolve(root): from repoze.catalog.query import Any from repoze.catalog.query import Contains from repoze.catalog.query import Eq from pyramid.traversal import resource_path from voteit.core.models.catalog import reindex_object from voteit.core.models.catalog import resolve_catalog_docid print "Removing absolute urls in profile links" catalog = root.catalog host = None while not host: host = raw_input( "Enter a host to replace (ex http://127.0.0.1:6543): ") count, result = catalog.query(Eq('path', resource_path(root)) & \ Contains('searchable_text', 'class="inlineinfo"') & \ Any('content_type', ('DiscussionPost', 'Proposal', ))) catalog = root.catalog print "Processing %s objects" % count for docid in result: # get object obj = resolve_catalog_docid(catalog, root, docid) obj.title = obj.title.replace(host, '') reindex_object(catalog, obj)
def test_edit_acl(self): login(self.portal, 'ulearn.testuser1') community = self.create_test_community() acl = dict(users=[ dict(id=u'janet.dura', displayName=u'Janet Durà', role=u'writer'), dict(id=u'victor.fernandez', displayName=u'Víctor Fernández de Alba', role=u'reader') ], groups=[ dict(id=u'PAS', displayName=u'PAS UPC', role=u'writer'), dict(id=u'UPCnet', displayName=u'UPCnet', role=u'reader') ]) httpretty.enable() http_mock_hub_syncacl(acl, self.settings.hub_server) adapter = community.adapted() adapter.update_acl(acl) httpretty.disable() httpretty.reset() soup = get_soup('communities_acl', self.portal) records = [ r for r in soup.query(Eq('gwuuid', IGWUUID(community).get())) ] self.assertEqual(cmp(records[0].attrs['acl'], acl), 0)
def get_proposal_objects(self): """ Return proposal objects relevant to this poll. Will sort them in specified order. """ agenda_item = self.__parent__ if agenda_item is None: raise ValueError("Can't find any agenda item in the polls lineage") query = Any('uid', tuple(self.proposal_uids)) & Eq( 'type_name', 'Proposal') root = find_root(agenda_item) results = [] for docid in root.catalog.query(query)[1]: path = root.document_map.address_for_docid(docid) obj = find_resource(root, path) # Permission check shouldn't be needed at this point if obj: results.append(obj) if self.proposal_order: proposal_order = self.proposal_order else: meeting = find_interface(self, IMeeting) # During tests, we might not have a real meeting here :) proposal_order = getattr(meeting, 'poll_proposals_default_order', '') key_method = PROPOSAL_ORDER_KEY_METHODS.get( proposal_order, PROPOSAL_ORDER_KEY_METHODS[PROPOSAL_ORDER_DEFAULT]) return sorted(results, key=key_method)
def render(self): portal = getSite() current_user = api.user.get_current() userid = current_user.id search_items_string = self.request.form['items'] search_items = search_items_string.split(',') soup_searches = get_soup('user_news_searches', portal) exist = [r for r in soup_searches.query(Eq('id', userid))] if not exist: record = Record() record.attrs['id'] = userid record.attrs['searches'] = [search_items] record_id = soup_searches.add(record) acl_record = soup_searches.get(record_id) else: acl_record = exist[0] in_list = False total_searches = acl_record.attrs['searches'] if acl_record.attrs['searches']: for search in acl_record.attrs['searches']: for i, item in enumerate(search_items): if item not in search: break if i == len(search_items) - 1: if len(search_items) < len(search): break else: in_list = True if not in_list: total_searches.append(search_items) acl_record.attrs['searches'] = total_searches else: acl_record.attrs['searches'] = total_searches soup_searches.reindex(records=[acl_record])
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 _already_exists(self, data): """ Checks if the record already exists. :param data: row dictionary :return: True or False """ r_uid = data.get(REMOTE_UID, False) or '-1' l_uid = data.get(LOCAL_UID, False) or '-1' r_path = data.get(REMOTE_PATH, False) or '-1' l_path = data.get(LOCAL_PATH, False) or '-1' r_uid_q = Eq(REMOTE_UID, r_uid) l_uid_q = Eq(LOCAL_UID, l_uid) r_p_q = Eq(REMOTE_PATH, r_path) l_p_q = Eq(LOCAL_PATH, l_path) ret = [r for r in self.soup.query(Or(r_uid_q, l_uid_q, r_p_q, l_p_q))] return ret != []
def comments_json(context, request): results = [] def get_user(obj): try: return request.root['users'][obj.creator[0]] except (KeyError, IndexError): pass query = Eq('type_name', 'Comment') & Eq('path', request.resource_path(context)) docids = request.root.catalog.query(query, sort_index='created')[1] for obj in request.resolve_docids(docids, perm=None): # Perm already checked if IComment.providedBy(obj): user = get_user(obj) if user: author_title = "%s (%s)" % (user.title, user.userid) try: img_tag = request.thumb_tag(user, 'square', direction='down') except AttributeError: img_tag = '' else: author_title = '' img_tag = '' item = { 'body': obj.body, 'created': request.dt_handler.format_dt(obj.created), 'author': author_title, 'img_tag': img_tag, 'edit': bool( request.has_permission(DELETE_COMMENT, obj) or request.has_permission(EDIT_COMMENT, obj)), 'path': request.resource_path(obj), 'uid': obj.uid, } results.append(item) return results