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)
