コード例 #1
0
  /**
   * Updates values in InputParameterAttributes to the given report parameter.
   *
   * @param dataAttrs the latest input parameter attributes
   * @param cachedDataAttrs the cached input parameter attributes
   * @param reportParam the report parameter
   * @param setHandle the ROM data set that has the corresponding data set parameter
   * @throws SemanticException
   */
  private void updateInputParameterAttrsToReportParam(
      InputParameterAttributes inputParamAttrs,
      InputParameterAttributes cachedInputParamAttrs,
      AbstractScalarParameterHandle reportParam,
      OdaDataSetHandle setHandle)
      throws SemanticException {
    if (inputParamAttrs == null) return;

    InputParameterUIHints paramUiHints = inputParamAttrs.getUiHints();
    if (paramUiHints != null && reportParam.getContainer() instanceof ParameterGroupHandle) {
      ParameterGroupHandle paramGroup = (ParameterGroupHandle) reportParam.getContainer();

      InputParameterUIHints cachedParamUiHints =
          cachedInputParamAttrs == null ? null : cachedInputParamAttrs.getUiHints();

      String cachedGroupPromptDisplayName =
          cachedParamUiHints == null ? null : cachedParamUiHints.getGroupPromptDisplayName();

      String groupPromptDisplayName = paramUiHints.getGroupPromptDisplayName();

      if (cachedGroupPromptDisplayName == null
          || !cachedGroupPromptDisplayName.equals(groupPromptDisplayName)) {
        paramGroup.setDisplayName(groupPromptDisplayName);

        paramGroup.setDisplayNameKey(paramUiHints.getGroupPromptDisplayNameKey());
      }
    }

    updateInputElementAttrsToReportParam(
        inputParamAttrs.getElementAttributes(),
        cachedInputParamAttrs == null ? null : cachedInputParamAttrs.getElementAttributes(),
        reportParam,
        setHandle);
  }
コード例 #2
0
  /**
   * @param inputAttrs
   * @param inputParamAttrs
   * @param paramHandle
   */
  protected void updateDefaultStaticValues(
      InputElementAttributes inputAttrs, AbstractScalarParameterHandle paramHandle) {
    // update default values.

    StaticValues newValues = null;
    List<Expression> tmpValues = paramHandle.getDefaultValueList();
    if (tmpValues != null) {
      for (int i = 0; i < tmpValues.size(); i++) {
        if (newValues == null) newValues = designFactory.createStaticValues();

        Expression tmpExpr = tmpValues.get(i);
        String odaValue = null;

        // for the constant, there is no need to remove quotes
        if (ExpressionType.CONSTANT.equalsIgnoreCase(tmpExpr.getType())) {
          odaValue = tmpExpr.getStringExpression();
        } else {
          odaValue =
              ParameterValueUtil.toODAValue(
                  tmpValues.get(i).getStringExpression(), paramHandle.getDataType());
        }
        newValues.add(odaValue);
      }
    }
    inputAttrs.setDefaultValues(newValues);
  }
コード例 #3
0
  /**
   * Creates an DataElementAttributes with the given ROM report parameter.
   *
   * @param paramHandle the ROM report parameter.
   * @return the created DataElementAttributes
   */
  private DataElementAttributes updateDataElementAttrs(
      DataElementAttributes dataAttrs, AbstractScalarParameterHandle paramHandle) {
    DataElementAttributes retDataAttrs = dataAttrs;

    if (retDataAttrs == null) retDataAttrs = designFactory.createDataElementAttributes();

    // retDataAttrs.setNullability( DataSetParameterAdapter
    // .newElementNullability( paramHandle.allowNll( ) ) );

    retDataAttrs.setNullability(
        DataSetParameterAdapter.newElementNullability(
            getReportParamAllowMumble(paramHandle, ALLOW_NULL_PROP_NAME)));

    DataElementUIHints uiHints = designFactory.createDataElementUIHints();

    String text = paramHandle.getPromptText();
    String textKey = paramHandle.getPromptTextID();

    if (text != null || textKey != null) {
      uiHints.setDisplayName(text);
      uiHints.setDisplayNameKey(textKey);
    }

    text = paramHandle.getHelpText();
    textKey = paramHandle.getHelpTextKey();

    if (text != null || textKey != null) {
      uiHints.setDescription(text);
      uiHints.setDescriptionKey(textKey);
    }

    retDataAttrs.setUiHints(uiHints);

    return retDataAttrs;
  }
