def _form_rows(self, domain):
        time_filter = form_es.submitted
        datespan = DateSpan(datetime.now() - timedelta(days=self.window),
                            datetime.utcnow())
        apps = get_brief_apps_in_domain(domain.name)
        apps = {a.id: a.name for a in apps}

        users_filter = form_es.user_id(
            EMWF.user_es_query(
                domain.name,
                ['t__0'],  # All mobile workers
                self.couch_user).values_list('_id', flat=True))
        query = (form_es.FormES().domain(domain.name).filter(
            time_filter(gte=datespan.startdate,
                        lt=datespan.enddate_adjusted)).filter(users_filter))
        rows = []
        for hit in query.run().hits:
            username = hit['form']['meta']['username']
            submitted = self._format_date(
                datetime.strptime(hit['received_on'][:19],
                                  '%Y-%m-%dT%H:%M:%S'))
            rows.append([
                hit['form']['@name'],
                submitted,
                apps[hit['app_id']] if hit['app_id'] in
                apps else 'App not found',
                username,
            ] + self._domain_properties(domain))
        return rows
Exemple #2
0
 def test_filtered_forms(self):
     json_output = {
         "query": {
             "filtered": {
                 "filter": {
                     "and": [
                         {"term": {"domain.exact": "zombocom"}},
                         {"term": {"xmlns.exact": "banana"}},
                         {"not": {"missing": {
                             "field": "domain"}}},
                         {"term": {"doc_type": "xforminstance"}},
                         {"not": {"missing":
                             {"field": "xmlns"}}},
                         {"not": {"missing":
                             {"field": "form.meta.userID"}}},
                     ]
                 },
                 "query": {"match_all": {}}
             }
         },
         "size": SIZE_LIMIT
     }
     query = forms.FormES()\
             .filter(filters.domain("zombocom"))\
             .xmlns('banana')
     self.checkQuery(query, json_output)
Exemple #3
0
 def test_form_query(self):
     json_output = {
         "query": {
             "filtered": {
                 "filter": {
                     "and": [
                         {"not": {"missing": {
                             "field": "domain"}}},
                         {"term": {"doc_type": "xforminstance"}},
                         {"not": {"missing":
                             {"field": "xmlns"}}},
                         {"not": {"missing":
                             {"field": "form.meta.userID"}}},
                     ]
                 },
                 "query": {"match_all": {}}
             }
         },
         "size": SIZE_LIMIT
     }
     query = forms.FormES()
     raw_query = query.raw_query
     self.assertItemsEqual(
         raw_query['query']['filtered']['filter'].pop('and'),
         json_output['query']['filtered']['filter'].pop('and')
     )
     self.checkQuery(raw_query, json_output, is_raw_query=True)
Exemple #4
0
    def es_query(self):
        time_filter = form_es.submitted if self.by_submission_time else form_es.completed
        mobile_user_and_group_slugs = self.request.GET.getlist(EMWF.slug)

        query = (form_es.FormES().domain(self.domain).filter(
            time_filter(
                gte=self.datespan.startdate,
                lt=self.datespan.enddate_adjusted)).filter(
                    self._get_users_filter(mobile_user_and_group_slugs)))

        if not self.request.can_access_all_locations:
            query = query.filter(self.scope_filter())

        # filter results by app and xmlns if applicable
        if FormsByApplicationFilter.has_selections(self.request):
            form_values = self.all_relevant_forms.values()
            if form_values:
                query = query.OR(*[self._form_filter(f) for f in form_values])

        # Exclude system forms unless they selected "Unknown User"
        if HQUserType.UNKNOWN not in EMWF.selected_user_types(
                mobile_user_and_group_slugs):
            query = query.NOT(form_es.xmlns(SYSTEM_FORM_XMLNS))

        return query
    def test_values_list(self):
        example_response = {
            u'_shards': {
                u'failed': 0,
                u'successful': 5,
                u'total': 5
            },
            u'hits': {
                u'hits': [{
                    u'_id': u'8063dff5-460b-46f2-b4d0-5871abfd97d4',
                    u'_index': u'xforms_1cce1f049a1b4d864c9c25dc42648a45',
                    u'_score': 1.0,
                    u'_type': u'xform',
                    u'_source': {
                        u'app_id':
                        u'fe8481a39c3738749e6a4766fca99efd',
                        u'doc_type':
                        u'xforminstance',
                        u'domain':
                        u'mikesproject',
                        u'xmlns':
                        u'http://openrosa.org/formdesigner/3a7cc07c-551c-4651-ab1a-d60be3017485'
                    }
                }, {
                    u'_id': u'dc1376cd-0869-4c13-a267-365dfc2fa754',
                    u'_index': u'xforms_1cce1f049a1b4d864c9c25dc42648a45',
                    u'_score': 1.0,
                    u'_type': u'xform',
                    u'_source': {
                        u'app_id':
                        u'3d622620ca00d7709625220751a7b1f9',
                        u'doc_type':
                        u'xforminstance',
                        u'domain':
                        u'jacksproject',
                        u'xmlns':
                        u'http://openrosa.org/formdesigner/54db1962-b938-4e2b-b00e-08414163ead4'
                    }
                }],
                u'max_score':
                1.0,
                u'total':
                5247
            },
            u'timed_out': False,
            u'took': 4
        }
        fields = [u'app_id', u'doc_type', u'domain']
        query = forms.FormES()
        with patch('corehq.apps.es.es_query.run_query',
                   return_value=example_response):
            response = query.values_list(*fields)
            self.assertEqual([(u'fe8481a39c3738749e6a4766fca99efd',
                               u'xforminstance', u'mikesproject'),
                              (u'3d622620ca00d7709625220751a7b1f9',
                               u'xforminstance', u'jacksproject')], response)

            response = query.values_list('domain', flat=True)
            self.assertEqual([u'mikesproject', u'jacksproject'], response)
