private Class<?> findParameterClass( ReportParameterDefinition definition, String parameterName ) { for ( int i = 0; i < definition.getParameterCount(); i++ ) { ParameterDefinitionEntry entry = definition.getParameterDefinition( i ); if ( parameterName.equals( entry.getName() ) ) { return entry.getValueType(); } } return null; } }
private String getParameterDefinitionEntryTypeDescription( ParameterDefinitionEntry entry ) { Class<?> clazz = entry.getValueType(); String extra = " ("; String namespace = entry.getParameterAttributeNamespaces()[0]; String[] attributes = entry.getParameterAttributeNames( namespace ); for ( int i = 0; i < attributes.length; i++ ) { if ( i > 0 ) { extra += ", "; String attr = entry.getParameterAttribute( namespace, attributes[i], null ); extra += attributes[i] + "=" + attr; .getValueType().getSimpleName() );
public TextAreaParameterComponent( final ParameterDefinitionEntry entry, final ParameterContext parameterContext, final ParameterUpdateContext updateContext ) { this.updateContext = updateContext; final String formatString = entry.getTranslatedParameterAttribute( ParameterAttributeNames.Core.NAMESPACE, ParameterAttributeNames.Core.DATA_FORMAT, parameterContext ); final String timeZoneSpec = entry.getParameterAttribute( ParameterAttributeNames.Core.NAMESPACE, ParameterAttributeNames.Core.TIMEZONE, parameterContext ); final Locale locale = parameterContext.getResourceBundleFactory().getLocale(); final TimeZone timeZone = TextComponentEditHandler.createTimeZone( timeZoneSpec, parameterContext.getResourceBundleFactory() .getTimeZone() ); textArea = new JTextArea(); format = TextComponentEditHandler.createFormat( formatString, locale, timeZone, entry.getValueType() ); handler = new TextComponentEditHandler( entry.getValueType(), entry.getName(), textArea, updateContext, format ); textArea.getDocument().addDocumentListener( handler ); textArea.setColumns( 60 ); textArea.setRows( 10 ); setViewportView( textArea ); parameterName = entry.getName(); updateContext.addChangeListener( new TextUpdateHandler() ); }
public Object getMetaAttribute( final String domain, final String name, final Class type, final DataAttributeContext context, final Object defaultValue ) { if ( domain == null ) { throw new NullPointerException(); } if ( name == null ) { throw new NullPointerException(); } if ( context == null ) { throw new NullPointerException(); } if ( MetaAttributeNames.Core.NAMESPACE.equals( domain ) ) { if ( MetaAttributeNames.Core.NAME.equals( name ) ) { return entry.getName(); } if ( MetaAttributeNames.Core.SOURCE.equals( name ) ) { return MetaAttributeNames.Core.SOURCE_VALUE_PARAMETER; } if ( MetaAttributeNames.Core.TYPE.equals( name ) ) { return entry.getValueType(); } } final Object override = entry.getParameterAttribute( domain, name, parameterContext ); if ( override != null ) { return override; } return globalAttributes.getMetaAttribute( domain, name, type, context, defaultValue ); }
for ( int i = 0; i < definition.getParameterCount(); i++ ) { ParameterDefinitionEntry entry = definition.getParameterDefinition( i ); ValueMetaInterface valueMeta = new ValueMetaString( entry.getName() ); valueMeta.setComments( getParameterDefinitionEntryTypeDescription( entry ) ); r.addValueMeta( valueMeta );
String computeLabel( final ParameterDefinitionEntry entry ) { final String swingLabel = entry.getParameterAttribute( ParameterAttributeNames.Swing.NAMESPACE, ParameterAttributeNames.Swing.LABEL, parameterContext ); if ( swingLabel != null ) { return swingLabel; } String coreLabel = entry.getTranslatedParameterAttribute( ParameterAttributeNames.Core.NAMESPACE, ParameterAttributeNames.Core.LABEL, parameterContext ); return coreLabel == null ? entry.getName() : coreLabel; }
if ( untrustedValue == null ) { defaultValue = parameterDefinitionEntry.getDefaultValue( trustedParameterContext ); untrustedValue = defaultValue; logger.debug( "On Validate Single Parameter: " + parameterDefinitionEntry.getName() ); logger.debug( "On Validate Single Parameter: " + trustedParameterContext.getParameterData() ); logger.debug( "On Validate Single Parameter: " + untrustedValue ); logger.debug( "On Validate Single Parameter: ------------------------------" ); final String parameterName = parameterDefinitionEntry.getName(); final ReportParameterValues tempValue = new ReportParameterValues( trustedParameterContext.getTrustedValues() ); tempValue.put( parameterName, untrustedValue ); final Class parameterType = parameterDefinitionEntry.getValueType(); if ( parameterType.isInstance( computedValue ) == false ) { logger.warn( "Parameter validation error: Value cannot be matched due to invalid value type '" + parameterDefinitionEntry.getName() + "' with value '" + computedValue + "'" ); result.addError( parameterName, new ValidationMessage( Messages.getInstance( locale ).getString( "DefaultReportParameterValidator.ParameterIsInvalidType" ) ) );
for ( int i = 0; i < entries.length; i++ ) { final ParameterDefinitionEntry entry = entries[i]; final Object oldValue = parameters.get( entry.getName() ); if ( oldValue == null ) { parameters.put( entry.getName(), entry.getDefaultValue( wrapper ) );
private ParameterComponent createTextComponent( final ParameterDefinitionEntry entry, final ParameterContext parameterContext, final ParameterUpdateContext updateContext ) { final String type = entry.getParameterAttribute( ParameterAttributeNames.Core.NAMESPACE, ParameterAttributeNames.Core.TYPE, parameterContext ); if ( "datepicker".equals( type ) && Date.class.isAssignableFrom( entry.getValueType() ) ) { // NON-NLS return new DatePickerParameterComponent( entry, parameterContext, updateContext ); } if ( "multi-line".equals( type ) ) { // NON-NLS return new TextAreaParameterComponent( entry, parameterContext, updateContext ); } else { return new TextFieldParameterComponent( entry, parameterContext, updateContext ); } }
default String getTranslatedParameterAttribute( final String namespace, final String name, final ParameterContext context ) { final String formulaName = name + "-formula"; final String formula = getParameterAttribute( namespace, formulaName, context ); if ( StringUtils.isEmpty( formula, true ) ) { return getParameterAttribute( namespace, name, context ); } else { try { ParameterExpressionRuntime runtime = new ParameterExpressionRuntime( context, context.getParameterData() ); final FormulaExpression fe = new FormulaExpression(); fe.setFormula( formula ); fe.setRuntime( runtime ); final Object res = fe.getValue(); return String.valueOf( res ); } catch ( ReportProcessingException e ) { return getParameterAttribute( namespace, name, context ); } } } }
private void addToPanel( final ParameterDefinitionEntry entry, final int gridY, final JComponent editor ) { final JLabel label = new JLabel( computeLabel( entry ) ); final JLabel errorLabel = new JLabel(); errorLabels.put( entry.getName(), errorLabel ); carrierPanel.add( label, gbc ); if ( entry.isMandatory() ) { gbc = new GridBagConstraints(); gbc.gridy = gridY;
public String[] getMetaAttributeNames( final String domainName ) { final String[] metaNamess = globalAttributes.getMetaAttributeNames( domainName ); if ( MetaAttributeNames.Core.NAMESPACE.equals( domainName ) ) { return StringUtils.merge( ParameterDataAttributes.NAMES, metaNamess ); } return StringUtils.merge( metaNamess, entry.getParameterAttributeNames( domainName ) ); }
public String[] getMetaAttributeDomains() { return StringUtils.merge( globalAttributes.getMetaAttributeDomains(), StringUtils.merge( ParameterDataAttributes.NAMESPACES, entry.getParameterAttributeNamespaces() ) ); }
public TextFieldParameterComponent( final ParameterDefinitionEntry entry, final ParameterContext parameterContext, final ParameterUpdateContext updateContext ) { this.updateContext = updateContext; this.parameterName = entry.getName(); final String formatString = entry.getTranslatedParameterAttribute( ParameterAttributeNames.Core.NAMESPACE, ParameterAttributeNames.Core.DATA_FORMAT, parameterContext ); final String timeZoneSpec = entry.getParameterAttribute( ParameterAttributeNames.Core.NAMESPACE, ParameterAttributeNames.Core.TIMEZONE, parameterContext ); final Locale locale = parameterContext.getResourceBundleFactory().getLocale(); final TimeZone timeZone = TextComponentEditHandler.createTimeZone( timeZoneSpec, parameterContext.getResourceBundleFactory() .getTimeZone() ); format = TextComponentEditHandler.createFormat( formatString, locale, timeZone, entry.getValueType() ); handler = new TextComponentEditHandler( entry.getValueType(), entry.getName(), this, updateContext, format ); setColumns( 60 ); getDocument().addDocumentListener( handler ); addActionListener( handler ); updateContext.addChangeListener( new TextUpdateHandler() ); }
private Map<String, ParameterDefinitionEntry> normalizeParameterDefinitions( final ParameterDataRow parameters, final ParameterDefinitionEntry[] parameterDefinitionEntries ) { final String[] parameterNames = parameters.getColumnNames(); final HashMap<String, ParameterDefinitionEntry> map = new HashMap<String, ParameterDefinitionEntry>(); if ( parameterDefinitionEntries != null ) { for ( int i = 0; i < parameterDefinitionEntries.length; i++ ) { final ParameterDefinitionEntry entry = parameterDefinitionEntries[i]; map.put( entry.getName(), entry ); } } for ( int i = 0; i < parameterNames.length; i++ ) { final String name = parameterNames[i]; if ( map.containsKey( name ) ) { continue; } final Object value = parameters.get( name ); if ( value != null ) { map.put( name, new PlainParameter( name, value.getClass() ) ); } else { map.put( name, new PlainParameter( name, Object.class ) ); } } return map; }
final Object o = computePostProcessingValue( result, parameterContext, parameterValues, entry, parameterValues.get( entry .getName() ), entry.getDefaultValue( parameterContext ) ); parameterValues.put( entry.getName(), o ); } catch ( ReportProcessingException e ) { if ( logger.isDebugEnabled() ) { logger.debug( "Unable to compute default value for parameter '" + entry.getName() + "'", e ); result.addError( entry.getName(), new ValidationMessage( Messages.getInstance( locale ).formatMessage( "FormulaParameterEvaluator.PostProcessingInitFailed", e.getLocalizedMessage() ) ) );
private static boolean isAllParametersHidden( final MasterReport report, final ReportParameterDefinition parameterDefinition ) { try { final DefaultParameterContext parameterContext = new DefaultParameterContext( report ); try { final ParameterDefinitionEntry[] entries = parameterDefinition.getParameterDefinitions(); for ( int i = 0; i < entries.length; i++ ) { final ParameterDefinitionEntry entry = entries[i]; if ( "true".equals( entry.getParameterAttribute( ParameterAttributeNames.Core.NAMESPACE, ParameterAttributeNames.Core.HIDDEN, parameterContext ) ) == false ) { return false; } } } finally { parameterContext.close(); } return true; } catch ( ReportDataFactoryException e ) { return false; } catch ( ReportProcessingException e ) { return false; } }
this.parameterName = entry.getName(); this.updateContext = updateContext; this.dateType = entry.getValueType(); if ( this.dateType.isArray() ) { this.dateType = this.dateType.getComponentType(); String formatString = entry.getTranslatedParameterAttribute( ParameterAttributeNames.Core.NAMESPACE, ParameterAttributeNames.Core.DATA_FORMAT, parameterContext ); entry.getParameterAttribute( ParameterAttributeNames.Core.NAMESPACE, ParameterAttributeNames.Core.TIMEZONE, parameterContext ); final Locale locale = parameterContext.getResourceBundleFactory().getLocale(); new TextComponentEditHandler( entry.getValueType(), entry.getName(), dateField, updateContext, sdf ); dateField.getDocument().addDocumentListener( listener ); dateField.addActionListener( listener );
if ( error != null ) { if ( result != null ) { result.addError( entry.getName(), new ValidationMessage( Messages.getInstance( locale ).formatMessage( "FormulaParameterEvaluator.PostProcessingFormulaFailed", error.getLocalizedMessage() ) ) ); logger.debug( "Unable to compute default value for parameter '" + entry.getName() + "'", error ); } else if ( entry.getValueType().isInstance( value ) ) { return value; } else if ( value instanceof ErrorValue ) { final ErrorValue errorValue = (ErrorValue) value; if ( result != null ) { result.addError( entry.getName(), new ValidationMessage( Messages.getInstance( locale ).formatMessage( "FormulaParameterEvaluator.PostProcessingFormulaFailed", final ValueConverter valueConverter = ConverterRegistry.getInstance().getValueConverter( entry.getValueType() ); if ( valueConverter != null ) { return ConverterRegistry.toPropertyValue( textValue, entry.getValueType() ); } catch ( BeanException e ) { if ( logger.isDebugEnabled() ) { logger.debug( "Unable to convert computed default value for parameter '" + entry.getName() + "'", e ); result.addError( entry.getName(), new ValidationMessage( Messages.getInstance( locale ).getString( "FormulaParameterEvaluator.ErrorConvertingValue" ) ) ); result.addError( entry.getName(), new ValidationMessage( "The post-processing result cannot be converted into the target-type." ) );
protected void processParameters( final ParameterDataRow parameters, final ParameterDefinitionEntry[] parameterDefinitionEntries, final ReportEnvironment reportEnvironment, final DefaultDataAttributes globalAttributes, final DataSchemaRule[] indirectRules, final DataSchemaRule[] directRules, final DefaultDataSchema schema ) throws ReportDataFactoryException { final Map<String, ParameterDefinitionEntry> map = normalizeParameterDefinitions( parameters, parameterDefinitionEntries ); for ( final Map.Entry<String, ParameterDefinitionEntry> entry : map.entrySet() ) { final ParameterDefinitionEntry parameter = entry.getValue(); parameterDataAttributes.setup( parameter, globalAttributes, reportEnvironment, resourceManager ); final DefaultDataAttributes computedParameterDataAttributes = new DefaultDataAttributes(); computedParameterDataAttributes.merge( this.parameterDataAttributes, context ); applyRules( indirectRules, directRules, computedParameterDataAttributes ); schema.setAttributes( parameter.getName(), computedParameterDataAttributes ); } }