def test_rfs_update(self):
fieldset_a = rfs(('a', 'b', 'b__c', 'b__g', ('d', ('e__f',))))
fieldset_b = rfs(('a__i', 'l'))
fieldset_a.update(fieldset_b)
assert_equal(str(fieldset_a), 'a(i),b(c,g),d(e(f)),l')
assert_equal(str(fieldset_b), 'a(i),l')
def test_rfs_update(self):
fieldset_a = rfs(('a', 'b', 'b__c', 'b__g', ('d', ('e__f', ))))
fieldset_b = rfs(('a__i', 'l'))
fieldset_a.update(fieldset_b)
assert_equal(str(fieldset_a), 'a(i),b(c,g),d(e(f)),l')
assert_equal(str(fieldset_b), 'a(i),l')
def test_rfs_add(self):
fieldset_a = rfs(('a', 'b', 'b__c', 'b__g', ('d', ('e__f', ))))
fieldset_b = rfs(('a__i', 'l'))
fieldset_c = fieldset_a + fieldset_b
assert_equal(str(fieldset_a), 'a,b(c,g),d(e(f))')
assert_equal(str(fieldset_b), 'a(i),l')
assert_equal(str(fieldset_c), 'a(i),b(c,g),d(e(f)),l')
def test_rfs_add(self):
fieldset_a = rfs(('a', 'b', 'b__c', 'b__g', ('d', ('e__f',))))
fieldset_b = rfs(('a__i', 'l'))
fieldset_c = fieldset_a + fieldset_b
assert_equal(str(fieldset_a), 'a,b(c,g),d(e(f))')
assert_equal(str(fieldset_b), 'a(i),l')
assert_equal(str(fieldset_c), 'a(i),b(c,g),d(e(f)),l')
def _get_method_filter(self, method, identifiers_prefix, identifiers, identifiers_suffix, model, resource, request,
filters_fields_rfs):
"""
:param method: method from which we can get filter.
:param identifiers_prefix: because filters are recursive if model relations property contains list of
identifiers that was used for recursive searching the filter.
:param identifiers: list of identifiers that conclusively identifies the filter.
:param identifiers_suffix: list of suffixes that can be used for more specific filters.
:param model: django model class.
:param resource: resource object.
:param request: django HTTP request.
:param filters_fields_rfs: RFS of fields that is allowed to filter.
:return: method returns filter object that is obtained from method.
"""
if hasattr(method, 'filter_by'):
# If method has filter_by attribute filter is being searched according to this value.
filter_by_identifiers = method.filter_by.split(LOOKUP_SEP)
next_identifiers = filter_by_identifiers + identifiers_suffix
# Because method must be inside allowed filter fields RFS, we must add value filter_by of the method
# to the next RFS.
next_filters_fields_rfs = rfs(filter_by_identifiers)
return self._get_filter_recursive(
identifiers_prefix, next_identifiers, model, resource, request, next_filters_fields_rfs
)
suffix = LOOKUP_SEP.join(identifiers_suffix)
if not hasattr(method, 'filter') or (suffix and suffix not in method.filter.get_suffixes()):
raise FilterIdentifierError
return method.filter(identifiers_prefix, identifiers, identifiers_suffix, method=method)
def _get_filter_recursive(self, identifiers_prefix, identifiers, model, resource, request,
extra_filter_fields_rfs=None):
"""
:param identifiers_prefix: because filters are recursive if model relations property contains list of
identifiers that was used for recursive searching the filter.
:param identifiers: list of identifiers that conclusively identifies the filter.
:param model: django model class.
:param resource: resource object.
:param request: django HTTP request.
:param extra_filter_fields_rfs: RFS of fields that is allowed to filter.
:return: method search recursive filter with resource_filter and model_filter getters.
"""
extra_filter_fields_rfs = rfs() if extra_filter_fields_rfs is None else extra_filter_fields_rfs
filters_fields_rfs = (
extra_filter_fields_rfs.join(
resource.get_filter_fields_rfs() if resource else get_allowed_filter_fields_rfs_from_model(model)
)
)
filter_obj = (
self._get_resource_filter(
identifiers_prefix, identifiers, model, resource, request, filters_fields_rfs) or
self._get_model_filter(
identifiers_prefix, identifiers, model, resource, request, filters_fields_rfs)
)
if not filter_obj:
raise FilterIdentifierError
return filter_obj
def _get_sorter_from_method(self, method, identifiers_prefix, identifiers, direction, model, resource, request,
order_fields_rfs):
"""
:param method: method from which we can get order string.
:param identifiers_prefix: because order strings are recursive if model relations property contains list of
identifiers that was used for recursive searching the order string.
:param identifiers: list of identifiers that conclusively identifies order string.
:param direction: direction of ordering ASC or DESC.
:param model: django model class.
:param resource: resource object.
:param request: django HTTP request.
:param order_fields_rfs: RFS of fields that is allowed to order.
:return: db order method string that is obtained from method.
"""
if hasattr(method, 'order_by'):
# If method has order_by attribute order string is being searched according to this value.
order_identifiers = method.order_by.split(LOOKUP_SEP)
# Because method must be inside allowed order fields RFS, we must add value order_by of the method
# to the next RFS.
next_order_fields_rfs = rfs(order_identifiers)
return self._get_sorter_recursive(
identifiers_prefix, order_identifiers, direction, model, resource, request, next_order_fields_rfs
)
if not identifiers_prefix and hasattr(method, 'sorter'):
return method.sorter(identifiers_prefix + identifiers, direction)
raise OrderIdentifierError
def _get_filter_recursive(self,
identifiers_prefix,
identifiers,
model,
resource,
request,
extra_filter_fields_rfs=None):
"""
:param identifiers_prefix: because filters are recursive if model relations property contains list of
identifiers that was used for recursive searching the filter.
:param identifiers: list of identifiers that conclusively identifies the filter.
:param model: django model class.
:param resource: resource object.
:param request: django HTTP request.
:param extra_filter_fields_rfs: RFS of fields that is allowed to filter.
:return: method search recursive filter with resource_filter and model_filter getters.
"""
extra_filter_fields_rfs = rfs(
) if extra_filter_fields_rfs is None else extra_filter_fields_rfs
filters_fields_rfs = (extra_filter_fields_rfs.join(
resource.get_filter_fields_rfs()
if resource else get_allowed_filter_fields_rfs_from_model(model)))
filter_obj = (
self._get_resource_filter(identifiers_prefix, identifiers, model,
resource, request, filters_fields_rfs)
or self._get_model_filter(identifiers_prefix, identifiers, model,
resource, request, filters_fields_rfs))
if not filter_obj:
raise FilterIdentifierError
return filter_obj
def _get_method_filter(self, method, identifiers_prefix, identifiers,
identifiers_suffix, model, resource, request,
filters_fields_rfs):
"""
:param method: method from which we can get filter.
:param identifiers_prefix: because filters are recursive if model relations property contains list of
identifiers that was used for recursive searching the filter.
:param identifiers: list of identifiers that conclusively identifies the filter.
:param identifiers_suffix: list of suffixes that can be used for more specific filters.
:param model: django model class.
:param resource: resource object.
:param request: django HTTP request.
:param filters_fields_rfs: RFS of fields that is allowed to filter.
:return: method returns filter object that is obtained from method.
"""
if hasattr(method, 'filter_by'):
# If method has filter_by attribute filter is being searched according to this value.
filter_by_identifiers = method.filter_by.split(LOOKUP_SEP)
next_identifiers = filter_by_identifiers + identifiers_suffix
# Because method must be inside allowed filter fields RFS, we must add value filter_by of the method
# to the next RFS.
next_filters_fields_rfs = rfs(filter_by_identifiers)
return self._get_filter_recursive(identifiers_prefix,
next_identifiers, model,
resource, request,
next_filters_fields_rfs)
suffix = LOOKUP_SEP.join(identifiers_suffix)
if not hasattr(method, 'filter') or (
suffix and suffix not in method.filter.get_suffixes()):
raise FilterIdentifierError
return method.filter(identifiers_prefix,
identifiers,
identifiers_suffix,
method=method)
def _get_sorter_from_method(self, method, identifiers_prefix, identifiers,
direction, model, resource, request,
order_fields_rfs):
"""
:param method: method from which we can get order string.
:param identifiers_prefix: because order strings are recursive if model relations property contains list of
identifiers that was used for recursive searching the order string.
:param identifiers: list of identifiers that conclusively identifies order string.
:param direction: direction of ordering ASC or DESC.
:param model: django model class.
:param resource: resource object.
:param request: django HTTP request.
:param order_fields_rfs: RFS of fields that is allowed to order.
:return: db order method string that is obtained from method.
"""
if hasattr(method, 'order_by'):
# If method has order_by attribute order string is being searched according to this value.
order_identifiers = method.order_by.split(LOOKUP_SEP)
# Because method must be inside allowed order fields RFS, we must add value order_by of the method
# to the next RFS.
next_order_fields_rfs = rfs(order_identifiers)
return self._get_sorter_recursive(identifiers_prefix,
order_identifiers, direction,
model, resource, request,
next_order_fields_rfs)
if not identifiers_prefix and hasattr(method, 'sorter'):
return method.sorter(identifiers_prefix + identifiers, direction)
raise OrderIdentifierError
def _get_sorter_recursive(self, identifiers_prefix, identifiers, direction, model, resource, request,
extra_order_fields_rfs=None):
"""
:param identifiers_prefix: because order strings are recursive if model relations property contains list of
identifiers that was used for recursive searching the order string.
:param identifiers: list of identifiers that conclusively identifies order string.
:param direction: direction of ordering ASC or DESC.
:param model: django model class.
:param resource: resource object.
:param request: django HTTP request.
:param extra_order_fields_rfs: RFS of fields that is allowed to order.
:return: method search resursice order string with order_string_from_model or order_string_from_resource
getters.
"""
extra_order_fields_rfs = rfs() if extra_order_fields_rfs is None else extra_order_fields_rfs
order_fields_rfs = (
extra_order_fields_rfs.join(
resource.get_order_fields_rfs() if resource else get_allowed_order_fields_rfs_from_model(model)
)
)
order_string = (
self._get_sorter_from_resource(
identifiers_prefix, identifiers, direction, model, resource, request, order_fields_rfs) or
self._get_sorter_from_model(
identifiers_prefix, identifiers, direction, model, resource, request, order_fields_rfs)
)
if not order_string:
raise OrderIdentifierError
return order_string
def _get_sorter_recursive(self,
identifiers_prefix,
identifiers,
direction,
model,
resource,
request,
extra_order_fields_rfs=None):
"""
:param identifiers_prefix: because order strings are recursive if model relations property contains list of
identifiers that was used for recursive searching the order string.
:param identifiers: list of identifiers that conclusively identifies order string.
:param direction: direction of ordering ASC or DESC.
:param model: django model class.
:param resource: resource object.
:param request: django HTTP request.
:param extra_order_fields_rfs: RFS of fields that is allowed to order.
:return: method search resursice order string with order_string_from_model or order_string_from_resource
getters.
"""
extra_order_fields_rfs = rfs(
) if extra_order_fields_rfs is None else extra_order_fields_rfs
order_fields_rfs = (
extra_order_fields_rfs.join(resource.get_order_fields_rfs(
) if resource else get_allowed_order_fields_rfs_from_model(model)))
order_string = (self._get_sorter_from_resource(
identifiers_prefix, identifiers, direction, model, resource,
request, order_fields_rfs) or self._get_sorter_from_model(
identifiers_prefix, identifiers, direction, model, resource,
request, order_fields_rfs))
if not order_string:
raise OrderIdentifierError
return order_string
def test_rfs_append(self):
fieldset = rfs(('a', 'b', 'b__c', 'b__g', ('d', ('e__f',))))
fieldset.append('a')
assert_equal(str(fieldset), 'a,b(c,g),d(e(f))')
fieldset.append('a__h')
assert_equal(str(fieldset), 'a(h),b(c,g),d(e(f))')
fieldset.append('b__c__i')
assert_equal(str(fieldset), 'a(h),b(c(i),g),d(e(f))')
fieldset.append(('b', ('k')))
assert_equal(str(fieldset), 'a(h),b(c(i),g,k),d(e(f))')
def test_rfs_append(self):
fieldset = rfs(('a', 'b', 'b__c', 'b__g', ('d', ('e__f', ))))
fieldset.append('a')
assert_equal(str(fieldset), 'a,b(c,g),d(e(f))')
fieldset.append('a__h')
assert_equal(str(fieldset), 'a(h),b(c,g),d(e(f))')
fieldset.append('b__c__i')
assert_equal(str(fieldset), 'a(h),b(c(i),g),d(e(f))')
fieldset.append(('b', ('k')))
assert_equal(str(fieldset), 'a(h),b(c(i),g,k),d(e(f))')
def test_create_rfs_from_list(self):
assert_equal(str(rfs(('a', 'b', 'b__c', 'b__g', ('d', ('e__f',))))), 'a,b(c,g),d(e(f))')
assert_equal(str(rfs(('a', 'b', ('d', ('e__f',)), ('b', ('c',))))), 'a,b(c),d(e(f))')
assert_equal(str(rfs(())), '')
def test_rfs_intersection(self):
fieldset_a = rfs((('a', ('i', 'j')), 'b', 'b__c', 'b__g', ('d', ('e__f',))))
fieldset_b = rfs(('a__i', 'b', 'l'))
assert_equal(str(fieldset_a.intersection(fieldset_b)), 'a(i),b')
def test_rfs_get(self):
fieldset = rfs(('a', 'b', 'b__c', 'b__g', ('d', ('e__f',))))
assert_equal(str(fieldset.get('b')), 'b(c,g)')
assert_is_none(fieldset.get('k'))
assert_equal(str(fieldset.get('a')), 'a')
def get_default_fields_rfs(self, obj=None):
return super(RESTModelResource, self).get_default_fields_rfs(obj=obj).join(
rfs(self.get_default_fields_extension(obj))
)
def test_rfs_bool(self):
assert_true(rfs(('a', 'b', 'b__c', 'b__g', ('d', ('e__f',)))))
assert_false(rfs())
assert_false(rfs(()))
assert_false(rfs({}))
def test_rfs_flat(self):
assert_equal(rfs(('a', 'b', 'b__c', 'b__g', ('d', ('e__f',)))).flat(), {'a', 'b', 'd'})
def test_rfs_bool(self):
assert_true(rfs(('a', 'b', 'b__c', 'b__g', ('d', ('e__f', )))))
assert_false(rfs())
assert_false(rfs(()))
assert_false(rfs({}))
def get_allowed_filter_fields_rfs_from_model(model):
return rfs(model._rest_meta.extra_filter_fields).join(
rfs(model._rest_meta.filter_fields))
def test_rfs_get(self):
fieldset = rfs(('a', 'b', 'b__c', 'b__g', ('d', ('e__f', ))))
assert_equal(str(fieldset.get('b')), 'b(c,g)')
assert_is_none(fieldset.get('k'))
assert_equal(str(fieldset.get('a')), 'a')
def get_default_fields_rfs(self, obj=None):
return super(RESTModelResource, self).get_default_fields_rfs(obj=obj).join(
rfs(self.get_default_fields_extension(obj))
)
def get_allowed_filter_fields_rfs_from_model(model):
return rfs(model._rest_meta.extra_filter_fields).join(rfs(model._rest_meta.filter_fields))
def test_rfs_intersection(self):
fieldset_a = rfs(
(('a', ('i', 'j')), 'b', 'b__c', 'b__g', ('d', ('e__f', ))))
fieldset_b = rfs(('a__i', 'b', 'l'))
assert_equal(str(fieldset_a.intersection(fieldset_b)), 'a(i),b')
def test_rfs_flat(self):
assert_equal(
rfs(('a', 'b', 'b__c', 'b__g', ('d', ('e__f', )))).flat(),
{'a', 'b', 'd'})
def test_create_rfs_from_list(self):
assert_equal(str(rfs(('a', 'b', 'b__c', 'b__g', ('d', ('e__f', ))))),
'a,b(c,g),d(e(f))')
assert_equal(str(rfs(('a', 'b', ('d', ('e__f', )), ('b', ('c', ))))),
'a,b(c),d(e(f))')
assert_equal(str(rfs(())), '')
def _get_allowed_fieldset(self):
from pyston.resource import DefaultRESTObjectResource
# For security reasons only resource which defines allowed fields can be fully converted to the CSV/XLSX
# or similar formats
return self.resource.get_allowed_fields_rfs() if isinstance(self.resource, DefaultRESTObjectResource) else rfs()
