def add_query_criteria(self,
                        query_fields,
                        query,
                        query_text,
                        query_params=None):
     query = super(SubmissionQueryBuilder,
                   self).add_query_criteria(query_fields, query, query_text,
                                            query_params)
     search_filter_param = query_params.get('search_filters')
     if search_filter_param:
         submission_date_range = search_filter_param.get(
             "submissionDatePicker")
         reporting_date_range = search_filter_param.get(
             "reportingPeriodPicker")
         query = SubmissionDateRangeFilter(
             submission_date_range).build_filter_query(query)
         query = ReportingDateRangeFilter(
             reporting_date_range,
             self.form_model).build_filter_query(query)
         datasender_filter = search_filter_param.get("datasenderFilter")
         if datasender_filter:
             query = query.filter(ds_id=datasender_filter)
         subjectFilter = search_filter_param.get("subjectFilter")
         if subjectFilter:
             query = query.filter(entity_short_code=subjectFilter)
     return query
    def test_get_formatted_date(self):
        submission_date_format = DateField.FORMAT_DATE_DICTIONARY.get(
            'submission_date_format')

        result = SubmissionDateRangeFilter('a-a')._format_date(
            '28.11.2013', submission_date_format)
        self.assertEquals('Nov. 28, 2013, 12:00 AM', result)
 def test_should_call_query_match_for_current_day(self):
     mock_query = Mock(spec=elasticutils.S)
     today = "26.11.2013"
     SubmissionDateRangeFilter(today).build_filter_query(mock_query)
     mock_query.filter.assert_called_with(date_value__range=[
         'Nov. 26, 2013, 12:00 AM', 'Nov. 26, 2013, 11:59 PM'
     ])
 def test_should_build_query_with_start_and_end_date(self):
     mock_query = Mock(spec=elasticutils.S)
     SubmissionDateRangeFilter('21.11.2013-28.11.2013').build_filter_query(
         mock_query)
     mock_query.filter.assert_called_with(date_value__range=[
         'Nov. 21, 2013, 12:00 AM', 'Nov. 28, 2013, 11:59 PM'
     ])
Example #5
0
def _create_search(dbm, form_model, local_time_delta, pagination_params,
                   sort_params, search_parameters):
    es = Elasticsearch(hosts=[{
        "host": ELASTIC_SEARCH_HOST,
        "port": ELASTIC_SEARCH_PORT
    }])
    search = Search(using=es, index=dbm.database_name, doc_type=form_model.id)
    search = search.sort(sort_params)
    search = search.extra(**pagination_params)
    search = search.query('match', status='Success')
    search = search.query('term', void=False)
    if search_parameters.get('data_sender_filter'):
        search = search.query(
            "term",
            **{"datasender.id": search_parameters.get('data_sender_filter')})
    if search_parameters.get('unique_id_filters'):
        search = _add_unique_id_filters(
            form_model, search_parameters.get('unique_id_filters'), search)
    if search_parameters.get('date_question_filters'):
        for key, values in search_parameters.get(
                'date_question_filters').iteritems():
            query = DateQuestionRangeFilter(values['dateRange'], form_model,
                                            key).build_filter_query()
            if query is not None:
                search = search.query(query)
    if search_parameters.get('search_text'):
        query_text_escaped = ElasticUtilsHelper().replace_special_chars(
            search_parameters.get('search_text'))
        search = search.query("query_string", query=query_text_escaped)
    submission_date_query = SubmissionDateRangeFilter(
        search_parameters.get('submission_date_range'),
        local_time_delta).build_filter_query()
    if submission_date_query:
        search = search.query(submission_date_query)
    return search
Example #6
0
def _add_search_filters(search_filter_param, form_model, local_time_delta,
                        query_fields, search):
    if not search_filter_param:
        return

    query_text = search_filter_param.get("search_text")
    query_text_escaped = ElasticUtilsHelper().replace_special_chars(query_text)
    if query_text:
        search = search.query("query_string",
                              query=query_text_escaped,
                              fields=query_fields)
    submission_date_range = search_filter_param.get("submissionDatePicker")
    submission_date_query = SubmissionDateRangeFilter(
        submission_date_range, local_time_delta).build_filter_query()
    if submission_date_query:
        search = search.query(submission_date_query)
    search = _add_date_range_filters(
        search_filter_param.get("dateQuestionFilters"), form_model, search)
    datasender_filter = search_filter_param.get("datasenderFilter")
    if datasender_filter:
        search = search.query("term", ds_id_exact=datasender_filter)
    search = _add_unique_id_filters(form_model,
                                    search_filter_param.get("uniqueIdFilters"),
                                    search)
    return search
    def add_query_criteria(self,
                           query_fields,
                           query,
                           query_text,
                           query_params=None):
        query = super(SubmissionQueryBuilder,
                      self).add_query_criteria(query_fields, query, query_text,
                                               query_params)
        search_filter_param = query_params.get('search_filters')
        if search_filter_param:
            submission_date_range = search_filter_param.get(
                "submissionDatePicker")
            query = SubmissionDateRangeFilter(
                submission_date_range).build_filter_query(query)
            query = self._add_date_range_filters(query, search_filter_param)
            datasender_filter = search_filter_param.get("datasenderFilter")
            if datasender_filter:
                query = query.filter(ds_id=datasender_filter)

            query = self._add_unique_id_filters(
                query, search_filter_param.get("uniqueIdFilters"))
        return query
 def test_should_not_call_query_with_start_and_end_date_for_invalid_date_range(
         self):
     mock_query = Mock(spec=elasticutils.S)
     result = SubmissionDateRangeFilter('All Periods').build_filter_query(
         mock_query)
     self.assertEquals(result, mock_query)
 def test_should_return_no_query_for_invalid_date_range(self):
     actual_query = SubmissionDateRangeFilter('All Periods', ('+', 1, 30)).build_filter_query()
     self.assertEqual(actual_query, None)
 def test_should_return_range_with_local_to_utc_conversion(self):
     actual_query = SubmissionDateRangeFilter('21.11.2013-28.11.2013', ('+', 1, 30)).build_filter_query()
     self.assertDictEqual(actual_query.to_dict(),
                          {'range': {'date_value': {'gte': 'Nov. 20, 2013, 10:30 PM',
                                                    'lte': 'Nov. 28, 2013, 10:29 PM'}}})
 def test_should_call_query_match_for_current_day(self):
     today = "26.11.2013"
     actual_query = SubmissionDateRangeFilter(today, ('+', 0, 0)).build_filter_query()
     self.assertDictEqual(actual_query.to_dict(),
                          {'range': {'date_value': {'gte': 'Nov. 26, 2013, 12:00 AM',
                                                    'lte': 'Nov. 26, 2013, 11:59 PM'}}})
 def test_should_build_query_with_start_and_end_date(self):
     actual_query = SubmissionDateRangeFilter('21.11.2013-28.11.2013', ('-', 1, 30)).build_filter_query()
     self.assertDictEqual(actual_query.to_dict(),
                          {'range': {'date_value': {'gte': 'Nov. 21, 2013, 01:30 AM',
                                                    'lte': 'Nov. 29, 2013, 01:29 AM'}}})