Refine search
public static String relativizeUrl(String url) { if (Url.parse(url).isFull()) return url; else return RequestCycle.get().getUrlRenderer().renderContextRelativeUrl(url); }
/** * Returns whether the Url is context absolute. Absolute Urls start with a '{@literal /}'. * * @return <code>true</code> if Url starts with the context path, <code>false</code> otherwise. */ public boolean isContextAbsolute() { return !contextRelative && !isFull() && !getSegments().isEmpty() && Strings.isEmpty(getSegments().get(0)); }
/** * Stringizes this url using the specific {@link StringMode} and url's charset * * @param mode * {@link StringMode} that determines how to stringize the url * @return stringized url */ public String toString(StringMode mode) { return toString(mode, getCharset()); }
/** * return path for current url in original encoding * * @return path string */ public String getPath() { return getPath(getCharset()); }
@Override public Url getClientUrl() { Url baseUrl = new Url(url.getSegments(), Collections.<QueryParameter> emptyList()); baseUrl.setContextRelative(url.isContextRelative()); return baseUrl; }
protected static CharSequence urlFor(ResourceReference ref, ODocument document, String field, String contentType, boolean fullUrl) { PageParameters params = new PageParameters(); params.add("rid", document.getIdentity().toString().substring(1)); params.add("field", field); params.add("v", document.getVersion()); if(!Strings.isEmpty(contentType)) params.add("type", contentType); CharSequence url = RequestCycle.get().urlFor(ref, params); if(fullUrl) { url = RequestCycle.get().getUrlRenderer().renderFullUrl(Url.parse(url)); } return url; }
public static String getBaseURL() { final RequestCycle requestCycle = RequestCycle.get(); final Request request = requestCycle.getRequest(); final String currentPath = request.getUrl().toString(); String fullUrl = requestCycle.getUrlRenderer().renderFullUrl(request.getUrl()); if (org.apache.commons.lang3.StringUtils.isNotBlank(currentPath)) { final int beginPath = fullUrl.lastIndexOf(currentPath); fullUrl = fullUrl.substring(0, beginPath - 1); } final Optional<String> contextPath = Optional.ofNullable(requestCycle.getRequest().getContextPath()); final Optional<String> filterPath = Optional.ofNullable(requestCycle.getRequest().getFilterPath()); return fullUrl + contextPath.orElse("") + filterPath.orElse(""); }
/** * Build value to Origin header based on RequestCycle Url * * @return Origin header */ protected String createOriginHeader(){ Url url = RequestCycle.get().getRequest().getUrl(); return url.getProtocol() + "://" +url.getHost() + ":" + url.getPort(); }
public CharSequence getBaseUrl() { if (baseUrl.get() == null) { Url _baseUrl = RequestCycle.get().getUrlRenderer().getBaseUrl(); return Strings.escapeMarkup(_baseUrl.toString()); } return baseUrl.get(); }
private Url encodeSharedResourceUrl(Url url) { if (url != null) { Request request = RequestCycle.get().getRequest(); StringBuilder urlBuilder = new StringBuilder(); urlBuilder.append(request.getContextPath()); urlBuilder.append(request.getFilterPath()); urlBuilder.append(PortletFilter.SHARED_RESOURCE_URL_PORTLET_WINDOW_ID_PREFIX); urlBuilder.append(Base64.encodeBase64URLSafeString(ThreadPortletContext.getWindowID().getBytes())); urlBuilder.append('/'); urlBuilder.append(url.toString()); url = Url.parse(urlBuilder.toString()); } return url; }
private boolean isActiveItem(IModel<String> urlModel) { String currentUrl = RequestCycle.get().getRequest().getUrl().getPath(); String url = urlModel.getObject(); return url!=null && currentUrl.equals(url.replaceFirst("^/", "")); } }
/** * Get the absolute bookmarkable path of a page * * @param pageClass Page * @param pageParameters Optional page parameters * @return Bookmarkable path */ public static String absoluteMountPathForPage(Class<? extends Page> pageClass, PageParameters pageParameters) { HttpServletRequest req = getHttpServletRequest(); RequestCycle requestCycle = RequestCycle.get(); Url url = requestCycle.mapUrlFor(pageClass, pageParameters); String renderedUrl = url.toString(); renderedUrl = Strings.isEmpty(renderedUrl) ? "." : renderedUrl; return RequestUtils.toAbsolutePath(HttpUtils.getWebappContextUrl(req), requestCycle.getOriginalResponse().encodeURL(renderedUrl)); }
@Override public PageParameters decodePageParameters(final Url url) { PageParameters parameters = new PageParameters(); int i = 0; for (String s : url.getSegments()) { parameters.set(i, s); ++i; } for (QueryParameter p : url.getQueryParameters()) { String parameterName = p.getName(); if (Strings.isEmpty(parameterName) == false) { parameters.add(parameterName, p.getValue(), INamedParameters.Type.QUERY_STRING); } } return parameters.isEmpty() ? null : parameters; }
/** * @param link * @return url for Link */ public String urlFor(Link<?> link) { Args.notNull(link, "link"); Url url = Url.parse(link.urlForListener(new PageParameters()).toString()); return transform(url).toString(); }
/** * Extracts {@link PageParameters} from the URL using the given {@link IPageParametersEncoder} . * * @param request * @param segmentsToSkip * how many URL segments should be skipped because they "belong" to the * {@link IRequestMapper} * @param encoder * @return PageParameters instance */ protected PageParameters extractPageParameters(final Request request, int segmentsToSkip, final IPageParametersEncoder encoder) { Args.notNull(request, "request"); Args.notNull(encoder, "encoder"); // strip the segments and first query parameter from URL Url urlCopy = new Url(request.getUrl()); while ((segmentsToSkip > 0) && (urlCopy.getSegments().isEmpty() == false)) { urlCopy.getSegments().remove(0); --segmentsToSkip; } if (!urlCopy.getQueryParameters().isEmpty() && Strings.isEmpty(urlCopy.getQueryParameters().get(0).getValue())) { removeMetaParameter(urlCopy); } return encoder.decodePageParameters(urlCopy); }
/** * Determines whether a URL should be rendered in its full form * * @param url * @return {@code true} if URL should be rendered in the full form */ protected boolean shouldRenderAsFull(final Url url) { Url clientUrl = request.getClientUrl(); if (!Strings.isEmpty(url.getProtocol()) && !url.getProtocol().equals(clientUrl.getProtocol())) { return true; } if (!Strings.isEmpty(url.getHost()) && !url.getHost().equals(clientUrl.getHost())) { return true; } if ((url.getPort() != null) && !url.getPort().equals(clientUrl.getPort())) { return true; } if (url.isContextAbsolute()) { // do not relativize urls like "/a/b" return true; } return false; }
@Override public Url encodePageParameters(PageParameters params) { Args.notNull(params, "params"); Args.isTrue(params.getIndexedCount() == 0, "This encoder does not support indexed page parameters. Specified parameters: %s", params); Url url = new Url(); for (PageParameters.NamedPair pair : params.getAllNamed()) { url.getSegments().add(pair.getKey()); url.getSegments().add(pair.getValue()); } return url; }
final String path = getPath(charset); if (Strings.isEmpty(host)) if (Strings.isEmpty(protocol) == false) else if (Strings.isEmpty(protocol) && Strings.isEmpty(host) == false) if (port != null && port.equals(getDefaultPortForProtocol(protocol)) == false) StringMode.FULL.name() + " mode because it has a `..` segment: " + toString()); final String queryString = getQueryString(charset); if (queryString != null) String _fragment = getFragment(); if (Strings.isEmpty(_fragment) == false)