net.sf.jasperreports.engine.design.JasperDesign Java Examples

@Override
public void performAction() throws ActionException {
	JRDesignDatasetRun datasetRun = (JRDesignDatasetRun)table.getDatasetRun();

	String datasetName = datasetRun.getDatasetName();
	
	JasperDesignCache cache = JasperDesignCache.getInstance(getJasperReportsContext(), getReportContext());
	
	JasperDesign jasperDesign = cache.getJasperDesign(targetUri);
	JRDesignDataset dataset = (JRDesignDataset)jasperDesign.getDatasetMap().get(datasetName);
	
	// execute command
	try {
		getCommandStack().execute(
			new ResetInCacheCommand(
				new FilterCommand(getJasperReportsContext(), dataset, getFilterData()),
				getJasperReportsContext(),
				getReportContext(), 
				targetUri
				)
			);
	} catch (CommandException e) {
		throw new ActionException(e);
	}
}
 

protected void verifyEvaluation(JRVerifier verifier,
		PieChartComponent chart)
{
	EvaluationTimeEnum evaluationTime = chart.getEvaluationTime();
	if (evaluationTime == EvaluationTimeEnum.AUTO)
	{
		verifier.addBrokenRule("Pie chart evaluation time cannot be Auto", chart);
	}
	else if (evaluationTime == EvaluationTimeEnum.GROUP)
	{
		String groupName = chart.getEvaluationGroup();
		if (groupName == null)
		{
			verifier.addBrokenRule("Evaluation group not set for pie chart", chart);
		}
		else
		{
			JasperDesign report = verifier.getReportDesign();
			if (!report.getGroupsMap().containsKey(groupName))
			{
				verifier.addBrokenRule("Pie chart evaluation group " + groupName 
						+ " not found in report", chart);
			}
		}
	}
}
 

protected void verifyEvaluation(JRVerifier verifier,
		XYChartComponent chart)
{
	EvaluationTimeEnum evaluationTime = chart.getEvaluationTime();
	if (evaluationTime == EvaluationTimeEnum.AUTO)
	{
		verifier.addBrokenRule("Axis chart evaluation time cannot be Auto", chart);
	}
	else if (evaluationTime == EvaluationTimeEnum.GROUP)
	{
		String groupName = chart.getEvaluationGroup();
		if (groupName == null)
		{
			verifier.addBrokenRule("Evaluation group not set for axis chart", chart);
		}
		else
		{
			JasperDesign report = verifier.getReportDesign();
			if (!report.getGroupsMap().containsKey(groupName))
			{
				verifier.addBrokenRule("Axis chart evaluation group " + groupName 
						+ " not found in report", chart);
			}
		}
	}
}
 

protected void verifyEvaluation(JRVerifier verifier,
		SpiderChartComponent chart)
{
	EvaluationTimeEnum evaluationTime = chart.getEvaluationTime();
	if (evaluationTime == EvaluationTimeEnum.AUTO)
	{
		verifier.addBrokenRule("Spider chart evaluation time cannot be Auto", chart);
	}
	else if (evaluationTime == EvaluationTimeEnum.GROUP)
	{
		String groupName = chart.getEvaluationGroup();
		if (groupName == null)
		{
			verifier.addBrokenRule("Evaluation group not set for spider chart", chart);
		}
		else
		{
			JasperDesign report = verifier.getReportDesign();
			if (!report.getGroupsMap().containsKey(groupName))
			{
				verifier.addBrokenRule("Spider chart evaluation group " + groupName 
						+ " not found in report", chart);
			}
		}
	}
}
 

/**
 * 
 */
private JasperDesignReportResource getResource(String uri)
{
	JasperDesignReportResource resource = cachedResourcesMap.get(uri);
	
	if (resource != null)
	{
		JasperDesign jasperDesign = resource.getJasperDesign();
		JasperReport jasperReport = resource.getReport();
		
		if (jasperReport == null && jasperDesign != null)
		{
			try
			{
				jasperReport = reportCompiler.compile(jasperDesign);
				resource.setReport(jasperReport);
			}
			catch (JRException e)
			{
				throw new JRRuntimeException(e);
			}
		}
	}
	
	return resource;
}
 

/**
 * generate report ByteArrayOutputStream
 *
 * @param jrDataSource data for report
 * @param template       report template
 * @return report ByteArrayOutputStream
 * @throws JRException will occurred generating report
 */
