def get_search_query(self):
'''Create search request'''
queries = []
_column_names = [
d['data'] for d in self.columns
if d['data'] in self.field_type_dict.keys()
]
# global search for all columns
if self.search_string:
for col in _column_names:
_q = self.search_string
_obj = self.query_by_col_type(_q, col)
queries += _obj
# search by specific columns
_own_col_q = []
for column_search in self.dt_column_search:
col = column_search['column']
term = column_search['value']
_obj = self.query_by_col_type(term, col)
_own_col_q += _obj
if self.q_obj:
queries.append(self.q_obj)
_search_query = QCombination(QCombination.OR, queries)
if _own_col_q:
_own_col_q = QCombination(QCombination.AND, _own_col_q)
_search_query = (_search_query & _own_col_q)
if self.custom_filter:
_search_query = (_search_query & Q(**self.custom_filter))
return _search_query
def get_query(document, fields, is_and=True):
filds_name = [f.name for f in fields]
queries = map(
lambda i: Q(**{i[0]: i[1]}),
[d for d in document._data.items() if d[0] in filds_name])
query = QCombination(QCombination.AND, queries)
if not is_and:
query = QCombination(QCombination.OR, queries)
return query
def get_users(user_ids=[],
emails=[],
query='',
page=None,
limit=None,
paginate=True,
data_objects=False):
"""
:param page: page number
:param limit: no of results per page
:param query: query string
:param user_ids: List of ad IDs
:param emails: List of emails
:param paginate: Boolean, to return paginated results if true
:param data_objects: Boolean, to return queryset
:return: Returns users filtered on the requirement in the specified format
"""
if user_ids:
users = User.objects.filter(id__in=user_ids, deleted=False)
else:
match_case_query = [Q(deleted=False)]
if emails:
match_case_query.append(Q(email__in=emails))
match_query = QCombination(QCombination.AND, match_case_query)
users = User.objects.filter((Q(name__icontains=query)
| Q(email__icontains=query))
& match_query).order_by('-created_at')
if data_objects:
return users # Returns QuerySet
if not paginate:
return {"data": [instance.to_dict() for instance in list(users)]}
else:
users = users.paginate(page=page, per_page=limit)
return {
"data": [instance.to_dict() for instance in users.items],
"current_page": users.page,
"total_pages_for_query": users.pages,
"item_per_page": users.per_page,
"total_records": users.total,
"next_num": users.next_num,
"prev_num": users.prev_num,
"has_next": users.has_next,
"has_prev": users.has_prev
}
def find_user(self, case_insensitive=False, **kwargs):
from mongoengine.queryset.visitor import Q, QCombination
from mongoengine.errors import ValidationError
try:
if case_insensitive:
# While it is of course possible to pass in multiple keys to filter on
# that isn't the normal use case. If caller asks for case_insensitive
# AND gives multiple keys - throw an error.
if len(kwargs) > 1:
raise ValueError("Case insensitive option only supports single key")
attr, identifier = kwargs.popitem()
query = {f"{attr}__iexact": identifier}
return self.user_model.objects(**query).first()
else:
queries = map(lambda i: Q(**{i[0]: i[1]}), kwargs.items())
query = QCombination(QCombination.AND, queries)
return self.user_model.objects(query).first()
except ValidationError: # pragma: no cover
return None
def get_query(self, years):
queries = [Q(**{HospitalDischargeDocument.discharge_year.name: y}) for y in years]
result = QCombination(QCombination.OR, queries)
return result