/**
* Compares the URI with the given object for equality. If the object is not a <code>URI</code>,
* then the method returns false. Otherwise, the following criteria are observed:
*
* <ul>
* <li>The scheme of the URIs must either be null (undefined) in both cases, or equal, ignorant
* of case.
* <li>The raw fragment of the URIs must either be null (undefined) in both cases, or equal,
* ignorant of case.
* <li>Both URIs must be of the same type (opaque or hierarchial)
* <li><strong>For opaque URIs:</strong>
* <ul>
* <li>The raw scheme-specific parts must be equal.
* </ul>
* <li>For hierarchical URIs:
* <ul>
* <li>The raw paths must be equal, ignorant of case.
* <li>The raw queries are either both undefined or both equal, ignorant of case.
* <li>The raw authority sections are either both undefined or:
* <li><strong>For registry-based authorities:</strong>
* <ul>
* <li>they are equal.
* </ul>
* <li><strong>For server-based authorities:</strong>
* <ul>
* <li>the hosts are equal, ignoring case
* <li>the ports are equal
* <li>the user information components are equal
* </ul>
* </ul>
* </ul>
*
* @param obj the obj to compare the URI with.
* @return <code>true</code> if the objects are equal, according to the specification above.
*/
public boolean equals(Object obj) {
if (!(obj instanceof URI)) return false;
URI uriObj = (URI) obj;
if (scheme == null) {
if (uriObj.getScheme() != null) return false;
} else if (!(scheme.equalsIgnoreCase(uriObj.getScheme()))) return false;
if (rawFragment == null) {
if (uriObj.getRawFragment() != null) return false;
} else if (!(rawFragment.equalsIgnoreCase(uriObj.getRawFragment()))) return false;
boolean opaqueThis = isOpaque();
boolean opaqueObj = uriObj.isOpaque();
if (opaqueThis && opaqueObj)
return rawSchemeSpecificPart.equals(uriObj.getRawSchemeSpecificPart());
else if (!opaqueThis && !opaqueObj) {
boolean common =
rawPath.equalsIgnoreCase(uriObj.getRawPath())
&& ((rawQuery == null && uriObj.getRawQuery() == null)
|| rawQuery.equalsIgnoreCase(uriObj.getRawQuery()));
if (rawAuthority == null && uriObj.getRawAuthority() == null) return common;
if (host == null) return common && rawAuthority.equalsIgnoreCase(uriObj.getRawAuthority());
return common
&& host.equalsIgnoreCase(uriObj.getHost())
&& port == uriObj.getPort()
&& (rawUserInfo == null
? uriObj.getRawUserInfo() == null
: rawUserInfo.equalsIgnoreCase(uriObj.getRawUserInfo()));
} else return false;
}
@Override
public UriBuilder uri(URI uri) {
if (uri == null) {
throw new IllegalArgumentException("URI parameter is null");
}
if (uri.getRawFragment() != null) {
fragment = uri.getRawFragment();
}
if (uri.isOpaque()) {
scheme = uri.getScheme();
ssp = uri.getRawSchemeSpecificPart();
return this;
}
if (uri.getScheme() == null) {
if (ssp != null) {
if (uri.getRawSchemeSpecificPart() != null) {
ssp = uri.getRawSchemeSpecificPart();
return this;
}
}
} else {
scheme = uri.getScheme();
}
ssp = null;
if (uri.getRawAuthority() != null) {
if (uri.getRawUserInfo() == null && uri.getHost() == null && uri.getPort() == -1) {
authority = uri.getRawAuthority();
userInfo = null;
host = null;
port = -1;
} else {
authority = null;
if (uri.getRawUserInfo() != null) {
userInfo = uri.getRawUserInfo();
}
if (uri.getHost() != null) {
host = uri.getHost();
}
if (uri.getPort() != -1) {
port = uri.getPort();
}
}
}
if (uri.getRawPath() != null && uri.getRawPath().length() > 0) {
path.setLength(0);
path.append(uri.getRawPath());
}
if (uri.getRawQuery() != null && uri.getRawQuery().length() > 0) {
query.setLength(0);
query.append(uri.getRawQuery());
}
return this;
}
/**
* Validate the instance
*
* <p>Unlike all other validators:
*
* <ul>
* <li>this is the only one which will, if required, go over the net to grab new schemas;
* <li>this is the only one which can spawn a {@link ValidationContext} with a different root
* schema (if the ref represents an absolute {@link URI});
* <li>this is the only validator implementation which can spawn errors (ie, {@link
* ValidationReport#isError()} returns {@code true}) and not only failures.
* </ul>
*
* @return the report from the spawned validator
*/
@Override
public ValidationReport validate(final ValidationContext context, final JsonNode instance)
throws JsonValidationFailureException {
final ValidationReport report = context.createReport();
final String ref = context.getSchema().get(keyword).getTextValue();
final URI uri, baseURI;
final JsonPointer pointer;
try {
uri = new URI(ref);
baseURI = new URI(uri.getScheme(), uri.getSchemeSpecificPart(), null);
pointer = new JsonPointer(uri.getRawFragment());
} catch (URISyntaxException e) {
throw new RuntimeException(
"PROBLEM: invalid URI found (" + ref + "), syntax validation should have caught that", e);
}
final ValidationContext ctx;
try {
ctx = context.fromURI(baseURI);
} catch (IOException e) {
report.error(
String.format(
"cannot download schema at ref %s: %s: " + "%s",
ref, e.getClass().getName(), e.getMessage()));
return report;
} catch (IllegalArgumentException e) {
report.error(String.format("cannot use ref %s: %s", ref, e.getMessage()));
return report;
}
return ctx.getValidator(pointer, instance).validate(ctx, instance);
}
/**
* Update the query (encoded) of this MutableUri.
*
* @param rawQuery new query element (encoded)
* @throws URISyntaxException if the new equivalent URI is invalid
*/
public void setRawQuery(String rawQuery) throws URISyntaxException {
uri =
create(
uri.getScheme(),
uri.getRawUserInfo(),
uri.getHost(),
uri.getPort(),
uri.getRawPath(),
rawQuery,
uri.getRawFragment());
}
/** Convert a java.net.URI to a Uri. */
public static Uri fromJavaUri(URI uri) {
if (uri.isOpaque()) {
throw new IllegalArgumentException("No support for opaque Uris " + uri.toString());
}
return new UriBuilder()
.setScheme(uri.getScheme())
.setAuthority(uri.getRawAuthority())
.setPath(uri.getRawPath())
.setQuery(uri.getRawQuery())
.setFragment(uri.getRawFragment())
.toUri();
}
private String extractFullPath(String uriString) {
URI uri = validateAndConvertToURI(uriString);
StringBuilder pathBuilder = new StringBuilder(uri.getRawPath());
String query = uri.getRawQuery();
if (query != null) {
pathBuilder.append('?');
pathBuilder.append(query);
}
String fragment = uri.getRawFragment();
if (fragment != null) {
pathBuilder.append(fragment);
}
return pathBuilder.toString();
}
private URI rewriteUri(URI uri) {
assert _serviceName.equals(LoadBalancerUtil.getServiceNameFromUri(uri));
String path = LoadBalancerUtil.getRawPathFromUri(uri);
UriBuilder builder = UriBuilder.fromUri(_uri);
if (path != null) {
builder.path(path);
}
builder.replaceQuery(uri.getRawQuery());
builder.fragment(uri.getRawFragment());
URI rewrittenUri = builder.build();
debug(_log, "rewrite uri ", uri, " -> ", rewrittenUri);
return rewrittenUri;
}
/**
* Relativizes the given URI against this URI. The following algorithm is used:
*
* <ul>
* <li>If either URI is opaque, the given URI is returned.
* <li>If the schemes of the URIs differ, the given URI is returned.
* <li>If the authority components of the URIs differ, then the given URI is returned.
* <li>If the path of this URI is not a prefix of the supplied URI, then the given URI is
* returned.
* <li>If all the above conditions hold, a new URI is created using the query and fragment
* components of the given URI, along with a path computed by removing the path of this URI
* from the start of the path of the supplied URI.
* </ul>
*
* @param uri the URI to relativize agsint this URI
* @return the resulting URI
* @throws NullPointerException if the uri is null
*/
public URI relativize(URI uri) {
if (isOpaque() || uri.isOpaque()) return uri;
if (scheme == null && uri.getScheme() != null) return uri;
if (scheme != null && !(scheme.equals(uri.getScheme()))) return uri;
if (rawAuthority == null && uri.getRawAuthority() != null) return uri;
if (rawAuthority != null && !(rawAuthority.equals(uri.getRawAuthority()))) return uri;
if (!(uri.getRawPath().startsWith(rawPath))) return uri;
try {
return new URI(
null,
null,
uri.getRawPath().substring(rawPath.length()),
uri.getRawQuery(),
uri.getRawFragment());
} catch (URISyntaxException e) {
throw (Error)
new InternalError("Relativized URI variant could not " + "be constructed").initCause(e);
}
}
/** Normalize the given openid as a standard openid */
public static String normalize(String openID) {
openID = openID.trim();
if (!openID.startsWith("http://") && !openID.startsWith("https://")) {
openID = "http://" + openID;
}
try {
URI url = new URI(openID);
String frag = url.getRawFragment();
if (frag != null && frag.length() > 0) {
openID = openID.replace("#" + frag, "");
}
if (url.getPath().equals("")) {
openID += "/";
}
openID = new URI(openID).toString();
} catch (Exception e) {
throw new RuntimeException(openID + " is not a valid URL");
}
return openID;
}
private void setHeaders(MultivaluedMap<String, Object> headers) {
this.headers = headers;
Object location = headers.getFirst(HttpHeaders.LOCATION);
if (location != null) {
if (location instanceof URI) {
final URI locationUri = (URI) location;
if (!locationUri.isAbsolute()) {
final URI base =
(statusType.getStatusCode() == Status.CREATED.getStatusCode())
? request.getAbsolutePath()
: request.getBaseUri();
location =
UriBuilder.fromUri(base)
.path(locationUri.getRawPath())
.replaceQuery(locationUri.getRawQuery())
.fragment(locationUri.getRawFragment())
.build();
}
headers.putSingle(HttpHeaders.LOCATION, location);
}
}
}
@SuppressWarnings("deprecation")
@Override
public void filterHttpRequest(SubmitContext context, HttpRequestInterface<?> request) {
HttpRequestBase httpMethod =
(HttpRequestBase) context.getProperty(BaseHttpRequestTransport.HTTP_METHOD);
String path = PropertyExpander.expandProperties(context, request.getPath());
StringBuffer query = new StringBuffer();
String encoding =
System.getProperty("soapui.request.encoding", StringUtils.unquote(request.getEncoding()));
StringToStringMap responseProperties =
(StringToStringMap) context.getProperty(BaseHttpRequestTransport.RESPONSE_PROPERTIES);
MimeMultipart formMp =
"multipart/form-data".equals(request.getMediaType())
&& httpMethod instanceof HttpEntityEnclosingRequestBase
? new MimeMultipart()
: null;
RestParamsPropertyHolder params = request.getParams();
for (int c = 0; c < params.getPropertyCount(); c++) {
RestParamProperty param = params.getPropertyAt(c);
String value = PropertyExpander.expandProperties(context, param.getValue());
responseProperties.put(param.getName(), value);
List<String> valueParts =
sendEmptyParameters(request) || (!StringUtils.hasContent(value) && param.getRequired())
? RestUtils.splitMultipleParametersEmptyIncluded(
value, request.getMultiValueDelimiter())
: RestUtils.splitMultipleParameters(value, request.getMultiValueDelimiter());
// skip HEADER and TEMPLATE parameter encoding (TEMPLATE is encoded by
// the URI handling further down)
if (value != null
&& param.getStyle() != ParameterStyle.HEADER
&& param.getStyle() != ParameterStyle.TEMPLATE
&& !param.isDisableUrlEncoding()) {
try {
if (StringUtils.hasContent(encoding)) {
value = URLEncoder.encode(value, encoding);
for (int i = 0; i < valueParts.size(); i++)
valueParts.set(i, URLEncoder.encode(valueParts.get(i), encoding));
} else {
value = URLEncoder.encode(value);
for (int i = 0; i < valueParts.size(); i++)
valueParts.set(i, URLEncoder.encode(valueParts.get(i)));
}
} catch (UnsupportedEncodingException e1) {
SoapUI.logError(e1);
value = URLEncoder.encode(value);
for (int i = 0; i < valueParts.size(); i++)
valueParts.set(i, URLEncoder.encode(valueParts.get(i)));
}
// URLEncoder replaces space with "+", but we want "%20".
value = value.replaceAll("\\+", "%20");
for (int i = 0; i < valueParts.size(); i++)
valueParts.set(i, valueParts.get(i).replaceAll("\\+", "%20"));
}
if (param.getStyle() == ParameterStyle.QUERY && !sendEmptyParameters(request)) {
if (!StringUtils.hasContent(value) && !param.getRequired()) continue;
}
switch (param.getStyle()) {
case HEADER:
for (String valuePart : valueParts) httpMethod.addHeader(param.getName(), valuePart);
break;
case QUERY:
if (formMp == null || !request.isPostQueryString()) {
for (String valuePart : valueParts) {
if (query.length() > 0) query.append('&');
query.append(URLEncoder.encode(param.getName()));
query.append('=');
if (StringUtils.hasContent(valuePart)) query.append(valuePart);
}
} else {
try {
addFormMultipart(
request, formMp, param.getName(), responseProperties.get(param.getName()));
} catch (MessagingException e) {
SoapUI.logError(e);
}
}
break;
case TEMPLATE:
try {
value =
getEncodedValue(
value,
encoding,
param.isDisableUrlEncoding(),
request.getSettings().getBoolean(HttpSettings.ENCODED_URLS));
path = path.replaceAll("\\{" + param.getName() + "\\}", value == null ? "" : value);
} catch (UnsupportedEncodingException e) {
SoapUI.logError(e);
}
break;
case MATRIX:
try {
value =
getEncodedValue(
value,
encoding,
param.isDisableUrlEncoding(),
request.getSettings().getBoolean(HttpSettings.ENCODED_URLS));
} catch (UnsupportedEncodingException e) {
SoapUI.logError(e);
}
if (param.getType().equals(XmlBoolean.type.getName())) {
if (value.toUpperCase().equals("TRUE") || value.equals("1")) {
path += ";" + param.getName();
}
} else {
path += ";" + param.getName();
if (StringUtils.hasContent(value)) {
path += "=" + value;
}
}
break;
case PLAIN:
break;
}
}
if (request.getSettings().getBoolean(HttpSettings.FORWARD_SLASHES))
path = PathUtils.fixForwardSlashesInPath(path);
if (PathUtils.isHttpPath(path)) {
try {
// URI(String) automatically URLencodes the input, so we need to
// decode it first...
URI uri = new URI(path, request.getSettings().getBoolean(HttpSettings.ENCODED_URLS));
context.setProperty(BaseHttpRequestTransport.REQUEST_URI, uri);
java.net.URI oldUri = httpMethod.getURI();
httpMethod.setURI(
HttpUtils.createUri(
oldUri.getScheme(),
oldUri.getRawUserInfo(),
oldUri.getHost(),
oldUri.getPort(),
oldUri.getRawPath(),
uri.getEscapedQuery(),
oldUri.getRawFragment()));
} catch (Exception e) {
SoapUI.logError(e);
}
} else if (StringUtils.hasContent(path)) {
try {
java.net.URI oldUri = httpMethod.getURI();
String pathToSet =
StringUtils.hasContent(oldUri.getRawPath()) && !"/".equals(oldUri.getRawPath())
? oldUri.getRawPath() + path
: path;
java.net.URI newUri =
URIUtils.createURI(
oldUri.getScheme(),
oldUri.getHost(),
oldUri.getPort(),
pathToSet,
oldUri.getQuery(),
oldUri.getFragment());
httpMethod.setURI(newUri);
context.setProperty(
BaseHttpRequestTransport.REQUEST_URI,
new URI(
newUri.toString(), request.getSettings().getBoolean(HttpSettings.ENCODED_URLS)));
} catch (Exception e) {
SoapUI.logError(e);
}
}
if (query.length() > 0 && !request.isPostQueryString()) {
try {
java.net.URI oldUri = httpMethod.getURI();
httpMethod.setURI(
URIUtils.createURI(
oldUri.getScheme(),
oldUri.getHost(),
oldUri.getPort(),
oldUri.getRawPath(),
query.toString(),
oldUri.getFragment()));
} catch (Exception e) {
SoapUI.logError(e);
}
}
if (request instanceof RestRequest) {
String acceptEncoding = ((RestRequest) request).getAccept();
if (StringUtils.hasContent(acceptEncoding)) {
httpMethod.setHeader("Accept", acceptEncoding);
}
}
if (formMp != null) {
// create request message
try {
if (request.hasRequestBody() && httpMethod instanceof HttpEntityEnclosingRequest) {
String requestContent =
PropertyExpander.expandProperties(
context, request.getRequestContent(), request.isEntitizeProperties());
if (StringUtils.hasContent(requestContent)) {
initRootPart(request, requestContent, formMp);
}
}
for (Attachment attachment : request.getAttachments()) {
MimeBodyPart part = new PreencodedMimeBodyPart("binary");
if (attachment instanceof FileAttachment<?>) {
String name = attachment.getName();
if (StringUtils.hasContent(attachment.getContentID())
&& !name.equals(attachment.getContentID())) name = attachment.getContentID();
part.setDisposition(
"form-data; name=\"" + name + "\"; filename=\"" + attachment.getName() + "\"");
} else part.setDisposition("form-data; name=\"" + attachment.getName() + "\"");
part.setDataHandler(new DataHandler(new AttachmentDataSource(attachment)));
formMp.addBodyPart(part);
}
MimeMessage message = new MimeMessage(AttachmentUtils.JAVAMAIL_SESSION);
message.setContent(formMp);
message.saveChanges();
RestRequestMimeMessageRequestEntity mimeMessageRequestEntity =
new RestRequestMimeMessageRequestEntity(message, request);
((HttpEntityEnclosingRequest) httpMethod).setEntity(mimeMessageRequestEntity);
httpMethod.setHeader("Content-Type", mimeMessageRequestEntity.getContentType().getValue());
httpMethod.setHeader("MIME-Version", "1.0");
} catch (Throwable e) {
SoapUI.logError(e);
}
} else if (request.hasRequestBody() && httpMethod instanceof HttpEntityEnclosingRequest) {
if (StringUtils.hasContent(request.getMediaType()))
httpMethod.setHeader(
"Content-Type", getContentTypeHeader(request.getMediaType(), encoding));
if (request.isPostQueryString()) {
try {
((HttpEntityEnclosingRequest) httpMethod).setEntity(new StringEntity(query.toString()));
} catch (UnsupportedEncodingException e) {
SoapUI.logError(e);
}
} else {
String requestContent =
PropertyExpander.expandProperties(
context, request.getRequestContent(), request.isEntitizeProperties());
List<Attachment> attachments = new ArrayList<Attachment>();
for (Attachment attachment : request.getAttachments()) {
if (attachment.getContentType().equals(request.getMediaType())) {
attachments.add(attachment);
}
}
if (StringUtils.hasContent(requestContent) && attachments.isEmpty()) {
try {
byte[] content =
encoding == null ? requestContent.getBytes() : requestContent.getBytes(encoding);
((HttpEntityEnclosingRequest) httpMethod).setEntity(new ByteArrayEntity(content));
} catch (UnsupportedEncodingException e) {
((HttpEntityEnclosingRequest) httpMethod)
.setEntity(new ByteArrayEntity(requestContent.getBytes()));
}
} else if (attachments.size() > 0) {
try {
MimeMultipart mp = null;
if (StringUtils.hasContent(requestContent)) {
mp = new MimeMultipart();
initRootPart(request, requestContent, mp);
} else if (attachments.size() == 1) {
((HttpEntityEnclosingRequest) httpMethod)
.setEntity(new InputStreamEntity(attachments.get(0).getInputStream(), -1));
httpMethod.setHeader(
"Content-Type", getContentTypeHeader(request.getMediaType(), encoding));
}
if (((HttpEntityEnclosingRequest) httpMethod).getEntity() == null) {
if (mp == null) mp = new MimeMultipart();
// init mimeparts
AttachmentUtils.addMimeParts(request, attachments, mp, new StringToStringMap());
// create request message
MimeMessage message = new MimeMessage(AttachmentUtils.JAVAMAIL_SESSION);
message.setContent(mp);
message.saveChanges();
RestRequestMimeMessageRequestEntity mimeMessageRequestEntity =
new RestRequestMimeMessageRequestEntity(message, request);
((HttpEntityEnclosingRequest) httpMethod).setEntity(mimeMessageRequestEntity);
httpMethod.setHeader(
"Content-Type",
getContentTypeHeader(
mimeMessageRequestEntity.getContentType().getValue(), encoding));
httpMethod.setHeader("MIME-Version", "1.0");
}
} catch (Exception e) {
SoapUI.logError(e);
}
}
}
}
}
/**
* Compares the fragment of this URI with that of the supplied URI.
*
* @param uri the URI to compare with this one.
* @return a negative integer, zero or a positive integer depending on whether this uri's fragment
* is less than, equal to or greater than the fragment of the uri supplied, respectively.
*/
private int compareFragments(URI uri) {
if (rawFragment == null && uri.getRawFragment() != null) return -1;
else if (rawFragment == null) return 0;
else return rawFragment.compareTo(uri.getRawFragment());
}
/**
* Returns the raw (encoded) fragment element.
*
* @return the raw fragment element.
*/
public String getRawFragment() {
return uri.getRawFragment();
}
/**
* Fully relativize the source part URI against the target part URI.
*
* @param sourceURI The source part URI.
* @param targetURI The target part URI.
* @param msCompatible if true then remove leading slash from the relativized URI. This flag
* violates [M1.4]: A part name shall start with a forward slash ('/') character, but allows
* generating URIs compatible with MS Office and OpenOffice.
* @return A fully relativize part name URI ('word/media/image1.gif', '/word/document.xml' =>
* 'media/image1.gif') else <code>null</code>.
*/
public static URI relativizeURI(URI sourceURI, URI targetURI, boolean msCompatible) {
StringBuilder retVal = new StringBuilder();
String[] segmentsSource = sourceURI.getPath().split("/", -1);
String[] segmentsTarget = targetURI.getPath().split("/", -1);
// If the source URI is empty
if (segmentsSource.length == 0) {
throw new IllegalArgumentException("Can't relativize an empty source URI !");
}
// If target URI is empty
if (segmentsTarget.length == 0) {
throw new IllegalArgumentException("Can't relativize an empty target URI !");
}
// If the source is the root, then the relativized
// form must actually be an absolute URI
if (sourceURI.toString().equals("/")) {
String path = targetURI.getPath();
if (msCompatible && path.length() > 0 && path.charAt(0) == '/') {
try {
targetURI = new URI(path.substring(1));
} catch (Exception e) {
_logger.log(POILogger.WARN, e);
return null;
}
}
return targetURI;
}
// Relativize the source URI against the target URI.
// First up, figure out how many steps along we can go
// and still have them be the same
int segmentsTheSame = 0;
for (int i = 0; i < segmentsSource.length && i < segmentsTarget.length; i++) {
if (segmentsSource[i].equals(segmentsTarget[i])) {
// Match so far, good
segmentsTheSame++;
} else {
break;
}
}
// If we didn't have a good match or at least except a first empty element
if ((segmentsTheSame == 0 || segmentsTheSame == 1)
&& segmentsSource[0].equals("")
&& segmentsTarget[0].equals("")) {
for (int i = 0; i < segmentsSource.length - 2; i++) {
retVal.append("../");
}
for (int i = 0; i < segmentsTarget.length; i++) {
if (segmentsTarget[i].equals("")) continue;
retVal.append(segmentsTarget[i]);
if (i != segmentsTarget.length - 1) retVal.append("/");
}
try {
return new URI(retVal.toString());
} catch (Exception e) {
_logger.log(POILogger.WARN, e);
return null;
}
}
// Special case for where the two are the same
if (segmentsTheSame == segmentsSource.length && segmentsTheSame == segmentsTarget.length) {
if (sourceURI.equals(targetURI)) {
// if source and target are the same they should be resolved to the last segment,
// Example: if a slide references itself, e.g. the source URI is
// "/ppt/slides/slide1.xml" and the targetURI is "slide1.xml" then
// this it should be relativized as "slide1.xml", i.e. the last segment.
retVal.append(segmentsSource[segmentsSource.length - 1]);
} else {
retVal.append("");
}
} else {
// Matched for so long, but no more
// Do we need to go up a directory or two from
// the source to get here?
// (If it's all the way up, then don't bother!)
if (segmentsTheSame == 1) {
retVal.append("/");
} else {
for (int j = segmentsTheSame; j < segmentsSource.length - 1; j++) {
retVal.append("../");
}
}
// Now go from here on down
for (int j = segmentsTheSame; j < segmentsTarget.length; j++) {
if (retVal.length() > 0 && retVal.charAt(retVal.length() - 1) != '/') {
retVal.append("/");
}
retVal.append(segmentsTarget[j]);
}
}
// if the target had a fragment then append it to the result
String fragment = targetURI.getRawFragment();
if (fragment != null) {
retVal.append("#").append(fragment);
}
try {
return new URI(retVal.toString());
} catch (Exception e) {
_logger.log(POILogger.WARN, e);
return null;
}
}
public static URI toURI(String strUrl, int port) throws URISyntaxException {
// print.o((strUrl));
URI uri = new URI(strUrl);
String host = uri.getHost();
String fragment = uri.getRawFragment();
String path = uri.getRawPath();
String query = uri.getRawQuery();
String scheme = uri.getScheme();
String userInfo = uri.getRawUserInfo();
if (port <= 0) port = uri.getPort();
// decode path
if (!StringUtil.isEmpty(path)) {
int sqIndex = path.indexOf(';');
String q = null;
if (sqIndex != -1) {
q = path.substring(sqIndex + 1);
path = path.substring(0, sqIndex);
}
StringBuilder res = new StringBuilder();
StringList list = ListUtil.toListTrim(path, '/');
String str;
while (list.hasNext()) {
str = list.next();
// str=URLDecoder.decode(str);
if (StringUtil.isEmpty(str)) continue;
res.append("/");
res.append(escapeQSValue(str));
}
if (StringUtil.endsWith(path, '/')) res.append('/');
path = res.toString();
if (sqIndex != -1) {
path += decodeQuery(q, ';');
}
}
// decode query
query = decodeQuery(query, '?');
// decode ref/anchor
if (!StringUtil.isEmpty(fragment)) {
fragment = escapeQSValue(fragment);
}
// user/pasword
if (!StringUtil.isEmpty(userInfo)) {
int index = userInfo.indexOf(':');
if (index != -1) {
userInfo =
escapeQSValue(userInfo.substring(0, index))
+ ":"
+ escapeQSValue(userInfo.substring(index + 1));
} else userInfo = escapeQSValue(userInfo);
}
/*print.o("- fragment:"+fragment);
print.o("- host:"+host);
print.o("- path:"+path);
print.o("- query:"+query);
print.o("- scheme:"+scheme);
print.o("- userInfo:"+userInfo);
print.o("- port:"+port);
print.o("- absolute:"+uri.isAbsolute());
print.o("- opaque:"+uri.isOpaque());*/
StringBuilder rtn = new StringBuilder();
if (scheme != null) {
rtn.append(scheme);
rtn.append("://");
}
if (userInfo != null) {
rtn.append(userInfo);
rtn.append("@");
}
if (host != null) {
rtn.append(host);
}
if (port > 0) {
rtn.append(":");
rtn.append(port);
}
if (path != null) {
rtn.append(path);
}
if (query != null) {
// rtn.append("?");
rtn.append(query);
}
if (fragment != null) {
rtn.append("#");
rtn.append(fragment);
}
return new URI(rtn.toString());
}