public JasperPrint createJasperPrint(JRDataSource jrDataSource, String template)throws JRException {

    // create a byte array from given report template
    
    byte[] templateBytes = template.getBytes();
    InputStream templateInputStream = new ByteArrayInputStream(templateBytes);
    JasperPrint jasperPrint;
    try {
        // load JasperDesign
        JasperDesign jasperDesign = JRXmlLoader.load(templateInputStream);
        // compiling JasperDesign from JasperCompileManager
        JasperReport jasperReport = JasperCompileManager.compileReport(jasperDesign);
        // generate JasperPrint Object from given JasperReport file and JRDataSource by JasperFillManager
        jasperPrint = JasperFillManager.fillReport(jasperReport, new HashMap(), jrDataSource);
    } catch (JRException e) {
        throw new JRException("JasperPrint creation failed from " + template , e);
    }
    return jasperPrint;
}
 

public JasperReport compileReport() throws JRException, IOException
{
	InputStream jrxmlInput = JRLoader.getResourceInputStream(jrxml);
	JasperDesign design;
	try
	{
		design = JRXmlLoader.load(jrxmlInput);
	}
	finally
	{
		jrxmlInput.close();
	}
	
	report = JasperCompileManager.compileReport(design);
	
	//TODO do we need this here?
	fillManager = JasperFillManager.getInstance(jasperReportsContext);
	
	return report;
}
 

@Override
public void begin(String namespace, String name, Attributes attributes)
		throws Exception
{
	DesignStyleContainer styleContainer = (DesignStyleContainer) digester.peek();
	
	JasperDesign jasperDesign = (JasperDesign) digester.peek(digester.getCount() - 2);
	styleContainer.setDefaultStyleProvider(jasperDesign);
	
	String styleName = attributes.getValue(styleAttribute);
	if (styleName != null)
	{
		Map<String,JRStyle> stylesMap = jasperDesign.getStylesMap();
		if (stylesMap.containsKey(styleName))
		{
			JRStyle style = stylesMap.get(styleName);
			styleContainer.setStyle(style);
		}
		else
		{
			styleContainer.setStyleNameReference(styleName);
		}
	}
}
 

@Override
public void renderDocument() {
    try {
        switch (getExtension(reportTemplate)) {
            case JASPER_EXT:
                printReport((JasperReport) JRLoader.loadObject(reportTemplate.getDocumentContent()));
                break;
            case JRXML_EXT:
                JasperDesign design = JRXmlLoader.load(reportTemplate.getDocumentContent());
                if (!design.getParametersMap().containsKey(CUBA_PARAM))
                    design.addParameter(createJRParameter());

                printReport(JasperCompileManager.compileReport(design));
                break;
            default:
                throw new ReportFormattingException("Error handling template extension");
        }
    } catch (JRException e) {
        throw new ReportFormattingException("Error formatting jasper report: " + e.getMessage(), e);
    }
}
 

@Override
public Object createObject(Attributes atts)
{
	JasperDesign jasperDesign = (JasperDesign)digester.peek(digester.getCount() - 2);

	JRDesignSubreport subreport = new JRDesignSubreport(jasperDesign);

	String isUsingCache = atts.getValue(JRXmlConstants.ATTRIBUTE_isUsingCache);
	if (isUsingCache != null && isUsingCache.length() > 0)
	{
		subreport.setUsingCache(Boolean.valueOf(isUsingCache));
	}
	
	String runToBottomAttr = atts.getValue(JRXmlConstants.ATTRIBUTE_runToBottom);
	if (runToBottomAttr != null)
	{
		subreport.setRunToBottom(Boolean.valueOf(runToBottomAttr));
	}

	return subreport;
}
 

@Override
public Object createObject(Attributes attrs) throws Exception
{
	JasperDesign jasperDesign = (JasperDesign)digester.peek(digester.getCount() - 2);
	JRDesignGenericElement element = new JRDesignGenericElement(jasperDesign);
	
	EvaluationTimeEnum evaluationTime = EvaluationTimeEnum.getByName(attrs.getValue(JRXmlConstants.ATTRIBUTE_evaluationTime));
	if (evaluationTime != null)
	{
		element.setEvaluationTime(evaluationTime);
	}
	
	if (element.getEvaluationTimeValue() == EvaluationTimeEnum.GROUP)
	{
		String groupName = attrs.getValue(JRXmlConstants.ATTRIBUTE_evaluationGroup);
		if (groupName != null)
		{
			element.setEvaluationGroupName(groupName);
		}
	}
	
	return element;
}
 

