Returns a list of recipients subscribed to receive SMS's
        for this "notifications" class.

        See also: edc_auth.UserProfile.
503518
def sms_recipients(self):
        
        sms_recipients = []
        UserProfile = django_apps.get_model("edc_auth.UserProfile")
        for user_profile in UserProfile.objects.filter(
            user__is_active=True, user__is_staff=True
        ):
            try:
                user_profile.sms_notifications.get(name=self.name)
            except ObjectDoesNotExist:
                pass
            else:
                if user_profile.mobile:
                    sms_recipients.append(user_profile.mobile)
        return sms_recipients
944714
def get_all_subscriptions(self, next_token=None):
        
        params = {'ContentType' : 'JSON'}
        if next_token:
            params['NextToken'] = next_token
        response = self.make_request('ListSubscriptions', params, '/', 'GET')
        body = response.read()
        if response.status == 200:
            return json.loads(body)
        else:
            boto.log.error('%s %s' % (response.status, response.reason))
            boto.log.error('%s' % body)
            raise self.ResponseError(response.status, response.reason, body)
33879
def messages(self):
        
        if self._messages is None:
            self._messages = MessageList(self._version, account_sid=self._solution['sid'], )
        return self._messages
1211564
def members(self):
        
        if self._members is None:
            self._members = MemberList(
                self._version,
                account_sid=self._solution['account_sid'],
                queue_sid=self._solution['sid'],
            )
        return self._members
95333
def list_user_luisaccounts(custom_headers:nil)
      response = list_user_luisaccounts_async(custom_headers:custom_headers).value!
      response.body unless response.nil?
    end
564796
def users(self):
        
        return Users(url="%s/users" % self.root,
                     securityHandler=self._securityHandler,
                     proxy_url=self._proxy_url,
                     proxy_port=self._proxy_port)
366721
def subscribers(self):
        """"""
        return [s for p, s in sorted(self._subscribers, key=lambda x: x[0])]
82960
def get_subscribers(self):
        
        data = self.signal.instance_subscribers
        if self.instance not in data:
            data[self.instance] = MethodAwareWeakList()
        return data[self.instance]
428706
def discord_to_users(self, memberlist):
		
		_memberlist = self.get_discord_user(x.id for x in memberlist)
		return list(set(x.owner() for x in _memberlist))
1267024
def getVerifiers(self):
        
        contacts = list()
        for verifier in self.getVerifiersIDs():
            user = api.get_user(verifier)
            contact = api.get_user_contact(user, ["LabContact"])
            if contact:
                contacts.append(contact)
        return contacts
982195
private Collection<User> getSFSRecipients() {
        List<User> answer = new ArrayList<>();
        for(String recipient : recipients) {
            User sfsUser = CommandUtil.getSfsUser(recipient, api);
            if(sfsUser != null)
                answer.add(sfsUser);
        }
        return answer;
    }
39324
def contacts_getPublicList(user_id):
    """"""
    method = 'flickr.contacts.getPublicList'
    data = _doget(method, auth=False, user_id=user_id)
    if isinstance(data.rsp.contacts.contact, list):
        return [User(user.nsid, username=user.username) \
                for user in data.rsp.contacts.contact]
    else:
        user = data.rsp.contacts.contact
        return [User(user.nsid, username=user.username)]
660716
def list_subscriptions(self, service):
        """"""
        data = {
            'service': service,
        }
        return self._perform_post_request(self.list_subscriptions_endpoint, data, self.token_header)
1181694
def get_followers(self):
        
        response = self._session.fetch_items("users.getFollowers", self.from_json, self._session,  count=1000, user_id=self.id, fields=self.USER_FIELDS)
        return response
976527
def has_subscriber(self, user):
        
        if not hasattr(self, '_subscribers'):
            self._subscribers = list(self.subscribers.all())
        return user in self._subscribers
750218
def notifications(self):
        
        if self._notifications is None:
            self._notifications = NotificationList(self._version, account_sid=self._solution['sid'], )
        return self._notifications
639149
def inbox_count_for(user):
    
    return Message.objects.filter(recipient=user, read_at__isnull=True, recipient_deleted_at__isnull=True).count()