def _get_rates_user_non_anonymized(context: IResource, request: IRequest, value: dict) -> [IRate]: catalogs = find_service(context, 'catalogs') authenticated_user = request.anonymized_user or request.user query = search_query._replace( references=(Reference(None, IRate, 'subject', authenticated_user), Reference(None, IRate, 'object', value['object'])), resolve=True, ) rates = catalogs.search(query).elements return rates
def test_apply_all(self): from adhocracy_core.interfaces import ISheet from adhocracy_core.interfaces import Reference import BTrees inst = self.make_one() query = {'reference': Reference(None, ISheet, '', object())} result_query = BTrees.family64.IF.TreeSet((1, 2, 3)) query2 = {'reference': Reference(object(), ISheet, '', None)} result_query2 = BTrees.family64.IF.TreeSet((2, 3, 4)) inst._search = Mock(side_effect=[result_query, result_query2]) result = inst.applyAll([query, query2]) assert list(result) == [2, 3]
def test_search_raise_if_source_and_target_is_none(self): from adhocracy_core.interfaces import Reference from adhocracy_core.interfaces import ISheet inst = self.make_one() reference = Reference(None, ISheet, '', None) with raises(ValueError): inst._search(reference)
def test_search_raise_if_source_and_target_is_none(self): from adhocracy_core.interfaces import Reference from adhocracy_core.interfaces import ISheet inst = self.make_one() query = {'reference': Reference(None, ISheet, '', None), 'traverse': False} with raises(ValueError): inst._search(query)
def test_eq(self): from adhocracy_core.interfaces import ISheet from adhocracy_core.interfaces import Reference inst = self.make_one() target = testing.DummyResource() reference = Reference(None, ISheet, '', target) result = inst.eq(reference) assert result._value == {'reference': reference}
def get_back_references(self, target, base_isheet=ISheet, base_reftype=SheetReference) -> Iterator: """Get generator of :class:`Reference` with this `target`.""" for isheet, field, reftype in self.get_reftypes( base_isheet, base_reftype): for source in ObjectMap.sources(self._objectmap, target, reftype): yield Reference(source, isheet, field, target)
def _ensure_rate_is_unique(self, node, value, request): # Other rates with the same subject and object may occur below the # current context (earlier versions of the same rate item). # If they occur elsewhere, an error is thrown. adhocracy_catalog = find_catalog(request.context, 'adhocracy') index = adhocracy_catalog['reference'] reference_subject = Reference(None, IRate, 'subject', value['subject']) query = index.eq(reference_subject) reference_object = Reference(None, IRate, 'object', value['object']) query &= index.eq(reference_object) system_catalog = find_catalog(request.context, 'system') path_index = system_catalog['path'] query &= path_index.noteq(resource_path(request.context), depth=None) elements = query.execute(resolver=None) if elements: err = colander.Invalid(node) err['object'] = 'Another rate by the same user already exists' raise err
def _get_reference_appstruct(self, query: SearchQuery) -> iter: """Might be overridden in subclasses.""" fields = self._fields['reference'].items() return self._yield_references( fields, query, lambda node: Reference(self.context, self.meta.isheet, node.name, None) )
def _get_rates_user_anonymized(context: IResource, request: IRequest, value: dict) -> [IRate]: from adhocracy_core.resources.principal import get_system_user_anonymous catalogs = find_service(context, 'catalogs') anonymous = get_system_user_anonymous(request) query = search_query._replace( references=(Reference(None, IRate, 'subject', anonymous), Reference(None, IRate, 'object', value['object'])), resolve=True, ) rates = catalogs.search(query).elements rates_deanonymized = [] authenticated_user = request.anonymized_user or request.user for rate in rates: anonymized_creator = get_anonymized_creator(rate) if anonymized_creator == resource_path(authenticated_user): rates_deanonymized.append(rate) return rates_deanonymized
def test_sheet_back_reference_removed(): from . import SheetBackReferenceRemoved from adhocracy_core.interfaces import ISheetBackReferenceRemoved from adhocracy_core.interfaces import ISheet from adhocracy_core.interfaces import Reference context = testing.DummyResource() reference = Reference(None, None, None, None) registry = testing.DummyResource() inst = SheetBackReferenceRemoved(context, ISheet, reference, registry) assert ISheetBackReferenceRemoved.providedBy(inst) assert verifyObject(ISheetBackReferenceRemoved, inst)
def test_ignore_if_no_equal_rates(self, node, context, request_, value, query, mock_catalogs, anonymous, mock_get_anonymous, version, search_result): from adhocracy_core.interfaces import Reference from .rate import IRate mock_catalogs.search.side_effect =\ [search_result, search_result._replace(elements=[version]), ] validator = self.call_fut(context, request_) assert validator(node, value) is None assert mock_catalogs.search.call_args_list[0][0][0] == query._replace( references=(Reference(None, IRate, 'subject', request_.user), Reference(None, IRate, 'object', value['object'])), resolve=True) assert mock_catalogs.search.call_args_list[1][0][0] == query._replace( references=(Reference(None, IRate, 'subject', anonymous), Reference(None, IRate, 'object', value['object'])), resolve=True)
def _get_follow_subscriptions(streams: [tuple], request: IRequest) -> dict: context = request.root catalogs = find_service(context, 'catalogs') subscriptions = defaultdict(set) for resource in [x for x, y in streams]: ref = Reference(None, INotification, 'follow_resources', resource) query = search_query._replace(references=(ref, )) followers = catalogs.search(query).elements for follower in followers: subscriptions[resource].add(follower) return subscriptions
def test_eq(self): from adhocracy_core.interfaces import ISheet from adhocracy_core.interfaces import Reference from hypatia.query import Eq inst = self.make_one() target = testing.DummyResource() reference = Reference(None, ISheet, '', target) query = {'reference': reference} result = inst.eq(query) assert isinstance(result, Eq) assert result._value == query
def test_apply(self, mock_graph, mock_objectmap): from adhocracy_core.interfaces import ISheet from adhocracy_core.interfaces import Reference from adhocracy_core.interfaces import SheetToSheet mock_objectmap.sourceids.return_value = set([1]) inst = self.make_one() inst._objectmap = mock_objectmap mock_graph.get_reftypes.return_value = [(ISheet, '', SheetToSheet)] inst.__graph__ = mock_graph target = testing.DummyResource() reference = Reference(None, ISheet, '', target) query = {'reference': reference} result = inst.apply(query) assert list(result) == [1]
def test_apply_intersect_reference_not_exists(self, mock_objectmap): # actually we test the default implementation in hypatia.util import BTrees from adhocracy_core.interfaces import ISheet from adhocracy_core.interfaces import Reference from adhocracy_core.graph import ObjectMap mock_objectmap.sourceids.return_value = set() inst = self.make_one() inst._mock_objectmap = mock_objectmap target = testing.DummyResource() reference = Reference(None, ISheet, '', target) query = {'reference': reference} other_result = BTrees.family64.IF.Set([1]) result = inst.apply_intersect(query, other_result) assert list(result) == []
def test_ignore_images_that_are_referenced(self, context, mock_catalogs, search_result, query): from adhocracy_core.interfaces import Reference from adhocracy_core.sheets.image import IImageReference image = testing.DummyResource() context['image'] = image mock_catalogs.search.side_effect = [ search_result._replace(elements=[image]), search_result ] self.call_fut(context, 10) assert mock_catalogs.search.call_args_list[1][0][0] == \ query._replace(references=((Reference(None, IImageReference, '', image)),), ) assert 'image' in context
def test_search_with_order_sources(self, mock_graph, mock_objectmap): from adhocracy_core.interfaces import ISheet from adhocracy_core.interfaces import Reference from adhocracy_core.interfaces import SheetToSheet target = testing.DummyResource() inst = self.make_one() inst.__graph__ = mock_graph mock_graph.get_reftypes.return_value = [(ISheet, '', SheetToSheet)] oid1, oid2 = 1, 2 mock_objectmap.sourceids.return_value = [oid2, oid1] inst._objectmap = mock_objectmap reference = Reference(None, ISheet, '', target) result = inst.search_with_order(reference) mock_objectmap.sourceids.assert_called_with(target, SheetToSheet) assert list(result) == [oid2, oid1]
def test_search_targets(self, mock_graph, mock_objectmap): from adhocracy_core.interfaces import ISheet from adhocracy_core.interfaces import Reference from adhocracy_core.interfaces import SheetToSheet source = testing.DummyResource() inst = self.make_one() inst.__graph__ = mock_graph mock_graph.get_reftypes.return_value = [(ISheet, '', SheetToSheet)] oid1, oid2 = 1, 2 mock_objectmap.targetids.return_value = [oid2, oid1] inst._objectmap = mock_objectmap query = {'reference': Reference(source, ISheet, '', None), 'traverse': False} result = inst._search(query) mock_objectmap.targetids.assert_called_with(source, SheetToSheet) assert list(result) == [oid1, oid2] # order is not preserver
def delete_not_referenced_images( root, max_age: int, ): """Delete images older than `max_age` that are not referenced.""" catalogs = find_service(root, 'catalogs') max_date = now() - timedelta(days=max_age) query = search_query._replace( interfaces=IImage, resolve=True, indexes={'item_creation_date': (FieldComparator.lt.value, max_date)}) images = catalogs.search(query).elements msg = 'Found {0} images older then {1} days'.format(len(images), max_age) logger.info(msg) for image in images: picture_reference = Reference(None, IImageReference, '', image) query = search_query._replace(references=(picture_reference, )) referencing = catalogs.search(query) if referencing.count > 0: msg = 'Deleting image {0} that is not referenced'.format(image) logger.info(msg) del image.__parent__[image.__name__]
def get_ref(node): isheet = node.reftype.getTaggedValue('source_isheet') isheet_field = node.reftype.getTaggedValue('source_isheet_field') return Reference(None, isheet, isheet_field, self.context)
def _create_reference_template(self, source, reftype): source_isheet = reftype.queryTaggedValue('source_isheet') source_isheet_field = reftype.queryTaggedValue('target_isheet_field') return Reference(source, source_isheet, source_isheet_field, None)