@Override
protected void setParentStyle(JRDesignStyle currentStyle, String parentStyleName)
{
	JasperDesign jasperDesign = (JasperDesign) digester.peek(digester.getCount() - 2);
	Map<String,JRStyle> stylesMap = jasperDesign.getStylesMap();

	if (stylesMap.containsKey(parentStyleName))
	{
		JRStyle parent = stylesMap.get(parentStyleName);
		currentStyle.setParentStyle(parent);
	}
	else
	{
		currentStyle.setParentStyleNameReference(parentStyleName);
	}
}
 

@Override
public void performAction() throws ActionException {
	if (zoomValue != null && zoomValue.length() > 0) {
		CommandTarget target = getCommandTarget(getJasperReportsContext(), getReportContext());
		if (target != null) {
			// execute command
			try {
				getCommandStack().execute(
					new ResetInCacheCommand(
							new SaveZoomCommand((JasperDesign)target.getIdentifiable(), zoomValue),
							getJasperReportsContext(),
							getReportContext(),
							target.getUri()
					)
				);
			} catch (CommandException e) {
				throw new ActionException(e);
			}
		}
	} else {
		errors.addAndThrow("net.sf.jasperreports.web.actions.empty.zoom");
	}
}
 

@Override
	public void performAction() 
	{
//		JasperDesign jasperDesign = getJasperDesign();
		JasperDesignCache cache = JasperDesignCache.getInstance(getJasperReportsContext(), getReportContext());
		Map<String, JasperDesignReportResource> cachedResources = cache.getCachedResources();
		for (String uri : cachedResources.keySet())
		{
			JasperDesignReportResource resource = cachedResources.get(uri);
			JasperDesign jasperDesign = resource.getJasperDesign();
			if (jasperDesign != null)
			{
				JasperReport jasperReport = resource.getReport();
				String appRealPath = null;//FIXMECONTEXT WebFileRepositoryService.getApplicationRealPath();
				try
				{
					JRSaver.saveObject(jasperReport, new File(new File(new File(appRealPath), "WEB-INF/repository"), uri));//FIXMEJIVE harcoded
				}
				catch (JRException e)
				{
					throw new JRRuntimeException(e);
				}
			}
		}
	}
 

/**
 *
 */
public ReportConverter(JasperReportsContext jasperReportsContext, JRReport report, boolean ignoreContent)
{
	this.jasperReportsContext = jasperReportsContext;
	this.componentsEnvironment = ComponentsEnvironment.getInstance(jasperReportsContext);
	this.report = report;
	this.locale = readLocale();//allow to pass this explicitly?
	this.timezone = readTimeZone();
	
	if (report instanceof JasperDesign)
	{
		((JasperDesign)report).preprocess();
	}
	
	convert(ignoreContent);
}
 

/**
 *
 */
public JRDesignTextField getTextField()
{
	JasperDesign jasperDesign = (JasperDesign)digester.peek(digester.getCount() - 2);

	return new JRDesignTextField(jasperDesign);
}
 

/**
 * 
 */
public void set(String uri, JasperDesign jasperDesign)
{
	JasperDesignReportResource resource = new JasperDesignReportResource();
	resource.setJasperDesign(jasperDesign);
	cachedResourcesMap.put(uri, resource);
}
 

@Override
public Object createObject(Attributes atts)
{
	JasperDesign jasperDesign = (JasperDesign)digester.peek(digester.getCount() - 2);

	JRDesignLine line = new JRDesignLine(jasperDesign);

	LineDirectionEnum direction = LineDirectionEnum.getByName(atts.getValue(JRXmlConstants.ATTRIBUTE_direction));
	if (direction != null)
	{
		line.setDirection(direction);
	}

	return line;
}
 

@Override
public Object createObject(Attributes atts)
{
	JasperDesign jasperDesign = (JasperDesign)digester.peek(digester.getCount() - 2);

	JRDesignBreak breakElement = new JRDesignBreak(jasperDesign);

	BreakTypeEnum type = BreakTypeEnum.getByName(atts.getValue(JRXmlConstants.ATTRIBUTE_type));
	if (type != null)
	{
		breakElement.setType(type);
	}

	return breakElement;
}
 

