/**
* Opens a stream from a public and system ID.
*
* @param publicID the public ID, which may be null
* @param systemID the system ID, which is never null
* @throws java.net.MalformedURLException if the system ID does not contain a valid URL
* @throws java.io.FileNotFoundException if the system ID refers to a local file which does not
* exist
* @throws java.io.IOException if an error occurred opening the stream
*/
public Reader openStream(final String publicID, final String systemID)
throws MalformedURLException, FileNotFoundException, IOException {
URL url = new URL(currentReader.systemId, systemID);
if (url.getRef() != null) {
final String ref = url.getRef();
if (url.getFile().length() > 0) {
url = new URL(url.getProtocol(), url.getHost(), url.getPort(), url.getFile());
url = new URL("jar:" + url + '!' + ref);
} else {
url = StdXMLReader.class.getResource(ref);
}
}
currentReader.publicId = publicID;
currentReader.systemId = url;
final StringBuilder charsRead = new StringBuilder();
final Reader reader = this.stream2reader(url.openStream(), charsRead);
if (charsRead.length() == 0) {
return reader;
}
final String charsReadStr = charsRead.toString();
final PushbackReader pbreader = new PushbackReader(reader, charsReadStr.length());
for (int i = charsReadStr.length() - 1; i >= 0; i--) {
pbreader.unread(charsReadStr.charAt(i));
}
return pbreader;
}
public SampleReportsEntry(
String[] filePattern,
String entryname,
String fragmentPath,
SampleReportsEntry parentEntry,
boolean isFile) {
// this( "BIRT Examples", "/samplereports", null, false );
// //$NON-NLS-1$//$NON-NLS-2$
this(entryname, fragmentPath, parentEntry, false);
this.isRoot = true;
this.displayName = "BIRT Examples"; // $NON-NLS-1$
// samplesBundle = Platform.getBundle( SAMPLE_REPORTS_HOST );
if (samplesBundle != null) {
if (filePattern != null && filePattern.length > 0) {
for (int i = 0; i < filePattern.length; i++) {
String[] patterns = filePattern[i].split(";"); // $NON-NLS-1$
for (int j = 0; j < patterns.length; j++) {
Enumeration enumeration = samplesBundle.findEntries(fragmentPath, patterns[j], true);
while (enumeration != null && enumeration.hasMoreElements()) {
URL element = (URL) enumeration.nextElement();
String path =
element.getPath()
+ (element.getRef() != null
? "#" //$NON-NLS-1$
+ element.getRef()
: ""); //$NON-NLS-1$
String[] pathtoken = path.split("/"); // $NON-NLS-1$
SampleReportsEntry parent = this;
for (int m = 0; m < pathtoken.length; m++) {
if (pathtoken[m].equals("")
|| pathtoken[m].equals(
fragmentPath.substring(fragmentPath.indexOf('/') + 1))) // $NON-NLS-1$
continue;
SampleReportsEntry child = parent.getChild(pathtoken[m]);
if (child == null) {
child =
new SampleReportsEntry(
pathtoken[m],
(parent.path.equals("/")
? "" //$NON-NLS-1$//$NON-NLS-2$
: parent.path)
+ "/" //$NON-NLS-1$
+ pathtoken[m],
parent,
m == pathtoken.length - 1);
}
parent = child;
}
}
}
}
}
}
}
/**
* Builds an URI from an URL (with a handle for URLs not compliant with RFC 2396).
*
* @param url an URL
* @return an URI
* @throws URISyntaxException if the URI is invalid and could not be repaired
*/
public static URI urlToUri(URL url) throws URISyntaxException {
URI uri;
try {
// Possible failing step.
uri = url.toURI();
} catch (Exception e) {
// URL did not comply with RFC 2396 => illegal non-escaped characters.
try {
uri =
new URI(
url.getProtocol(),
url.getUserInfo(),
url.getHost(),
url.getPort(),
url.getPath(),
url.getQuery(),
url.getRef());
} catch (Exception e1) {
throw new URISyntaxException(String.valueOf(url), "Broken URL.");
}
}
uri = uri.normalize();
return uri;
}
public static URL getURL(double latitude, double longitude, String output)
throws MalformedURLException, IOException {
StringBuilder stringBuilder = new StringBuilder(URL_PREFIX);
stringBuilder.append("?");
stringBuilder.append("output=" + output + "&");
stringBuilder.append("location=" + latitude + "," + longitude + "&");
stringBuilder.append("key=" + PRIVATE_KEY);
URL url = new URL(stringBuilder.toString());
System.out.println(String.format("getProtocol %s", url.getProtocol()));
System.out.println(String.format("getHost %s", url.getHost()));
System.out.println(String.format("getPath %s", url.getPath()));
System.out.println(String.format("getPort %s", url.getPort()));
System.out.println(String.format("getDefaultPort %s", url.getDefaultPort()));
System.out.println(String.format("getQuery %s", url.getQuery()));
System.out.println(String.format("getAuthority %s", url.getAuthority()));
System.out.println(String.format("getRef %s", url.getRef()));
System.out.println(String.format("getUserInfo %s", url.getUserInfo()));
System.out.println(String.format("getFile %s", url.getFile()));
System.out.println(String.format("getContent %s", url.getContent()));
System.out.println(String.format("toExternalForm %s", url.toExternalForm()));
System.out.println("---------------");
return url;
}
@Override
public boolean isValidAuthority(URL authorizationEndpoint) {
// For comparison purposes, convert to lowercase Locale.US
// getProtocol returns scheme and it is available if it is absolute url
// Authority is in the form of https://Instance/tenant/somepath
if (authorizationEndpoint != null
&& !StringExtensions.IsNullOrBlank(authorizationEndpoint.getHost())
&& authorizationEndpoint.getProtocol().equals("https")
&& StringExtensions.IsNullOrBlank(authorizationEndpoint.getQuery())
&& StringExtensions.IsNullOrBlank(authorizationEndpoint.getRef())
&& !StringExtensions.IsNullOrBlank(authorizationEndpoint.getPath())) {
if (UrlExtensions.isADFSAuthority(authorizationEndpoint)) {
throw new AuthenticationException(ADALError.DISCOVERY_NOT_SUPPORTED);
} else if (sValidHosts.contains(authorizationEndpoint.getHost().toLowerCase(Locale.US))) {
// host can be the instance or inside the validated list.
// Valid hosts will help to skip validation if validated before
// call Callback and skip the look up
return true;
} else {
// Only query from Prod instance for now, not all of the
// instances in the list
return queryInstance(authorizationEndpoint);
}
}
return false;
}
public static String removeprincipal(String u) {
// Must be a simpler way
String newurl = null;
try {
int index;
URL url = new URL(u);
String protocol = url.getProtocol() + "://";
String host = url.getHost();
int port = url.getPort();
String path = url.getPath();
String query = url.getQuery();
String ref = url.getRef();
String sport = (port <= 0 ? "" : (":" + port));
path = (path == null ? "" : path);
query = (query == null ? "" : "?" + query);
ref = (ref == null ? "" : "#" + ref);
// rebuild the url
// (and leaving encoding in place)
newurl = protocol + host + sport + path + query + ref;
} catch (MalformedURLException use) {
newurl = u;
}
return newurl;
}
@Override
protected URLConnection openConnection(URL u) throws IOException {
String path = u.getPath().substring(1);
String refr = u.getRef();
StringBuilder test = new StringBuilder(path);
if (refr != null && refr.length() > 0) {
test.append(".part.");
for (int i = 0; i < refr.length() - 1; i++) {
test.append("0");
}
test.append("1");
}
URL local = Thread.currentThread().getContextClassLoader().getResource(test.toString());
String base = local.toExternalForm();
int end = base.length() - test.length();
base = base.substring(0, end);
if ("file".equals(local.getProtocol())) {
return new XcfFileConnection(new URL(base), u);
} else if ("jar".equals(local.getProtocol())) {
return new XcfJarConnection(new URL(base), u);
} else {
throw new IOException("base protocol[" + local.getProtocol() + "] isn't supported");
}
}
/**
* The URL-safe version of a string is obtained by an URL encoding to a string value.
*
* @throws R2RMLDataError
* @throws MalformedURLException
*/
public static String getURLSafeVersion(String value) throws R2RMLDataError {
if (value == null) return null;
URL url = null;
try {
url = new URL(value);
} catch (MalformedURLException mue) {
// This template should be not a url : no encoding
return value;
}
// No exception raised, this template is a valid url : perform
// percent-encoding
try {
java.net.URI uri =
new java.net.URI(
url.getProtocol(), url.getAuthority(), url.getPath(), url.getQuery(), url.getRef());
String result = uri.toURL().toString();
// Percent encoding : complete with no supported char in this
// treatment
result = result.replaceAll("\\,", "%2C");
return result;
} catch (URISyntaxException e) {
throw new R2RMLDataError(
"[R2RMLToolkit:getIRISafeVersion] This value "
+ value
+ " can not be percent-encoded because "
+ e.getMessage());
} catch (MalformedURLException e) {
throw new R2RMLDataError(
"[R2RMLToolkit:getIRISafeVersion] This value "
+ value
+ " can not be percent-encoded because "
+ e.getMessage());
}
}
/**
* Construct a URL from its basic parts.
*
* @param base The base URL.
* @param url The URL that was found on the base URL's page.
* @param stripRef True if the URL's reference should be stripped.
* @return The new URL, built upon the base URL.
* @throws IOException Thrown if any IO error occurs.
*/
public static URL constructURL(final URL base, final String url, final boolean stripRef)
throws IOException {
URL result = new URL(base, url);
String file = result.getFile();
final String protocol = result.getProtocol();
final String host = result.getHost();
final int port = result.getPort();
final String ref = result.getRef();
final StringBuilder sb = new StringBuilder(file);
int index = sb.indexOf(" ");
while (index != -1) {
if (index != -1) {
sb.replace(index, index + 1, "%20");
}
index = sb.indexOf(" ");
}
file = sb.toString();
if ((ref != null) && !stripRef) {
result = new URL(protocol, host, port, file + "#" + ref);
} else {
result = new URL(protocol, host, port, file);
}
return result;
}
/**
* Encodes illegal characters in the specified URL's path, query string and anchor according to
* the URL encoding rules observed in real browsers.
*
* <p>For example, this method changes <tt>"http://first/?a=b c"</tt> to
* <tt>"http://first/?a=b%20c"</tt>.
*
* @param url the URL to encode
* @param minimalQueryEncoding whether or not to perform minimal query encoding, like IE does
* @param charset the charset
* @return the encoded URL
*/
public static URL encodeUrl(
final URL url, final boolean minimalQueryEncoding, final String charset) {
final String p = url.getProtocol();
if ("javascript".equalsIgnoreCase(p)
|| "about".equalsIgnoreCase(p)
|| "data".equalsIgnoreCase(p)) {
// Special exception.
return url;
}
try {
String path = url.getPath();
if (path != null) {
path = encode(path, PATH_ALLOWED_CHARS, "UTF-8");
}
String query = url.getQuery();
if (query != null) {
if (minimalQueryEncoding) {
query = org.apache.commons.lang3.StringUtils.replace(query, " ", "%20");
} else {
query = encode(query, QUERY_ALLOWED_CHARS, charset);
}
}
String anchor = url.getRef();
if (anchor != null) {
anchor = encode(anchor, ANCHOR_ALLOWED_CHARS, "UTF-8");
}
return createNewUrl(url.getProtocol(), url.getHost(), url.getPort(), path, anchor, query);
} catch (final MalformedURLException e) {
// Impossible... I think.
throw new RuntimeException(e);
}
}
private static void setValues(
URL url,
HttpResponse<InputStream> jsonResponse,
AbstractMap<String, String> localHeaders,
Long responseTime) {
generalInfo = new HashMap<>();
int responseCode = jsonResponse.getStatus();
generalInfo.put("Protocol", url.getProtocol());
generalInfo.put("Authority", url.getAuthority());
generalInfo.put("Host", url.getHost());
generalInfo.put("Default Port", Integer.toString(url.getDefaultPort()));
generalInfo.put("Port ", Integer.toString(url.getPort()));
generalInfo.put("Path", url.getPath());
generalInfo.put("Query", url.getQuery());
generalInfo.put("Filename", url.getFile());
generalInfo.put("Ref", url.getRef());
responseValues.resetProperties();
responseValues.setRequestHeaders(localHeaders);
responseValues.setResponseHeaders(jsonResponse.getHeaders());
responseValues.setGeneralInfo(generalInfo);
responseValues.setResponseTime(responseTime);
responseValues.setResponseCode(
Integer.toString(responseCode) + " " + jsonResponse.getStatusText());
}
public static String encodeDocumentUrl(String urlString) {
try {
URL url = new URL(urlString);
URI uri =
new URI(
url.getProtocol(),
url.getUserInfo(),
url.getHost(),
url.getPort(),
url.getPath(),
url.getQuery(),
url.getRef());
return uri.toASCIIString();
} catch (MalformedURLException e) {
if (Log.LOGD)
Log.d(ExoUtils.class.getSimpleName(), e.getMessage(), Log.getStackTraceString(e));
return null;
} catch (URISyntaxException e) {
if (Log.LOGD)
Log.d(ExoUtils.class.getSimpleName(), e.getMessage(), Log.getStackTraceString(e));
return null;
}
}
@Override
public void runner() throws Exception {
try {
initDriver();
String sUrl;
if (credentialItem != null) {
sUrl =
new URI(
url.getProtocol(),
credentialItem.getURLUserInfo(),
url.getHost(),
url.getPort(),
url.getPath(),
url.getQuery(),
url.getRef())
.toString();
} else sUrl = url.toExternalForm();
browserDriver.get(sUrl);
if (waitSec > 0) sleepSec(waitSec);
BufferedImage image = browserDriver.getScreenshot();
if (visiblePartOnly)
image = ImageUtils.getSubimage(image, 0, 0, capture.width, capture.height);
if (resize != null) image = ImageUtils.reduceImage(image, resize.width, resize.height);
if (reductionPercent < 100) image = ImageUtils.reduceImage(image, reductionPercent);
if (screenshotManager != null) screenshotManager.store(url, image);
finalImage = image;
} finally {
release();
}
}
public String evaluate(String urlStr, String partToExtract) {
if (urlStr == null || partToExtract == null) {
return null;
}
if (lastUrlStr == null || !urlStr.equals(lastUrlStr)) {
try {
url = new URL(urlStr);
} catch (Exception e) {
return null;
}
}
lastUrlStr = urlStr;
if (partToExtract.equals("HOST")) return url.getHost();
if (partToExtract.equals("PATH")) return url.getPath();
if (partToExtract.equals("QUERY")) return url.getQuery();
if (partToExtract.equals("REF")) return url.getRef();
if (partToExtract.equals("PROTOCOL")) return url.getProtocol();
if (partToExtract.equals("FILE")) return url.getFile();
if (partToExtract.equals("AUTHORITY")) return url.getAuthority();
if (partToExtract.equals("USERINFO")) return url.getUserInfo();
return null;
}
public static Map<String, String> parseRef(URL url) {
try {
return parseRef(url.getRef());
} catch (MalformedURLException e) {
e.printStackTrace();
throw new RuntimeException(e.getMessage());
}
}
/**
* Gets a file from a path relative to this AssetManager's root. Will be from a local file if the
* root is a local file, will be from a URL if the root is a URL. This method does not return a
* file for if it was from a jar file.
*
* @param loc the relative location
* @return the file at that location
*/
private File getFile(String loc) {
if (localRoot != null) {
return new File(localRoot.getAbsolutePath() + System.getProperty("file.separator") + loc);
} else if (urlRoot != null) {
return new File(urlRoot.getRef() + "/" + loc);
} else {
return null;
}
}
public static Bundle parseUrl(String url) {
try {
URL u = new URL(url);
Bundle b = decodeUrl(u.getQuery());
b.putAll(decodeUrl(u.getRef()));
return b;
} catch (MalformedURLException e) {
return new Bundle();
}
}
private String getURLString(URL url) {
String location = url.toExternalForm();
if (url.getRef() != null) {
int anchorIdx = location.lastIndexOf('#');
if (anchorIdx != -1) {
return location.substring(0, anchorIdx)
+ "?noframes=true"
+ location.substring(anchorIdx); // $NON-NLS-1$
}
}
return location + "?noframes=true"; // $NON-NLS-1$
}
/**
* Parse a URL query and fragment parameters into a key-value bundle.
*
* @param url the URL to parse
* @return a dictionary bundle of keys and values
*/
public static Bundle parseUrl(String url) {
// hack to prevent MalformedURLException
url = url.replace("fbconnect", "http");
try {
URL u = new URL(url);
Bundle b = decodeUrl(u.getQuery());
b.putAll(decodeUrl(u.getRef()));
return b;
} catch (MalformedURLException e) {
return new Bundle();
}
}
public void setPage(final URL page) throws IOException {
if (page == null) {
throw new IOException(Messages.getString("swing.03", "Page")); // $NON-NLS-1$ //$NON-NLS-2$
}
String url = page.toString();
String baseUrl = getBaseURL(url);
Document oldDoc = getDocument();
if (baseUrl != null
&& oldDoc != null
&& baseUrl.equals(oldDoc.getProperty(Document.StreamDescriptionProperty))) {
scrollToReference(page.getRef());
return;
}
InputStream stream = getStream(page);
if (stream == null) {
return;
}
Document newDoc = editorKit.createDefaultDocument();
// Perhaps, it is reasonable only for HTMLDocument...
if (newDoc instanceof HTMLDocument) {
newDoc.putProperty(Document.StreamDescriptionProperty, baseUrl);
newDoc.putProperty(StringConstants.IGNORE_CHARSET_DIRECTIVE, new Boolean(false));
try {
((HTMLDocument) newDoc).setBase(new URL(baseUrl));
} catch (IOException e) {
}
}
// TODO Asynch loading doesn't work with completely.
// Also page property change event is written incorrectly now
// (at the asynchrounous loading), because loading may not be
// completed.
// int asynchronousLoadPriority = getAsynchronousLoadPriority(newDoc);
int asynchronousLoadPriority = -1;
if (asynchronousLoadPriority >= 0) {
setDocument(newDoc);
AsynchLoad newThread = new AsynchLoad(asynchronousLoadPriority, stream, page);
newThread.start();
if (newThread.successfulLoading) {
changePage(page);
}
} else {
try {
documentLoading(stream, newDoc, page);
stream.close();
setDocument(newDoc);
changePage(page);
} catch (IOException e) {
}
}
}
private static URL _encode(URL url) throws Exception {
URI uri =
new URI(
url.getProtocol(),
url.getUserInfo(),
url.getHost(),
url.getPort(),
url.getPath(),
url.getQuery(),
url.getRef());
return new URL(uri.toASCIIString());
}
public static void main(String[] args) throws IOException {
URL url = new URL("http://www.javajeff.com/articles/articles/html");
System.out.println("Authority = " + url.getAuthority());
System.out.println("Default port = " + url.getDefaultPort());
System.out.println("File = " + url.getFile());
System.out.println("Host = " + url.getHost());
System.out.println("Path = " + url.getPath());
System.out.println("Port = " + url.getPort());
System.out.println("Protocol = " + url.getProtocol());
System.out.println("Query = " + url.getQuery());
System.out.println("Ref = " + url.getRef());
System.out.println("User Info = " + url.getUserInfo());
}
private void _log(@Nonnull final URL aURL) throws URISyntaxException {
s_aLogger.info("Next URL");
s_aLogger.info(" protocol = " + aURL.getProtocol());
s_aLogger.info(" authority = " + aURL.getAuthority());
s_aLogger.info(" host = " + aURL.getHost());
s_aLogger.info(" port = " + aURL.getPort());
s_aLogger.info(" defaultPort = " + aURL.getDefaultPort());
s_aLogger.info(" path = " + aURL.getPath());
s_aLogger.info(" query = " + aURL.getQuery());
s_aLogger.info(" file = " + aURL.getFile());
s_aLogger.info(" ref = " + aURL.getRef());
s_aLogger.info(" externalForm = " + aURL.toExternalForm());
s_aLogger.info(" URI = " + aURL.toURI().toString());
}
/** Build from an existing URL. */
public ParsedURLData(URL url) {
protocol = url.getProtocol();
if ((protocol != null) && (protocol.length() == 0)) protocol = null;
host = url.getHost();
if ((host != null) && (host.length() == 0)) host = null;
port = url.getPort();
path = url.getFile();
if ((path != null) && (path.length() == 0)) path = null;
ref = url.getRef();
if ((ref != null) && (ref.length() == 0)) ref = null;
}
/**
* Encodes passed URL
*
* @param url Prepared URL
*/
protected String encodeUrl(URL url) {
try {
URI uri =
new URI(
url.getProtocol(),
url.getUserInfo(),
url.getHost(),
url.getPort(),
url.getPath(),
url.getQuery(),
url.getRef());
return uri.toASCIIString();
} catch (URISyntaxException e) {
return url.toString();
}
}
@Test
public void test_javaNetUrl() throws Exception {
java.net.URL url =
new java.net.URL(
"http://*****:*****@10.20.130.230:20880/context/path?version=1.0.0&application=morgan#anchor1");
assertEquals("http", url.getProtocol());
assertEquals("admin:hello1234", url.getUserInfo());
assertEquals("10.20.130.230", url.getHost());
assertEquals(20880, url.getPort());
assertEquals("/context/path", url.getPath());
assertEquals("version=1.0.0&application=morgan", url.getQuery());
assertEquals("anchor1", url.getRef());
assertEquals("admin:[email protected]:20880", url.getAuthority());
assertEquals("/context/path?version=1.0.0&application=morgan", url.getFile());
}
public static int[] getCodigoETipo(URL url) {
if (url == null) return null;
String ref = url.getRef();
int pos_tip = ref.indexOf(TIP);
int pos_end = ref.indexOf(END, pos_tip + 1);
if (pos_tip > 0) {
int x[] = null;
try {
String cod = ref.substring(0, pos_tip);
String tip = ref.substring(pos_tip + 1, ref.length());
/*
String tip;
if( pos_end > 0 )
tip = ref.substring(pos_tip+1,pos_end);
else
tip = ref.substring(pos_tip+1,ref.length());
*/
x = new int[] {Integer.valueOf(cod).intValue(), Integer.valueOf(tip).intValue()};
} catch (Exception exc) {
x = null;
}
return x;
}
return null;
}
/** 设置现成的uri。 */
public final URIBroker setServerURI(String uriString) {
URL uri;
try {
uri = new URL(assertNotNull(trimToNull(uriString), "serverURI"));
} catch (MalformedURLException e) {
throw new IllegalArgumentException(e.getMessage());
}
String serverScheme = uri.getProtocol();
String[] userInfo = StringUtil.split(uri.getUserInfo(), ":");
String serverName = uri.getHost();
int serverPort = uri.getPort();
if (serverScheme != null) {
setServerScheme(serverScheme);
}
if (!isEmptyArray(userInfo)) {
if (userInfo.length > 0) {
setLoginUser(userInfo[0]);
}
if (userInfo.length > 1) {
setLoginPassword(userInfo[1]);
}
}
if (serverName != null) {
setServerName(serverName);
}
if (serverPort > 0) {
setServerPort(serverPort);
}
setServerURI(uri);
new URIBrokerQueryStringParser().parse(uri.getQuery());
setReference(uri.getRef());
return this;
}
/**
* Copies the gold folder to the runtime workspace CONTRACT: folder exists in the devspace,
* goldFolder has been set In this implementation, the gold folder is copied from
* bin/test/GoldFolder
*/
public static void copyGoldFolder() {
/* goldFolder (location where goldfolder should go in runspace) must not be null */
Assert.assertTrue(goldFolder != null);
Bundle model2testsBundle = EclipsePlugin.getDefault().getBundle();
/* this is the source for our goldfolder in the devspace that we're copying to the runspace */
URL gfURL = model2testsBundle.getEntry("/");
/* devspace GoldFolder must exist */
// Assert.assertTrue(goldFolder.exists());
// Assert.assertTrue(gf.exists());
IWorkspace workspace = ResourcesPlugin.getWorkspace();
IWorkspaceRoot workspaceRoot = workspace.getRoot();
IPath rootPath = workspaceRoot.getLocation();
try {
gfURL = Platform.asLocalURL(gfURL);
} catch (IOException e) {
e.printStackTrace();
}
System.out.println("URL path: " + gfURL.getPath());
System.out.println("URL file: " + gfURL.getFile());
System.out.println("URL ref: " + gfURL.getRef());
File srcDir = new File(gfURL.getPath(), "GoldFolder");
Path p = new Path(gfURL.getPath());
IResource igf = ((Workspace) workspace).newResource(p, IResource.FOLDER);
IPath gfpath = goldFolder.getFullPath();
File destDir = new File(gfpath.toOSString());
/* Make sure both of these directories exist */
System.out.println("Source directory exists: " + srcDir.exists());
/* destination directory shouldn't exist because we're going to create it */
// System.out.println ("Dest directory exists: " + destDir.exists());
/* Since assert isn't working for the moment... */
if (!srcDir.exists()) {
System.out.println("GoldFolder not found");
Log.log("GoldFolder not found");
Assert.fail("GoldFolder not found");
}
// Assert.assertTrue("Source goldfolder does not exist", srcDir.exists());
// Assert.assertTrue("Destination goldfolder does not exist", destDir.exists());
copyFolder(srcDir, destDir);
}
private String createPublicUrl(String baseUrl, String path) {
if (!ObjectUtils.isBlank(baseUrl)) {
path = StringUtils.ensureEnd(baseUrl, "/") + path;
try {
URL url = new URL(path);
path =
new URI(
url.getProtocol(),
url.getAuthority(),
url.getPath(),
url.getQuery(),
url.getRef())
.toASCIIString();
} catch (MalformedURLException error) {
// Return the path as is if the given path is malformed.
} catch (URISyntaxException error) {
// Return the path as is if the resolved path is malformed.
}
}
return path;
}