Get the whole account balance in a certain world / world group

@param world The world / world group to search in
@return A list of Balance
760291
public List<Balance> getAllWorldBalance(String world) {
        if (!Common.getInstance().getWorldGroupManager().worldGroupExist(world)) {
            world = Common.getInstance().getWorldGroupManager().getWorldGroupName(world);
        }
        return Common.getInstance().getStorageHandler().getStorageEngine().getAllWorldBalance(this, world);
    }
1348938
@Override
	public List<CommerceCurrency> findByGroupId(long groupId) {
		return findByGroupId(groupId, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
	}
313250
public List<Session> getSessionsByAccount(String account) {
        String url = WxEndpoint.get("url.care.session.list.byaccount");
        String response = wxClient.get(String.format(url, account));
        logger.debug("list care sessions by care account :{}", response);
        SessionList sessionList = JsonMapper.defaultMapper().fromJson(response, SessionList.class);
        return sessionList.getSessions();
    }
980087
def get_balance(self, acc_id=None, site='Pro', _async=False):
        
        acc_id = self.acc_id if acc_id is None else acc_id
        assert site in ['Pro', 'HADAX']
        path = f'/v1{"/" if site == "Pro" else "/hadax/"}account/accounts/{acc_id}/balance'
        # params = {'account-id': self.acct_id}
        params = {}
        return api_key_get(params, path, _async=_async)
947428
private int getConnections(IBlockAccess world, BlockPos pos, EnumFacing facing)
	{
		Block block = world.getBlockState(pos).getBlock();
		int connection = 0;
		for (int i = 0; i < 4; i++)
		{
			if (world.getBlockState(pos.offset(sides[facing.getIndex()][i])).getBlock() == block)
				connection |= (1 << i);
		}
		return ~connection & 15;
	}
747930
public List<Integer> getAllCurrencyID() throws GuildWars2Exception {
		try {
			Response<List<Integer>> response = gw2API.getAllCurrencies().execute();
			if (!response.isSuccessful()) throwError(response.code(), response.errorBody());
			return response.body();
		} catch (IOException e) {
			throw new GuildWars2Exception(ErrorCode.Network, "Network Error: " + e.getMessage());
		}
	}
668775
public java.util.List<GlobalCluster> getGlobalClusters() {
        if (globalClusters == null) {
            globalClusters = new com.amazonaws.internal.SdkInternalList<GlobalCluster>();
        }
        return globalClusters;
    }
469988
def get_for_accounts(self, accounts: List[Account]):
        '''  '''
        account_ids = [acc.guid for acc in accounts]
        query = (
            self.query
            .filter(Split.account_guid.in_(account_ids))
        )
        splits = query.all()
        return splits
1286892
public FilterGlobals getGlobals(final HttpServletRequest req) {
    HttpSession sess = req.getSession();

    if (sess == null) {
      // We're screwed
      return null;
    }

    Object o = sess.getAttribute(globalsName);
    FilterGlobals fg;

    if (o == null) {
      fg = newFilterGlobals();
      sess.setAttribute(globalsName, fg);

      if (debug()) {
        debug("Created new FilterGlobals from session " + sess.getId());
      }
    } else {
      fg = (FilterGlobals)o;
      //if (debug()) {
      //  getLogger().debug("Obtained FilterGlobals from session with id " +
      //                    sess.getId());
      //}
    }

    return fg;
  }
446281
public List<String> getEffectiveAccountLineage() {
        if (accountLineage == null) {
            if (effectiveAccount != null) {
                try {
                    accountLineage = accountsDao.getAccountLineage(effectiveAccount);
                } catch (AccountHierarchyDepthCrossed e) {
                    throw new RuntimeException("Logged account has a very big line of ancestors. Something seems wrong. Account sid: " + effectiveAccount.getSid().toString(), e);
                }
            }
        }
        return accountLineage;
    }
46556
public ArrayList<OvhCountryEnum> countries_GET(OvhOvhCompanyEnum ovhCompany, OvhOvhSubsidiaryEnum ovhSubsidiary) throws IOException {
		String qPath = "/newAccount/countries";
		StringBuilder sb = path(qPath);
		query(sb, "ovhCompany", ovhCompany);
		query(sb, "ovhSubsidiary", ovhSubsidiary);
		String resp = execN(qPath, "GET", sb.toString(), null);
		return convertTo(resp, t2);
	}
1072642
function getGlobalThis() {
    return t.callExpression(
      t.sequenceExpression([t.valueToNode(0), t.identifier("eval")]),
      [t.valueToNode("this")]
    );
  }
436916
def GET_account_balance(self, path_info, account_addr, token_type):
        
        if not check_account_address(account_addr):
            return self._reply_json({'error': 'Invalid address'}, status_code=400)

        if not check_token_type(token_type):
            return self._reply_json({'error': 'Invalid token type'}, status_code=400)

        blockstackd_url = get_blockstackd_url()
        res = blockstackd_client.get_account_balance(account_addr, token_type, hostport=blockstackd_url)
        if json_is_error(res):
            log.error("Failed to get account balance for {} {}: {}".format(account_addr, token_type, res['error']))
            return self._reply_json({'error': 'Failed to get balance of {} for {}: {}'.format(token_type, account_addr, res['error'])}, status_code=res.get('http_status', 500))

        self._reply_json({'balance': str(res)})     # NOTE: use a string, since this can be too big for js clients to parse
        return
219608
@SideOnly(Side.CLIENT)
	public static World getClientWorld()
	{
		return Minecraft.getMinecraft() != null ? Minecraft.getMinecraft().world : null;
	}
406427
public AccountBalance getAccountBalance(final String accountCode) {
        return doGET(Account.ACCOUNT_RESOURCE + "/" + accountCode + AccountBalance.ACCOUNT_BALANCE_RESOURCE, AccountBalance.class);
    }
1340163
public String getGroupedValue() {
        StringBuilder sb = new StringBuilder();
        sb.append(getRegisternummer()).append(Constants.DOT);
        sb.append(getAccountType()).append(Constants.DOT);
        sb.append(getPartAfterAccountType());
        return sb.toString();
    }
410394
def get_account_balance(self, account):
        
        balance = namedb_get_account_balance(account)
        assert isinstance(balance, (int,long)), 'BUG: account balance of {} is {} (type {})'.format(account['address'], balance, type(balance))
        return balance