@Override
public void performAction() throws ActionException
{
	if (sortData != null) 
	{
		CommandTarget target = getCommandTarget(UUID.fromString(sortData.getTableUuid()));
		if (target != null)
		{
			JasperDesignCache cache = JasperDesignCache.getInstance(getJasperReportsContext(), getReportContext());

			JasperDesign jasperDesign = cache.getJasperDesign(target.getUri());
			JRDesignDataset dataset = (JRDesignDataset)jasperDesign.getMainDataset();
			
			// obtain command stack
			CommandStack commandStack = getCommandStack();
			
			// execute command
			try {
				commandStack.execute(
					new ResetInCacheCommand(
						new SortCommand(getJasperReportsContext(), dataset, sortData),
						getJasperReportsContext(),
						getReportContext(),
						target.getUri()
						)
					);
			} catch (CommandException e) {
				 throw new ActionException(e);
			}
		}
	}
}
 

/**
 * Compiles the XML report design file specified by the parameter.
 * The result of this operation is another file that will contain the serialized  
 * {@link net.sf.jasperreports.engine.JasperReport} object representing the compiled report design,
 * having the same name as the report design as declared in the XML plus the <code>*.jasper</code> extension,
 * located in the same directory as the XML source file.
 * 
 * @param sourceFileName XML source file name
 * @return resulting file name containing a serialized {@link net.sf.jasperreports.engine.JasperReport} object 
 */
public String compileToFile(String sourceFileName) throws JRException
{
	File sourceFile = new File(sourceFileName);

	JasperDesign jasperDesign = JRXmlLoader.load(sourceFileName);

	File destFile = new File(sourceFile.getParent(), jasperDesign.getName() + ".jasper");
	String destFileName = destFile.toString();

	compileToFile(jasperDesign, destFileName);
	
	return destFileName;
}
 

/**
 * Compiles the report design object received as the first parameter, placing the result 
 * in the file specified by the second parameter.
 * The resulting file will contain a serialized instance of a 
 * {@link net.sf.jasperreports.engine.JasperReport} object representing the compiled report design.
 * 
 * @param jasperDesign source report design object
 * @param destFileName file name to place the compiled report design into
 */
public void compileToFile(
	JasperDesign jasperDesign,
	String destFileName
	) throws JRException
{
	JasperReport jasperReport = compile(jasperDesign);

	JRSaver.saveObject(jasperReport, destFileName);
}
 

@Override
public Object createObject(Attributes attributes)
{
	JasperDesign jasperDesign = (JasperDesign)digester.peek(digester.getCount() - 2);
	
	return new JRDesignFrame(jasperDesign);
}
 

private List<FieldFilter> getExistingFiltersForField(
	JasperReportsContext jasperReportsContext, 
	ReportContext reportContext, 
	String uuid, 
	String filterFieldName
	) 
{
	JasperDesignCache cache = JasperDesignCache.getInstance(jasperReportsContext, reportContext);
	FilterAction action = new FilterAction();
	action.init(jasperReportsContext, reportContext);
	CommandTarget target = action.getCommandTarget(UUID.fromString(uuid));
	List<FieldFilter> result = new ArrayList<FieldFilter>();
	if (target != null)
	{
		JasperDesign jasperDesign = cache.getJasperDesign(target.getUri());
		JRDesignDataset dataset = (JRDesignDataset)jasperDesign.getMainDataset();
		
		// get existing filter as JSON string
		String serializedFilters = "[]";
		JRPropertiesMap propertiesMap = dataset.getPropertiesMap();
		if (propertiesMap.getProperty(FilterCommand.DATASET_FILTER_PROPERTY) != null) {
			serializedFilters = propertiesMap.getProperty(FilterCommand.DATASET_FILTER_PROPERTY);
		}
		
		List<? extends DatasetFilter> existingFilters = JacksonUtil.getInstance(jasperReportsContext).loadList(serializedFilters, FieldFilter.class);
		if (existingFilters.size() > 0) {
			for (DatasetFilter filter: existingFilters) {
				if (((FieldFilter)filter).getField().equals(filterFieldName)) {
					result.add((FieldFilter)filter);
					break;
				}
			}
		}
	}
	
	return result;
}
 

/**
 * @see #compileToStream(JasperDesign, OutputStream)
 */
public static void compileReportToStream(
	JasperDesign jasperDesign,
	OutputStream outputStream
	) throws JRException
{
	getDefaultInstance().compileToStream(jasperDesign, outputStream);
}
 

