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