コード例 #4
0
  /**
   * Updates values in InputElementAttributes to the given report parameter.
   *
   * @param elementAttrs the latest input element attributes
   * @param cachedElementAttrs the cached input element attributes
   * @param reportParam the report parameter
   * @param setHandle the ROM data set that has the corresponding data set parameter
   * @throws SemanticException
   */
  protected void updateInputElementAttrsToReportParam(
      InputElementAttributes elementAttrs,
      InputElementAttributes cachedElementAttrs,
      AbstractScalarParameterHandle reportParam,
      OdaDataSetHandle setHandle)
      throws SemanticException {
    if (elementAttrs == null) return;

    // update default values.

    updateDefaultValueToReportParam(elementAttrs, cachedElementAttrs, reportParam);

    // update isOptional value
    Boolean isOptional = Boolean.valueOf(elementAttrs.isOptional());
    Boolean cachedIsOptional =
        cachedElementAttrs == null ? null : Boolean.valueOf(cachedElementAttrs.isOptional());
    if (!CompareUtil.isEquals(cachedIsOptional, isOptional))
      setReportParamIsRequired(reportParam, ALLOW_BLANK_PROP_NAME, isOptional.booleanValue());

    // update selection choices
    updateROMSelectionList(
        elementAttrs.getStaticValueChoices(),
        cachedElementAttrs == null ? null : cachedElementAttrs.getStaticValueChoices(),
        reportParam);

    // update dynamic list
    DynamicValuesQuery valueQuery = elementAttrs.getDynamicValueChoices();
    AdapterUtil.updateROMDyanmicList(
        valueQuery,
        cachedElementAttrs == null ? null : cachedElementAttrs.getDynamicValueChoices(),
        reportParam,
        setHandle);

    // for dynamic parameter, the flag is in DynamicValuesQuery is true
    // for static parameter, the DynamicValuesQuery is null or the flag is
    // false

    DynamicValuesQuery cachedValueQuery =
        cachedElementAttrs == null ? null : cachedElementAttrs.getDynamicValueChoices();

    boolean isEnabled = (valueQuery == null) ? false : valueQuery.isEnabled();

    if (reportParam.getContainer() != null
        && reportParam.getContainer() instanceof CascadingParameterGroupHandle) isEnabled = true;

    if (cachedValueQuery == null || cachedValueQuery.isEnabled() != isEnabled) {
      if (isEnabled) reportParam.setValueType(DesignChoiceConstants.PARAM_VALUE_TYPE_DYNAMIC);
      else reportParam.setValueType(DesignChoiceConstants.PARAM_VALUE_TYPE_STATIC);
    }
  }
コード例 #5
0
 /**
  * Returns the boolean value of allowMumble properties. Only support "allowNull" and "allowBlank"
  * properties.
  *
  * <p>"allowMumble" properties has been removed ROM. However, to do conversion, still need to know
  * their values.
  *
  * @param param the parameter
  * @param obsoletePropName either "allowNull" or "allowBlank".
  * @param value
  * @throws SemanticException
  */
 protected void setReportParamIsRequired(
     AbstractScalarParameterHandle param, String obsoletePropName, boolean value)
     throws SemanticException {
   if (ALLOW_NULL_PROP_NAME.equalsIgnoreCase(obsoletePropName)
       || ALLOW_BLANK_PROP_NAME.equalsIgnoreCase(obsoletePropName)) param.setIsRequired(!value);
   else assert false;
 }
コード例 #6
0
  /**
   * Returns the boolean value of allowMumble properties. Only support "allowNull" and "allowBlank"
   * properties.
   *
   * <p>"allowMumble" properties has been removed ROM. However, to do conversion, still need to know
   * their values.
   *
   * @param param the parameter
   * @param propName either "allowNull" or "allowBlank".
   * @return <code>true</code> if the parameter allows the value. Otherwise <code>false</code>.
   */
  protected boolean getReportParamAllowMumble(
      AbstractScalarParameterHandle param, String propName) {
    if (ALLOW_NULL_PROP_NAME.equalsIgnoreCase(propName)
        || ALLOW_BLANK_PROP_NAME.equalsIgnoreCase(propName)) return !param.isRequired();

    assert false;
    return false;
  }