private String getCurrentSortField(JasperReportsContext jasperReportsContext, ReportContext reportContext, String uuid, String sortDatasetName, String sortColumnName, String sortColumnType) 
{
	JasperDesignCache cache = JasperDesignCache.getInstance(jasperReportsContext, reportContext);
	SortAction action = new SortAction();
	action.init(jasperReportsContext, reportContext);
	CommandTarget target = action.getCommandTarget(UUID.fromString(uuid));
	if (target != null)
	{
		JasperDesign jasperDesign = cache.getJasperDesign(target.getUri());
		JRDesignDataset dataset = (JRDesignDataset)jasperDesign.getMainDataset();
		
		List<JRSortField> existingFields =  dataset.getSortFieldsList();
		String sortField = null;

		if (existingFields != null && existingFields.size() > 0) {
			for (JRSortField field: existingFields) {
				if (field.getName().equals(sortColumnName) && field.getType().getName().equals(sortColumnType)) {
					sortField = sortColumnName + SortElement.SORT_COLUMN_TOKEN_SEPARATOR + sortColumnType + SortElement.SORT_COLUMN_TOKEN_SEPARATOR;
					switch (field.getOrderValue()) {
						case ASCENDING:
							sortField += SortElement.SORT_ORDER_ASC;
							break;
						case DESCENDING:
							sortField += SortElement.SORT_ORDER_DESC;
							break;
					}
					break;
				}
			}
		}
	
		return sortField;
	}
	
	return null;
}
 

@Override
public void setStyle(JRFont font, Attributes atts)
{
	JRDesignElement element = (JRDesignElement)font;

	if (
		element.getStyle() == null
		&& element.getStyleNameReference() == null
		)
	{
		String styleName = atts.getValue(JRXmlConstants.ATTRIBUTE_reportFont);
		if (styleName != null)
		{
			JasperDesign jasperDesign = (JasperDesign)digester.peek(digester.getCount() - 2);
			Map<String,JRStyle> stylesMap = jasperDesign.getStylesMap();

			if (stylesMap.containsKey(styleName))
			{
				JRStyle style = stylesMap.get(styleName);
				element.setStyle(style);
			}
			else
			{
				element.setStyleNameReference(styleName);
			}
		}
	}
}
 

/**
 * Creates an object from a subreport copied value XML element.
 * 
 * @param atts the element attributes
 * @return a {@link JRDesignSubreportReturnValue JRDesignSubreportReturnValue} object
 */
@Override
public Object createObject(Attributes atts)
{
	JRXmlLoader xmlLoader = (JRXmlLoader) digester.peek(digester.getCount() - 1);
	JasperDesign design = (JasperDesign) digester.peek(digester.getCount() - 2);
	
	JRDesignSubreportReturnValue returnValue = new JRDesignSubreportReturnValue();

	String variableName = atts.getValue(JRXmlConstants.ATTRIBUTE_toVariable);
	
	XmlLoaderReportContext reportContext = xmlLoader.getReportContext();
	String subdatasetName = reportContext == null ? null : reportContext.getSubdatesetName();
	JRDesignDataset dataset = subdatasetName == null ? design.getMainDesignDataset() 
			: (JRDesignDataset) design.getDatasetMap().get(subdatasetName);
	JRVariable variable = dataset == null ? null : dataset.getVariablesMap().get(variableName);
	if (variable == null)
	{
		//TODO do we need this check here?  JRVerifier.verifySubreport also validates return values
		xmlLoader.addError(new JRValidationException("Unknown variable " + variableName, returnValue));
	}
	
	returnValue.setSubreportVariable(atts.getValue(JRXmlConstants.ATTRIBUTE_subreportVariable));
	returnValue.setToVariable(variableName);

	CalculationEnum calculation = CalculationEnum.getByName(atts.getValue(JRXmlConstants.ATTRIBUTE_calculation));
	if (calculation != null)
	{
		returnValue.setCalculation(calculation);
	}
	
	String incrementerFactoryClass = atts.getValue(JRXmlConstants.ATTRIBUTE_incrementerFactoryClass);
	if (incrementerFactoryClass != null)
	{
		returnValue.setIncrementerFactoryClassName(incrementerFactoryClass);
	}

	return returnValue;
}
 

/**
 * 
 */
public JasperDesign getJasperDesign(String uri)
{
	JasperDesignReportResource resource = getResource(uri);
	if (resource != null)
	{
		ensureJasperDesign(resource);
		return resource.getJasperDesign();
	}
	return null;
}
 

/**
 * Compiles the report design object represented by the first parameter and
 * writes the generated compiled report design object to the output stream specified 
 * by the second parameter.
 * 
 * @param jasperDesign source report design object
 * @param outputStream output stream to write the compiled report design to
 */
public void compileToStream(
	JasperDesign jasperDesign,
	OutputStream outputStream
	) throws JRException
{
	JasperReport jasperReport = compile(jasperDesign);

	JRSaver.saveObject(jasperReport, outputStream);
}