Retrieve a list of all the accounts
@param bank If we want a bank list or not
@return A List of accounts
493450
public List<String> getAllAccounts(boolean bank) {
        return Common.getInstance().getStorageHandler().getStorageEngine().getAllAccounts(bank);
    }
329661
@Nullable
    public List<Transaction> getTransactions() {
        return transactions == null ? null : ImmutableList.copyOf(transactions);
    }
357285
public static function getBanks($paymentMethodId = 10)
    {
        $paymentMethods = self::getList();
        if (isset($paymentMethods[$paymentMethodId])) {
            return $paymentMethods[$paymentMethodId]['banks'];
        }
        return array();
    }
481544
def list_(bank):
    '''
    
    '''
    try:
        _, keys = api.kv.get(bank + '/', keys=True, separator='/')
    except Exception as exc:
        raise SaltCacheError(
            'There was an error getting the key "{0}": {1}'.format(
                bank, exc
            )
        )
    if keys is None:
        keys = []
    else:
        # Any key could be a branch and a leaf at the same time in Consul
        # so we have to return a list of unique names only.
        out = set()
        for key in keys:
            out.add(key[len(bank) + 1:].rstrip('/'))
        keys = list(out)
    return keys
540261
def get_by_name_from(self, root: Account, name: str) -> List[Account]:
        
        result = []

        if root.name == name:
            result.append(root)

        for child in root.children:
            child_results = self.get_by_name_from(child, name)
            result += child_results

        return result
1176808
@Override
    public List<StorageAccount> getStorageAccounts() {
        List<StorageAccount> accts = new ArrayList<>();

        Iterator<String> ids = getAccountManager().getStorageAccountIds();
        while (ids.hasNext()) {
            accts.add(getAccountManager().getStorageAccount(ids.next()));
        }
        return accts;
    }
171792
public Accounts getChildAccounts(final String accountCode) {
        return doGET(Account.ACCOUNT_RESOURCE + "/" + accountCode + "/child_accounts", Accounts.class, new QueryParams());
    }
256417
def get_transactions(self, account_id, **params):
        """"""
        response = self._get('v2', 'accounts', account_id, 'transactions', params=params)
        return self._make_api_object(response, Transaction)
291378
public List<CmsAccountInfo> getAccountInfos() {

        if (m_accountInfos == null) {
            return Collections.unmodifiableList(Arrays.asList(DEFAULT_ACCOUNT_INFOS));
        } else {
            return Collections.unmodifiableList(m_accountInfos);
        }
    }
1328082
def get_list(self, ids: List[str]) -> List[Account]:
        
        query = (
            self.query
            .filter(Account.guid.in_(ids))
        )
        return query.all()
766972
def list_accounts(self):
        """"""

        account = self.client['Account']
        mask = 'cdnAccounts[%s]' % ', '.join(['id',
                                              'createDate',
                                              'cdnAccountName',
                                              'cdnSolutionName',
                                              'cdnAccountNote',
                                              'status'])
        return account.getObject(mask=mask).get('cdnAccounts', [])
705384
public java.util.List<BillingRecord> getBillingRecords() {
        if (billingRecords == null) {
            billingRecords = new com.amazonaws.internal.SdkInternalList<BillingRecord>();
        }
        return billingRecords;
    }
144446
def accounts(self):
        
        if self._accounts is None:
            self._accounts = AccountList(self)
        return self._accounts
514456
def account_lists(self, id):
        
        id = self.__unpack_id(id)
        params = self.__generate_params(locals(), ['id'])
        url = '/api/v1/accounts/{0}/lists'.format(str(id))
        return self.__api_request('GET', url, params)
269555
public List<StorageAccount> createStorageAccountsFrom(Element accounts) {
        List<StorageAccount> accts = new ArrayList<StorageAccount>();
        try {
            Iterator<?> accountList = accounts.getChildren().iterator();
            while (accountList.hasNext()) {
                Element accountXml = (Element) accountList.next();

                String type = accountXml.getChildText("storageProviderType");
                StorageProviderType acctType = StorageProviderType.fromString(
                    type);

                StorageAccountProviderBinding providerBinding = providerBindings
                    .get(acctType);
                if (null != providerBinding) {
                    accts.add(providerBinding.getAccountFromXml(accountXml));

                } else {
                    log.warn("Unexpected account type: " + acctType);
                }
            }

            // Make sure that there is at least one storage account
            if (accts.isEmpty()) {
                String error = "No storage accounts could be read";
                throw new StorageException(error);
            }

        } catch (Exception e) {
            String error = "Unable to build storage account information due " +
                           "to error: " + e.getMessage();
            log.error(error);
            throw new StorageException(error, e);
        }

        return accts;
    }
1086769
public List<Map<String, Object>> listBankAccounts(String moipAccountId, Setup setup) {
        this.requestMaker = new RequestMaker(setup);
        RequestProperties props = new RequestPropertiesBuilder()
                .method("GET")
                .endpoint(String.format("%s/%s/bankaccounts", ENDPOINT, moipAccountId))
                .type(BankAccounts.class)
                .contentType(CONTENT_TYPE)
                .build();

        return this.requestMaker.getList(props);
    }
86736
public function getAccounts(array $account_ids = [])
    {
        //Get account
        $response = $this->postToAPI('/users/get_account_batch', ['account_ids' => $account_ids]);
        $body = $response->getDecodedBody();

        //Make and return the model
        return new AccountList($body);
    }