Exemple #6
0
    def hits(self, domain_name):
        time_filter = form_es.submitted
        datespan = DateSpan(datetime.now() - timedelta(days=self.window),
                            datetime.utcnow())

        users_filter = form_es.user_id(
            EMWF.user_es_query(
                domain_name,
                ['t__0'],  # All mobile workers
                self.couch_user).values_list('_id', flat=True))
        query = (form_es.FormES().domain(domain_name).filter(
            time_filter(gte=datespan.startdate,
                        lt=datespan.enddate_adjusted)).filter(users_filter))
        return query.run().hits
Exemple #7
0
 def test_filtered_forms(self):
     json_output = {
         "query": {
             "bool": {
                 "filter": [
                     {
                         "term": {
                             "domain.exact": "zombocom"
                         }
                     },
                     {
                         "term": {
                             "xmlns.exact": "banana"
                         }
                     },
                     {
                         "term": {
                             "doc_type": "xforminstance"
                         }
                     },
                     {
                         "exists": {
                             "field": "xmlns"
                         }
                     },
                     {
                         "exists": {
                             "field": "form.meta.userID"
                         }
                     },
                     {
                         "exists": {
                             "field": "domain"
                         }
                     },
                 ],
                 "must": {
                     "match_all": {}
                 }
             }
         },
         "size": SIZE_LIMIT
     }
     query = forms.FormES()\
             .filter(filters.domain("zombocom"))\
             .xmlns('banana')
     raw_query = query.raw_query
     self.checkQuery(raw_query, json_output, is_raw_query=True)
 def test_form_query(self):
     json_output = {
         "query": {
             "filtered": {
                 "filter": {
                     "and": [
                         {
                             "not": {
                                 "missing": {
                                     "field": "domain"
                                 }
                             }
                         },
                         {
                             "term": {
                                 "doc_type": "xforminstance"
                             }
                         },
                         {
                             "not": {
                                 "missing": {
                                     "field": "xmlns"
                                 }
                             }
                         },
                         {
                             "not": {
                                 "missing": {
                                     "field": "form.meta.userID"
                                 }
                             }
                         },
                     ]
                 },
                 "query": {
                     "match_all": {}
                 }
             }
         },
         "size": SIZE_LIMIT
     }
     query = forms.FormES()
     self.checkQuery(query, json_output)
Exemple #9
0
 def test_form_query(self):
     json_output = {
         "query": {
             "bool": {
                 "filter": [
                     {
                         "term": {
                             "doc_type": "xforminstance"
                         }
                     },
                     {
                         "exists": {
                             "field": "xmlns"
                         }
                     },
                     {
                         "exists": {
                             "field": "form.meta.userID"
                         }
                     },
                     {
                         "exists": {
                             "field": "domain"
                         }
                     },
                 ],
                 "must": {
                     "match_all": {}
                 }
             }
         },
         "size": SIZE_LIMIT
     }
     query = forms.FormES()
     raw_query = query.raw_query
     self.checkQuery(raw_query, json_output, is_raw_query=True)