org.primefaces.model.StreamedContent Java Examples

public StreamedContent getOutputFile(int saveFormat) {
    if (!isLoaded()) {
        return null;
    }

    byte[] buf;
    String ext = getExtensionForSaveFormat(saveFormat);

    try {
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        getAsposeWorkbook().save(out, saveFormat);
        buf = out.toByteArray();
    } catch (Exception x) {
        LOGGER.throwing(null, null, x);
        msg.sendMessageDialog("Could not export", x.getMessage());
        return null;
    }

    return new DefaultStreamedContent(new ByteArrayInputStream(buf), "application/octet-stream", "Spreadsheet." + ext);
}
 

public StreamedContent downloadFile(File file) {

		if (!file.exists()) {
			logger.info("File {} does not exist", file.getPath());
			BeanUtil.addErrorMessage("File does not exist", "");
			return null;
		}
		
		try {

            InputStream stream = new BufferedInputStream(new FileInputStream(file));

			return new DefaultStreamedContent(stream, "*/*", file.getName());

        } catch (IOException e) {
			logger.error(e.getMessage(), e);
			BeanUtil.addErrorMessage("Download failed", e.getMessage());
		}
		
		return null;
	}
 

public StreamedContent getConverted() {

        try {
            File outputFile = Files.createTempFile("merged", ".csv").toFile();
            MergeMatrix.mergeMatrix(outputFile, uploadedFiles);
            for (File matrixFile: uploadedFiles) {
                matrixFile.delete();
            }
            uploadedFiles.clear();

            return new DefaultStreamedContent(new FileInputStream(outputFile), ContentType.DEFAULT_BINARY.toString(), outputFile.getName());
        } catch (Exception e) {
            logger.info(e.getMessage(), e);
            BeanUtil.showMessage(FacesMessage.SEVERITY_ERROR, e.getMessage(), ExceptionUtils.getStackTrace(e));
            return null;
        }
    }
 

public synchronized StreamedContent putImage(Object key, byte[] image, String mimeType) {
	if (image != null && image.length > 0 && mimeType != null && mimeType.length() > 0) {
		return imageStore.put(key, new DefaultStreamedContent(new ByteArrayInputStream(image), mimeType));
	} else {
		return imageStore.remove(key);
	}
}
 

public StreamedContent getStrContent() {
logger.info("getStrContent invoked {}", getUser());
      if(selectedFiles.length != 1) {
          return null; // Message?
      }
      if(selectedFiles[0].isDirectory()) {
          return null; // Message?
      }

      StreamedContent content = selectedFiles[0].getStrContent();
      return content == null ? null : content;
  }
 

public synchronized StreamedContent getImage() {
	FacesContext context = FacesContext.getCurrentInstance();
	if (PhaseId.RENDER_RESPONSE.equals(context.getCurrentPhaseId())) {
		// So, we're rendering the view. Return a stub StreamedContent so that it will generate right URL.
		return new DefaultStreamedContent();
	} else {
		// So, browser is requesting the image. Return a real StreamedContent with the image bytes.
		String uuid = WebUtil.getParamValue(GetParamNames.UUID);
		if (imageStore.containsKey(uuid)) {
			return imageStore.get(uuid);
		}
		return new DefaultStreamedContent();
	}
}
 

public StreamedContent getStrContent()
{
       if(!file.exists()) {
           return null;
       }

	try {
		InputStream stream = new BufferedInputStream(new FileInputStream(file));
		return new DefaultStreamedContent(stream, "*/*", file.getName());
	}
	catch(IOException e) {
		logger.error(e.getMessage(), e);
	}
	return null;
}
 

public StreamedContent getResultsInCSV() {
logger.info("getResultsInCSV invoked {}", getUser());

      if(selectedOptions.isEmpty() && !includeRawMessage) {
          BeanUtil.addWarningMessage("No columns selected", "Select at least one column");
          return null;
      }

      if(messageLazyModel.getRowCount() != 0) {
	try {
              String fileNameCsv = "query_result_" + UUID.randomUUID();
		File temp = File.createTempFile(fileNameCsv, ".csv");
		CsvMessageWriter writer = new CsvMessageWriter(selectedOptions, includeRawMessage);
              writer.writeAndClose(temp, messageLazyModel.load(0, messageLazyModel.getRowCount()));

		File zipFile = new File(temp.getParent(), "messages.zip");
		AppZip appZip = new AppZip();
		appZip.generateFileList(temp);
		appZip.zipIt(zipFile.getAbsoluteFile().toString());

		InputStream stream = new FileInputStream(zipFile);
		return new DefaultStreamedContent(stream, "application/zip", "Messages.zip");
	} catch (IOException e) {
		logger.error("Could not export messages", e);
		BeanUtil.addErrorMessage("Could not export messages", e.getMessage());
		return null;
	}
  	} else {
	BeanUtil.addWarningMessage("No data to export", "Table messages is empty");
}
  	return null;
  }
 

