예제 #1
0
  @Override
  protected void persistNode(NodeRef nodeRef, FormData data) {

    // let superclass persist properties
    super.persistNode(nodeRef, data);

    // implements File field persistance
    int fileFieldCount = 0;
    for (FieldData fieldData : data) {
      // NOTE: ignore file fields for now, not supported yet!
      if (fieldData.isFile() == true && fieldData instanceof CustomFormData.FieldData) {
        CustomFormData.FieldData cfd = (CustomFormData.FieldData) fieldData;
        if (fileFieldCount == 0) {
          InputStream inputStream = cfd.getInputStream();
          try {
            if (inputStream.available() > 0) {

              ContentWriter writer =
                  this.contentService.getWriter(nodeRef, ContentModel.PROP_CONTENT, true);
              String mimetype = cfd.getMimetype();

              logger.debug("write content in :" + nodeRef);
              logger.debug("mimeType :" + mimetype);
              logger.debug("encoding :" + writer.getEncoding());

              writer.setMimetype(mimetype);
              writer.putContent(inputStream);
            }
          } catch (InvalidTypeException e1) {
            logger.error(e1);
          } catch (ContentIOException e1) {
            logger.error(e1);
          } catch (InvalidNodeRefException e1) {
            logger.error(e1);
          } catch (IOException e1) {
            logger.error(e1);
          } finally {
            try {
              inputStream.close();
            } catch (IOException e) {
              logger.error("trying to close inputStream fail", e);
            }
          }

        } else {
          // TODO multi file upload not implemented yet
        }
        fileFieldCount++;
      }
    }
  }
  /**
   * @see
   *     org.alfresco.repo.content.transform.AbstractContentTransformer2#transformInternal(org.alfresco.service.cmr.repository.ContentReader,
   *     org.alfresco.service.cmr.repository.ContentWriter,
   *     org.alfresco.service.cmr.repository.TransformationOptions)
   */
  @Override
  public void transformInternal(
      ContentReader reader, ContentWriter writer, TransformationOptions options) throws Exception {
    final String outputMimetype = writer.getMimetype();
    final String outputFileExt = getMimetypeService().getExtension(outputMimetype);

    // We need to keep a reference to thrown exceptions as we're going to catch them and
    // then move on to the next transformer. In the event that they all fail, we will throw
    // the final exception.
    Exception transformationException = null;

    for (int i = 0; i < transformers.size(); i++) {
      int oneBasedCount = i + 1;
      ContentTransformer transf = transformers.get(i);
      ContentWriter currentWriter = null;
      File tempFile = null;
      try {
        if (logger.isDebugEnabled()) {
          logger.debug(
              "Transformation attempt "
                  + oneBasedCount
                  + " of "
                  + transformers.size()
                  + ": "
                  + transf);
        }

        if (!transf.isTransformable(
            reader.getMimetype(), reader.getSize(), outputMimetype, options)) {
          throw new UnsupportedTransformationException(
              "Unsupported transformation: " + reader.getMimetype() + " to " + outputMimetype);
        }

        // We can't know in advance which transformer in the sequence will work - if any.
        // Therefore we can't write into the ContentWriter stream.
        // So make a temporary file writer with the current transformer name.
        tempFile =
            TempFileProvider.createTempFile(
                "FailoverTransformer_intermediate_" + transf.getClass().getSimpleName() + "_",
                "." + outputFileExt);
        currentWriter = new FileContentWriter(tempFile);
        currentWriter.setMimetype(outputMimetype);
        currentWriter.setEncoding(writer.getEncoding());

        // attempt to transform
        transf.transform(reader, currentWriter, options);

        // TODO Could add a check for zero-length output and treat that as a failure
        // final long writtenSize = currentWriter.getSize();
      } catch (Exception are) {
        if (transformationException == null) {
          transformationException = are;
        }

        if (logger.isDebugEnabled()) {
          logger.debug("Transformation " + oneBasedCount + " was unsuccessful.");
          if (i != transformers.size() - 1) {
            // We don't log the last exception as we're going to throw it.
            logger.debug("The below exception is provided for information purposes only.", are);
          }
        }

        // Set a new reader to refresh the input stream.
        reader = reader.getReader();
        // and move to the next transformer
        continue;
      }
      // No need to close input or output streams

      // At this point the current transformation was successful i.e. it did not throw an exception.

      // Now we must copy the content from the temporary file into the ContentWriter stream.
      if (tempFile != null) {
        writer.putContent(tempFile);
      }

      if (logger.isInfoEnabled()) {
        logger.info("Transformation was successful");
      }
      return;
    }
    // At this point we have tried all transformers in the sequence without apparent success.
    if (transformationException != null) {
      transformerDebug.debug("          No more transformations to failover to");
      if (logger.isDebugEnabled()) {
        logger.debug(
            "All transformations were unsuccessful. Throwing first exception.",
            transformationException);
      }
      throw transformationException;
    }
  }