Access the credentialLists
547864
protected function getCredentialLists() {
        if (!$this->_credentialLists) {
            $this->_credentialLists = new CredentialListList($this->version, $this->solution['accountSid']);
        }

        return $this->_credentialLists;
    }
20965
def verify_credentials(self, delegate=None):
        ""
        parser = txml.Users(delegate)
        return self.__downloadPage('/account/verify_credentials.xml', parser)
878908
def endpoint_list(profile=None, **connection_args):
    '''
    
    '''
    kstone = auth(profile, **connection_args)
    ret = {}

    for endpoint in kstone.endpoints.list():
        ret[endpoint.id] = dict((value, getattr(endpoint, value)) for value in dir(endpoint)
                                if not value.startswith('_') and
                                isinstance(getattr(endpoint, value), (six.string_types, dict, bool)))
    return ret
1161768
protected function getCredentialListMappings() {
        if (!$this->_credentialListMappings) {
            $this->_credentialListMappings = new CredentialListMappingList(
                $this->version,
                $this->solution['accountSid'],
                $this->solution['sid']
            );
        }

        return $this->_credentialListMappings;
    }
933470
def user_list(profile=None, **connection_args):
    '''
    
    '''
    kstone = auth(profile, **connection_args)
    ret = {}
    for user in kstone.users.list():
        ret[user.name] = dict((value, getattr(user, value, None)) for value in dir(user)
                              if not value.startswith('_') and
                              isinstance(getattr(user, value, None), (six.string_types, dict, bool)))
        tenant_id = getattr(user, 'tenantId', None)
        if tenant_id:
            ret[user.name]['tenant_id'] = tenant_id
    return ret
30868
def list_certificates(self):

        '''
            
        '''

        title = '%s.list_certificates' % self.__class__.__name__

    # send request for list of certificates
        self.printer('Querying AWS for server certificates.')
        try:
            response = self.connection.list_server_certificates()
        except:
            raise AWSConnectionError(title)

    # construct certificate list from response
        cert_list = []
        if 'ServerCertificateMetadataList' in response.keys():
            for certificate in response['ServerCertificateMetadataList']:
                cert_list.append(certificate['ServerCertificateName'])

    # report results and return list
        if cert_list:
            print_out = 'Found server certificate'
            if len(cert_list) > 1:
                print_out += 's'
            from labpack.parsing.grammar import join_words
            print_out += ' %s.' % join_words(cert_list)
            self.printer(print_out)
        else:
            self.printer('No server certificates found.')

        self.certificate_list = cert_list
        
        return self.certificate_list
361304
def index(credentials = None):
    """"""

    #handle shortcut
    shortcutresponse = entryshortcut(credentials)
    if shortcutresponse is not None:
        return shortcutresponse

    projects = []
    user, oauth_access_token = parsecredentials(credentials)
    totalsize = 0.0
    if settings.LISTPROJECTS:
        projects, totalsize = getprojects(user)

    errors = "no"
    errormsg = ""

    corpora = CLAMService.corpusindex()

    #pylint: disable=bad-continuation
    return withheaders(flask.make_response(flask.render_template('response.xml',
            version=VERSION,
            system_id=settings.SYSTEM_ID,
            system_name=settings.SYSTEM_NAME,
            system_description=settings.SYSTEM_DESCRIPTION,
            system_author=settings.SYSTEM_AUTHOR,
            system_version=settings.SYSTEM_VERSION,
            system_email=settings.SYSTEM_EMAIL,
            user=user,
            project=None,
            url=getrooturl(),
            statuscode=-1,
            statusmessage="",
            statuslog=[],
            completion=0,
            errors=errors,
            errormsg=errormsg,
            parameterdata=settings.PARAMETERS,
            inputsources=corpora,
            outputpaths=None,
            inputpaths=None,
            profiles=settings.PROFILES,
            datafile=None,
            projects=projects,
            totalsize=totalsize,
            actions=settings.ACTIONS,
            disableinterface=not settings.ENABLEWEBAPP,
            info=False,
            accesstoken=None,
            interfaceoptions=settings.INTERFACEOPTIONS,
            customhtml=settings.CUSTOMHTML_INDEX,
            allow_origin=settings.ALLOW_ORIGIN,
            oauth_access_token=oauth_encrypt(oauth_access_token),
            auth_type=auth_type()
            )), headers={'allow_origin':settings.ALLOW_ORIGIN})
603721
def credentials(self):
        
        if self._credentials is None:
            self._credentials = CredentialList(
                self._version,
                account_sid=self._solution['account_sid'],
                credential_list_sid=self._solution['sid'],
            )
        return self._credentials
631359
public ListZonesResponse listZones() {
        return listZones(new AbstractBceRequest() {
            @Override
            public AbstractBceRequest withRequestCredentials(BceCredentials credentials) {
                return null;
            }
        });
    }
1005568
def get_credentials(self):
        
        return ReadOnlyCredentials(
            self.access_token, self.client_id, self.client_secret,
            self.refresh_token
        )
1234794
def list(self):
        
        
        uri = URITemplate(self.baseuri + '/{owner}').expand(
            owner=self.username)
        return self.session.get(uri)
817913
def get_auto_credentials(self, bucket):
        

        result = {k: v(self) for k, v in self.get_unique_creds_dict().items()}
        if bucket:
            result.update(self.get_cred_bucket(bucket))
        else:
            result.update(self.get_cred_not_bucket())
        return result
18749
protected function actionListCredential()
    {
        list($selected, $action) = $this->getPostedAction();

        $deleted = 0;

        foreach ($selected as $id) {
            if ($action === 'delete' && $this->access('module_gapi_credential_delete')) {
                $credential = $this->credential->get($id);
                $deleted += (int) $this->credential->callHandler($credential['type'], 'delete', array(
                    $credential['credential_id']));
            }
        }

        if ($deleted > 0) {
            $message = $this->text('Deleted %num item(s)', array('%num' => $deleted));
            $this->setMessage($message, 'success');
        }
    }
1254370
def certs(self):
        """"""
        return dict([(a, e) for a, e in self.entries.items()
                     if isinstance(e, TrustedCertEntry)])
984556
def credential_lists(self):
        
        if self._credential_lists is None:
            self._credential_lists = CredentialListList(
                self._version,
                account_sid=self._solution['account_sid'],
            )
        return self._credential_lists
94662
def _to_dict(self):
        """"""
        _dict = {}
        if hasattr(self, 'type') and self.type is not None:
            _dict['type'] = self.type
        if hasattr(self, 'credential_id') and self.credential_id is not None:
            _dict['credential_id'] = self.credential_id
        if hasattr(self, 'schedule') and self.schedule is not None:
            _dict['schedule'] = self.schedule._to_dict()
        if hasattr(self, 'options') and self.options is not None:
            _dict['options'] = self.options._to_dict()
        return _dict
648849
def find_credentials():
    '''
    
    '''

    # if the username and password were already found don't go through the
    # connection process again
    if 'username' in DETAILS and 'password' in DETAILS:
        return DETAILS['username'], DETAILS['password']

    passwords = __pillar__['proxy']['passwords']
    for password in passwords:
        DETAILS['password'] = password
        if not __salt__['vsphere.test_vcenter_connection']():
            # We are unable to authenticate
            continue
        # If we have data returned from above, we've successfully authenticated.
        return DETAILS['username'], password
    # We've reached the end of the list without successfully authenticating.
    raise excs.VMwareConnectionError('Cannot complete login due to '
                                     'incorrect credentials.')