public StreamedContent getServicesInZip() {
	logger.info("getServicesInZip invoked {}", getUser());

	try {
		InputStream stream = new FileInputStream(BeanUtil.getSfContext().getServiceMarshalManager().packInZip(exportServices()));
		return new DefaultStreamedContent(stream, "application/zip", "Services.zip");
	} catch (FileNotFoundException e) {
		logger.error(e.getMessage(), e);
	}
	return null;
}
 

public StreamedContent getDownloadFiles() {

        try {
            return getNewFile();
        } catch (IOException | RuntimeException e) {
            logger.error("Can not pack current dictionary.", e);
            BeanUtil.showMessage(FacesMessage.SEVERITY_ERROR, "Error",
                                 "can not pack current dictionary." + e.getMessage());
            return null;
        }

    }
 

public SessionScopeBean() {
	auth = new AuthenticationVO();
	imageStore = new MaxSizeHashMap<Object, StreamedContent>(WebUtil.IMAGE_STORE_MAX_SIZE);
	columnManager = new ColumnManagementBean();
	logon = null;
	failedAttempts = 0;
	authenticationFailed = false;
	localPasswordRequired = false;
	authenticationFailedMessage = null;
}
 

@Override
public void handleResourceRequest(FacesContext context) throws IOException {
	Map<String, String> params = context.getExternalContext().getRequestParameterMap();
	String library = params.get("ln");
	String dynamicContentId = params.get(Constants.DYNAMIC_CONTENT_PARAM);
	if (dynamicContentId != null && library != null && library.equals("primefaces")) {
		Map<String, Object> session = context.getExternalContext().getSessionMap();
		try {
			String dynamicContentEL = (String) session.get(dynamicContentId);
			if (!ALLOWED_EXPRESSIONS.contains(dynamicContentEL)) {
				throw new Exception("prevented EL " + dynamicContentEL);
			}
			System.out.println(dynamicContentEL);
			ELContext elContext = context.getELContext();
			ValueExpression ve = context.getApplication().getExpressionFactory().createValueExpression(context.getELContext(), dynamicContentEL, StreamedContent.class);
			StreamedContent content = (StreamedContent) ve.getValue(elContext);
			HttpServletResponse response = (HttpServletResponse) context.getExternalContext().getResponse();
			response.setContentType(content.getContentType());
			byte[] buffer = new byte[2048];
			int length;
			InputStream inputStream = content.getStream();
			while ((length = (inputStream.read(buffer))) >= 0) {
				response.getOutputStream().write(buffer, 0, length);
			}
			response.setStatus(200);
			response.getOutputStream().flush();
			context.responseComplete();
		} catch (Exception e) {
			logger.log(Level.SEVERE, "Error in streaming dynamic resource" + e.getMessage());
		} finally {
			session.remove(dynamicContentId);
		}
	} else {
		super.handleResourceRequest(context);
	}
}
 

public StreamedContent getMatrixInZip() {
	logger.debug("getMatrixInZip invoked {}", BeanUtil.getUser());
	try {
		InputStream stream = new FileInputStream(packZip());
		return new DefaultStreamedContent(stream, "application/zip", "matrix.zip");
	} catch (Exception e) {
		logger.error(e.getMessage(), e);
		BeanUtil.showMessage(FacesMessage.SEVERITY_ERROR, "Error", e.getMessage());
	}

	return null;

}
 

public void setContent(StreamedContent content) {
	this.content = content;
}
 

public StreamedContent getContent() {
	return content;
}
 

public void setFile(StreamedContent file) {
	this.file = file;
}
 

public StreamedContent getFile() {
	return file;
}
 

public StreamedContent getFileStreamedContent() throws Exception {
	if (isHasImage()) {
		return new DefaultStreamedContent(new ByteArrayInputStream(in.getDatas()), in.getMimeType(), in.getFileName());
	}
	return null;
}
 

public void setFile(StreamedContent file) {
    this.file = file;
}
 

public StreamedContent getFile() {
    System.out.println("return file " + file.getName());
    return file;
}
 

public void setFileData(StreamedContent fileData) {
    this.fileData = fileData;
}
 

public StreamedContent getFileData() {
    return fileData;
}
 

public StreamedContent getReimbursementsPdfNoTrialStreamedContent() throws Exception {
	return getReimbursementsPdfStreamedContent(null);
}
 

public StreamedContent getFile1() {
	return file1;
}
 

public void setFile1(StreamedContent file1) {
	this.file1 = file1;
}
 

public StreamedContent getFile2() {
	return file2;
}
 

public void setFile2(StreamedContent file2) {
	this.file2 = file2;
}
 

public StreamedContent getFile3() {
	return file3;
}
 

public void setFile3(StreamedContent file3) {
	this.file3 = file3;
}
 

public StreamedContent getFile() {
	return file;
}