/**
   * Streams content back to client from a given resource path.
   *
   * @param req The request
   * @param res The response
   * @param resourcePath The classpath resource path the content is required for.
   * @param attach Indicates whether the content should be streamed as an attachment or not
   * @param attachFileName Optional file name to use when attach is <code>true</code>
   * @throws IOException
   */
  protected void streamContent(
      WebScriptRequest req,
      WebScriptResponse res,
      String resourcePath,
      boolean attach,
      String attachFileName,
      Map<String, Object> model)
      throws IOException {
    if (logger.isDebugEnabled())
      logger.debug(
          "Retrieving content from resource path " + resourcePath + " (attach: " + attach + ")");

    // get extension of resource
    String ext = "";
    int extIndex = resourcePath.lastIndexOf('.');
    if (extIndex != -1) {
      ext = resourcePath.substring(extIndex);
    }

    // We need to retrieve the modification date/time from the resource itself.
    StringBuilder sb = new StringBuilder("classpath:").append(resourcePath);
    final String classpathResource = sb.toString();

    long resourceLastModified = resourceLoader.getResource(classpathResource).lastModified();

    // create temporary file
    File file = TempFileProvider.createTempFile("streamContent-", ext);

    InputStream is = resourceLoader.getResource(classpathResource).getInputStream();
    OutputStream os = new FileOutputStream(file);
    FileCopyUtils.copy(is, os);

    // stream the contents of the file, but using the modifiedDate of the original resource.
    streamContent(req, res, file, resourceLastModified, attach, attachFileName, model);
  }
 /**
  * Returns a writer to a thread-unique file. It's always the same file per thread so you must
  * use and close the writer before getting another.
  */
 @Override
 protected ContentWriter getWriterInternal(
     ContentReader existingContentReader, String newContentUrl) {
   File file = hammeredFile.get();
   if (file == null) {
     file = TempFileProvider.createTempFile("NullContentStore", ".txt");
     hammeredFile.set(file);
   }
   return new FileContentWriter(file);
 }
 private TFile getFile(String extension, String location) {
   File file = TempFileProvider.createTempFile("moduleManagementToolTest-", extension);
   InputStream is = this.getClass().getClassLoader().getResourceAsStream(location);
   assertNotNull(is);
   OutputStream os;
   try {
     os = new FileOutputStream(file);
     FileCopyUtils.copy(is, os);
   } catch (IOException error) {
     error.printStackTrace();
   }
   return new TFile(file);
 }
  @Override
  protected Map<String, Object> executeImpl(WebScriptRequest req, Status status, Cache cache) {
    // Check we got a valid Multi-Part Form Upload
    FormData form = (FormData) req.parseContent();
    if (form == null || !form.getIsMultiPart()) {
      throw new WebScriptException(Status.STATUS_BAD_REQUEST, "Bad Upload");
    }

    // Look for a file, we're quite flexible!
    File spreadsheet = null;
    for (FormData.FormField field : form.getFields()) {
      if (field.getIsFile()) {
        String ext = ".xls";
        if (field.getFilename() != null && field.getFilename().endsWith(".xlsx")) {
          ext = ".xlsx";
        }

        try {
          spreadsheet = TempFileProvider.createTempFile("spreadsheet", ext);
          FileOutputStream sout = new FileOutputStream(spreadsheet);
          IOUtils.copy(field.getInputStream(), sout);
          sout.close();
        } catch (IOException e) {
          throw new WebScriptException(Status.STATUS_BAD_REQUEST, "Upload Failed");
        }

        break;
      }
    }

    // Process
    String[] sheetnames = null;
    if (spreadsheet != null) {
      try {
        sheetnames = excerpter.getSheetNames(spreadsheet);
      } catch (IOException e) {
        throw new WebScriptException(Status.STATUS_BAD_REQUEST, "Spreadsheet Corrupt", e);
      }
    } else {
      throw new WebScriptException(Status.STATUS_BAD_REQUEST, "Spreadsheet Missing");
    }

    // Report
    Map<String, Object> model = new HashMap<String, Object>();
    model.put("file", spreadsheet.getName());
    model.put("sheets", sheetnames);
    return model;
  }
  private File convertPdfToPdfA(final InputStream source) throws IOException, DocumentException {

    final File pdfAFile =
        TempFileProvider.createTempFile("digitalSigning-" + System.currentTimeMillis(), ".pdf");

    // Reads a PDF document.
    PdfReader reader = new PdfReader(source);
    // PdfStamper: Applies extra content to the pages of a PDF document. This extra content can be
    // all the objects allowed in
    // PdfContentByte including pages from other Pdfs.
    PdfStamper stamper = new PdfStamper(reader, new FileOutputStream(pdfAFile));
    // A generic Document class.
    Document document = new Document();
    // we create a writer that listens to the document
    PdfWriter writer = stamper.getWriter();
    int numberPages = reader.getNumberOfPages();
    writer.setPDFXConformance(PdfWriter.PDFA1A);
    document.open();

    // PdfDictionary:A dictionary is an associative table containing pairs of objects.
    // The first element of each pair is called the key and the second  element is called the value
    // <CODE>PdfName</CODE> is an object that can be used as a name in a PDF-file
    PdfDictionary outi = new PdfDictionary(PdfName.OUTPUTINTENT);
    outi.put(PdfName.OUTPUTCONDITIONIDENTIFIER, new PdfString("sRGB IEC61966-2.1"));
    outi.put(PdfName.INFO, new PdfString("sRGB IEC61966-2.1"));
    outi.put(PdfName.S, PdfName.GTS_PDFA1);
    writer.getExtraCatalog().put(PdfName.OUTPUTINTENTS, new PdfArray(outi));

    // Add pages
    PdfImportedPage p = null;
    Image image;
    for (int i = 0; i < numberPages; i++) {
      p = writer.getImportedPage(reader, i + 1);
      image = Image.getInstance(p);
      document.add(image);
    }
    writer.createXmpMetadata();

    document.close();

    // Add Metadata from source pdf
    HashMap<String, String> info = reader.getInfo();
    stamper.setMoreInfo(info);
    stamper.close();

    return pdfAFile;
  }
  public static File copy(InputStream inputStream) {
    ParameterCheck.mandatory("inputStream", inputStream);

    File tempFile = TempFileProvider.createTempFile("acav_tempfile_", ".tmp");

    OutputStream outputStream = null;

    try {
      outputStream = new FileOutputStream(tempFile);

      IOUtils.copy(inputStream, outputStream);

      return tempFile;
    } catch (Exception ex) {
      tempFile.delete();

      throw new AlfrescoRuntimeException(ex.getMessage(), ex);
    } finally {
      IOUtils.closeQuietly(inputStream);
      IOUtils.closeQuietly(outputStream);
    }
  }
 private File tempfile() {
   File file = TempFileProvider.createTempFile("cached-content", ".bin");
   file.deleteOnExit();
   return file;
 }
  /**
   * @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;
    }
  }