| /* |
| * 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. |
| * |
| */ |
| |
| /* |
| * Copyright 2000-2013 Vaadin Ltd. |
| * |
| * Licensed 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.model; |
| |
| import java.io.File; |
| import java.io.FilenameFilter; |
| import java.io.IOException; |
| import java.io.Serializable; |
| import java.lang.reflect.Method; |
| import java.nio.file.Path; |
| import java.nio.file.Paths; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.Date; |
| import java.util.Iterator; |
| import java.util.LinkedList; |
| import java.util.List; |
| |
| 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.errors.NoWorkTreeException; |
| |
| import org.apache.openaz.xacml.util.XACMLPolicyScanner; |
| import com.vaadin.data.Container; |
| import com.vaadin.data.Item; |
| import com.vaadin.data.Property; |
| import com.vaadin.data.util.MethodProperty; |
| import com.vaadin.server.Resource; |
| import com.vaadin.ui.TextArea; |
| import com.vaadin.util.FileTypeResolver; |
| |
| /** |
| * A hierarchical container wrapper for a filesystem. |
| * |
| * @author Vaadin Ltd. |
| * @since 3.0 |
| */ |
| @SuppressWarnings("serial") |
| public class GitRepositoryContainer extends ItemSetChangeNotifier implements Container.Hierarchical { |
| private Log logger = LogFactory.getLog(GitRepositoryContainer.class); |
| |
| /** |
| * String identifier of a file's "name" property. |
| */ |
| public static String PROPERTY_NAME = "Name"; |
| |
| /** |
| * String identifier of a file's "size" property. |
| */ |
| public static String PROPERTY_SIZE = "Size"; |
| |
| /** |
| * String identifier of a file's "icon" property. |
| */ |
| public static String PROPERTY_ICON = "Icon"; |
| |
| /** |
| * String identifier of a file's "last modified" property. |
| */ |
| public static String PROPERTY_LASTMODIFIED = "Last Modified"; |
| |
| /** |
| * String identifier of a file's "version" property. |
| */ |
| public static String PROPERTY_VERSION = "Version"; |
| |
| /** |
| * String identifier of a file's "status" property. |
| */ |
| public static String PROPERTY_STATUS = "Status"; |
| |
| /** |
| * String identifier of a file's "data" property. |
| */ |
| public static String PROPERTY_DATA = "Data"; |
| |
| /** |
| * List of the string identifiers for the available properties. |
| */ |
| public static Collection<String> FILE_PROPERTIES; |
| |
| private final static Method FILEITEM_LASTMODIFIED; |
| |
| private final static Method FILEITEM_NAME; |
| |
| private final static Method FILEITEM_ICON; |
| |
| private final static Method FILEITEM_SIZE; |
| |
| private final static Method FILEITEM_VERSION; |
| |
| private final static Method FILEITEM_STATUS; |
| |
| private final static Method FILEITEM_DATA; |
| |
| static { |
| |
| FILE_PROPERTIES = new ArrayList<String>(); |
| FILE_PROPERTIES.add(PROPERTY_NAME); |
| FILE_PROPERTIES.add(PROPERTY_ICON); |
| FILE_PROPERTIES.add(PROPERTY_SIZE); |
| FILE_PROPERTIES.add(PROPERTY_LASTMODIFIED); |
| FILE_PROPERTIES.add(PROPERTY_VERSION); |
| FILE_PROPERTIES.add(PROPERTY_STATUS); |
| FILE_PROPERTIES.add(PROPERTY_DATA); |
| FILE_PROPERTIES = Collections.unmodifiableCollection(FILE_PROPERTIES); |
| try { |
| FILEITEM_VERSION = FileItem.class.getMethod("getVersion", new Class[]{}); |
| FILEITEM_LASTMODIFIED = FileItem.class.getMethod("lastModified", new Class[] {}); |
| FILEITEM_NAME = FileItem.class.getMethod("getName", new Class[] {}); |
| FILEITEM_ICON = FileItem.class.getMethod("getIcon", new Class[] {}); |
| FILEITEM_SIZE = FileItem.class.getMethod("getSize", new Class[] {}); |
| FILEITEM_STATUS = FileItem.class.getMethod("getStatus", new Class[] {}); |
| FILEITEM_DATA = FileItem.class.getMethod("getData", new Class[] {}); |
| } catch (final NoSuchMethodException e) { |
| throw new RuntimeException( |
| "Internal error finding methods in FilesystemContainer"); |
| } |
| } |
| |
| private File[] roots = new File[] {}; |
| |
| private FilenameFilter filter = null; |
| |
| private boolean recursive = true; |
| |
| private Path repository = null; |
| |
| /** |
| * Constructs a new <code>FileSystemContainer</code> with the specified file |
| * as the root of the filesystem. The files are included recursively. |
| * |
| * @param root |
| * the root file for the new file-system container. Null values |
| * are ignored. |
| */ |
| public GitRepositoryContainer(Path repository, File root) { |
| super(); |
| this.repository = repository; |
| if (root != null) { |
| roots = new File[] { root }; |
| } |
| this.setContainer(this); |
| } |
| |
| /** |
| * Constructs a new <code>FileSystemContainer</code> with the specified file |
| * as the root of the filesystem. The files are included recursively. |
| * |
| * @param root |
| * the root file for the new file-system container. |
| * @param recursive |
| * should the container recursively contain subdirectories. |
| */ |
| public GitRepositoryContainer(Path repository, File root, boolean recursive) { |
| this(repository, root); |
| setRecursive(recursive); |
| this.setContainer(this); |
| } |
| |
| /** |
| * Constructs a new <code>FileSystemContainer</code> with the specified file |
| * as the root of the filesystem. |
| * |
| * @param root |
| * the root file for the new file-system container. |
| * @param extension |
| * the Filename extension (w/o separator) to limit the files in |
| * container. |
| * @param recursive |
| * should the container recursively contain subdirectories. |
| */ |
| public GitRepositoryContainer(Path repository, File root, String extension, boolean recursive) { |
| this(repository, root); |
| this.setFilter(extension); |
| setRecursive(recursive); |
| this.setContainer(this); |
| } |
| |
| /** |
| * Constructs a new <code>FileSystemContainer</code> with the specified root |
| * and recursivity status. |
| * |
| * @param root |
| * the root file for the new file-system container. |
| * @param filter |
| * the Filename filter to limit the files in container. |
| * @param recursive |
| * should the container recursively contain subdirectories. |
| */ |
| public GitRepositoryContainer(Path repository, File root, FilenameFilter filter, boolean recursive) { |
| this(repository, root); |
| this.setFilter(filter); |
| setRecursive(recursive); |
| } |
| |
| /** |
| * Adds new root file directory. Adds a file to be included as root file |
| * directory in the <code>FilesystemContainer</code>. |
| * |
| * @param root |
| * the File to be added as root directory. Null values are |
| * ignored. |
| */ |
| public void addRoot(File root) { |
| if (root != null) { |
| final File[] newRoots = new File[roots.length + 1]; |
| for (int i = 0; i < roots.length; i++) { |
| newRoots[i] = roots[i]; |
| } |
| newRoots[roots.length] = root; |
| roots = newRoots; |
| } |
| } |
| |
| /** |
| * Tests if the specified Item in the container may have children. Since a |
| * <code>FileSystemContainer</code> contains files and directories, this |
| * method returns <code>true</code> for directory Items only. |
| * |
| * @param itemId |
| * the id of the item. |
| * @return <code>true</code> if the specified Item is a directory, |
| * <code>false</code> otherwise. |
| */ |
| @Override |
| public boolean areChildrenAllowed(Object itemId) { |
| if (logger.isTraceEnabled()) { |
| logger.trace("areChildrenAllowed: " + ((File)itemId).hashCode() + " " + ((File)itemId).getName()); |
| } |
| return itemId instanceof File && ((File) itemId).canRead() |
| && ((File) itemId).isDirectory(); |
| } |
| |
| /* |
| * Gets the ID's of all Items who are children of the specified Item. Don't |
| * add a JavaDoc comment here, we use the default documentation from |
| * implemented interface. |
| */ |
| @Override |
| public Collection<File> getChildren(Object itemId) { |
| |
| if (!(itemId instanceof File)) { |
| return Collections.unmodifiableCollection(new LinkedList<File>()); |
| } |
| File[] f; |
| if (filter != null) { |
| f = ((File) itemId).listFiles(filter); |
| } else { |
| f = ((File) itemId).listFiles(); |
| } |
| |
| if (f == null) { |
| return Collections.unmodifiableCollection(new LinkedList<File>()); |
| } |
| |
| final List<File> l = Arrays.asList(f); |
| Collections.sort(l); |
| |
| return Collections.unmodifiableCollection(l); |
| } |
| |
| /* |
| * Gets the parent item of the specified Item. Don't add a JavaDoc comment |
| * here, we use the default documentation from implemented interface. |
| */ |
| @Override |
| public Object getParent(Object itemId) { |
| if (logger.isTraceEnabled()) { |
| logger.trace("getParent: " + ((File)itemId).hashCode() + " " + ((File)itemId).getName()); |
| } |
| |
| if (!(itemId instanceof File)) { |
| return null; |
| } |
| return ((File) itemId).getParentFile(); |
| } |
| |
| /* |
| * Tests if the specified Item has any children. Don't add a JavaDoc comment |
| * here, we use the default documentation from implemented interface. |
| */ |
| @Override |
| public boolean hasChildren(Object itemId) { |
| if (logger.isTraceEnabled()) { |
| logger.trace("hasChildren: " + ((File)itemId).hashCode() + " " + ((File)itemId).getName()); |
| } |
| |
| if (!(itemId instanceof File)) { |
| return false; |
| } |
| String[] l; |
| if (filter != null) { |
| l = ((File) itemId).list(filter); |
| } else { |
| l = ((File) itemId).list(); |
| } |
| return l != null && l.length > 0; |
| } |
| |
| /* |
| * Tests if the specified Item is the root of the filesystem. Don't add a |
| * JavaDoc comment here, we use the default documentation from implemented |
| * interface. |
| */ |
| @Override |
| public boolean isRoot(Object itemId) { |
| if (logger.isTraceEnabled()) { |
| logger.trace("isRoot: " + ((File)itemId).hashCode() + " " + ((File)itemId).getName()); |
| } |
| |
| if (!(itemId instanceof File)) { |
| return false; |
| } |
| for (int i = 0; i < roots.length; i++) { |
| if (roots[i].equals(itemId)) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| /* |
| * Gets the ID's of all root Items in the container. Don't add a JavaDoc |
| * comment here, we use the default documentation from implemented |
| * interface. |
| */ |
| @Override |
| public Collection<File> rootItemIds() { |
| |
| File[] f; |
| |
| // in single root case we use children |
| if (roots.length == 1) { |
| if (filter != null) { |
| f = roots[0].listFiles(filter); |
| } else { |
| f = roots[0].listFiles(); |
| } |
| } else { |
| f = roots; |
| } |
| |
| if (f == null) { |
| return Collections.unmodifiableCollection(new LinkedList<File>()); |
| } |
| |
| final List<File> l = Arrays.asList(f); |
| Collections.sort(l); |
| |
| return Collections.unmodifiableCollection(l); |
| } |
| |
| /** |
| * Returns <code>false</code> when conversion from files to directories is |
| * not supported. |
| * |
| * @param itemId |
| * the ID of the item. |
| * @param areChildrenAllowed |
| * the boolean value specifying if the Item can have children or |
| * not. |
| * @return <code>true</code> if the operaton is successful otherwise |
| * <code>false</code>. |
| * @throws UnsupportedOperationException |
| * if the setChildrenAllowed is not supported. |
| */ |
| @Override |
| public boolean setChildrenAllowed(Object itemId, boolean areChildrenAllowed) |
| throws UnsupportedOperationException { |
| |
| throw new UnsupportedOperationException( |
| "Conversion file to/from directory is not supported"); |
| } |
| |
| /** |
| * Returns <code>false</code> when moving files around in the filesystem is |
| * not supported. |
| * |
| * @param itemId |
| * the ID of the item. |
| * @param newParentId |
| * the ID of the Item that's to be the new parent of the Item |
| * identified with itemId. |
| * @return <code>true</code> if the operation is successful otherwise |
| * <code>false</code>. |
| * @throws UnsupportedOperationException |
| * if the setParent is not supported. |
| */ |
| @Override |
| public boolean setParent(Object itemId, Object newParentId) |
| throws UnsupportedOperationException { |
| if (logger.isTraceEnabled()) { |
| logger.trace("setParent: " + |
| ((File)itemId).hashCode() + " " + |
| ((File)itemId).getName() + " to: " + |
| ((File)newParentId).hashCode() + " " + |
| ((File)newParentId).getName()); |
| } |
| |
| Path path = Paths.get(((File) itemId).getAbsolutePath()); |
| Path parent = Paths.get(((File) newParentId).getAbsolutePath()); |
| boolean ok = path.getParent() == parent; |
| |
| if (ok) { |
| fireItemSetChange(); |
| } |
| return ok; |
| } |
| |
| /* |
| * Tests if the filesystem contains the specified Item. Don't add a JavaDoc |
| * comment here, we use the default documentation from implemented |
| * interface. |
| */ |
| @Override |
| public boolean containsId(Object itemId) { |
| if (logger.isTraceEnabled()) { |
| logger.trace("containsId: " + ((File)itemId).hashCode() + " " + ((File)itemId).getName()); |
| } |
| |
| if (!(itemId instanceof File)) { |
| return false; |
| } |
| boolean val = false; |
| |
| // Try to match all roots |
| for (int i = 0; i < roots.length; i++) { |
| try { |
| val |= ((File) itemId).getCanonicalPath().startsWith( |
| roots[i].getCanonicalPath()); |
| } catch (final IOException e) { //NOPMD |
| // Exception ignored |
| } |
| |
| } |
| if (val && filter != null) { |
| val &= filter.accept(((File) itemId).getParentFile(), |
| ((File) itemId).getName()); |
| } |
| return val; |
| } |
| |
| /* |
| * Gets the specified Item from the filesystem. Don't add a JavaDoc comment |
| * here, we use the default documentation from implemented interface. |
| */ |
| @Override |
| public Item getItem(Object itemId) { |
| |
| if (logger.isTraceEnabled()) { |
| logger.trace("getItem: " + ((File)itemId).hashCode() + " " + ((File)itemId).getName()); |
| } |
| |
| if (!(itemId instanceof File)) { |
| return null; |
| } |
| return new FileItem((File) itemId); |
| } |
| |
| public Item updateItem(Object itemId) { |
| if (logger.isTraceEnabled()) { |
| logger.trace("updateItem: " + ((File)itemId).hashCode() + " " + ((File)itemId).getName()); |
| } |
| |
| if (!(itemId instanceof File)) { |
| return null; |
| } |
| |
| this.fireItemSetChange(); |
| |
| return new FileItem((File) itemId); |
| } |
| |
| /** |
| * Internal recursive method to add the files under the specified directory |
| * to the collection. |
| * |
| * @param col |
| * the collection where the found items are added |
| * @param f |
| * the root file where to start adding files |
| */ |
| private void addItemIds(Collection<File> col, File f) { |
| File[] l; |
| if (filter != null) { |
| l = f.listFiles(filter); |
| } else { |
| l = f.listFiles(); |
| } |
| if (l == null) { |
| // File.listFiles returns null if File does not exist or if there |
| // was an IO error (permission denied) |
| return; |
| } |
| final List<File> ll = Arrays.asList(l); |
| Collections.sort(ll); |
| |
| for (final Iterator<File> i = ll.iterator(); i.hasNext();) { |
| final File lf = i.next(); |
| col.add(lf); |
| if (lf.isDirectory()) { |
| addItemIds(col, lf); |
| } |
| } |
| } |
| |
| /* |
| * Gets the IDs of Items in the filesystem. Don't add a JavaDoc comment |
| * here, we use the default documentation from implemented interface. |
| */ |
| @Override |
| public Collection<File> getItemIds() { |
| |
| if (recursive) { |
| final Collection<File> col = new ArrayList<File>(); |
| for (int i = 0; i < roots.length; i++) { |
| addItemIds(col, roots[i]); |
| } |
| return Collections.unmodifiableCollection(col); |
| } else { |
| File[] f; |
| if (roots.length == 1) { |
| if (filter != null) { |
| f = roots[0].listFiles(filter); |
| } else { |
| f = roots[0].listFiles(); |
| } |
| } else { |
| f = roots; |
| } |
| |
| if (f == null) { |
| return Collections |
| .unmodifiableCollection(new LinkedList<File>()); |
| } |
| |
| final List<File> l = Arrays.asList(f); |
| Collections.sort(l); |
| return Collections.unmodifiableCollection(l); |
| } |
| |
| } |
| |
| /** |
| * Gets the specified property of the specified file Item. The available |
| * file properties are "Name", "Size" and "Last Modified". If propertyId is |
| * not one of those, <code>null</code> is returned. |
| * |
| * @param itemId |
| * the ID of the file whose property is requested. |
| * @param propertyId |
| * the property's ID. |
| * @return the requested property's value, or <code>null</code> |
| */ |
| @Override |
| public Property<?> getContainerProperty(Object itemId, Object propertyId) { |
| |
| if (!(itemId instanceof File)) { |
| return null; |
| } |
| |
| if (propertyId.equals(PROPERTY_NAME)) { |
| return new MethodProperty<Object>(getType(propertyId), |
| new FileItem((File) itemId), FILEITEM_NAME, null); |
| } |
| |
| if (propertyId.equals(PROPERTY_ICON)) { |
| return new MethodProperty<Object>(getType(propertyId), |
| new FileItem((File) itemId), FILEITEM_ICON, null); |
| } |
| |
| if (propertyId.equals(PROPERTY_SIZE)) { |
| return new MethodProperty<Object>(getType(propertyId), |
| new FileItem((File) itemId), FILEITEM_SIZE, null); |
| } |
| |
| if (propertyId.equals(PROPERTY_LASTMODIFIED)) { |
| return new MethodProperty<Object>(getType(propertyId), |
| new FileItem((File) itemId), FILEITEM_LASTMODIFIED, null); |
| } |
| |
| if (propertyId.equals(PROPERTY_VERSION)) { |
| return new MethodProperty<Object>(getType(propertyId), |
| new FileItem((File) itemId), FILEITEM_VERSION, null); |
| } |
| |
| if (propertyId.equals(PROPERTY_STATUS)) { |
| return new MethodProperty<Object>(getType(propertyId), |
| new FileItem((File) itemId), FILEITEM_STATUS, null); |
| } |
| |
| if (propertyId.equals(PROPERTY_DATA)) { |
| return new MethodProperty<Object>(getType(propertyId), |
| new FileItem((File) itemId), FILEITEM_DATA, null); |
| } |
| |
| return null; |
| } |
| |
| /** |
| * Gets the collection of available file properties. |
| * |
| * @return Unmodifiable collection containing all available file properties. |
| */ |
| @Override |
| public Collection<String> getContainerPropertyIds() { |
| return FILE_PROPERTIES; |
| } |
| |
| /** |
| * Gets the specified property's data type. "Name" is a <code>String</code>, |
| * "Size" is a <code>Long</code>, "Last Modified" is a <code>Date</code>. If |
| * propertyId is not one of those, <code>null</code> is returned. |
| * |
| * @param propertyId |
| * the ID of the property whose type is requested. |
| * @return data type of the requested property, or <code>null</code> |
| */ |
| @Override |
| public Class<?> getType(Object propertyId) { |
| |
| if (propertyId.equals(PROPERTY_NAME)) { |
| return String.class; |
| } |
| if (propertyId.equals(PROPERTY_ICON)) { |
| return Resource.class; |
| } |
| if (propertyId.equals(PROPERTY_SIZE)) { |
| return Long.class; |
| } |
| if (propertyId.equals(PROPERTY_LASTMODIFIED)) { |
| return Date.class; |
| } |
| if (propertyId.equals(PROPERTY_VERSION)) { |
| return String.class; |
| } |
| if (propertyId.equals(PROPERTY_STATUS)) { |
| return TextArea.class; |
| } |
| if (propertyId.equals(PROPERTY_DATA)) { |
| return Object.class; |
| } |
| return null; |
| } |
| |
| /** |
| * Internal method to recursively calculate the number of files under a root |
| * directory. |
| * |
| * @param f |
| * the root to start counting from. |
| */ |
| private int getFileCounts(File f) { |
| File[] l; |
| if (filter != null) { |
| l = f.listFiles(filter); |
| } else { |
| l = f.listFiles(); |
| } |
| |
| if (l == null) { |
| return 0; |
| } |
| int ret = l.length; |
| for (int i = 0; i < l.length; i++) { |
| if (l[i].isDirectory()) { |
| ret += getFileCounts(l[i]); |
| } |
| } |
| return ret; |
| } |
| |
| /** |
| * Gets the number of Items in the container. In effect, this is the |
| * combined amount of files and directories. |
| * |
| * @return Number of Items in the container. |
| */ |
| @Override |
| public int size() { |
| |
| if (recursive) { |
| int counts = 0; |
| for (int i = 0; i < roots.length; i++) { |
| counts += getFileCounts(roots[i]); |
| } |
| return counts; |
| } else { |
| File[] f; |
| if (roots.length == 1) { |
| if (filter != null) { |
| f = roots[0].listFiles(filter); |
| } else { |
| f = roots[0].listFiles(); |
| } |
| } else { |
| f = roots; |
| } |
| |
| if (f == null) { |
| return 0; |
| } |
| return f.length; |
| } |
| } |
| |
| |
| /** |
| * A Item wrapper for files in a filesystem. |
| * |
| * @author Vaadin Ltd. |
| * @since 3.0 |
| */ |
| public class FileItem implements Item { |
| |
| /** |
| * The wrapped file. |
| */ |
| private final File file; |
| |
| private Object data = null; |
| |
| /** |
| * Constructs a FileItem from a existing file. |
| */ |
| private FileItem(File file) { |
| if (logger.isTraceEnabled()) { |
| logger.trace("FileItem constructor: " + file.hashCode() + " " + file.getName()); |
| } |
| this.file = file; |
| } |
| |
| /* |
| * Gets the specified property of this file. Don't add a JavaDoc comment |
| * here, we use the default documentation from implemented interface. |
| */ |
| @Override |
| public Property<?> getItemProperty(Object id) { |
| return getContainerProperty(file, id); |
| } |
| |
| /* |
| * Gets the IDs of all properties available for this item Don't add a |
| * JavaDoc comment here, we use the default documentation from |
| * implemented interface. |
| */ |
| @Override |
| public Collection<String> getItemPropertyIds() { |
| return getContainerPropertyIds(); |
| } |
| |
| /** |
| * Calculates a integer hash-code for the Property that's unique inside |
| * the Item containing the Property. Two different Properties inside the |
| * same Item contained in the same list always have different |
| * hash-codes, though Properties in different Items may have identical |
| * hash-codes. |
| * |
| * @return A locally unique hash-code as integer |
| */ |
| @Override |
| public int hashCode() { |
| return file.hashCode() ^ GitRepositoryContainer.this.hashCode(); |
| } |
| |
| /** |
| * Tests if the given object is the same as the this object. Two |
| * Properties got from an Item with the same ID are equal. |
| * |
| * @param obj |
| * an object to compare with this object. |
| * @return <code>true</code> if the given object is the same as this |
| * object, <code>false</code> if not |
| */ |
| @Override |
| public boolean equals(Object obj) { |
| if (obj == null || !(obj instanceof FileItem)) { |
| return false; |
| } |
| final FileItem fi = (FileItem) obj; |
| return fi.getHost() == getHost() && fi.file.equals(file); |
| } |
| |
| /** |
| * Gets the host of this file. |
| */ |
| private GitRepositoryContainer getHost() { |
| return GitRepositoryContainer.this; |
| } |
| |
| /** |
| * Gets the file's version |
| * |
| * @return Integer |
| */ |
| |
| public String getVersion() { |
| /* |
| * If its a directory, there is no version |
| */ |
| if (this.file.isDirectory()) { |
| return null; |
| } |
| try { |
| return XACMLPolicyScanner.getVersion(Paths.get(this.file.getAbsolutePath())); |
| } catch (IOException e) { |
| logger.error("Could not get version: " + e); |
| return "n/a"; |
| } |
| } |
| |
| /** |
| * Gets the last modified date of this file. |
| * |
| * @return Date |
| */ |
| public Date lastModified() { |
| return new Date(file.lastModified()); |
| } |
| |
| /** |
| * Gets the name of this file. |
| * |
| * @return file name of this file. |
| */ |
| public String getName() { |
| return file.getName(); |
| } |
| |
| public File getFile() { |
| return file; |
| } |
| |
| /** |
| * Gets the icon of this file. |
| * |
| * @return the icon of this file. |
| */ |
| public Resource getIcon() { |
| return FileTypeResolver.getIcon(file); |
| } |
| |
| /** |
| * Gets the size of this file. |
| * |
| * @return size |
| */ |
| public Long getSize() { |
| if (file.isDirectory()) { |
| return null; |
| } |
| return file.length(); |
| } |
| |
| /** |
| * Gets the status of this file. |
| * |
| * @return status of this file. |
| */ |
| public TextArea getStatus() { |
| TextArea area = null; |
| try { |
| Path repoPath = this.getHost().repository; |
| Git git = Git.open(repoPath.toFile()); |
| |
| // |
| // I would like to use absolutePath, but that seems to barf when |
| // we try to relativize this if a full path is not given. |
| // |
| Path relativePath = repoPath.relativize(Paths.get(this.file.getPath())); |
| |
| Status status = git.status().addPath(relativePath.toString()).call(); |
| if (logger.isDebugEnabled()) { |
| logger.debug(this.file.getAbsolutePath()); |
| logger.debug("Added: " + status.getAdded()); |
| logger.debug("Changed: " + status.getChanged()); |
| logger.debug("Conflicting: " + status.getConflicting()); |
| logger.debug("Missing: " + status.getMissing()); |
| logger.debug("Modified: " + status.getModified()); |
| logger.debug("Removed: " + status.getRemoved()); |
| logger.debug("Uncommitted: " + status.getUncommittedChanges()); |
| logger.debug("Untracked: " + status.getUntracked()); |
| logger.debug("Untracked folders; " + status.getUntrackedFolders()); |
| } |
| // |
| // Are we a file or directory? |
| // |
| StringBuffer buffer = new StringBuffer(); |
| int length = 0; |
| if (this.file.isFile()) { |
| if (status.getAdded().contains(relativePath.toString())) { |
| buffer.append("Added" + "\n"); |
| length++; |
| } |
| if (status.getChanged().contains(relativePath.toString())) { |
| buffer.append("Changed" + "\n"); |
| length++; |
| } |
| if (status.getConflicting().contains(relativePath.toString())) { |
| buffer.append("Conflicting" + "\n"); |
| length++; |
| } |
| if (status.getMissing().contains(relativePath.toString())) { |
| buffer.append("Missing" + "\n"); |
| length++; |
| } |
| if (status.getModified().contains(relativePath.toString())) { |
| buffer.append("Modified" + "\n"); |
| length++; |
| } |
| if (status.getRemoved().contains(relativePath.toString())) { |
| buffer.append("Removed" + "\n"); |
| length++; |
| } |
| if (status.getUncommittedChanges().contains(relativePath.toString())) { |
| buffer.append("Uncommitted" + "\n"); |
| length++; |
| } |
| if (status.getUntracked().contains(relativePath.toString())) { |
| buffer.append("Untracked (New)" + "\n"); |
| length++; |
| } |
| if (status.getUntrackedFolders().contains(relativePath.toString())) { |
| buffer.append("Untracked Folders (New)" + "\n"); |
| length++; |
| } |
| } else if (this.file.isDirectory()) { |
| if (status.getUntracked().size() > 0) { |
| buffer.append("Untracked (New)" + "\n"); |
| length++; |
| } |
| if (status.getUntrackedFolders().size() > 0) { |
| buffer.append("Untracked Folders (New)" + "\n"); |
| length++; |
| } |
| } |
| if (length > 0) { |
| area = new TextArea(); |
| area.setValue(buffer.toString().trim()); |
| area.setWidth("100.0%"); |
| area.setRows(length); |
| area.setReadOnly(true); |
| } |
| } catch (IOException | NoWorkTreeException | GitAPIException e) { |
| logger.error(e); |
| } |
| return area; |
| } |
| |
| /** |
| * Gets the file's data |
| * |
| * @return file data |
| */ |
| public Object getData() { |
| return this.data; |
| } |
| /** |
| * @see java.lang.Object#toString() |
| */ |
| @Override |
| public String toString() { |
| // if ("".equals(file.getName())) { |
| // return file.getAbsolutePath(); |
| // } |
| return file.getName(); |
| } |
| |
| /** |
| * Filesystem container does not support adding new properties. |
| * |
| * @see com.vaadin.data.Item#addItemProperty(Object, Property) |
| */ |
| @Override |
| public boolean addItemProperty(Object id, @SuppressWarnings("rawtypes") Property property) throws UnsupportedOperationException { |
| throw new UnsupportedOperationException("Filesystem container does not support adding new properties"); |
| } |
| |
| /** |
| * Filesystem container does not support removing properties. |
| * |
| * @see com.vaadin.data.Item#removeItemProperty(Object) |
| */ |
| @Override |
| public boolean removeItemProperty(Object id) throws UnsupportedOperationException { |
| throw new UnsupportedOperationException("Filesystem container does not support property removal"); |
| } |
| } |
| |
| /** |
| * Generic file extension filter for displaying only files having certain |
| * extension. |
| * |
| * @author Vaadin Ltd. |
| * @since 3.0 |
| */ |
| public class FileExtensionFilter implements FilenameFilter, Serializable { |
| |
| private final String filter; |
| |
| /** |
| * Constructs a new FileExtensionFilter using given extension. |
| * |
| * @param fileExtension |
| * the File extension without the separator (dot). |
| */ |
| public FileExtensionFilter(String fileExtension) { |
| filter = "." + fileExtension; |
| } |
| |
| /** |
| * Allows only files with the extension and directories. |
| * |
| * @see java.io.FilenameFilter#accept(File, String) |
| */ |
| @Override |
| public boolean accept(File dir, String name) { |
| if (name.endsWith(filter)) { |
| return true; |
| } |
| return new File(dir, name).isDirectory(); |
| } |
| |
| } |
| |
| /** |
| * Returns the file filter used to limit the files in this container. |
| * |
| * @return Used filter instance or null if no filter is assigned. |
| */ |
| public FilenameFilter getFilter() { |
| return filter; |
| } |
| |
| /** |
| * Sets the file filter used to limit the files in this container. |
| * |
| * @param filter |
| * The filter to set. <code>null</code> disables filtering. |
| */ |
| public void setFilter(FilenameFilter filter) { |
| this.filter = filter; |
| } |
| |
| /** |
| * Sets the file filter used to limit the files in this container. |
| * |
| * @param extension |
| * the Filename extension (w/o separator) to limit the files in |
| * container. |
| */ |
| public void setFilter(String extension) { |
| filter = new FileExtensionFilter(extension); |
| } |
| |
| /** |
| * Is this container recursive filesystem. |
| * |
| * @return <code>true</code> if container is recursive, <code>false</code> |
| * otherwise. |
| */ |
| public boolean isRecursive() { |
| return recursive; |
| } |
| |
| /** |
| * Sets the container recursive property. Set this to false to limit the |
| * files directly under the root file. |
| * <p> |
| * Note : This is meaningful only if the root really is a directory. |
| * </p> |
| * |
| * @param recursive |
| * the New value for recursive property. |
| */ |
| public void setRecursive(boolean recursive) { |
| this.recursive = recursive; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see com.vaadin.data.Container#addContainerProperty(java.lang.Object, |
| * java.lang.Class, java.lang.Object) |
| */ |
| @Override |
| public boolean addContainerProperty(Object propertyId, Class<?> type, |
| Object defaultValue) throws UnsupportedOperationException { |
| throw new UnsupportedOperationException( |
| "File system container does not support this operation"); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see com.vaadin.data.Container#addItem() |
| */ |
| @Override |
| public Object addItem() throws UnsupportedOperationException { |
| throw new UnsupportedOperationException( |
| "Git repository container does not support this operation"); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see com.vaadin.data.Container#addItem(java.lang.Object) |
| */ |
| @Override |
| public Item addItem(Object itemId) throws UnsupportedOperationException { |
| if (! (itemId instanceof File)) { |
| throw new UnsupportedOperationException( |
| "Git repository container does not support this operation for Objects that are not files."); |
| } |
| if (logger.isTraceEnabled()) { |
| logger.trace("addItem: " + ((File)itemId).hashCode() + " " + ((File)itemId).getName()); |
| } |
| |
| fireItemSetChange(); |
| |
| return new FileItem((File) itemId); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see com.vaadin.data.Container#removeAllItems() |
| */ |
| @Override |
| public boolean removeAllItems() throws UnsupportedOperationException { |
| throw new UnsupportedOperationException( |
| "File system container does not support this operation"); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see com.vaadin.data.Container#removeItem(java.lang.Object) |
| */ |
| @Override |
| public boolean removeItem(Object itemId) |
| throws UnsupportedOperationException { |
| |
| if (logger.isTraceEnabled()) { |
| logger.trace("removeItem: " + ((File)itemId).hashCode() + " " + ((File)itemId).getName()); |
| } |
| |
| fireItemSetChange(); |
| return true; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see com.vaadin.data.Container#removeContainerProperty(java.lang.Object ) |
| */ |
| @Override |
| public boolean removeContainerProperty(Object propertyId) |
| throws UnsupportedOperationException { |
| throw new UnsupportedOperationException( |
| "File system container does not support this operation"); |
| } |
| |
| public Object getRoot(int index) { |
| if (index >= this.roots.length) { |
| return null; |
| } |
| return this.roots[index]; |
| } |
| } |
