| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| */ |
| |
| package org.apache.openaz.xacml.admin.components; |
| |
| import java.io.File; |
| import java.io.FilenameFilter; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.io.OutputStream; |
| import java.nio.file.FileVisitResult; |
| import java.nio.file.Files; |
| import java.nio.file.Path; |
| import java.nio.file.Paths; |
| import java.nio.file.SimpleFileVisitor; |
| import java.nio.file.attribute.BasicFileAttributes; |
| import java.util.Collection; |
| import java.util.Iterator; |
| |
| import oasis.names.tc.xacml._3_0.core.schema.wd_17.PolicySetType; |
| import oasis.names.tc.xacml._3_0.core.schema.wd_17.PolicyType; |
| import oasis.names.tc.xacml._3_0.core.schema.wd_17.RuleType; |
| |
| import org.apache.commons.compress.archivers.tar.TarArchiveEntry; |
| import org.apache.commons.compress.archivers.tar.TarArchiveOutputStream; |
| import org.apache.commons.compress.compressors.gzip.GzipCompressorOutputStream; |
| import org.apache.commons.io.FilenameUtils; |
| import org.apache.commons.io.IOUtils; |
| import org.apache.commons.logging.Log; |
| import org.apache.commons.logging.LogFactory; |
| import org.eclipse.jgit.api.Git; |
| import org.eclipse.jgit.api.Status; |
| import org.eclipse.jgit.api.errors.GitAPIException; |
| import org.eclipse.jgit.dircache.DirCache; |
| import org.eclipse.jgit.dircache.DirCacheEntry; |
| import org.eclipse.jgit.errors.NoWorkTreeException; |
| import org.eclipse.jgit.revwalk.RevCommit; |
| import org.eclipse.jgit.transport.PushResult; |
| import org.vaadin.dialogs.ConfirmDialog; |
| import org.vaadin.dialogs.ConfirmDialog.ContentMode; |
| |
| import org.apache.openaz.xacml.admin.XacmlAdminAuthorization; |
| import org.apache.openaz.xacml.admin.XacmlAdminUI; |
| import org.apache.openaz.xacml.admin.model.GitRepositoryContainer; |
| import org.apache.openaz.xacml.admin.util.AdminNotification; |
| import org.apache.openaz.xacml.admin.util.OnDemandFileDownloader; |
| import org.apache.openaz.xacml.admin.util.OnDemandFileDownloader.OnDemandStreamResource; |
| import org.apache.openaz.xacml.admin.util.XACMLPolicyImporter; |
| import org.apache.openaz.xacml.admin.view.windows.GitPushWindow; |
| import org.apache.openaz.xacml.admin.view.windows.GitSynchronizeWindow; |
| import org.apache.openaz.xacml.admin.view.windows.PolicyNameEditorWindow; |
| import org.apache.openaz.xacml.admin.view.windows.PolicyUploadWindow; |
| import org.apache.openaz.xacml.admin.view.windows.RenamePolicyFileWindow; |
| import org.apache.openaz.xacml.admin.view.windows.SubDomainEditorWindow; |
| import org.apache.openaz.xacml.std.pap.StdPDPPolicy; |
| import org.apache.openaz.xacml.util.XACMLPolicyScanner; |
| import org.apache.openaz.xacml.util.XACMLPolicyScanner.CallbackResult; |
| import org.apache.openaz.xacml.util.XACMLPolicyWriter; |
| import com.vaadin.annotations.AutoGenerated; |
| import com.vaadin.data.Item; |
| import com.vaadin.event.Action; |
| import com.vaadin.event.Action.Handler; |
| import com.vaadin.event.ItemClickEvent; |
| import com.vaadin.event.ItemClickEvent.ItemClickListener; |
| import com.vaadin.event.ShortcutAction.KeyCode; |
| import com.vaadin.event.Transferable; |
| import com.vaadin.event.dd.DragAndDropEvent; |
| import com.vaadin.event.dd.DropHandler; |
| import com.vaadin.event.dd.acceptcriteria.AcceptAll; |
| import com.vaadin.event.dd.acceptcriteria.AcceptCriterion; |
| import com.vaadin.ui.AbstractSelect.AbstractSelectTargetDetails; |
| import com.vaadin.ui.Alignment; |
| import com.vaadin.ui.Button; |
| import com.vaadin.ui.Button.ClickEvent; |
| import com.vaadin.ui.Button.ClickListener; |
| import com.vaadin.ui.Component; |
| import com.vaadin.ui.CustomComponent; |
| import com.vaadin.ui.HorizontalLayout; |
| import com.vaadin.ui.HorizontalSplitPanel; |
| import com.vaadin.ui.Notification; |
| import com.vaadin.ui.TabSheet; |
| import com.vaadin.ui.TabSheet.CloseHandler; |
| import com.vaadin.ui.TabSheet.Tab; |
| import com.vaadin.ui.Table.TableDragMode; |
| import com.vaadin.ui.Table.TableTransferable; |
| import com.vaadin.ui.TreeTable; |
| import com.vaadin.ui.UI; |
| import com.vaadin.ui.VerticalLayout; |
| import com.vaadin.ui.Window.CloseEvent; |
| import com.vaadin.ui.Window.CloseListener; |
| |
| /** |
| * The class represents Policy Editor in Policy Authoring Tool |
| */ |
| public class PolicyWorkspace extends CustomComponent implements DropHandler, OnDemandStreamResource { |
| /*- VaadinEditorProperties={"grid":"RegularGrid,20","showGrid":true,"snapToGrid":true,"snapToObject":true,"movingGuides":false,"snappingDistance":10} */ |
| |
| @AutoGenerated |
| private VerticalLayout mainLayout; |
| |
| @AutoGenerated |
| private HorizontalSplitPanel horizontalSplitPanel; |
| |
| @AutoGenerated |
| private VerticalLayout verticalLayoutRightPanel; |
| |
| @AutoGenerated |
| private TabSheet tabSheet; |
| |
| @AutoGenerated |
| private HorizontalLayout horizontalLayoutRightToolbar; |
| |
| @AutoGenerated |
| private Button buttonRight; |
| |
| @AutoGenerated |
| private VerticalLayout verticalLayoutLeftPanel; |
| |
| @AutoGenerated |
| private TreeTable treeWorkspace; |
| |
| @AutoGenerated |
| private HorizontalLayout horizontalLayoutLeftToolbar; |
| |
| @AutoGenerated |
| private Button buttonLeft; |
| |
| @AutoGenerated |
| private HorizontalLayout horizontalLayoutLeftToolbarLeft; |
| |
| @AutoGenerated |
| private Button buttonExport; |
| |
| @AutoGenerated |
| private Button buttonSynchronize; |
| |
| private static final long serialVersionUID = 1L; |
| private static final Log logger = LogFactory.getLog(PolicyWorkspace.class); |
| private final PolicyWorkspace self = this; |
| private final OnDemandFileDownloader downloader = new OnDemandFileDownloader(this); |
| |
| private GitRepositoryContainer treeContainer; |
| |
| private static final Action EXPORT_REPOSITORY = new Action ("Export Repository"); |
| private static final Action SYNCHRONIZE_REPOSITORY =new Action ("Synchronize"); |
| private static final Action PUSH_CHANGES = new Action ("Push Changes"); |
| private static final Action CREATE_SUBDOMAIN = new Action("Create Sub Domain"); |
| private static final Action RENAME_SUBDOMAIN = new Action("Rename Sub Domain"); |
| private static final Action CREATE_NEWPOLICY = new Action ("Create New Policy"); |
| private static final Action RENAME_POLICY = new Action ("Rename Policy"); |
| private static final Action IMPORT_POLICY = new Action ("Import Policy"); |
| private static final Action DELETE_SUBDOMAIN = new Action ("Delete Sub Domain"); |
| private static final Action CLONE_POLICY = new Action ("Clone Policy"); |
| private static final Action VIEW_POLICY = new Action ("View Policy"); |
| private static final Action EDIT_POLICY = new Action ("Edit Policy"); |
| private static final Action EXPORT_POLICY = new Action ("Export Policy"); |
| private static final Action DELETE_POLICY = new Action ("Delete Policy"); |
| |
| public static final String VIEWNAME = PolicyWorkspace.class.getCanonicalName(); |
| |
| /** |
| * The constructor should first build the main layout, set the |
| * composition root and then do any custom initialization. |
| * |
| * The constructor will not be automatically regenerated by the |
| * visual editor. |
| */ |
| public PolicyWorkspace() { |
| buildMainLayout(); |
| setCompositionRoot(mainLayout); |
| // |
| // Initialize GUI |
| // |
| this.initializeTree(); |
| this.initializeButtons(); |
| } |
| |
| protected void initializeButtons() { |
| buttonLeft.addClickListener(new ClickListener() { |
| private static final long serialVersionUID = 1L; |
| |
| @Override |
| public void buttonClick(ClickEvent event) { |
| if (horizontalSplitPanel.getSplitPosition() == 100.0) |
| horizontalSplitPanel.setSplitPosition(36, Unit.PERCENTAGE); |
| else |
| horizontalSplitPanel.setSplitPosition(0); |
| } |
| }); |
| buttonRight.addClickListener(new ClickListener() { |
| private static final long serialVersionUID = 1L; |
| |
| @Override |
| public void buttonClick(ClickEvent event) { |
| if (horizontalSplitPanel.getSplitPosition() == 0.0) |
| horizontalSplitPanel.setSplitPosition(36, Unit.PERCENTAGE); |
| else |
| horizontalSplitPanel.setSplitPosition(100, Unit.PERCENTAGE); |
| } |
| }); |
| // |
| // Check user write-access |
| // |
| if (((XacmlAdminUI)UI.getCurrent()).isAuthorized( |
| XacmlAdminAuthorization.AdminAction.ACTION_WRITE, |
| XacmlAdminAuthorization.AdminResource.RESOURCE_POLICY_WORKSPACE)) { |
| this.buttonSynchronize.addClickListener(new ClickListener() { |
| private static final long serialVersionUID = 1L; |
| |
| @Override |
| public void buttonClick(ClickEvent event) { |
| self.synchronizeRepository(); |
| } |
| }); |
| } else { |
| logger.info("user not authorized to write, removing synchronize button."); |
| this.buttonSynchronize.setVisible(false); |
| } |
| // |
| // The export button is attached to dynamic downloader |
| // |
| downloader.extend(this.buttonExport); |
| } |
| |
| protected void initializeTree() { |
| // |
| // This is where the user's Git repository is located |
| // |
| final Path gitPath = ((XacmlAdminUI)UI.getCurrent()).getUserGitPath(); |
| // |
| // Create our Git file system container |
| // |
| this.treeContainer = new GitRepositoryContainer(gitPath, gitPath.toFile()); |
| // |
| // Create our own filter to filter out File extensions and |
| // also the Git directory. |
| // |
| this.treeContainer.setFilter(new FilenameFilter() { |
| |
| @Override |
| public boolean accept(File dir, String name) { |
| // |
| // We don't want any of the hidden files |
| // |
| if (name.startsWith(".git") || name.equals(".DS_Store")) { |
| return false; |
| } |
| // |
| // We definitely want xml files |
| // |
| if (name.endsWith(".xml")) { |
| return true; |
| } |
| // |
| // We should test if its a directory, we want those |
| // included. |
| // |
| Path path = Paths.get(dir.getAbsolutePath(), name); |
| if (Files.isDirectory(path)) { |
| return true; |
| } |
| logger.warn("Filtering out: " + path.toString()); |
| return false; |
| } |
| |
| }); |
| // |
| // Set TreeTables datasource as our git container |
| // |
| this.treeWorkspace.setContainerDataSource(this.treeContainer); |
| // |
| // Setup other properties etc. |
| // |
| this.treeWorkspace.setItemIconPropertyId("Icon"); |
| this.treeWorkspace.setVisibleColumns(new Object[]{"Name", "Version", "Size", "Last Modified", "Status"}); |
| this.treeWorkspace.setSizeFull(); |
| this.treeWorkspace.setSelectable(true); |
| this.treeWorkspace.setEditable(false); |
| // |
| // Expand the first couple of directories |
| // |
| for (Object id : this.treeWorkspace.getItemIds()) { |
| this.treeWorkspace.setCollapsed(id, false); |
| for (Object child : this.treeWorkspace.getChildren(id)) { |
| this.treeWorkspace.setCollapsed(child, false); |
| } |
| } |
| // |
| // Respond to table selections |
| // |
| /* |
| this.treeWorkspace.addValueChangeListener(new ValueChangeListener() { |
| private static final long serialVersionUID = 1L; |
| |
| @Override |
| public void valueChange(ValueChangeEvent event) { |
| File selection = (File) self.treeWorkspace.getValue(); |
| if (selection != null) { |
| self.buttonImport.setEnabled(selection.isDirectory()); |
| self.buttonExport.setEnabled(selection.isFile()); |
| } else { |
| |
| } |
| } |
| |
| }); |
| */ |
| this.treeWorkspace.addItemClickListener(new ItemClickListener() { |
| private static final long serialVersionUID = 1L; |
| |
| @Override |
| public void itemClick(ItemClickEvent event) { |
| if (event.isDoubleClick() && |
| event.getItemId() instanceof File && |
| ((File) event.getItemId()).isFile()) { |
| self.openPolicyTab((File) event.getItemId(), true); |
| } |
| } |
| }); |
| // |
| // Setup our action handlers |
| // |
| this.treeWorkspace.addActionHandler(new Handler() { |
| private static final long serialVersionUID = 1L; |
| |
| @Override |
| public Action[] getActions(Object target, Object sender) { |
| if (target == null) { |
| // |
| // Nothing is selected, they right-clicked empty space |
| // |
| return new Action[] {SYNCHRONIZE_REPOSITORY, EXPORT_REPOSITORY, CREATE_SUBDOMAIN}; |
| } |
| if (! (target instanceof File)) { |
| return null; |
| } |
| if (((File)target).isDirectory()) { |
| // |
| // Selected a directory |
| // |
| return new Action[] {CREATE_SUBDOMAIN, RENAME_SUBDOMAIN, DELETE_SUBDOMAIN, CREATE_NEWPOLICY, IMPORT_POLICY, PUSH_CHANGES}; |
| } |
| if (((File)target).isFile()) { |
| // |
| // Selected a policy file |
| // |
| return new Action[] {VIEW_POLICY, EDIT_POLICY, CLONE_POLICY, EXPORT_POLICY, RENAME_POLICY, DELETE_POLICY, PUSH_CHANGES}; |
| } |
| return null; |
| } |
| |
| @Override |
| public void handleAction(Action action, Object sender, Object target) { |
| if (action == SYNCHRONIZE_REPOSITORY) { |
| self.synchronizeRepository(); |
| return; |
| } |
| if (action == EXPORT_REPOSITORY) { |
| self.exportRepository(); |
| return; |
| } |
| if (action == PUSH_CHANGES) { |
| self.pushChanges((File) target); |
| return; |
| } |
| if (action == CREATE_SUBDOMAIN) { |
| self.editSubDomain((File) target, null); |
| return; |
| } |
| if (action == RENAME_SUBDOMAIN) { |
| self.editSubDomain((File) self.treeWorkspace.getParent(target), ((File)target).getName()); |
| return; |
| } |
| if (action == CREATE_NEWPOLICY) { |
| self.createPolicy((File) target); |
| return; |
| } |
| if (action == RENAME_POLICY) { |
| self.renamePolicy((File) target); |
| return; |
| |
| } |
| if (action == IMPORT_POLICY) { |
| self.importPolicy((File) target); |
| return; |
| } |
| if (action == DELETE_SUBDOMAIN) { |
| self.deleteSubDomain((File) target); |
| return; |
| } |
| if (action == CLONE_POLICY) { |
| self.clonePolicy((File) target); |
| return; |
| } |
| if (action == VIEW_POLICY) { |
| self.openPolicyTab((File) target, true); |
| return; |
| } |
| if (action == EDIT_POLICY) { |
| self.openPolicyTab((File) target, false); |
| return; |
| } |
| if (action == EXPORT_POLICY) { |
| return; |
| |
| } |
| if (action == DELETE_POLICY) { |
| self.deletePolicy((File) target); |
| return; |
| } |
| } |
| }); |
| // |
| // Set the drop handler |
| // |
| this.treeWorkspace.setDragMode(TableDragMode.ROW); |
| this.treeWorkspace.setDropHandler(this); |
| // |
| // Detect when a tab closes and remove it from the |
| // tab sheet. |
| // |
| this.tabSheet.setCloseHandler(new CloseHandler() { |
| private static final long serialVersionUID = 1L; |
| |
| @Override |
| public void onTabClose(TabSheet tabsheet, Component tabContent) { |
| logger.info("tabsheet closing: " + tabsheet.getCaption()); |
| tabsheet.removeTab(tabsheet.getTab(tabContent)); |
| } |
| |
| }); |
| } |
| |
| protected void editSubDomain(final File parent, final String subdomain) { |
| final SubDomainEditorWindow editor = new SubDomainEditorWindow(null); |
| editor.setCaption((subdomain == null ? "Create New SubDomain" : "Edit SubDomain")); |
| editor.setCloseShortcut(KeyCode.ESCAPE); |
| editor.setModal(true); |
| editor.addCloseListener(new CloseListener() { |
| private static final long serialVersionUID = 1L; |
| |
| @Override |
| public void windowClose(CloseEvent event) { |
| // |
| // Did the user save it |
| // |
| if (editor.isSaved() == false) { |
| return; |
| } |
| String newSubDomain = editor.getSubDomain(); |
| if (newSubDomain == null) { |
| logger.warn("Shouldn't have a null subdomain if the user clicked save button"); |
| return; |
| } |
| // |
| // New subdomain? |
| // |
| if (subdomain == null) { |
| // |
| // Create new one |
| // |
| Path createDir; |
| if (parent == null) { |
| // |
| // New Root domain |
| // |
| createDir = Paths.get(((XacmlAdminUI)UI.getCurrent()).getUserGitPath().toAbsolutePath().toString(), newSubDomain); |
| } else { |
| // |
| // New subdomain |
| // |
| createDir = Paths.get(parent.getAbsolutePath(), newSubDomain); |
| } |
| try { |
| // |
| // Does the new subdomain exist? |
| // |
| Path newDir; |
| if (Files.exists(createDir)) { |
| // |
| // It already exists |
| // |
| newDir = createDir; |
| } else { |
| // |
| // Create it |
| // |
| newDir = Files.createDirectory(createDir); |
| // |
| // Create empty .gitignore file |
| // |
| Files.createFile(Paths.get(newDir.toString(), ".gitignore")); |
| } |
| // |
| // Setup the TreeTable |
| // |
| File file = newDir.toFile(); |
| if (parent == null) { |
| Item item = self.treeWorkspace.addItem(file); |
| if (item != null) { |
| self.treeWorkspace.setCollapsed(file, false); |
| self.treeWorkspace.select(file); |
| } |
| } else { |
| Item item = self.treeWorkspace.addItem(file); |
| if (item != null) { |
| self.treeWorkspace.setParent(file, parent); |
| self.treeWorkspace.setCollapsed(parent, false); |
| self.treeWorkspace.select(file); |
| } |
| } |
| } catch (IOException e) { |
| logger.error("Failed to create subdomain: " + createDir.toString(), e); |
| } |
| } else { |
| // |
| // Get our paths |
| // |
| Path oldDir = Paths.get(parent.getAbsolutePath(), subdomain); |
| Path newDir = Paths.get(parent.getAbsolutePath(), newSubDomain); |
| try { |
| // |
| // Rename the subdomain |
| // |
| Files.move(oldDir, newDir); |
| // |
| // Add to the TreeTable |
| // |
| File newFile = newDir.toFile(); |
| File oldFile = oldDir.toFile(); |
| Item item = self.treeWorkspace.addItem(newFile); |
| if (item != null) { |
| self.treeWorkspace.setChildrenAllowed(newFile, true); |
| // |
| // Make sure its parent is the same as the old one, unless they |
| // renamed the top-level. |
| // |
| Object parent = self.treeWorkspace.getParent(oldFile); |
| if (parent != null) { |
| self.treeWorkspace.setParent(newFile, parent); |
| } |
| // |
| // Make any children of the old subdomain now children |
| // of the new subdomain. |
| // |
| Collection<?> children = self.treeWorkspace.getChildren(oldFile); |
| Iterator<?> iter = children.iterator(); |
| while (iter.hasNext()) { |
| Object child = iter.next(); |
| self.treeWorkspace.setParent(child, newFile); |
| } |
| // |
| // Finally remove the old subdomain |
| // |
| self.treeWorkspace.removeItem(oldFile); |
| } |
| } catch (IOException e) { |
| logger.error("Failed to rename subdomain: " + oldDir.toString() + " to: " + newDir.toString(), e); |
| } |
| } |
| } |
| }); |
| editor.center(); |
| UI.getCurrent().addWindow(editor); |
| } |
| |
| protected void deleteSubDomain(final File subdomain) { |
| String message = "Are you sure you want to delete subdomain\n" + subdomain.getName() + "\nThis will remove <B>ALL</B> of its subdomains and policy files."; |
| ConfirmDialog dialog = ConfirmDialog.getFactory().create("Confirm SubDomain Deletion", message, "Delete", "Cancel"); |
| dialog.setContentMode(ContentMode.HTML); |
| dialog.show(getUI(), new ConfirmDialog.Listener() { |
| private static final long serialVersionUID = 1L; |
| |
| @Override |
| public void onClose(ConfirmDialog dialog) { |
| if (dialog.isConfirmed()) { |
| // |
| // Iterate the subdomain |
| // |
| try { |
| Files.walkFileTree(Paths.get(subdomain.getAbsolutePath()), new SimpleFileVisitor<Path>() { |
| @Override |
| public FileVisitResult visitFile(Path deleteFile, BasicFileAttributes attrs) |
| throws IOException { |
| try { |
| boolean removeFromTree = deleteFile.getFileName().toString().endsWith(".xml"); |
| Files.delete(deleteFile); |
| if (removeFromTree) { |
| self.treeWorkspace.removeItem(deleteFile.toFile()); |
| } |
| if (logger.isDebugEnabled()) { |
| logger.debug("Deleted file: " + deleteFile.toString()); |
| } |
| } catch (IOException e) { |
| logger.error("Failed to delete file: " + deleteFile.toString(), e); |
| return FileVisitResult.TERMINATE; |
| } |
| return super.visitFile(deleteFile, attrs); |
| } |
| |
| @Override |
| public FileVisitResult postVisitDirectory(Path dir, IOException exc) |
| throws IOException { |
| try { |
| Files.delete(dir); |
| self.treeWorkspace.removeItem(dir.toFile()); |
| if (logger.isDebugEnabled()) { |
| logger.debug("Deleted dir: " + dir.toString()); |
| } |
| } catch (IOException e) { |
| logger.error("Failed to delete directory: " + dir.toString(), e); |
| return FileVisitResult.TERMINATE; |
| } |
| return super.postVisitDirectory(dir, exc); |
| } |
| |
| }); |
| } catch (IOException e) { |
| logger.error("Failed to walk subdomain: " + subdomain.getAbsolutePath(), e); |
| } |
| } |
| } |
| |
| }, true); |
| |
| } |
| |
| protected void createPolicy(final File parentDirectory) { |
| // |
| // Construct our parameters |
| // |
| Path parent = Paths.get(parentDirectory.getAbsolutePath()); |
| Path newFile = this.getNextFilename(parent, "Policy"); |
| // |
| // Run the window |
| // |
| this.runPolicyWindow("Create New Policy", parent, newFile, null, null); |
| } |
| |
| protected void renamePolicy(final File policy) { |
| // |
| // Run the rename window |
| // |
| final RenamePolicyFileWindow window = new RenamePolicyFileWindow(policy.getName()); |
| window.setCaption("Rename Policy"); |
| window.setModal(true); |
| window.addCloseListener(new CloseListener() { |
| private static final long serialVersionUID = 1L; |
| |
| @Override |
| public void windowClose(CloseEvent event) { |
| String newFilename = window.getNewFilename(); |
| if (newFilename == null) { |
| // |
| // User cancelled |
| // |
| return; |
| } |
| Path newPolicy = Paths.get(policy.getParent(), newFilename); |
| if (Files.exists(newPolicy)) { |
| Notification.show("Cannot rename to an existing file", Notification.Type.ERROR_MESSAGE); |
| return; |
| } |
| try { |
| if (policy.renameTo(newPolicy.toFile()) == false) { |
| throw new Exception("No known error, rename failed"); |
| } |
| self.treeContainer.updateItem(newPolicy.getParent().toFile()); |
| } catch (Exception e) { |
| Notification.show("Failed to rename file: " + e.getLocalizedMessage()); |
| } |
| } |
| }); |
| window.center(); |
| UI.getCurrent().addWindow(window); |
| } |
| |
| protected void clonePolicy(final File policy) { |
| // |
| // Figure out a new name for the cloned policy |
| // |
| Path policyClone = Paths.get(policy.getAbsolutePath()); |
| Path newFile = this.getNextFilename(policyClone.getParent(), policy.getName()); |
| if (newFile == null) { |
| return; |
| } |
| // |
| // Scan the policy in, replace policy ID's and rule ID's |
| // |
| Object policyData = new XACMLPolicyScanner(policyClone, new XACMLPolicyScanner.SimpleCallback() { |
| |
| @Override |
| public CallbackResult onPreVisitRule(PolicyType parent, RuleType rule) { |
| rule.setRuleId(((XacmlAdminUI)getUI()).newRuleID()); |
| return CallbackResult.CONTINUE; |
| } |
| |
| @Override |
| public CallbackResult onPreVisitPolicySet(PolicySetType parent, PolicySetType policySet) { |
| policySet.setPolicySetId(((XacmlAdminUI)getUI()).newPolicyID()); |
| policySet.setVersion("1"); |
| return CallbackResult.CONTINUE; |
| } |
| |
| @Override |
| public CallbackResult onPreVisitPolicy(PolicySetType parent, PolicyType policy) { |
| policy.setPolicyId(((XacmlAdminUI)getUI()).newPolicyID()); |
| policy.setVersion("1"); |
| return CallbackResult.CONTINUE; |
| } |
| |
| }).scan(); |
| // |
| // Run the window |
| // |
| this.runPolicyWindow("Clone Policy", newFile.getParent(), newFile.getFileName(), policyData, null); |
| } |
| |
| protected void runPolicyWindow(String caption, final Path parentPath, final Path policyPath, final Object policyData, final Path oldPolicyFile) { |
| // |
| // Create our editor window |
| // |
| final PolicyNameEditorWindow editor = new PolicyNameEditorWindow((policyPath != null ? policyPath.getFileName().toString() : null), |
| policyData, |
| ((XacmlAdminUI)getUI()).getPolicyAlgorithms(), |
| ((XacmlAdminUI)getUI()).getRuleAlgorithms()); |
| editor.setCaption(caption); |
| editor.setCloseShortcut(KeyCode.ESCAPE); |
| editor.setModal(true); |
| editor.addCloseListener(new CloseListener() { |
| private static final long serialVersionUID = 1L; |
| |
| @Override |
| public void windowClose(CloseEvent event) { |
| // |
| // Did the user hit save button or esc? |
| // |
| if (editor.isSaved() == false) { |
| return; |
| } |
| final Object data = editor.getPolicyData(); |
| String filename = editor.getPolicyFilename(); |
| if (filename == null || data == null) { |
| logger.warn("Editor said is was saved but filename/data is null."); |
| return; |
| } |
| // |
| // Determine new path |
| // |
| final Path newPolicyPath = Paths.get(parentPath.toString(), filename); |
| // |
| // Is it ok to overwrite the new file? |
| // |
| try { |
| // |
| // Handle if we are not replacing an old file and we are overwriting |
| // an existing file. |
| // |
| if (self.isOverwritingAPolicy(newPolicyPath, oldPolicyFile) == false && Files.exists(newPolicyPath)) { |
| // |
| // Confirm they wanted to do this, and figure out |
| // new version number. |
| // |
| String message = "You are overwriting a file: " + newPolicyPath.getFileName().toString(); |
| ConfirmDialog dialog = ConfirmDialog.getFactory().create("Confirm Policy File Overwriting", message, "Overwrite", "Cancel"); |
| dialog.setData(false); |
| dialog.setContentMode(ContentMode.HTML); |
| dialog.setModal(true); |
| dialog.show(getUI(), new ConfirmDialog.Listener() { |
| private static final long serialVersionUID = 1L; |
| |
| @Override |
| public void onClose(ConfirmDialog dialog) { |
| if (dialog.isConfirmed()) { |
| // |
| // Yep the user wants to overwrite it |
| // |
| self.savePolicy(newPolicyPath, data, oldPolicyFile); |
| // |
| // Open it for editing |
| // |
| self.openPolicyTab(newPolicyPath.toFile(), false); |
| } |
| } |
| |
| }, true); |
| // |
| // Exit out of this thread |
| // |
| return; |
| } |
| } catch (Exception e) { |
| logger.error(e); |
| return; |
| } |
| // |
| // Save it off |
| // |
| self.savePolicy(newPolicyPath, data, oldPolicyFile); |
| // |
| // Open it for editing |
| // |
| self.openPolicyTab(newPolicyPath.toFile(), false); |
| } |
| }); |
| editor.center(); |
| UI.getCurrent().addWindow(editor); |
| } |
| |
| protected Path getNextFilename(Path parent, String filename) { |
| filename = FilenameUtils.removeExtension(filename); |
| Path newFile = null; |
| int i = 0; |
| while (true) { |
| newFile = Paths.get(parent.toString(), String.format("%s(%02d)", filename, i++) + ".xml"); |
| if (Files.notExists(newFile)) { |
| return newFile; |
| } |
| if (i == 100) { |
| logger.error("Could not construct a new name for cloned policy."); |
| return null; |
| } |
| } |
| |
| } |
| |
| protected boolean isOverwritingAPolicy(Path newPolicyPath, Path oldPolicyPath) throws Exception { |
| // |
| // Check to see if we were editing an existing file. Then check if the |
| // new file actually exists. Then check if we are overwriting the original old file |
| // |
| if (oldPolicyPath != null && Files.exists(newPolicyPath) && Files.isSameFile(newPolicyPath, oldPolicyPath)) { |
| // |
| // Yes its the same, overwriting it is expected. |
| // |
| logger.info("isOverwritingAPolicy"); |
| return true; |
| } |
| return false; |
| } |
| |
| protected void savePolicy(final Path newPolicyPath, final Object policyData, Path oldPolicyPath) { |
| // |
| // Are they overwriting another policy? |
| // |
| String version = "1.0"; |
| boolean delete = false; |
| if (oldPolicyPath != null) { |
| // |
| // This policy name was being edited. Is it still the same? |
| // |
| try { |
| delete = true; |
| if (Files.exists(newPolicyPath) && Files.isSameFile(newPolicyPath, oldPolicyPath)) { |
| delete = false; |
| } |
| } catch (Exception e) { |
| logger.error("Could not determine if same file", e); |
| return; |
| } |
| logger.info("Deleting old file: " + delete); |
| } |
| // |
| // Are we now overwriting another file? |
| // |
| if (Files.exists(newPolicyPath)) { |
| // |
| // Yes |
| // |
| logger.info("Overwriting file"); |
| // |
| // Overwrite is happening. Bump the version (IF WE CAN) |
| // |
| //TODO - What if user wants to change something other than the last number? For example, changing 1.5.23 to 2.0.0. |
| //TODO We need a mechanism that allows the user to specify the new policy version (disallowing backtracking) if they desire |
| //TODO and get that new number (if any) passed down to here. This code then becomes the "then" branch of "If new version has been specified..." |
| try { |
| int[] versionArray = StdPDPPolicy.versionStringToArray(XACMLPolicyScanner.getVersion(newPolicyPath)); |
| // increment the right-most digit |
| versionArray[versionArray.length - 1]++; |
| version = StdPDPPolicy.versionArrayToString(versionArray); |
| } catch (NumberFormatException | IOException e) { |
| try { |
| logger.warn("Previous version '" + XACMLPolicyScanner.getVersion(newPolicyPath) + "' not a series of itegers"); |
| } catch (IOException e1) { |
| logger.error("could not get previous version"); |
| } |
| //TODO - This may not be wise since the intent is to increase the version number. Perhaps we should abort this an go back to the user? |
| version = "1.0"; |
| } |
| if (policyData instanceof PolicySetType) { |
| ((PolicySetType) policyData).setVersion(version); |
| } else if (policyData instanceof PolicyType) { |
| ((PolicyType) policyData).setVersion(version); |
| } |
| } else { |
| // |
| // Nope, a completely new file |
| // |
| logger.info("New file"); |
| } |
| // |
| // Is the root a PolicySet or Policy? |
| // |
| Path finalPolicyPath; |
| if (policyData instanceof PolicySetType) { |
| // |
| // Write it out |
| // |
| finalPolicyPath = XACMLPolicyWriter.writePolicyFile(newPolicyPath, (PolicySetType) policyData); |
| } else if (policyData instanceof PolicyType) { |
| // |
| // Write it out |
| // |
| finalPolicyPath = XACMLPolicyWriter.writePolicyFile(newPolicyPath, (PolicyType) policyData); |
| } else { |
| logger.error("Unknown data type sent back."); |
| return; |
| } |
| // |
| // Did it get written? |
| // |
| if (finalPolicyPath == null || ! Files.exists(finalPolicyPath)) { |
| logger.error("Failed to write policy file."); |
| return; |
| } |
| // |
| // Add it into our tree |
| // |
| this.addPolicyFileToTree(finalPolicyPath.getParent().toFile(), finalPolicyPath.toFile()); |
| // |
| // Do we need to delete the old file? |
| // |
| if (oldPolicyPath != null && delete) { |
| try { |
| Files.delete(oldPolicyPath); |
| } catch (Exception e) { |
| logger.error("Failed to delete old policy", e); |
| } |
| if (self.treeWorkspace.removeItem(oldPolicyPath.toFile()) == false) { |
| logger.warn("Failed to remove old policy path"); |
| } |
| } |
| } |
| |
| protected void deletePolicy(final File policy) { |
| String message = "Are you sure you want to delete policy: " + policy.getName(); |
| ConfirmDialog dialog = ConfirmDialog.getFactory().create("Confirm Policy File Deletion", message, "Delete", "Cancel"); |
| dialog.setContentMode(ContentMode.HTML); |
| dialog.show(getUI(), new ConfirmDialog.Listener() { |
| private static final long serialVersionUID = 1L; |
| |
| @Override |
| public void onClose(ConfirmDialog dialog) { |
| if (dialog.isConfirmed() && policy.delete()) { |
| self.treeWorkspace.removeItem(policy); |
| if (logger.isDebugEnabled()) { |
| logger.debug("Deleted file: " + policy.toString()); |
| } |
| } |
| } |
| |
| }, true); |
| |
| } |
| |
| protected void importPolicy(final File domain) { |
| // |
| // Get the current domain |
| // |
| if (! domain.isDirectory()) { |
| logger.error("Table must have a directory selected to import the file."); |
| return; |
| } |
| // |
| // Create the upload window |
| // |
| final PolicyUploadWindow upload = new PolicyUploadWindow(Paths.get(domain.toURI())); |
| upload.setCaption("Import Xacml 3.0 Policy File"); |
| upload.setCloseShortcut(KeyCode.ESCAPE); |
| upload.setModal(true); |
| upload.addCloseListener(new CloseListener() { |
| private static final long serialVersionUID = 1L; |
| |
| @Override |
| public void windowClose(CloseEvent e) { |
| // |
| // Was it successful? |
| // |
| Path newFile = upload.getUploadedFile(); |
| if (newFile == null) { |
| return; |
| } |
| // |
| // Add it |
| // |
| self.addPolicyFileToTree(domain, newFile.toFile()); |
| // |
| // Are we importing anything in the policy file? |
| // |
| boolean importAttributes = upload.importAttributes(); |
| boolean importObligations = upload.importObligations(); |
| boolean importAdvice = upload.importAdvice(); |
| if (importAttributes || importObligations || importAdvice) { |
| // |
| // Create our importer |
| // |
| XACMLPolicyImporter importer = new XACMLPolicyImporter(); |
| importer.setImportAttributes(importAttributes); |
| importer.setImportObligations(importObligations); |
| importer.setImportAdvice(importAdvice); |
| importer.setIgnoreStandardAttributes(upload.ignoreStandard()); |
| // |
| // Yes load and scan the policy |
| // |
| new XACMLPolicyScanner(newFile, importer).scan(); |
| } |
| } |
| }); |
| upload.center(); |
| UI.getCurrent().addWindow(upload); |
| } |
| |
| protected void addPolicyFileToTree(File domain, File file) { |
| // |
| // Add it into our tree |
| // |
| if (this.treeWorkspace.addItem(file) != null) { |
| // |
| // Make sure it has the right parent |
| // |
| this.treeWorkspace.setParent(file, domain); |
| // |
| // Select our new policy |
| // |
| self.treeWorkspace.select(file); |
| } else { |
| logger.error("Failed to add policy to workspace tree"); |
| } |
| } |
| |
| /* |
| protected void publishPolicy(final File policy) { |
| // |
| // Get its ID |
| // |
| Item item = this.treeContainer.getItem(policy); |
| if (item == null) { |
| logger.error("Failed to get the item"); |
| return; |
| } |
| Object policyData = item.getItemProperty("Data"); |
| if (policyData == null) { |
| logger.error("Failed to get item data property."); |
| return; |
| } |
| String fullId = XACMLPolicyScanner.getID(policyData); |
| String version = XACMLPolicyScanner.getVersion(policyData); |
| if (fullId == null || version == null) { |
| logger.error("Failed to get policy Id"); |
| return; |
| } |
| List<String> ids = Lists.newArrayList(Splitter.on(':').split(fullId)); |
| if (ids.isEmpty()) { |
| logger.error("Couldn't parse policy Id"); |
| return; |
| } |
| final String id = ids.get(ids.size() - 1) + "." + version; |
| // |
| // Is there only one group? |
| // |
| PAPEngine engine = ((XacmlAdminUI)getUI()).getPAPEngine(); |
| Set<PDPGroup> groups; |
| PDPGroup defaultGroup; |
| try { |
| groups = engine.getPDPGroups(); |
| } catch (PAPException e) { |
| String message = "Unable to retrieve Groups from server: " + e; |
| logger.error(message, e); |
| throw new RuntimeException(message); |
| } |
| try { |
| defaultGroup = engine.getDefaultGroup(); |
| } catch (PAPException e) { |
| String message = "Unable to retrieve Default Group from server: " + e; |
| logger.error(message, e); |
| throw new RuntimeException(message); |
| } |
| if (groups.size() == 1) { |
| this.doPublish(id, policy, defaultGroup); |
| return; |
| } |
| // |
| // Have user select a group |
| // |
| final SelectPDPGroupWindow window = new SelectPDPGroupWindow(groups, "Select PDP Group to publish in"); |
| window.setCaption("Select PDP Group"); |
| window.setCloseShortcut(KeyCode.ESCAPE); |
| window.setModal(true); |
| window.addCloseListener(new CloseListener() { |
| private static final long serialVersionUID = 1L; |
| |
| @Override |
| public void windowClose(CloseEvent event) { |
| PDPGroup group = window.selectedGroup(); |
| if (group != null) { |
| self.doPublish(id, policy, group); |
| } |
| } |
| }); |
| window.center(); |
| UI.getCurrent().addWindow(window); |
| |
| } |
| |
| protected void doPublish(String id, File policy, PDPGroup group) { |
| // |
| // The policy status must be up-to-date |
| // |
| // TODO |
| |
| // |
| // TODO - get list of referenced policies and publish |
| // them first. |
| // |
| |
| // |
| // Publish the policy |
| // |
| |
| PAPEngine engine = ((XacmlAdminUI)getUI()).getPAPEngine(); |
| try (InputStream is = new FileInputStream(policy)) { |
| engine.publishPolicy(id, policy.getName(), true, is, group); |
| } catch (PAPException | IOException e) { |
| logger.error("Failed to publish policy: ", e); |
| } |
| } |
| */ |
| |
| protected void pushChanges(final File target) { |
| try { |
| // |
| // Grab our working repository |
| // |
| Path repoPath = ((XacmlAdminUI)getUI()).getUserGitPath(); |
| final Git git = Git.open(repoPath.toFile()); |
| // |
| // Get our status |
| // |
| final String base; |
| Status status; |
| if (target == null) { |
| base = "."; |
| } else { |
| Path relativePath = repoPath.relativize(Paths.get(target.getPath())); |
| base = relativePath.toString(); |
| } |
| if (logger.isDebugEnabled()) { |
| logger.debug("Status on base: " + base); |
| } |
| status = git.status().addPath(base).call(); |
| // |
| // Check if its clean |
| // |
| if (status.isClean()) { |
| // |
| // Its clean |
| // |
| AdminNotification.warn(target.getName() + " is clean!"); |
| return; |
| } |
| // |
| // Create the window |
| // |
| final GitPushWindow window = new GitPushWindow(git, target, status); |
| window.setCaption("Push Changes"); |
| window.setModal(true); |
| window.addCloseListener(new CloseListener() { |
| private static final long serialVersionUID = 1L; |
| |
| @Override |
| public void windowClose(CloseEvent e) { |
| if (window.isSaved() == false) { |
| return; |
| } |
| try { |
| // |
| // Needs to be added first |
| // |
| DirCache cache = git.add().addFilepattern(base).call(); |
| for (int i = 0; i < cache.getEntryCount(); i++) { |
| DirCacheEntry entry = cache.getEntry(i); |
| if (logger.isDebugEnabled()) { |
| logger.debug("Entry: " + entry); |
| } |
| } |
| // |
| // Next they need to be committed |
| // |
| RevCommit rev = git.commit().setMessage(window.getComment()).call(); |
| if (logger.isDebugEnabled()) { |
| logger.debug("RevCommit: " + rev); |
| } |
| // |
| // Now we can push changes to the Git repository |
| // |
| Iterable<PushResult> results = git.push().call(); |
| for (PushResult result : results) { |
| logger.info(result); |
| } |
| // |
| // Have the container fire an item set change notification |
| // |
| self.treeContainer.updateItem(target); |
| } catch (NoWorkTreeException | GitAPIException e1) { |
| logger.error(e); |
| AdminNotification.error("Exception occurred while trying to push: " + e1); |
| } |
| } |
| |
| }); |
| window.center(); |
| UI.getCurrent().addWindow(window); |
| } catch (IOException | GitAPIException e) { |
| logger.error(e); |
| AdminNotification.error("Exception occurred while trying to get status: " + e); |
| } |
| } |
| |
| protected void synchronizeRepository() { |
| final GitSynchronizeWindow window = new GitSynchronizeWindow(); |
| window.setCaption("Synchronize with server repository?"); |
| window.setModal(true); |
| window.center(); |
| UI.getCurrent().addWindow(window); |
| } |
| |
| protected void exportRepository() { |
| this.buttonExport.click(); |
| } |
| |
| @Override |
| public String getFilename() { |
| return "Repository.tgz"; |
| } |
| |
| @Override |
| public InputStream getStream() { |
| // |
| // Grab our working repository |
| // |
| final Path repoPath = ((XacmlAdminUI)getUI()).getUserGitPath(); |
| Path workspacePath = ((XacmlAdminUI)getUI()).getUserWorkspace(); |
| final Path tarFile = Paths.get(workspacePath.toString(), "Repository.tgz"); |
| |
| try (OutputStream os = Files.newOutputStream(tarFile)) { |
| try (GzipCompressorOutputStream gzOut = new GzipCompressorOutputStream(os)) { |
| try (TarArchiveOutputStream tarOut = new TarArchiveOutputStream(gzOut)) { |
| |
| tarOut.setLongFileMode(TarArchiveOutputStream.LONGFILE_GNU); |
| |
| Files.walkFileTree(repoPath, new SimpleFileVisitor<Path>() { |
| |
| @Override |
| public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) throws IOException { |
| if (dir.getFileName().toString().startsWith(".git")) { |
| return FileVisitResult.SKIP_SUBTREE; |
| } |
| Path relative = repoPath.relativize(dir); |
| if (relative.toString().isEmpty()) { |
| return super.preVisitDirectory(dir, attrs); |
| } |
| TarArchiveEntry entry = new TarArchiveEntry(relative.toFile()); |
| tarOut.putArchiveEntry(entry); |
| tarOut.closeArchiveEntry(); |
| return super.preVisitDirectory(dir, attrs); |
| } |
| |
| @Override |
| public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException { |
| if (file.getFileName().toString().endsWith(".xml") == false) { |
| return super.visitFile(file, attrs); |
| } |
| Path relative = repoPath.relativize(file); |
| TarArchiveEntry entry = new TarArchiveEntry(relative.toFile()); |
| entry.setSize(Files.size(file)); |
| tarOut.putArchiveEntry(entry); |
| try { |
| IOUtils.copy(Files.newInputStream(file), tarOut); |
| } catch (IOException e) { |
| logger.error(e); |
| } |
| tarOut.closeArchiveEntry(); |
| return super.visitFile(file, attrs); |
| } |
| |
| }); |
| tarOut.finish(); |
| } |
| } |
| } catch (IOException e) { |
| logger.error(e); |
| } |
| try { |
| return Files.newInputStream(tarFile); |
| } catch (IOException e) { |
| logger.error(e); |
| } |
| return null; |
| } |
| |
| protected void openPolicyTab(File policy, boolean readOnly) { |
| // |
| // Sanity check |
| // |
| assert policy != null; |
| assert policy.isFile(); |
| if (policy == null || ! policy.isFile()) { |
| throw new IllegalArgumentException("You must specify a file."); |
| } |
| Status status; |
| Path relativePath; |
| String base; |
| try { |
| // |
| // Grab our working repository |
| // |
| Path repoPath = ((XacmlAdminUI)getUI()).getUserGitPath(); |
| final Git git = Git.open(repoPath.toFile()); |
| // |
| // Get our status |
| // |
| relativePath = repoPath.relativize(Paths.get(policy.getPath())); |
| base = relativePath.toString(); |
| if (logger.isDebugEnabled()) { |
| logger.debug("Status on base: " + base); |
| } |
| status = git.status().addPath(base).call(); |
| } catch (NoWorkTreeException | IOException | GitAPIException e) { |
| logger.error("Failed to get status on " + policy + " " + e); |
| AdminNotification.error("Could not get Git status on the file."); |
| return; |
| } |
| // |
| // Check if its clean |
| // |
| if (status.isClean() == false) { |
| // |
| // Check if its conflicting |
| // |
| for (String conflict : status.getConflicting()) { |
| if (conflict.equals(base)) { |
| // |
| // Yes - we won't be able to edit it |
| // |
| AdminNotification.error("Policy has conflicts with master, please synchronize the repository."); |
| return; |
| } |
| } |
| } |
| // |
| // Check to see if there already is a tab open |
| // |
| Iterator<Component> iter = self.tabSheet.iterator(); |
| while (iter.hasNext()) { |
| Component c = iter.next(); |
| if (c instanceof PolicyEditor) { |
| Object data = ((PolicyEditor) c).getData(); |
| if (data != null && data instanceof File && ((File)data).equals(policy)) { |
| self.tabSheet.setSelectedTab(c); |
| return; |
| } |
| } |
| } |
| // |
| // No tab is open, create a new one |
| // |
| PolicyEditor editor = null; |
| try { |
| editor = new PolicyEditor(policy, this.treeContainer, readOnly); |
| } catch (IOException e) { |
| logger.error("Failed to open policy"); |
| editor = null; |
| } |
| if (editor != null) { |
| editor.setWidth("100%"); |
| Tab tab = self.tabSheet.addTab(editor); |
| editor.setTab(tab); |
| tab.setClosable(true); |
| |
| self.tabSheet.setSelectedTab(editor); |
| } else { |
| AdminNotification.error("The Policy File is not a Xacml 3.0 policy."); |
| } |
| } |
| |
| @Override |
| public void drop(DragAndDropEvent event) { |
| Transferable t = event.getTransferable(); |
| Component source = t.getSourceComponent(); |
| if (source != this.treeWorkspace) { |
| assert false; |
| throw new IllegalArgumentException(); |
| } |
| TableTransferable tt = (TableTransferable) t; |
| File sourceFile = (File) tt.getItemId(); |
| |
| AbstractSelectTargetDetails target = (AbstractSelectTargetDetails)event.getTargetDetails(); |
| File targetFile = (File) target.getItemIdOver(); |
| |
| if (sourceFile.isFile() && targetFile != null && targetFile.isDirectory()) { |
| // |
| // Construct destination filename |
| // |
| Path dest = targetFile.toPath().resolve(sourceFile.getName()); |
| // |
| // Check if the target domain exists |
| // |
| if (Files.exists(dest)) { |
| // |
| // Prompt the user |
| // |
| Notification.show("A policy file with that name already exists in that directory.", Notification.Type.ERROR_MESSAGE); |
| } else { |
| // |
| // Go ahead and rename it |
| // |
| this.renamePolicyFile(sourceFile, dest.toFile(), targetFile); |
| } |
| } |
| } |
| |
| protected void renamePolicyFile(File sourceFile, File dest, File parent) { |
| try { |
| if (sourceFile.renameTo(dest)) { |
| this.treeContainer.setParent(sourceFile, parent); |
| this.treeContainer.updateItem(parent); |
| } |
| } catch (Exception e) { |
| String error = "Failed to rename " + sourceFile + " to: " + dest + System.lineSeparator() + e.getLocalizedMessage(); |
| logger.error(error); |
| AdminNotification.error(error); |
| } |
| } |
| |
| @Override |
| public AcceptCriterion getAcceptCriterion() { |
| return AcceptAll.get(); |
| } |
| |
| @AutoGenerated |
| private VerticalLayout buildMainLayout() { |
| // common part: create layout |
| mainLayout = new VerticalLayout(); |
| mainLayout.setImmediate(false); |
| mainLayout.setWidth("100%"); |
| mainLayout.setHeight("100%"); |
| mainLayout.setMargin(false); |
| |
| // top-level component properties |
| setWidth("100.0%"); |
| setHeight("100.0%"); |
| |
| // horizontalSplitPanel |
| horizontalSplitPanel = buildHorizontalSplitPanel(); |
| mainLayout.addComponent(horizontalSplitPanel); |
| mainLayout.setExpandRatio(horizontalSplitPanel, 1.0f); |
| |
| return mainLayout; |
| } |
| |
| @AutoGenerated |
| private HorizontalSplitPanel buildHorizontalSplitPanel() { |
| // common part: create layout |
| horizontalSplitPanel = new HorizontalSplitPanel(); |
| horizontalSplitPanel.setImmediate(false); |
| horizontalSplitPanel.setWidth("100.0%"); |
| horizontalSplitPanel.setHeight("100.0%"); |
| |
| // verticalLayoutLeftPanel |
| verticalLayoutLeftPanel = buildVerticalLayoutLeftPanel(); |
| horizontalSplitPanel.addComponent(verticalLayoutLeftPanel); |
| |
| // verticalLayoutRightPanel |
| verticalLayoutRightPanel = buildVerticalLayoutRightPanel(); |
| horizontalSplitPanel.addComponent(verticalLayoutRightPanel); |
| |
| return horizontalSplitPanel; |
| } |
| |
| @AutoGenerated |
| private VerticalLayout buildVerticalLayoutLeftPanel() { |
| // common part: create layout |
| verticalLayoutLeftPanel = new VerticalLayout(); |
| verticalLayoutLeftPanel.setImmediate(false); |
| verticalLayoutLeftPanel.setWidth("100.0%"); |
| verticalLayoutLeftPanel.setHeight("100.0%"); |
| verticalLayoutLeftPanel.setMargin(true); |
| verticalLayoutLeftPanel.setSpacing(true); |
| |
| // horizontalLayoutLeftToolbar |
| horizontalLayoutLeftToolbar = buildHorizontalLayoutLeftToolbar(); |
| verticalLayoutLeftPanel.addComponent(horizontalLayoutLeftToolbar); |
| |
| // treeWorkspace |
| treeWorkspace = new TreeTable(); |
| treeWorkspace.setImmediate(true); |
| treeWorkspace.setWidth("100.0%"); |
| treeWorkspace.setHeight("100.0%"); |
| verticalLayoutLeftPanel.addComponent(treeWorkspace); |
| verticalLayoutLeftPanel.setExpandRatio(treeWorkspace, 1.0f); |
| |
| return verticalLayoutLeftPanel; |
| } |
| |
| @AutoGenerated |
| private HorizontalLayout buildHorizontalLayoutLeftToolbar() { |
| // common part: create layout |
| horizontalLayoutLeftToolbar = new HorizontalLayout(); |
| horizontalLayoutLeftToolbar.setImmediate(false); |
| horizontalLayoutLeftToolbar.setWidth("100.0%"); |
| horizontalLayoutLeftToolbar.setHeight("-1px"); |
| horizontalLayoutLeftToolbar.setMargin(false); |
| horizontalLayoutLeftToolbar.setSpacing(true); |
| |
| // horizontalLayoutLeftToolbarLeft |
| horizontalLayoutLeftToolbarLeft = buildHorizontalLayoutLeftToolbarLeft(); |
| horizontalLayoutLeftToolbar |
| .addComponent(horizontalLayoutLeftToolbarLeft); |
| |
| // buttonLeft |
| buttonLeft = new Button(); |
| buttonLeft.setCaption("<<"); |
| buttonLeft.setImmediate(true); |
| buttonLeft.setDescription("Minimize left panel."); |
| buttonLeft.setWidth("-1px"); |
| buttonLeft.setHeight("-1px"); |
| horizontalLayoutLeftToolbar.addComponent(buttonLeft); |
| horizontalLayoutLeftToolbar.setComponentAlignment(buttonLeft, |
| new Alignment(34)); |
| |
| return horizontalLayoutLeftToolbar; |
| } |
| |
| @AutoGenerated |
| private HorizontalLayout buildHorizontalLayoutLeftToolbarLeft() { |
| // common part: create layout |
| horizontalLayoutLeftToolbarLeft = new HorizontalLayout(); |
| horizontalLayoutLeftToolbarLeft.setImmediate(false); |
| horizontalLayoutLeftToolbarLeft.setWidth("-1px"); |
| horizontalLayoutLeftToolbarLeft.setHeight("-1px"); |
| horizontalLayoutLeftToolbarLeft.setMargin(false); |
| horizontalLayoutLeftToolbarLeft.setSpacing(true); |
| |
| // buttonSynchronize |
| buttonSynchronize = new Button(); |
| buttonSynchronize.setCaption("Synchronize Repository"); |
| buttonSynchronize.setImmediate(true); |
| buttonSynchronize |
| .setDescription("Synchronize local repository with main branch."); |
| buttonSynchronize.setWidth("-1px"); |
| buttonSynchronize.setHeight("-1px"); |
| horizontalLayoutLeftToolbarLeft.addComponent(buttonSynchronize); |
| |
| // buttonExport |
| buttonExport = new Button(); |
| buttonExport.setCaption("Export Workspace"); |
| buttonExport.setImmediate(true); |
| buttonExport.setDescription("Export your workspace to your local drive."); |
| buttonExport.setWidth("-1px"); |
| buttonExport.setHeight("-1px"); |
| horizontalLayoutLeftToolbarLeft.addComponent(buttonExport); |
| |
| return horizontalLayoutLeftToolbarLeft; |
| } |
| |
| @AutoGenerated |
| private VerticalLayout buildVerticalLayoutRightPanel() { |
| // common part: create layout |
| verticalLayoutRightPanel = new VerticalLayout(); |
| verticalLayoutRightPanel.setImmediate(false); |
| verticalLayoutRightPanel.setWidth("100.0%"); |
| verticalLayoutRightPanel.setHeight("-1px"); |
| verticalLayoutRightPanel.setMargin(true); |
| verticalLayoutRightPanel.setSpacing(true); |
| |
| // horizontalLayoutRightToolbar |
| horizontalLayoutRightToolbar = buildHorizontalLayoutRightToolbar(); |
| verticalLayoutRightPanel.addComponent(horizontalLayoutRightToolbar); |
| |
| // tabSheet |
| tabSheet = new TabSheet(); |
| tabSheet.setImmediate(true); |
| tabSheet.setWidth("100.0%"); |
| tabSheet.setHeight("-1px"); |
| verticalLayoutRightPanel.addComponent(tabSheet); |
| verticalLayoutRightPanel.setExpandRatio(tabSheet, 1.0f); |
| |
| return verticalLayoutRightPanel; |
| } |
| |
| @AutoGenerated |
| private HorizontalLayout buildHorizontalLayoutRightToolbar() { |
| // common part: create layout |
| horizontalLayoutRightToolbar = new HorizontalLayout(); |
| horizontalLayoutRightToolbar.setImmediate(false); |
| horizontalLayoutRightToolbar.setWidth("100.0%"); |
| horizontalLayoutRightToolbar.setHeight("-1px"); |
| horizontalLayoutRightToolbar.setMargin(false); |
| horizontalLayoutRightToolbar.setSpacing(true); |
| |
| // buttonRight |
| buttonRight = new Button(); |
| buttonRight.setCaption(">>"); |
| buttonRight.setImmediate(true); |
| buttonRight.setDescription("Restore left panel."); |
| buttonRight.setWidth("-1px"); |
| buttonRight.setHeight("-1px"); |
| horizontalLayoutRightToolbar.addComponent(buttonRight); |
| |
| return horizontalLayoutRightToolbar; |
| } |
| } |
