protected InputParameterInfo mapInputParameterInfo(ReportInputParameter parameter) { InputParameterInfo inputParameterInfo = new InputParameterInfo(); inputParameterInfo.name = parameter.getName(); inputParameterInfo.alias = parameter.getAlias(); if (parameter.getType() != null) { inputParameterInfo.type = parameter.getType().toString(); } inputParameterInfo.required = Boolean.TRUE.equals(parameter.getRequired()); inputParameterInfo.hidden = Boolean.TRUE.equals(parameter.getHidden()); if (parameter.getEntityMetaClass() != null) { inputParameterInfo.entityMetaClass = parameter.getEntityMetaClass(); } if (parameter.getEnumerationClass() != null) { inputParameterInfo.enumerationClass = parameter.getEnumerationClass(); } return inputParameterInfo; }
protected boolean canHaveDefaultValue() { ReportInputParameter parameter = getItem(); if (parameter == null) { return false; } if (isParameterDateOrTime() && BooleanUtils.isTrue(parameter.getDefaultDateIsCurrent())) { return false; } ParameterType type = parameter.getType(); return type != null && type != ParameterType.ENTITY_LIST && (type != ParameterType.ENTITY || StringUtils.isNotBlank(parameter.getEntityMetaClass())) && (type != ParameterType.ENUMERATION || StringUtils.isNotBlank(parameter.getEnumerationClass())); }
@Override protected Map<String, Object> handleParameters(com.haulmont.yarg.structure.Report report, Map<String, Object> params) { Map<String, Object> handledParams = new HashMap<String, Object>(super.handleParameters(report, params)); for (ReportParameter reportParameter : report.getReportParameters()) { if (reportParameter instanceof ReportInputParameter) { ReportInputParameter reportInputParameter = (ReportInputParameter) reportParameter; String paramName = reportParameter.getAlias(); Object paramValue = handledParams.get(paramName); if (BooleanUtils.isTrue(reportInputParameter.getDefaultDateIsCurrent())) { handleDateTimeRelatedParameterAsNow(paramName, paramValue, reportInputParameter.getType(), handledParams); } if (paramValue == null) { continue; } if (reportInputParameter.getPredefinedTransformation() != null) { handledParams.put(paramName, handlePredefinedTransformation(paramValue, reportInputParameter.getPredefinedTransformation())); } else if (!Strings.isNullOrEmpty(reportInputParameter.getTransformationScript())) { handledParams.put(paramName, handleScriptTransformation(paramValue, reportInputParameter.getTransformationScript(), handledParams)); } } } return handledParams; }
@Nullable public Class resolveClass(ReportInputParameter parameter) { Class aClass = primitiveParameterTypeMapping.get(parameter.getType()); if (aClass == null) { if (parameter.getType() == ParameterType.ENTITY || parameter.getType() == ParameterType.ENTITY_LIST) { MetaClass metaClass = metadata.getSession().getClass(parameter.getEntityMetaClass()); if (metaClass != null) { return metaClass.getJavaClass(); } else { return null; } } else if (parameter.getType() == ParameterType.ENUMERATION) { if (StringUtils.isNotBlank(parameter.getEnumerationClass())) { return scripting.loadClass(parameter.getEnumerationClass()); } } } return aClass; }
for (ReportData.Parameter queryParameter : reportData.getQueryParameters()) { ReportInputParameter parameter = createParameter(report, i++); parameter.setAlias(queryParameter.name); parameter.setName(StringUtils.capitalize(queryParameter.name)); parameter.setType(queryParameter.parameterType); parameter.setParameterClass(queryParameter.javaClass); parameter.setDefaultValue(queryParameter.defaultValue); parameter.setPredefinedTransformation(queryParameter.predefinedTransformation); parameter.setHidden(queryParameter.hidden); MetaClass metaClass = metadata.getClass(queryParameter.javaClass); if (metaClass != null) { parameter.setEntityMetaClass(metaClass.getName()); parameter.setEnumerationClass(queryParameter.javaClass.getName());
public Field createField(ReportInputParameter parameter) { Field field = fieldCreationMapping.get(parameter.getType()).createField(parameter); field.setRequiredMessage(messages.formatMessage(this.getClass(), "error.paramIsRequiredButEmpty", parameter.getLocName())); field.setId("param_" + parameter.getAlias()); field.setWidth("100%"); field.setFrame(frame.getWrappedFrame()); field.setEditable(true); field.setRequired(parameter.getRequired()); return field; }
protected void initListeners() { type.addValueChangeListener(e -> enableControlsByParamType(e.getValue()) ); parameterDs.addItemPropertyChangeListener(e -> { boolean typeChanged = e.getProperty().equalsIgnoreCase("type"); boolean classChanged = e.getProperty().equalsIgnoreCase("entityMetaClass") || e.getProperty().equalsIgnoreCase("enumerationClass"); boolean defaultDateIsCurrentChanged = e.getProperty().equalsIgnoreCase("defaultDateIsCurrent"); ReportInputParameter parameter = getItem(); if (typeChanged || classChanged) { parameter.setParameterClass(parameterClassResolver.resolveClass(parameter)); if (typeChanged) { parameter.setEntityMetaClass(null); parameter.setEnumerationClass(null); } parameter.setDefaultValue(null); parameter.setScreen(null); initScreensLookup(); initDefaultValueField(); } if (defaultDateIsCurrentChanged) { initDefaultValueField(); initCurrentDateTimeField(); } ((DatasourceImplementation<ReportInputParameter>) parameterDs).modified(e.getItem()); }); }
@Override public void setItem(Entity item) { ReportInputParameter newParameter = (ReportInputParameter) metadata.create(parameterDs.getMetaClass()); metadata.getTools().copy(item, newParameter); newParameter.setId((UUID) item.getId()); if (newParameter.getParameterClass() == null) { newParameter.setParameterClass(parameterClassResolver.resolveClass(newParameter)); } super.setItem(newParameter); enableControlsByParamType(newParameter.getType()); initScreensLookup(); initTransformations(); }
@Nullable protected ReportInputParameter findParameterByAlias(String alias) { for (ReportInputParameter reportInputParameter : parametersDs.getItems()) { if (reportInputParameter.getAlias().equals(alias)) { return reportInputParameter; } } return null; }
@Override public Field createField(final ReportInputParameter parameter) { TokenList tokenList = componentsFactory.createComponent(TokenList.class); MetaClass entityMetaClass = metadata.getClassNN(parameter.getEntityMetaClass()); .setId("entities_" + parameter.getAlias()) .setMetaClass(entityMetaClass) .setViewName(View.LOCAL) tokenList.setHeight("120px"); String screen = parameter.getScreen();
reportHasMoreThanOneParameter || inputParametersRequiredByTemplates); boolean reportTypeIsSingleEntity = ParameterType.ENTITY == parameter.getType() && resultingParamValue instanceof Collection; boolean moreThanOneEntitySelected = resultingParamValue instanceof Collection && ((Collection) resultingParamValue).size() > 1; boolean bulkPrint = reportTypeIsSingleEntity && moreThanOneEntitySelected; openReportParamsDialog(screen, report, ParamsMap.of(parameter.getAlias(), resultingParamValue), parameter, templateCode, outputFileName,bulkPrint); } else { Collection selectedEntities = (Collection) resultingParamValue; if (moreThanOneEntitySelected) { bulkPrint(report, parameter.getAlias(), selectedEntities, screen); } else if (selectedEntities.size() == 1) { printReport(report, ParamsMap.of(parameter.getAlias(), selectedEntities.iterator().next()), templateCode, outputFileName, screen); printReport(report, ParamsMap.of(parameter.getAlias(), resultingParamValue), templateCode, outputFileName, screen);
protected Object prepareValue(ReportInputParameter inputParam, ParameterValueInfo paramValue) { ParameterType parameterType = inputParam.getType(); if (parameterType == ParameterType.ENTITY) { if (paramValue.value != null) { MetaClass entityClass = metadata.getClassNN(inputParam.getEntityMetaClass()); checkCanReadEntity(entityClass); Object entityId = getIdFromString(paramValue.value, entityClass); MetaClass entityClass = metadata.getClassNN(inputParam.getEntityMetaClass()); checkCanReadEntity(entityClass); List<Entity> entities = new ArrayList<>();
protected void setCurrentDateAsNow(ReportInputParameter parameter, Field dateField) { Date now = reportService.currentDateOrTime(parameter.getType()); dateField.setValue(now); parameter.setDefaultValue(reportService.convertToString(now.getClass(), now)); }
protected void initParametersListeners() { parametersDs.addCollectionChangeListener(e -> { Map<String, Object> paramAliases = new HashMap<>(); for (ReportInputParameter item : e.getDs().getItems()) { paramAliases.put(item.getName(), item.getAlias()); } entitiesParamLookup.setOptionsMap(paramAliases); entityParamLookup.setOptionsMap(paramAliases); }); }
/** * Check if the meta class is applicable for the input parameter */ public boolean parameterMatchesMetaClass(ReportInputParameter parameter, MetaClass metaClass) { if (isNotBlank(parameter.getEntityMetaClass())) { MetaClass parameterMetaClass = metadata.getClassNN(parameter.getEntityMetaClass()); return (metaClass.equals(parameterMetaClass) || metaClass.getAncestors().contains(parameterMetaClass)); } else { return false; } }
protected boolean isParameterDateOrTime() { ReportInputParameter parameter = getItem(); return Optional.ofNullable(parameter) .map(reportInputParameter -> ParameterType.DATE.equals(parameter.getType()) || ParameterType.DATETIME.equals(parameter.getType()) || ParameterType.TIME.equals(parameter.getType())) .orElse(false); } }
protected void initTransformations() { ReportInputParameter parameter = getItem(); predefinedTransformation.setValue(parameter.getPredefinedTransformation() != null); enableControlsByTransformationType(parameter.getPredefinedTransformation() != null); predefinedTransformation.addValueChangeListener(e -> { boolean hasPredefinedTransformation = e.getValue() != null && e.getValue(); enableControlsByTransformationType(hasPredefinedTransformation); if (hasPredefinedTransformation) { parameter.setTransformationScript(null); } else { parameter.setPredefinedTransformation(null); } }); predefinedTransformation.setEditable(security.isEntityOpPermitted(ReportInputParameter.class, EntityOp.UPDATE)); }
@Override public Field createField(ReportInputParameter parameter) { PickerField pickerField = componentsFactory.createComponent(PickerField.class); MetaClass entityMetaClass = metadata.getClassNN(parameter.getEntityMetaClass()); pickerField.setMetaClass(entityMetaClass); PickerField.LookupAction pickerLookupAction = pickerField.addLookupAction(); pickerField.addAction(pickerLookupAction); pickerField.addClearAction(); String parameterScreen = parameter.getScreen(); if (StringUtils.isNotEmpty(parameterScreen)) { pickerLookupAction.setLookupScreen(parameterScreen); pickerLookupAction.setLookupScreenParams(Collections.emptyMap()); } else { pickerLookupAction.setLookupScreen(COMMON_LOOKUP_SCREEN_ID); Map<String, Object> params = new HashMap<>(); params.put(CLASS_PARAMETER, entityMetaClass); if (parameter.getReport().getReportType() == ReportType.SIMPLE) { WindowParams.MULTI_SELECT.set(params, false); } pickerLookupAction.setLookupScreenParams(params); } return pickerField; } }
field.setWidth("400px"); Object value = parameters.get(parameter.getAlias()); if (value == null && parameter.getDefaultValue() != null) { Class parameterClass = parameterClassResolver.resolveClass(parameter); if (parameterClass != null) { value = reportService.convertFromString(parameterClass, parameter.getDefaultValue()); if (BooleanUtils.isTrue(parameter.getValidationOn())) { field.addValidator(new ReportParamFieldValidator(parameter)); field.setVisible(visible); parameterComponents.put(parameter.getAlias(), field); parametersGrid.add(label, 0, currentGridRow); parametersGrid.add(field, 1, currentGridRow);
protected void initDefaultValueField() { defaultValueLabel.setVisible(false); defaultValueBox.removeAll(); ReportInputParameter parameter = getItem(); if (canHaveDefaultValue()) { Field<Object> field = parameterFieldCreator.createField(parameter); field.addValueChangeListener(e -> { if (e.getValue() != null) { parameter.setDefaultValue(reportService.convertToString(e.getValue().getClass(), e.getValue())); } else { parameter.setDefaultValue(null); } }); if (parameter.getParameterClass() != null) { field.setValue(reportService.convertFromString(parameter.getParameterClass(), parameter.getDefaultValue())); } field.setRequired(false); defaultValueBox.add(field); defaultValueLabel.setVisible(true); } defaultValueBox.setEnabled(security.isEntityOpPermitted(metadata.getClassNN(ReportInputParameter.class), EntityOp.UPDATE)); }