コード例 #7
0
 /**
  * Sets the default value for ROM data set parameter.
  *
  * @param setParam the ROM data set parameter
  * @param literalValue the value
  */
 private void setROMDefaultValue(AbstractScalarParameterHandle setParam, Object value)
     throws SemanticException {
   List<Expression> newValues = null;
   if (!AdapterUtil.isNullExpression(value)) {
     assert value instanceof Expression;
     newValues = new ArrayList<Expression>();
     newValues.add(
         new Expression(
             ((Expression) value).getExpression(), ((Expression) value).getUserDefinedType()));
   }
   setParam.setDefaultValueList(newValues);
 }
コード例 #8
0
 public static void addParameterSortBy(
     QueryDefinition queryDefn, AbstractScalarParameterHandle parameter, IModelAdapter adapter) {
   String sortBy = parameter.getSortByColumn();
   if (sortBy != null) {
     String sortDirection = parameter.getSortDirection();
     if (sortDirection != null) {
       org.eclipse.birt.report.model.api.Expression mexpr =
           (org.eclipse.birt.report.model.api.Expression)
               parameter
                   .getExpressionProperty(AbstractScalarParameter.SORT_BY_COLUMN_PROP)
                   .getValue();
       ScriptExpression dexpr = adapter.adaptExpression(mexpr);
       SortDefinition sort = new SortDefinition();
       sort.setExpression(dexpr);
       boolean direction =
           DesignChoiceConstants.SORT_DIRECTION_ASC.equalsIgnoreCase(sortDirection);
       sort.setSortDirection(direction ? ISortDefinition.SORT_ASC : ISortDefinition.SORT_DESC);
       queryDefn.addSort(sort);
     }
   }
 }
コード例 #9
0
  /**
   * Updates values in DataElementAttributes to the given report parameter.
   *
   * @param dataAttrs the latest data element attributes
   * @param cachedDataAttrs the cached data element attributes
   * @param reportParam the report parameter
   * @throws SemanticException
   */
  private void updateDataElementAttrsToReportParam(
      DataElementAttributes dataAttrs,
      DataElementAttributes cachedDataAttrs,
      AbstractScalarParameterHandle reportParam)
      throws SemanticException {

    if (dataAttrs == null) return;

    boolean allowsNull = dataAttrs.allowsNull();
    if (cachedDataAttrs == null || cachedDataAttrs.allowsNull() != allowsNull)
      setReportParamIsRequired(reportParam, ALLOW_NULL_PROP_NAME, dataAttrs.allowsNull());

    // reportParam.setAllowNull( dataAttrs.allowsNull( ) );

    DataElementUIHints dataUiHints = dataAttrs.getUiHints();
    DataElementUIHints cachedDataUiHints =
        (cachedDataAttrs == null ? null : cachedDataAttrs.getUiHints());
    if (dataUiHints != null) {
      String displayName = dataUiHints.getDisplayName();
      String cachedDisplayName =
          cachedDataUiHints == null ? null : cachedDataUiHints.getDisplayName();

      boolean isChanged = false;

      if (cachedDisplayName == null || !cachedDisplayName.equals(displayName)) {
        isChanged = true;
        reportParam.setPromptText(displayName);
        reportParam.setPromptTextID(dataUiHints.getDisplayNameKey());
      }
      if (!isChanged && cachedDataUiHints != null && cachedDisplayName != null) {
        reportParam.setPromptText(cachedDisplayName);
        reportParam.setPromptTextID(cachedDataUiHints.getDisplayNameKey());
      }

      isChanged = false;
      String description = dataUiHints.getDescription();
      String cachedDescription =
          cachedDataUiHints == null ? null : cachedDataUiHints.getDescription();
      if (cachedDescription == null || !cachedDescription.equals(description)) {
        isChanged = true;
        reportParam.setHelpText(description);
        reportParam.setHelpTextKey(dataUiHints.getDescriptionKey());
      }

      if (!isChanged && cachedDataUiHints != null && cachedDescription != null) {
        reportParam.setHelpText(cachedDescription);
        reportParam.setHelpTextKey(cachedDataUiHints.getDescriptionKey());
      }
    }
  }
