def VideohubChannel(included_ids=None, excluded_ids=None):
f = MatchAll()
if included_ids:
f &= Nested(path="videohub_ref",
filter=Terms(**{"videohub_ref.channel_id": included_ids}))
if excluded_ids:
f &= ~Nested(path="videohub_ref",
filter=Terms(**{"videohub_ref.channel_id": excluded_ids}))
def Authors(usernames): # noqa
included, excluded = _parse_slugs(usernames)
f = MatchAll()
if included:
f &= Terms(**{"authors.username": included})
if excluded:
f &= Terms(**{"authors.username": excluded})
return f
def Tags(slugs): # noqa
included, excluded = _parse_slugs(slugs)
f = MatchAll()
if included:
f &= Nested(path="tags", filter=Terms(**{"tags.slug": included}))
if excluded:
f &= ~Nested(path="tags", filter=Terms(**{"tags.slug": excluded}))
return f
def FeatureTypes(slugs): # noqa
included, excluded = _parse_slugs(slugs)
f = MatchAll()
if included:
f &= Nested(path="feature_type",
filter=Terms(**{"feature_type.slug": included}))
if excluded:
f &= ~Nested(path="feature_type",
filter=Terms(**{"feature_type.slug": excluded}))
return f
def date_range_filter(range_name):
"""Create a filter from a named date range."""
filter_days = list(
filter(lambda time: time["label"] == range_name,
settings.CUSTOM_SEARCH_TIME_PERIODS))
num_days = filter_days[0]["days"] if len(filter_days) else None
if num_days:
dt = timedelta(num_days)
start_time = timezone.now() - dt
return Range(published={"gte": start_time})
return MatchAll()
def groups_filter_from_query(query, field_map={}):
"""Creates an F object for the groups of a search query."""
f = None
# filter groups
for group in query.get("groups", []):
group_f = MatchAll()
for condition in group.get("conditions", []):
field_name = condition["field"]
field_name = field_map.get(field_name, field_name)
operation = condition["type"]
values = condition["values"]
if values:
values = [v["value"] for v in values]
if operation == "all":
# NOTE: is there a better way to express this?
for value in values:
if "." in field_name:
path = field_name.split(".")[0]
group_f &= Nested(
path=path, filter=Term(**{field_name: value}))
else:
group_f &= Term(**{field_name: value})
elif operation == "any":
if "." in field_name:
path = field_name.split(".")[0]
group_f &= Nested(path=path,
filter=Terms(**{field_name: values}))
else:
group_f &= Terms(**{field_name: values})
elif operation == "none":
if "." in field_name:
path = field_name.split(".")[0]
group_f &= ~Nested(
path=path, filter=Terms(**{field_name: values}))
else:
group_f &= ~Terms(**{field_name: values})
date_range = group.get("time")
if date_range:
group_f &= date_range_filter(date_range)
if f:
f |= group_f
else:
f = group_f
return f
def get_condition_filter(condition, field_map={}):
"""
Return the appropriate filter for a given group condition.
# TODO: integrate this into groups_filter_from_query function.
"""
field_name = condition.get("field")
field_name = field_map.get(field_name, field_name)
operation = condition["type"]
values = condition["values"]
condition_filter = MatchAll()
if values:
values = [v["value"] for v in values]
if operation == "all":
for value in values:
if "." in field_name:
path = field_name.split(".")[0]
condition_filter &= Nested(
path=path, filter=Term(**{field_name: value}))
else:
condition_filter &= Term(**{field_name: value})
elif operation == "any":
if "." in field_name:
path = field_name.split(".")[0]
condition_filter &= Nested(
path=path, filter=Terms(**{field_name: values}))
else:
condition_filter &= Terms(**{field_name: values})
elif operation == "none":
if "." in field_name:
path = field_name.split(".")[0]
condition_filter &= ~Nested(
path=path, filter=Terms(**{field_name: values}))
else:
condition_filter &= ~Terms(**{field_name: values})
else:
raise ValueError(
"""ES conditions must be one of the following values: ['all', 'any', 'none']"""
)
return condition_filter
def filter_from_query(query, id_field="id", field_map={}):
"""This returns a filter which actually filters out everything, unlike the
preview filter which includes excluded_ids for UI purposes.
"""
f = groups_filter_from_query(query, field_map=field_map)
excluded_ids = query.get("excluded_ids")
included_ids = query.get("included_ids")
if included_ids: # include these, please
if f is None:
f = Terms(pk=included_ids)
else:
f |= Terms(pk=included_ids)
if excluded_ids: # exclude these
if f is None:
f = MatchAll()
f &= ~Terms(pk=excluded_ids)
return f
def Status(status): # noqa
if status:
return Term(status=status)
else:
return MatchAll()