/**
 * Content provider that takes an enum class as input an provides its elements.
 *
 * @author Simon Templer
 */
public class EnumContentProvider implements IStructuredContentProvider {

  private static final ALogger log = ALoggerFactory.getLogger(EnumContentProvider.class);

  private static EnumContentProvider instance;

  /**
   * Get the content provider singleton instance.
   *
   * @return the content provider instance
   */
  public static EnumContentProvider getInstance() {
    synchronized (EnumContentProvider.class) {
      if (instance == null) {
        instance = new EnumContentProvider();
      }
    }
    return instance;
  }

  /** Default constructor. */
  protected EnumContentProvider() {
    super();
  }

  /** @see IContentProvider#dispose() */
  @Override
  public void dispose() {
    // do nothing
  }

  /** @see IContentProvider#inputChanged(Viewer, Object, Object) */
  @Override
  public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
    // do nothing
  }

  /** @see IStructuredContentProvider#getElements(Object) */
  @Override
  public Object[] getElements(Object inputElement) {
    if (inputElement instanceof Class<?> && ((Class<?>) inputElement).isEnum()) {
      @SuppressWarnings("unchecked")
      Class<? extends Enum<?>> enumClass = (Class<? extends Enum<?>>) inputElement;
      try {
        Method method = enumClass.getMethod("values");
        return (Object[]) method.invoke(null);
      } catch (Exception e) {
        log.error("Could not get values from enum.");
      }
    }
    return new Object[] {};
  }
}
/**
 * Extension for {@link ResourceAdvisor}s
 *
 * @author Simon Templer
 */
public class ResourceAdvisorExtension
    extends AbstractExtension<ResourceAdvisor, ResourceAdvisorDescriptor> {

  /** {@link ResourceAdvisor} factory based on a {@link IConfigurationElement} */
  private static class ConfigurationFactory extends AbstractConfigurationFactory<ResourceAdvisor>
      implements ResourceAdvisorDescriptor {

    /**
     * Create the {@link ResourceAdvisor} factory
     *
     * @param conf the configuration element
     */
    protected ConfigurationFactory(IConfigurationElement conf) {
      super(conf, "class");
    }

    /** @see ExtensionObjectFactory#dispose(Object) */
    @Override
    public void dispose(ResourceAdvisor advisor) {
      // do nothing
    }

    /** @see ExtensionObjectDefinition#getDisplayName() */
    @Override
    public String getDisplayName() {
      return getIdentifier();
    }

    /** @see ExtensionObjectDefinition#getIdentifier() */
    @Override
    public String getIdentifier() {
      return conf.getAttribute("id");
    }

    @Override
    public Set<IContentType> getAssociatedTypes() {
      IConfigurationElement[] children = conf.getChildren("contentType");

      if (children != null) {
        Set<IContentType> result = new HashSet<IContentType>();

        for (IConfigurationElement child : children) {
          String id = child.getAttribute("ref");
          IContentType ct = Platform.getContentTypeManager().getContentType(id);
          if (ct != null) {
            result.add(ct);
          } else {
            log.error(
                MessageFormat.format("Content type with ID {0} not known by the platform", id));
          }
        }

        return result;
      } else {
        return Collections.emptySet();
      }
    }
  }

  /** The extension point ID */
  public static final String ID = "eu.esdihumboldt.hale.io.resource";

  private static final ALogger log = ALoggerFactory.getLogger(ResourceAdvisorExtension.class);

  /** Default resource advisor */
  private static final ResourceAdvisor DEFAULT = new DefaultResourceAdvisor();

  private static ResourceAdvisorExtension instance;

  /**
   * Get the I/O provider extension instance
   *
   * @return the extension instance
   */
  public static ResourceAdvisorExtension getInstance() {
    if (instance == null) {
      instance = new ResourceAdvisorExtension();
    }
    return instance;
  }

  /** Default constructor */
  private ResourceAdvisorExtension() {
    super(ID);
  }

  @Override
  protected ResourceAdvisorDescriptor createFactory(IConfigurationElement conf) throws Exception {
    if (conf.getName().equals("advisor")) {
      return new ConfigurationFactory(conf);
    }
    return null;
  }

  /**
   * Create an I/O advisor for the given content type.
   *
   * @param contentType the content type, may be <code>null</code>
   * @return the resource advisor for that content type or a default resource advisor
   */
  public ResourceAdvisor getAdvisor(IContentType contentType) {
    if (contentType == null) {
      return DEFAULT;
    }

    boolean error = false;
    for (ResourceAdvisorDescriptor factory : getFactories()) {
      if (factory.getAssociatedTypes().contains(contentType)) {
        try {
          return factory.createExtensionObject();
        } catch (Exception e) {
          log.error("Could not create resource advisor " + factory.getIdentifier(), e);
          error = true;
        }
      }
    }

    if (error) {
      log.warn(
          "Using default resource advisor as fall-back for content type " + contentType.getName());
    }

    return DEFAULT;
  }
}
Beispiel #3
0
/**
 * Upload form for new projects.
 *
 * @author Simon Templer
 */
public class UploadForm extends Form<Void> {

  private static final long serialVersionUID = -8077630706189091706L;

  private static final ALogger log = ALoggerFactory.getLogger(UploadForm.class);

  private final FileUploadField file;

  private final TextField<String> identifier;

  private Set<String> allowedContentTypes = null;

  private String customTypeErrorMessage = null;

  @SpringBean private ProjectScavenger projects;

