Python models.HQUserType类代码示例

    def es_query(self):
        if not getattr(self, 'es_response', None):
            q = {
                "query": {
                    "range": {
                        self.time_field: {
                            "from": self.datespan.startdate_param,
                            "to": self.datespan.enddate_param,
                            "include_upper": False}}},
                "filter": {"and": ADD_TO_ES_FILTER["forms"][:]}}

            xmlnss = filter(None, [f["xmlns"] for f in self.all_relevant_forms.values()])
            if xmlnss:
                q["filter"]["and"].append({"terms": {"xmlns.exact": xmlnss}})

            users_data = ExpandedMobileWorkerFilter.pull_users_and_groups(self.domain, self.request, True, True)
            if "t__0" not in self.request.GET.getlist("emw") or users_data["admin_and_demo_users"]:
                q["filter"]["and"].append(
                    {"terms": {"form.meta.userID": filter(None, [u["user_id"] for u in users_data["combined_users"]])}})
            else:
                negated_ids = util.get_all_users_by_domain(self.domain, user_filter=HQUserType.all_but_users(), simplified=True)
                ids = filter(None, [user['user_id'] for user in negated_ids])
                q["filter"]["and"].append({"not": {"terms": {"form.meta.userID": ids}}})

            for cp in filter(None, self.request.GET.get('form_data', "").split(",")):
                q["filter"]["and"].append({"term": {"__props_for_querying": cp.lower()}})

            q["sort"] = self.get_sorting_block() if self.get_sorting_block() else [{self.time_field : {"order": "desc"}}]
            self.es_response = es_query(params={"domain.exact": self.domain}, q=q, es_url=XFORM_INDEX + '/xform/_search',
                start_at=self.pagination.start, size=self.pagination.count)
        return self.es_response

 def get_user_filter(cls, request):
     ufilter = group = individual = None
     try:
         if request.GET.get('ufilter', ''):
             ufilter = request.GET.getlist('ufilter')
         group = request.GET.get('group', '')
         individual = request.GET.get('individual', '')
     except KeyError:
         pass
     show_filter = True
     toggle = HQUserType.use_defaults()
     if ufilter and not (group or individual):
         toggle = HQUserType.use_filter(ufilter)
     elif group or individual:
         show_filter = False
     return toggle, show_filter

 def get_admins_and_demo_users(self, ufilters=None):
     ufilters = ufilters if ufilters is not None else ['1', '2', '3']
     users = self.get_all_users_by_domain(
         group=None,
         user_filter=tuple(HQUserType.use_filter(ufilters)),
         simplified=True
     ) if ufilters else []
     return users

def get_all_users_by_domain(domain=None, group=None, user_ids=None,
                            user_filter=None, simplified=False, CommCareUser=None, include_inactive=False):
    """
        WHEN THERE ARE A LOT OF USERS, THIS IS AN EXPENSIVE OPERATION.
        Returns a list of CommCare Users based on domain, group, and user 
        filter (demo_user, admin, registered, unknown)
    """
    user_ids = user_ids if user_ids and user_ids[0] else None
    if not CommCareUser:
        from corehq.apps.users.models import CommCareUser

    if group:
        # get all the users only in this group and don't bother filtering.
        if not isinstance(group, Group):
            group = Group.get(group)
        users = group.get_users(is_active=(not include_inactive), only_commcare=True)
    elif user_ids is not None:
        try:
            users = [CommCareUser.get_by_user_id(id) for id in user_ids]
        except Exception:
            users = []
        if users and users[0] is None:
            raise Http404()
    else:
        if not user_filter:
            user_filter = HQUserType.all()
        users = []
        submitted_user_ids = get_all_userids_submitted(domain)
        registered_user_ids = dict([(user.user_id, user) for user in CommCareUser.by_domain(domain)])
        if include_inactive:
            registered_user_ids.update(dict([(u.user_id, u) for u in CommCareUser.by_domain(domain, is_active=False)]))
        for user_id in submitted_user_ids:
            if user_id in registered_user_ids and user_filter[HQUserType.REGISTERED].show:
                user = registered_user_ids[user_id]
                users.append(user)
            elif not user_id in registered_user_ids and \
                 (user_filter[HQUserType.ADMIN].show or
                  user_filter[HQUserType.DEMO_USER].show or
                  user_filter[HQUserType.UNKNOWN].show):
                username = get_username_from_forms(domain, user_id)
                temp_user = TempCommCareUser(domain, username, user_id)
                if user_filter[temp_user.filter_flag].show:
                    users.append(temp_user)
        if user_filter[HQUserType.UNKNOWN].show:
            users.append(TempCommCareUser(domain, '*', None))

        if user_filter[HQUserType.REGISTERED].show:
            # now add all the registered users who never submitted anything
            for user_id in registered_user_ids:
                if not user_id in submitted_user_ids:
                    user = CommCareUser.get_by_user_id(user_id)
                    users.append(user)

    if simplified:
        return [_report_user_dict(user) for user in users]
    return users

 def report_context(self):
     context = super(CaseReassignmentInterface, self).report_context
     active_users = util.get_all_users_by_domain(self.domain, user_filter=HQUserType.use_defaults(), simplified=True)
     context.update(
         users=[dict(ownerid=user.get('user_id'), name=user.get('username_in_report'), type="user")
                for user in active_users],
         groups=[dict(ownerid=group.get_id, name=group.name, type="group")
                 for group in self.all_case_sharing_groups]
     )
     return context

 def report_context(self):
     context = super(CaseReassignmentInterface, self).report_context
     active_users = self.get_all_users_by_domain(user_filter=tuple(HQUserType.all()), simplified=True)
     context.update(
         users=[dict(ownerid=user.user_id, name=user.username_in_report, type="user")
                for user in active_users],
         groups=[dict(ownerid=group.get_id, name=group.name, type="group")
                 for group in self.all_case_sharing_groups],
         user_ids=self.user_ids,
     )
     return context