def test_exceptions_on_complex_calls(self):
for daterange in [
choice for choice in get_all_daterange_choices()
if not choice.simple
]:
with self.assertRaises(InvalidDaterangeException):
get_daterange_start_end_dates(daterange.slug)
class PreFilterValue(FilterValue):
# All dynamic date operators use BasicBetweenFilter
dyn_date_operators = [c.slug for c in get_all_daterange_choices()]
null_operator_filters = {
'=': ISNULLFilter,
'!=': NOTNULLFilter,
'is': ISNULLFilter,
'is not': NOTNULLFilter,
}
array_operator_filters = {
'in': INFilter,
'between': BasicBetweenFilter,
}
scalar_operator_filters = NumericFilterValue.operators_to_filters
def _is_dyn_date(self):
return self.value.get('operator') in self.dyn_date_operators
def _is_null(self):
return self.value['operand'] is None
def _is_list(self):
"""
Returns true if operand should be treated like an array when building
the query.
"""
return isinstance(self.value['operand'], list)
@property
def _null_filter(self):
operator = self.value.get('operator') or 'is'
try:
return self.null_operator_filters[operator]
except KeyError:
raise TypeError(
'Null value does not support "{}" operator'.format(operator))
@property
def _array_filter(self):
operator = self.value.get('operator') or 'in'
try:
return self.array_operator_filters[operator]
except KeyError:
raise TypeError(
'Array value does not support "{}" operator'.format(operator))
@property
def _scalar_filter(self):
operator = self.value.get('operator') or '='
try:
return self.scalar_operator_filters[operator]
except KeyError:
raise TypeError(
'Scalar value does not support "{}" operator'.format(operator))
def to_sql_filter(self):
if self._is_dyn_date():
return BasicBetweenFilter(
self.filter.field,
get_INFilter_bindparams(self.filter.slug,
['start_date', 'end_date']))
elif self._is_null():
return self._null_filter(self.filter.field)
elif self._is_list():
return self._array_filter(
self.filter.field,
get_INFilter_bindparams(self.filter.slug,
self.value['operand']))
else:
return self._scalar_filter.sql(self.filter.field, self.filter.slug)
def to_sql_values(self):
if self._is_dyn_date():
start_date, end_date = get_daterange_start_end_dates(
self.value['operator'], *self.value['operand'])
return {
get_INFilter_element_bindparam(self.filter.slug, i): str(v)
for i, v in enumerate([start_date, end_date])
}
elif self._is_null():
return {}
elif self._is_list():
# Array params work like IN bind params
return {
get_INFilter_element_bindparam(self.filter.slug, i): v
for i, v in enumerate(self.value['operand'])
}
else:
return {self.filter.slug: self.value['operand']}
def to_es_filter(self):
# TODO: support the array and null operators defined at top of class
if self._is_dyn_date():
start_date, end_date = get_daterange_start_end_dates(
self.value['operator'], *self.value['operand'])
return filters.date_range(self.filter.field,
gt=start_date,
lt=end_date)
elif self._is_null():
return filters.missing(self.filter.field)
elif self._is_list():
terms = [v.value for v in self.value['operand']]
return filters.term(self.filter.field, terms)
else:
return self._scalar_filter.es(self.filter.field,
self.value['operand'])
def test_exceptions_on_complex_calls(self):
for daterange in [choice for choice in get_all_daterange_choices() if not choice.simple]:
with self.assertRaises(InvalidDaterangeException):
get_daterange_start_end_dates(daterange.slug)
def test_exceptions_on_complex_calls(self):
for daterange in filter(lambda choice: not choice.simple,
get_all_daterange_choices()):
with self.assertRaises(InvalidDaterangeException):
get_daterange_start_end_dates(daterange.slug)
class PreFilterValue(FilterValue):
# All dynamic date operators use BasicBetweenFilter
dyn_date_operators = [c.slug for c in get_all_daterange_choices()]
null_operator_filters = {
'=': ISNULLFilter,
'!=': NOTNULLFilter,
'is': ISNULLFilter,
'is not': NOTNULLFilter,
}
array_operator_filters = {
'in': INFilter,
'between': BasicBetweenFilter,
}
scalar_operator_filters = NumericFilterValue.operators_to_filters
def _is_dyn_date(self):
return self.value.get('operator') in self.dyn_date_operators
def _is_null(self):
return self.value['operand'] is None
def _is_list(self):
"""
Returns true if operand should be treated like an array when building
the query.
"""
return isinstance(self.value['operand'], list)
def _is_empty(self):
"""
Returns true if operand has no value.
"""
return self.value['operand'] == '' or self._is_null()
@property
def _array_filter(self):
operator = self.value.get('operator') or 'in'
try:
return self.array_operator_filters[operator]
except KeyError:
raise TypeError(
'Array value does not support "{}" operator'.format(operator))
@property
def _scalar_filter(self):
operator = self.value.get('operator') or '='
try:
return self.scalar_operator_filters[operator]
except KeyError:
raise TypeError(
'Scalar value does not support "{}" operator'.format(operator))
def to_sql_filter(self):
if self._is_dyn_date():
return BasicBetweenFilter(
self.filter['field'],
get_INFilter_bindparams(self.filter['slug'],
['start_date', 'end_date']))
elif self._is_empty():
return ORFilter([
EQFilter(self.filter['field'], self.filter['slug']),
ISNULLFilter(self.filter['field']),
])
elif self._is_list():
return self._array_filter(
self.filter['field'],
get_INFilter_bindparams(self.filter['slug'],
self.value['operand']))
else:
return self._scalar_filter(self.filter['field'],
self.filter['slug'])
def to_sql_values(self):
if self._is_dyn_date():
start_date, end_date = get_daterange_start_end_dates(
self.value['operator'], *self.value['operand'])
return {
get_INFilter_element_bindparam(self.filter['slug'], i): str(v)
for i, v in enumerate([start_date, end_date])
}
elif self._is_empty():
return {
self.filter['slug']: '',
}
elif self._is_list():
# Array params work like IN bind params
return {
get_INFilter_element_bindparam(self.filter['slug'], i): v
for i, v in enumerate(self.value['operand'])
}
else:
return {self.filter['slug']: self.value['operand']}
class PreFilterValue(FilterValue):
# All dynamic date operators use BasicBetweenFilter
dyn_date_operators = [c.slug for c in get_all_daterange_choices()]
null_operator_filters = {
'=': ISNULLFilter,
'!=': NOTNULLFilter,
'is': ISNULLFilter,
'is not': NOTNULLFilter,
}
array_operator_filters = {
'in': INFilter,
'between': BasicBetweenFilter,
}
scalar_operator_filters = NumericFilterValue.operators_to_filters
def _is_dyn_date(self):
return self.value.get('operator') in self.dyn_date_operators
def _is_list(self):
"""
Returns true if operand should be treated like an array when building
the query.
"""
return isinstance(self.value['operand'], list)
def _has_empty_value(self):
"""
Returns true if operand has no value.
"""
return self.value['operand'] == '' or self.value['operand'] is None
def _is_empty(self):
"""
Returns true if the value should be treated as a filter to show only empty data
"""
operator = self.value.get('operator') or '='
return self._has_empty_value() and operator == '='
def _is_exists(self):
"""
Returns true if the value should be treated as a filter to show non-empty data
"""
return self._has_empty_value() and self.value.get('operator') == '!='
@property
def _array_filter(self):
operator = self.value.get('operator') or 'in'
try:
return self.array_operator_filters[operator]
except KeyError:
raise TypeError(
'Array value does not support "{}" operator'.format(operator))
@property
def _scalar_filter(self):
operator = self.value.get('operator') or '='
try:
return self.scalar_operator_filters[operator]
except KeyError:
raise TypeError(
'Scalar value does not support "{}" operator'.format(operator))
def to_sql_filter(self):
if self._is_dyn_date():
return BasicBetweenFilter(
self.filter['field'],
get_INFilter_bindparams(self.filter['slug'],
['start_date', 'end_date']))
elif self._is_empty():
if self.filter.get('datatype') in [
DATA_TYPE_DATE, DATA_TYPE_DATETIME
]:
return ISNULLFilter(self.filter['field'])
else:
return ORFilter([
EQFilter(self.filter['field'], self.filter['slug']),
ISNULLFilter(self.filter['field']),
])
elif self._is_exists():
if self.filter.get('datatype') in [
DATA_TYPE_DATE, DATA_TYPE_DATETIME
]:
return NOTNULLFilter(self.filter['field'])
else:
# this resolves to != '', which also filters out null data in postgres
return NOTEQFilter(self.filter['field'], self.filter['slug'])
elif self._is_list():
return self._array_filter(
self.filter['field'],
get_INFilter_bindparams(self.filter['slug'],
self.value['operand']))
else:
return self._scalar_filter(self.filter['field'],
self.filter['slug'])
def to_sql_values(self):
if self._is_dyn_date():
start_date, end_date = get_daterange_start_end_dates(
self.value['operator'], *self.value['operand'])
return {
get_INFilter_element_bindparam(self.filter['slug'], i): str(v)
for i, v in enumerate([start_date, end_date])
}
elif self._is_empty() or self._is_exists():
if self.filter.get('datatype') in [
DATA_TYPE_DATE, DATA_TYPE_DATETIME
]:
# Both == '' and != '' do not work for dates in postgres so the expression should only be for NULL
# checks that get added later. Hence don't return any comparison for value here
return {}
else:
return {
self.filter['slug']: '',
}
elif self._is_list():
# Array params work like IN bind params
return {
get_INFilter_element_bindparam(self.filter['slug'], i): v
for i, v in enumerate(self.value['operand'])
}
else:
return {self.filter['slug']: self.value['operand']}
def test_exceptions_on_complex_calls(self):
for daterange in filter(lambda choice: not choice.simple, get_all_daterange_choices()):
with self.assertRaises(InvalidDaterangeException):
get_daterange_start_end_dates(daterange.slug)