  /** @see Form#Form(String) */
  public UploadForm(String id) {
    super(id);

    // multipart always needed for uploads
    setMultiPart(true);

    // input field for identifier text
    identifier = new TextField<String>("identifier", new Model<String>());
    // pattern validator
    identifier.add(new PatternValidator("[A-Za-z0-9 _\\-]+"));
    // validator that checks if the project name is already taken
    identifier.add(
        new IValidator<String>() {

          private static final long serialVersionUID = 275885544279441469L;

          @Override
          public void validate(IValidatable<String> validatable) {
            String name = validatable.getValue();
            for (String project : projects.getResources()) {
              // ignore case to avoid confusion
              if (name.equalsIgnoreCase(project)) {
                validatable.error(new ValidationError().setMessage("Identifier already in use"));
                break;
              }
            }
          }
        });
    FieldMessage identifierMessage =
        new FieldMessage(
            "identifierMessage",
            new Model<String>("Unique identifier for the project"),
            identifier);
    identifier.add(new FieldValidatingBehavior("onblur", identifierMessage));
    identifier.setOutputMarkupId(true);
    identifier.setRequired(true);
    //		identifier.add(new DefaultFocus()); XXX not working well with ajax
    add(identifier);
    add(identifierMessage);

    // Add one file input field
    add(file = new FileUploadField("file"));
    add(new FeedbackPanel("feedback"));

    addAllowedContentType("application/zip");
    addAllowedContentType("application/x-zip");
    addAllowedContentType("application/x-zip-compressed");
    addAllowedContentType("application/octet-stream");

    //		setCustomTypeErrorMessage("Only ZIP archives are supported for upload");

    setMaxSize(Bytes.megabytes(20));
  }

  /**
   * Add an allowed content type. If none is added, any content type is allowed.
   *
   * @param contentType the content type to add
   */
  public void addAllowedContentType(String contentType) {
    if (allowedContentTypes == null) {
      allowedContentTypes = new HashSet<String>();
    }

    allowedContentTypes.add(contentType);
  }

  /**
   * Check if the given content type is allowed for upload
   *
   * @param contentType the content type
   * @return if the upload shall be allowed
   */
  protected boolean checkContentType(String contentType) {
    if (allowedContentTypes == null) {
      return true;
    } else {
      return allowedContentTypes.contains(contentType);
    }
  }

  /** @see Form#onSubmit() */
  @Override
  protected void onSubmit() {
    final String project = identifier.getModel().getObject();
    try {
      final FileUpload upload = file.getFileUpload();
      if (upload != null) {
        File dir = projects.reserveResourceId(project);

        //				File target = new File(dir, upload.getClientFileName());
        String type = upload.getContentType();
        if (checkContentType(type)) {
          //					IOUtils.copy(upload.getInputStream(), new FileOutputStream(target));

          // try extracting the archive
          IOUtils.extract(dir, new BufferedInputStream(upload.getInputStream()));

          // trigger scan after upload
          projects.triggerScan();
          info("Successfully uploaded project");

          onUploadSuccess();
        } else {
          projects.releaseResourceId(project);
          error(getTypeErrorMessage(type));
        }
      } else {
        warn("Please provide a file for upload");
      }
    } catch (ScavengerException e) {
      error(e.getMessage());
    } catch (Exception e) {
      projects.releaseResourceId(project);
      log.error("Error while uploading file", e);
      error("Error saving the file");
    }
  }

  /** Called after a successful upload. */
  protected void onUploadSuccess() {
    setResponsePage(ProjectsPage.class);
  }

  /**
   * Get the error message if the upload of the given type is not supported
   *
   * @param type the content type
   * @return the error message
   */
  protected String getTypeErrorMessage(String type) {
    if (customTypeErrorMessage != null) {
      return customTypeErrorMessage;
    } else {
      return "Files of type " + type + " are not supported.";
    }
  }

  /** @see Form#onFileUploadException(FileUploadException, Map) */
  @Override
  protected void onFileUploadException(FileUploadException e, Map<String, Object> model) {
    if (e instanceof SizeLimitExceededException) {
      final String msg =
          "Only files up to  " + bytesToString(getMaxSize(), Locale.US) + " can be uploaded.";
      error(msg);
    } else {
      final String msg = "Error uploading the file: " + e.getLocalizedMessage();
      error(msg);

      log.warn(msg, e);
    }
  }

  /** @param customTypeErrorMessage the customTypeErrorMessage to set */
  public void setCustomTypeErrorMessage(String customTypeErrorMessage) {
    this.customTypeErrorMessage = customTypeErrorMessage;
  }

  /**
   * Convert {@link Bytes} to a string, produces a prettier output than {@link
   * Bytes#toString(Locale)}
   *
   * @param bytes the bytes
   * @param locale the locale
   * @return the converted string
   */
  public static String bytesToString(Bytes bytes, Locale locale) {
    if (bytes.bytes() >= 0) {
      if (bytes.terabytes() >= 1.0) {
        return unitString(bytes.terabytes(), "TB", locale);
      }

      if (bytes.gigabytes() >= 1.0) {
        return unitString(bytes.gigabytes(), "GB", locale);
      }

      if (bytes.megabytes() >= 1.0) {
        return unitString(bytes.megabytes(), "MB", locale);
      }

      if (bytes.kilobytes() >= 1.0) {
        return unitString(bytes.kilobytes(), "KB", locale);
      }

      return Long.toString(bytes.bytes()) + " bytes";
    } else {
      return "N/A";
    }
  }

  private static String unitString(final double value, final String units, final Locale locale) {
    return StringValue.valueOf(value, locale) + " " + units;
  }
}