コード例 #10
0
  public ParameterHelper(AbstractScalarParameterHandle param, ULocale ulocale, TimeZone timezone) {
    this.labelColumnName = getLabelColumnName(param);
    this.valueColumnName = getValueColumnName(param);
    this.valueType = param.getDataType();
    this.alreadySorted = param.getSortByColumn() != null;
    this.distinct = param.distinct();

    String sortDirection = param.getSortDirection();
    boolean sortByLabel = "label".equalsIgnoreCase(param.getSortBy());
    if (param instanceof ScalarParameterHandle) {
      parameterType = SCALAR_PARAMETER;
      ScalarParameterHandle parameter = (ScalarParameterHandle) param;
      this.fixedOrder = parameter.isFixedOrder();
      if (param.getLabelExpr()
          == null) { // if no label expression was set, apply pattern to value column
        pattern = parameter.getPattern();
      }
    } else {
      parameterType = FILTER_PARAMETER;
    }

    if (!(parameterType == SCALAR_PARAMETER && fixedOrder)
        && !alreadySorted
        && sortDirection != null) {
      boolean sortDirectionValue =
          DesignChoiceConstants.SORT_DIRECTION_ASC.equalsIgnoreCase(sortDirection);
      Comparator choiceComparator =
          new SelectionChoiceComparator(sortByLabel, pattern, sortDirectionValue, ulocale);
      this.comparator = new DistinctComparatorDecorator(choiceComparator, distinct);
    }
    this.converter = new ReportParameterConverter(pattern, ulocale, timezone);
  }
コード例 #11
0
  public static void addParameterBinding(
      QueryDefinition queryDefn, AbstractScalarParameterHandle parameter, IModelAdapter adapter)
      throws DataException {
    String labelColumnName = getLabelColumnName(parameter);
    String valueColumnName = getValueColumnName(parameter);
    if (labelColumnName != null) {
      org.eclipse.birt.report.model.api.Expression mexpr =
          (org.eclipse.birt.report.model.api.Expression)
              parameter.getExpressionProperty(AbstractScalarParameter.LABEL_EXPR_PROP).getValue();
      ScriptExpression dexpr = adapter.adaptExpression(mexpr);
      addBinding(queryDefn, labelColumnName, dexpr);
    }
    org.eclipse.birt.report.model.api.Expression mexpr =
        (org.eclipse.birt.report.model.api.Expression)
            parameter.getExpressionProperty(AbstractScalarParameter.VALUE_EXPR_PROP).getValue();

    String dataType = parameter.getDataType();
    if (DesignChoiceConstants.PARAM_TYPE_STRING.equals(dataType)) {
      dataType = DesignChoiceConstants.PARAM_TYPE_JAVA_OBJECT;
    }
    ScriptExpression dexpr = adapter.adaptExpression(mexpr, dataType);
    addBinding(queryDefn, valueColumnName, dexpr);
  }
コード例 #12
0
  /**
   * Updates values in report parameter by given ROM data set parameter.
   *
   * @param reportParam the report parameter
   * @param dataSetParam the data set parameter
   * @param updateDefaultValue the flag which indicates if the default value need to be forced
   *     updated.
   * @throws SemanticException
   */
  protected void updateLinkedReportParameterFromROMParameter(
      AbstractScalarParameterHandle reportParam,
      OdaDataSetParameterHandle dataSetParam,
      boolean updateDefaultValue)
      throws SemanticException {
    assert reportParam != null;

    if (dataSetParam == null) return;

    // should not convert report parameter name here.

    Object defaultValue =
        dataSetParam.getExpressionProperty(OdaDataSetParameter.DEFAULT_VALUE_MEMBER).getValue();
    String paramName = dataSetParam.getParamName();

    if (StringUtil.isBlank(paramName)) {
      dataSetParam.setParamName(reportParam.getName());
    }
    if (updateDefaultValue) setROMDefaultValue(reportParam, defaultValue);
  }
コード例 #13
0
  /**
   * Refreshes property values of the given report parameter by the given parameter definition and
   * cached parameter definition. If values in cached parameter definition is null or values in
   * cached parameter definition are not equal to values in parameter defnition, update values in
   * given report parameter.
   *
   * @param reportParam the report parameter
   * @param paramDefn the ODA parameter definition
   * @param cachedParamDefn the cached ODA parameter definition in designerValues
   * @param dataType the updated data type
   * @param setHandle the ROM data set that has the corresponding data set parameter
   * @throws SemanticException if value in the data set design is invalid
   */
  void updateLinkedReportParameter(
      AbstractScalarParameterHandle reportParam,
      ParameterDefinition paramDefn,
      ParameterDefinition cachedParamDefn,
      OdaDataSetHandle setHandle)
      throws SemanticException {
    if (paramDefn == null) return;

    CommandStack cmdStack = reportParam.getModuleHandle().getCommandStack();
    try {
      cmdStack.startTrans(null);

      updateAbstractScalarParameter(reportParam, paramDefn, cachedParamDefn, setHandle);

    } catch (SemanticException e) {
      cmdStack.rollback();
      throw e;
    }

    cmdStack.commit();
  }
