Java tutorial
/** * The contents of this file are subject to the license and copyright * detailed in the LICENSE file at the root of the source * tree and available online at * * https://github.com/keeps/roda */ /** * */ package org.roda.wui.common.client.tools; import java.util.ArrayList; import java.util.Arrays; import java.util.List; import org.roda.core.data.v2.formats.Format; import org.roda.core.data.v2.index.IsIndexed; import org.roda.core.data.v2.ip.DIPFile; import org.roda.core.data.v2.ip.IndexedAIP; import org.roda.core.data.v2.ip.IndexedDIP; import org.roda.core.data.v2.ip.IndexedFile; import org.roda.core.data.v2.ip.IndexedRepresentation; import org.roda.core.data.v2.ip.TransferredResource; import org.roda.core.data.v2.jobs.IndexedReport; import org.roda.core.data.v2.jobs.Job; import org.roda.core.data.v2.notifications.Notification; import org.roda.core.data.v2.risks.IndexedRisk; import org.roda.core.data.v2.risks.RiskIncidence; import org.roda.wui.client.browse.BrowseAIP; import org.roda.wui.client.browse.BrowseDIP; import org.roda.wui.client.browse.BrowseFile; import org.roda.wui.client.browse.BrowseRepresentation; import org.roda.wui.client.browse.BrowserService; import org.roda.wui.client.common.utils.AsyncCallbackUtils; import org.roda.wui.client.ingest.process.ShowJob; import org.roda.wui.client.ingest.process.ShowJobReport; import org.roda.wui.client.ingest.transfer.IngestTransfer; import org.roda.wui.client.ingest.transfer.TransferUpload; import org.roda.wui.client.management.ShowNotification; import org.roda.wui.client.planning.ShowFormat; import org.roda.wui.client.planning.ShowRisk; import org.roda.wui.client.planning.ShowRiskIncidence; import org.roda.wui.common.client.HistoryResolver; import org.roda.wui.common.client.widgets.Toast; import com.google.gwt.http.client.URL; import com.google.gwt.user.client.Window; import com.google.gwt.user.client.rpc.AsyncCallback; import com.google.gwt.user.client.ui.Widget; /** * Useful methods * * @author Luis Faria */ public class HistoryUtils { private HistoryUtils() { } public static final String HISTORY_SEP = "/"; public static final String HISTORY_SEP_REGEX = "/"; public static final String HISTORY_SEP_ESCAPE = "%2F"; public static final String HISTORY_PERMISSION_SEP = "."; public static <T> List<T> tail(List<T> list) { return list.subList(1, list.size()); } public static <T> List<T> removeLast(List<T> list) { return list.subList(0, list.size() - 1); } /** * Split history string to history path using HISTORY_SEP as the separator * * @param history * @return the history path */ public static List<String> splitHistory(String history) { List<String> historyPath; if (history.indexOf(HISTORY_SEP) == -1) { historyPath = Arrays.asList(history); } else { historyPath = Arrays.asList(history.split(HISTORY_SEP_REGEX)); } return historyPath; } public static List<String> decodeList(List<String> splitted) { List<String> tokens = new ArrayList<>(); for (String item : splitted) { tokens.add(URL.decodeQueryString(item)); } return tokens; } public static List<String> getCurrentHistoryPath() { String hash = Window.Location.getHash(); if (hash.length() > 0) { hash = hash.substring(1); } return decodeList(Arrays.asList(hash.split(HISTORY_SEP_REGEX))); } public static String createHistoryToken(List<String> tokens) { StringBuilder builder = new StringBuilder(); boolean first = true; for (String token : tokens) { if (first) { first = false; } else { builder.append(HISTORY_SEP); } String encodedToken = URL.encodeQueryString(token).replaceAll(HISTORY_SEP_REGEX, HISTORY_SEP_ESCAPE); builder.append(encodedToken); } return builder.toString(); } public static void newHistory(List<String> path) { String hash = createHistoryToken(path); Window.Location.assign("#" + hash); } public static void replaceHistory(List<String> path) { String hash = createHistoryToken(path); Window.Location.replace("#" + hash); } public static void newHistory(HistoryResolver resolver) { newHistory(resolver.getHistoryPath()); } public static void newHistory(HistoryResolver resolver, String... extrapath) { List<String> path = ListUtils.concat(resolver.getHistoryPath(), extrapath); newHistory(path); } public static void newHistory(HistoryResolver resolver, List<String> extrapath) { List<String> path = ListUtils.concat(resolver.getHistoryPath(), extrapath); newHistory(path); } public static String createHistoryHashLink(List<String> path) { String hash = createHistoryToken(path); return "#" + hash; } public static String createHistoryHashLink(HistoryResolver resolver, String... extrapath) { List<String> path = ListUtils.concat(resolver.getHistoryPath(), extrapath); return createHistoryHashLink(path); } public static String createHistoryHashLink(HistoryResolver resolver, List<String> extrapath) { List<String> path = ListUtils.concat(resolver.getHistoryPath(), extrapath); return createHistoryHashLink(path); } public static List<String> getHistoryBrowse(String aipId) { List<String> history = new ArrayList<>(); history.addAll(BrowseAIP.RESOLVER.getHistoryPath()); history.add(aipId); return history; } public static List<String> getHistoryBrowseDIP(String dipId) { List<String> history = new ArrayList<>(); history.addAll(BrowseAIP.RESOLVER.getHistoryPath()); history.add(BrowseDIP.RESOLVER.getHistoryToken()); history.add(dipId); return history; } public static List<String> getHistoryBrowseDIPFile(String dipId, String dipFileUUID) { List<String> history = new ArrayList<>(); history.addAll(BrowseAIP.RESOLVER.getHistoryPath()); history.add(BrowseDIP.RESOLVER.getHistoryToken()); history.add(dipId); history.add(dipFileUUID); return history; } public static List<String> getHistoryBrowse(DIPFile dipFile) { return getHistoryBrowseDIPFile(dipFile.getDipId(), dipFile.getUUID()); } public static void openBrowse(IndexedDIP dip) { HistoryUtils.newHistory(getHistoryBrowseDIP(dip.getId())); } public static void openBrowse(DIPFile dipFile) { HistoryUtils.newHistory(getHistoryBrowseDIPFile(dipFile.getDipId(), dipFile.getUUID())); } public static void openBrowseDIP(String dipId) { HistoryUtils.newHistory(getHistoryBrowseDIP(dipId)); } public static void openBrowse(String aipId) { HistoryUtils.newHistory(getHistoryBrowse(aipId)); } public static void openBrowse(IndexedAIP aip) { openBrowse(aip.getId()); } public static List<String> getHistoryBrowse(String aipId, String representationId) { List<String> history = new ArrayList<>(); history.addAll(BrowseAIP.RESOLVER.getHistoryPath()); history.add(BrowseRepresentation.RESOLVER.getHistoryToken()); history.add(aipId); history.add(representationId); return history; } public static List<String> getHistoryBrowse(IndexedRepresentation representation) { return getHistoryBrowse(representation.getAipId(), representation.getId()); } public static void openBrowse(String aipId, String representationId) { HistoryUtils.newHistory(getHistoryBrowse(aipId, representationId)); } public static void openBrowse(IndexedRepresentation representation) { openBrowse(representation.getAipId(), representation.getId()); } public static List<String> getHistoryBrowse(String aipId, String representationId, List<String> filePath, String fileId) { List<String> history = new ArrayList<>(); history.addAll(BrowseAIP.RESOLVER.getHistoryPath()); history.add(BrowseFile.RESOLVER.getHistoryToken()); history.add(aipId); history.add(representationId); history.addAll(filePath); history.add(fileId); return history; } public static List<String> getHistoryBrowse(IndexedFile file) { return getHistoryBrowse(file.getAipId(), file.getRepresentationId(), file.getPath(), file.getId()); } public static void openBrowse(String aipId, String representationId, List<String> filePath, String fileId) { HistoryUtils.newHistory(getHistoryBrowse(aipId, representationId, filePath, fileId)); } public static void openBrowse(IndexedFile file) { openBrowse(file.getAipId(), file.getRepresentationId(), file.getPath(), file.getId()); } public static List<String> getHistoryUpload(IndexedFile folder) { List<String> history = new ArrayList<>(); history.addAll(BrowseAIP.RESOLVER.getHistoryPath()); history.add(TransferUpload.BROWSE_RESOLVER.getHistoryToken()); history.add(folder.getAipId()); history.add(folder.getRepresentationId()); history.addAll(folder.getPath()); history.add(folder.getId()); return history; } public static void openUpload(IndexedRepresentation representation) { HistoryUtils.newHistory(getHistoryUpload(representation)); } public static List<String> getHistoryUpload(IndexedRepresentation representation) { List<String> history = new ArrayList<>(); history.addAll(BrowseAIP.RESOLVER.getHistoryPath()); history.add(TransferUpload.BROWSE_RESOLVER.getHistoryToken()); history.add(representation.getAipId()); history.add(representation.getId()); return history; } public static void openUpload(IndexedFile folder) { if (folder.isDirectory()) { HistoryUtils.newHistory(getHistoryUpload(folder)); } } public static List<String> getHistory(List<String> resolverPath, String resourceUUID) { List<String> history = new ArrayList<>(); history.addAll(resolverPath); history.add(resourceUUID); return history; } public static void resolve(final String objectClass, final String objectUUID) { resolve(objectClass, objectUUID, false); } public static <T extends IsIndexed> void resolve(final String objectClass, final String objectUUID, final boolean replace) { BrowserService.Util.getInstance().retrieveFromModel(objectClass, objectUUID, new AsyncCallback<T>() { @Override public void onFailure(Throwable caught) { AsyncCallbackUtils.defaultFailureTreatment(caught); } @Override public void onSuccess(T object) { resolve(object, replace); } }); } public static <T extends IsIndexed> void resolve(T object) { resolve(object, false); } public static <T extends IsIndexed> void resolve(T object, boolean replace) { List<String> path = null; if (object instanceof IndexedAIP) { IndexedAIP aip = (IndexedAIP) object; path = HistoryUtils.getHistoryBrowse(aip.getId()); } else if (object instanceof IndexedRepresentation) { IndexedRepresentation representation = (IndexedRepresentation) object; path = HistoryUtils.getHistoryBrowse(representation); } else if (object instanceof IndexedFile) { IndexedFile file = (IndexedFile) object; path = HistoryUtils.getHistoryBrowse(file); } else if (object instanceof IndexedDIP) { IndexedDIP dip = (IndexedDIP) object; path = HistoryUtils.getHistoryBrowseDIP(dip.getId()); } else if (object instanceof DIPFile) { DIPFile dipFile = (DIPFile) object; path = HistoryUtils.getHistoryBrowseDIPFile(dipFile.getDipId(), dipFile.getUUID()); } else if (object instanceof TransferredResource) { TransferredResource resource = (TransferredResource) object; path = HistoryUtils.getHistory(IngestTransfer.RESOLVER.getHistoryPath(), resource.getUUID()); } else if (object instanceof IndexedRisk) { IndexedRisk risk = (IndexedRisk) object; path = HistoryUtils.getHistory(ShowRisk.RESOLVER.getHistoryPath(), risk.getUUID()); } else if (object instanceof Format) { Format format = (Format) object; path = HistoryUtils.getHistory(ShowFormat.RESOLVER.getHistoryPath(), format.getUUID()); } else if (object instanceof Notification) { Notification notification = (Notification) object; path = HistoryUtils.getHistory(ShowNotification.RESOLVER.getHistoryPath(), notification.getUUID()); } else if (object instanceof RiskIncidence) { RiskIncidence incidence = (RiskIncidence) object; path = HistoryUtils.getHistory(ShowRiskIncidence.RESOLVER.getHistoryPath(), incidence.getUUID()); } else if (object instanceof Job) { Job job = (Job) object; path = HistoryUtils.getHistory(ShowJob.RESOLVER.getHistoryPath(), job.getUUID()); } else if (object instanceof IndexedReport) { IndexedReport report = (IndexedReport) object; path = HistoryUtils.getHistory(ShowJobReport.RESOLVER.getHistoryPath(), report.getUUID()); } else { Toast.showError("Resolve of class not supported: " + object.getClass().getName()); } if (path != null) { if (replace) { HistoryUtils.replaceHistory(path); } else { HistoryUtils.newHistory(path); } } } public static final HistoryResolver UUID_RESOLVER = new HistoryResolver() { @Override public void resolve(List<String> historyTokens, AsyncCallback<Widget> callback) { if (historyTokens.size() == 2) { String objectClass = historyTokens.get(0); String objectUUID = historyTokens.get(1); HistoryUtils.resolve(objectClass, objectUUID, true); } callback.onSuccess(null); } @Override public void isCurrentUserPermitted(AsyncCallback<Boolean> callback) { callback.onSuccess(true); } @Override public String getHistoryToken() { return "uuid"; } @Override public List<String> getHistoryPath() { return new ArrayList<>(); } }; public static List<String> getHistoryUuidResolver(String objectClass, String objectUUID) { return Arrays.asList(UUID_RESOLVER.getHistoryToken(), objectClass, objectUUID); } }