def post(self, request, *args, **kwargs):
from corehq.apps.es.case_search import CaseSearchES
if not case_search_enabled_for_domain(self.domain):
raise BadRequest("Domain does not have case search enabled")
query = json.loads(request.POST.get('q'))
case_type = query.get('type')
owner_id = query.get('owner_id')
search_params = query.get('parameters', [])
query_addition = query.get("customQueryAddition", None)
search = CaseSearchES()
search = search.domain(self.domain).is_closed(False)
if case_type:
search = search.case_type(case_type)
if owner_id:
search = search.owner(owner_id)
for param in search_params:
value = re.sub(param.get('regex', ''), '', param.get('value'))
search = search.case_property_query(
param.get('key'),
value,
clause=param.get('clause'),
fuzzy=param.get('fuzzy'),
)
if query_addition:
addition = CaseSearchQueryAddition.objects.get(id=query_addition,
domain=self.domain)
new_query = merge_queries(search.get_query(),
addition.query_addition)
search = search.set_query(new_query)
search_results = search.values()
return json_response({'values': search_results})
def post(self, request, *args, **kwargs):
from corehq.apps.es.case_search import CaseSearchES
if not case_search_enabled_for_domain(self.domain):
raise BadRequest("Domain does not have case search enabled")
query = json.loads(request.POST.get('q'))
case_type = query.get('type')
owner_id = query.get('owner_id')
search_params = query.get('parameters', [])
xpath = query.get("xpath")
search = CaseSearchES()
search = search.domain(self.domain).size(10)
if case_type:
search = search.case_type(case_type)
if owner_id:
search = search.owner(owner_id)
for param in search_params:
value = re.sub(param.get('regex', ''), '', param.get('value'))
if '/' in param.get('key'):
query = '{} = "{}"'.format(param.get('key'), value)
search = search.xpath_query(self.domain,
query,
fuzzy=param.get('fuzzy'))
else:
search = search.case_property_query(
param.get('key'),
value,
clause=param.get('clause'),
fuzzy=param.get('fuzzy'),
)
if xpath:
search = search.xpath_query(self.domain, xpath)
include_profile = request.POST.get("include_profile", False)
if include_profile:
search = search.enable_profiling()
search_results = search.run()
return json_response({
'values':
search_results.raw_hits,
'count':
search_results.total,
'took':
search_results.raw['took'],
'query':
search_results.query.dumps(pretty=True),
'profile':
json.dumps(search_results.raw.get('profile', {}), indent=2),
})
def post(self, request, *args, **kwargs):
from corehq.apps.es.case_search import CaseSearchES
if not case_search_enabled_for_domain(self.domain):
raise BadRequest("Domain does not have case search enabled")
query = json.loads(request.POST.get('q'))
case_type = query.get('type')
search_params = query.get('parameters', [])
search = CaseSearchES()
search = search.domain(self.domain).is_closed(False)
if case_type:
search = search.case_type(case_type)
for param in search_params:
search = search.case_property_query(**param)
search_results = search.values()
return json_response({'values': search_results})
def post(self, request, *args, **kwargs):
from corehq.apps.es.case_search import CaseSearchES
if not case_search_enabled_for_domain(self.domain):
raise BadRequest("Domain does not have case search enabled")
query = json.loads(request.POST.get('q'))
case_type = query.get('type')
owner_id = query.get('owner_id')
search_params = query.get('parameters', [])
query_addition = query.get("customQueryAddition", None)
include_closed = query.get("includeClosed", False)
xpath = query.get("xpath")
search = CaseSearchES()
search = search.domain(self.domain).size(10)
if not include_closed:
search = search.is_closed(False)
if case_type:
search = search.case_type(case_type)
if owner_id:
search = search.owner(owner_id)
for param in search_params:
value = re.sub(param.get('regex', ''), '', param.get('value'))
search = search.case_property_query(
param.get('key'),
value,
clause=param.get('clause'),
fuzzy=param.get('fuzzy'),
)
if query_addition:
addition = CaseSearchQueryAddition.objects.get(id=query_addition,
domain=self.domain)
new_query = merge_queries(search.get_query(),
addition.query_addition)
search = search.set_query(new_query)
if xpath:
search = search.xpath_query(self.domain, xpath)
search_results = search.run()
return json_response({
'values': search_results.raw_hits,
'count': search_results.total,
'took': search_results.raw['took'],
'query': search_results.query.dumps(pretty=True),
})
def post(self, request, *args, **kwargs):
from corehq.apps.es.case_search import CaseSearchES
if not case_search_enabled_for_domain(self.domain):
raise BadRequest("Domain does not have case search enabled")
query = json.loads(request.POST.get('q'))
case_type = query.get('type')
owner_id = query.get('owner_id')
search_params = query.get('parameters', [])
query_addition = query.get("customQueryAddition", None)
include_closed = query.get("includeClosed", False)
xpath = query.get("xpath")
search = CaseSearchES()
search = search.domain(self.domain).size(10)
if not include_closed:
search = search.is_closed(False)
if case_type:
search = search.case_type(case_type)
if owner_id:
search = search.owner(owner_id)
for param in search_params:
value = re.sub(param.get('regex', ''), '', param.get('value'))
search = search.case_property_query(
param.get('key'),
value,
clause=param.get('clause'),
fuzzy=param.get('fuzzy'),
)
if query_addition:
addition = CaseSearchQueryAddition.objects.get(id=query_addition, domain=self.domain)
new_query = merge_queries(search.get_query(), addition.query_addition)
search = search.set_query(new_query)
if xpath:
search = search.xpath_query(self.domain, xpath)
search_results = search.run()
return json_response({
'values': search_results.raw_hits,
'count': search_results.total,
'took': search_results.raw['took'],
'query': search_results.query.dumps(pretty=True),
})
class TestCaseSearchES(ElasticTestMixin, TestCase):
def setUp(self):
self.es = CaseSearchES()
def test_simple_case_property_query(self):
json_output = {
"query": {
"filtered": {
"filter": {
"and": [
{
"term": {
"domain.exact": "swashbucklers"
}
},
{
"match_all": {}
}
]
},
"query": {
"bool": {
"must": [
{
"nested": {
"path": "case_properties",
"query": {
"filtered": {
"filter": {
"term": {
"case_properties.key": "name"
}
},
"query": {
"match": {
"case_properties.value": {
"query": "redbeard",
"fuzziness": "0"
}
}
}
}
}
}
}
]
}
}
}
},
"size": SIZE_LIMIT
}
query = self.es.domain('swashbucklers').case_property_query("name", "redbeard")
self.checkQuery(query, json_output)
def test_multiple_case_search_queries(self):
json_output = {
"query": {
"filtered": {
"filter": {
"and": [
{
"term": {
"domain.exact": "swashbucklers"
}
},
{
"match_all": {}
}
]
},
"query": {
"bool": {
"must": [
{
"nested": {
"path": "case_properties",
"query": {
"filtered": {
"filter": {
"term": {
"case_properties.key": "name"
}
},
"query": {
"match": {
"case_properties.value": {
"query": "redbeard",
"fuzziness": "0"
}
}
}
}
}
}
}
],
"should": [
{
"nested": {
"path": "case_properties",
"query": {
"filtered": {
"filter": {
"term": {
"case_properties.key": "parrot_name"
}
},
"query": {
"match": {
"case_properties.value": {
"query": "polly",
"fuzziness": "AUTO"
}
}
}
}
}
}
}
]
}
}
}
},
"size": SIZE_LIMIT
}
query = (self.es.domain('swashbucklers')
.case_property_query("name", "redbeard")
.case_property_query("parrot_name", "polly", clause="should", fuzzy=True))
self.checkQuery(query, json_output)
def test_flatten_result(self):
expected = {'name': 'blah', 'foo': 'bar', 'baz': 'buzz'}
self.assertEqual(
flatten_result(
{
'name': 'blah',
'case_properties': [
{'key': 'foo', 'value': 'bar'},
{'key': 'baz', 'value': 'buzz'}]
}
),
expected
)
class TestCaseSearchES(ElasticTestMixin, TestCase):
def setUp(self):
self.es = CaseSearchES()
def test_simple_case_property_query(self):
json_output = {
"query": {
"filtered": {
"filter": {
"and": [{
"term": {
"domain.exact": "swashbucklers"
}
}, {
"match_all": {}
}]
},
"query": {
"bool": {
"must": [{
"nested": {
"path": "case_properties",
"query": {
"filtered": {
"filter": {
"term": {
"case_properties.key":
"name"
}
},
"query": {
"match": {
"case_properties.value": {
"query": "redbeard",
"fuzziness": "0"
}
}
}
}
}
}
}]
}
}
}
},
"size": SIZE_LIMIT
}
query = self.es.domain('swashbucklers').case_property_query(
"name", "redbeard")
self.checkQuery(query, json_output)
def test_multiple_case_search_queries(self):
json_output = {
"query": {
"filtered": {
"filter": {
"and": [{
"term": {
"domain.exact": "swashbucklers"
}
}, {
"match_all": {}
}]
},
"query": {
"bool": {
"must": [{
"nested": {
"path": "case_properties",
"query": {
"filtered": {
"filter": {
"term": {
"case_properties.key":
"name"
}
},
"query": {
"match": {
"case_properties.value": {
"query": "redbeard",
"fuzziness": "0"
}
}
}
}
}
}
}, {
"nested": {
"path": "case_properties",
"query": {
"filtered": {
"filter": {
"term": {
"case_properties.key":
"parrot_name"
}
},
"query": {
"match": {
"case_properties.value": {
"query": "polly",
"fuzziness": "AUTO"
}
}
}
}
}
}
}],
"should": [{
"nested": {
"path": "case_properties",
"query": {
"filtered": {
"filter": {
"term": {
"case_properties.key":
"parrot_name"
}
},
"query": {
"match": {
"case_properties.value": {
"query": "polly",
"fuzziness": "0"
}
}
}
}
}
}
}]
}
}
}
},
"size": SIZE_LIMIT
}
query = (self.es.domain('swashbucklers').case_property_query(
"name", "redbeard").case_property_query("parrot_name",
"polly",
clause="should",
fuzzy=True))
self.checkQuery(query, json_output)
def test_flatten_result(self):
expected = {
'name': 'blah',
'foo': 'bar',
'baz': 'buzz',
RELEVANCE_SCORE: "1.095"
}
self.assertEqual(
flatten_result({
"_score": "1.095",
"_source": {
'name':
'blah',
'case_properties': [{
'key': 'foo',
'value': 'bar'
}, {
'key': 'baz',
'value': 'buzz'
}]
}
}), expected)
def test_blacklisted_owner_ids(self):
query = self.es.domain('swashbucklers').blacklist_owner_id(
'123').owner('234')
expected = {
'query': {
'filtered': {
'filter': {
'and': [{
'term': {
'domain.exact': 'swashbucklers'
}
}, {
'not': {
'term': {
'owner_id': '123'
}
}
}, {
'term': {
'owner_id': '234'
}
}, {
'match_all': {}
}]
},
"query": {
"match_all": {}
}
}
},
'size': SIZE_LIMIT
}
self.checkQuery(query, expected)
class TestCaseSearchES(ElasticTestMixin, SimpleTestCase):
def setUp(self):
self.es = CaseSearchES()
def test_simple_case_property_query(self):
json_output = {
"query": {
"filtered": {
"filter": {
"and": [
{
"term": {
"domain.exact": "swashbucklers"
}
},
{
"match_all": {}
}
]
},
"query": {
"bool": {
"must": [
{
"nested": {
"path": "case_properties",
"query": {
"filtered": {
"query": {
"match_all": {
}
},
"filter": {
"and": (
{
"term": {
"case_properties.key.exact": "name"
}
},
{
"term": {
"case_properties.value.exact": "redbeard"
}
}
)
}
}
}
}
}
]
}
}
}
},
"size": SIZE_LIMIT
}
query = self.es.domain('swashbucklers').case_property_query("name", "redbeard")
self.checkQuery(query, json_output)
def test_multiple_case_search_queries(self):
json_output = {
"query": {
"filtered": {
"filter": {
"and": [
{
"term": {
"domain.exact": "swashbucklers"
}
},
{
"match_all": {}
}
]
},
"query": {
"bool": {
"must": [
{
"nested": {
"path": "case_properties",
"query": {
"filtered": {
"filter": {
"and": (
{
"term": {
"case_properties.key.exact": "name"
}
},
{
"term": {
"case_properties.value.exact": "redbeard"
}
}
)
},
"query": {
"match_all": {
}
}
}
}
}
}
],
"should": [
{
"nested": {
"path": "case_properties",
"query": {
"filtered": {
"filter": {
"term": {
"case_properties.key.exact": "parrot_name"
}
},
"query": {
"match": {
"case_properties.value": {
"query": "polly",
"fuzziness": "AUTO"
}
}
}
}
}
}
},
{
"nested": {
"path": "case_properties",
"query": {
"filtered": {
"filter": {
"term": {
"case_properties.key.exact": "parrot_name"
}
},
"query": {
"match": {
"case_properties.value": {
"query": "polly",
"fuzziness": "0"
}
}
}
}
}
}
}
]
}
}
}
},
"size": SIZE_LIMIT
}
query = (self.es.domain('swashbucklers')
.case_property_query("name", "redbeard")
.case_property_query("parrot_name", "polly", clause="should", fuzzy=True))
self.checkQuery(query, json_output)
def test_flatten_result(self):
expected = {'name': 'blah', 'foo': 'bar', 'baz': 'buzz', RELEVANCE_SCORE: "1.095"}
self.assertEqual(
flatten_result(
{
"_score": "1.095",
"_source": {
'name': 'blah',
'case_properties': [
{'key': '@case_id', 'value': 'should be removed'},
{'key': 'name', 'value': 'should be removed'},
{'key': 'case_name', 'value': 'should be removed'},
{'key': 'last_modified', 'value': 'should be removed'},
{'key': 'foo', 'value': 'bar'},
{'key': 'baz', 'value': 'buzz'}]
}
},
include_score=True
),
expected
)
def test_blacklisted_owner_ids(self):
query = self.es.domain('swashbucklers').blacklist_owner_id('123').owner('234')
expected = {'query':
{'filtered':
{'filter':
{'and': [
{'term': {'domain.exact': 'swashbucklers'}},
{'not': {'term': {'owner_id': '123'}}},
{'term': {'owner_id': '234'}},
{'match_all': {}}
]},
"query": {
"match_all": {}
}}},
'size': SIZE_LIMIT}
self.checkQuery(query, expected)
class TestCaseSearchES(ElasticTestMixin, TestCase):
def setUp(self):
self.es = CaseSearchES()
def test_simple_case_property_query(self):
json_output = {
"query": {
"filtered": {
"filter": {
"and": [{
"term": {
"domain.exact": "swashbucklers"
}
}, {
"match_all": {}
}]
},
"query": {
"bool": {
"must": [{
"nested": {
"path": "case_properties",
"query": {
"filtered": {
"filter": {
"term": {
"case_properties.key":
"name"
}
},
"query": {
"match": {
"case_properties.value": {
"query": "redbeard",
"fuzziness": "0"
}
}
}
}
}
}
}]
}
}
}
},
"size": SIZE_LIMIT
}
query = self.es.domain('swashbucklers').case_property_query(
"name", "redbeard")
self.checkQuery(query, json_output)
def test_multiple_case_search_queries(self):
json_output = {
"query": {
"filtered": {
"filter": {
"and": [{
"term": {
"domain.exact": "swashbucklers"
}
}, {
"match_all": {}
}]
},
"query": {
"bool": {
"must": [{
"nested": {
"path": "case_properties",
"query": {
"filtered": {
"filter": {
"term": {
"case_properties.key":
"name"
}
},
"query": {
"match": {
"case_properties.value": {
"query": "redbeard",
"fuzziness": "0"
}
}
}
}
}
}
}],
"should": [{
"nested": {
"path": "case_properties",
"query": {
"filtered": {
"filter": {
"term": {
"case_properties.key":
"parrot_name"
}
},
"query": {
"match": {
"case_properties.value": {
"query": "polly",
"fuzziness": "AUTO"
}
}
}
}
}
}
}]
}
}
}
},
"size": SIZE_LIMIT
}
query = (self.es.domain('swashbucklers').case_property_query(
"name", "redbeard").case_property_query("parrot_name",
"polly",
clause="should",
fuzzy=True))
self.checkQuery(query, json_output)
def test_flatten_result(self):
expected = {'name': 'blah', 'foo': 'bar', 'baz': 'buzz'}
self.assertEqual(
flatten_result({
'name':
'blah',
'case_properties': [{
'key': 'foo',
'value': 'bar'
}, {
'key': 'baz',
'value': 'buzz'
}]
}), expected)