コード例 #14
0
  /**
   * Creates a ODA InputParameterAttributes with the given ROM report parameter.
   *
   * @param inputParamAttrs
   * @param paramHandle the ROM report parameter.
   * @param dataSetDesign
   * @return the created <code>InputParameterAttributes</code>.
   */
  protected InputParameterAttributes updateInputElementAttrs(
      InputParameterAttributes inputParamAttrs,
      AbstractScalarParameterHandle paramHandle,
      DataSetDesign dataSetDesign) {
    InputParameterAttributes retInputParamAttrs = inputParamAttrs;

    if (inputParamAttrs == null)
      retInputParamAttrs = designFactory.createInputParameterAttributes();

    InputElementAttributes inputAttrs = retInputParamAttrs.getElementAttributes();
    if (inputAttrs == null) inputAttrs = designFactory.createInputElementAttributes();

    // update default values.

    updateDefaultStaticValues(inputAttrs, paramHandle);

    // inputAttrs.setOptional( paramHandle.allowBlank( ) );
    inputAttrs.setOptional(getReportParamAllowMumble(paramHandle, ALLOW_BLANK_PROP_NAME));

    ScalarValueChoices staticChoices = null;
    Iterator selectionList = paramHandle.choiceIterator();
    while (selectionList.hasNext()) {
      if (staticChoices == null) staticChoices = designFactory.createScalarValueChoices();
      SelectionChoiceHandle choice = (SelectionChoiceHandle) selectionList.next();

      ScalarValueDefinition valueDefn = designFactory.createScalarValueDefinition();
      valueDefn.setValue(choice.getValue());

      String label = choice.getLabel();
      String labelKey = choice.getLabelKey();

      if (label != null || labelKey != null) {
        valueDefn.setDisplayName(label);
        valueDefn.setDisplayNameKey(labelKey);
      }

      staticChoices.getScalarValues().add(valueDefn);
    }
    inputAttrs.setStaticValueChoices(staticChoices);

    ExpressionHandle valueExpr =
        paramHandle.getExpressionProperty(IAbstractScalarParameterModel.VALUE_EXPR_PROP);
    ExpressionHandle labelExpr =
        paramHandle.getExpressionProperty(IAbstractScalarParameterModel.LABEL_EXPR_PROP);

    DynamicValuesQuery valueQuery =
        updateDynamicValueQuery(
            paramHandle.getDataSet(),
            valueExpr.getValue(),
            labelExpr.getValue(),
            dataSetDesign,
            DesignChoiceConstants.PARAM_VALUE_TYPE_DYNAMIC.equalsIgnoreCase(
                paramHandle.getValueType()));
    inputAttrs.setDynamicValueChoices(valueQuery);

    if (paramHandle.getContainer() instanceof ParameterGroupHandle) {
      ParameterGroupHandle groupHandle = (ParameterGroupHandle) paramHandle.getContainer();

      InputParameterUIHints paramUiHints = designFactory.createInputParameterUIHints();

      String text = groupHandle.getDisplayName();
      String textKey = groupHandle.getDisplayNameKey();

      if (text != null || textKey != null) {
        paramUiHints.setGroupPromptDisplayName(text);
        paramUiHints.setGroupPromptDisplayNameKey(textKey);
      }

      retInputParamAttrs.setUiHints(paramUiHints);
    }

    retInputParamAttrs.setElementAttributes(inputAttrs);
    return retInputParamAttrs;
  }
コード例 #15
0
 public static String getLabelColumnName(AbstractScalarParameterHandle parameter) {
   if (parameter.getLabelExpr() == null) {
     return null;
   }
   return LABEL_PREFIX + "_" + parameter.getName();
 }
コード例 #16
0
 public static String getValueColumnName(AbstractScalarParameterHandle parameter) {
   return VALUE_PREFIX + "_" + parameter.getName();
 }