Examples with ExpressionIdentifier org.drools.scenariosimulation.api.model.ExpressionIdentifier used on opensource projects

Example 6 with ExpressionIdentifier

use of org.drools.scenariosimulation.api.model.ExpressionIdentifier in project drools-wb by kiegroup.

the class AbstractScenarioSimulationTest method setup.

@Before
public void setup() {
    settingsLocal = new Settings();
    backgroundLocal = new Background();
    scenarioWithIndexLocal = new ArrayList<>();
    scenarioGridWidgetSpy = spy(new ScenarioGridWidget() {

        {
            this.scenarioGridPanel = scenarioGridPanelMock;
        }
    });
    backgroundGridWidgetSpy = spy(new ScenarioGridWidget() {

        {
            this.scenarioGridPanel = backgroundGridPanelMock;
        }
    });
    when(simulationMock.getScesimModelDescriptor()).thenReturn(simulationDescriptorMock);
    when(simulationMock.getScenarioWithIndex()).thenReturn(scenarioWithIndexLocal);
    when(backgroundMock.getScesimModelDescriptor()).thenReturn(simulationDescriptorMock);
    when(simulationRunResultMock.getScenarioWithIndex()).thenReturn(scenarioWithIndexLocal);
    GridData.Range range = new GridData.Range(FIRST_INDEX_LEFT, FIRST_INDEX_RIGHT - 1);
    collectionEditorSingletonDOMElementFactoryTest = new CollectionEditorSingletonDOMElementFactory(scenarioGridPanelMock, scenarioGridLayerMock, scenarioGridMock, scenarioSimulationContextLocal, viewsProviderMock);
    scenarioCellTextAreaSingletonDOMElementFactorySpy = spy(new ScenarioCellTextAreaSingletonDOMElementFactory(scenarioGridPanelMock, scenarioGridLayerMock, scenarioGridMock));
    scenarioHeaderTextBoxSingletonDOMElementFactorySpy = spy(new ScenarioHeaderTextBoxSingletonDOMElementFactory(scenarioGridPanelMock, scenarioGridLayerMock, scenarioGridMock));
    scenarioExpressionCellTextAreaSingletonDOMElementFactorySpy = spy(new ScenarioExpressionCellTextAreaSingletonDOMElementFactory(scenarioGridPanelMock, scenarioGridLayerMock, scenarioGridMock));
    scenarioGridModelMock = spy(new ScenarioGridModel(false) {

        {
            this.abstractScesimModel = simulationMock;
            this.columns = gridColumns;
            this.rows = rowsMock;
            this.collectionEditorSingletonDOMElementFactory = collectionEditorSingletonDOMElementFactoryTest;
            this.scenarioCellTextAreaSingletonDOMElementFactory = scenarioCellTextAreaSingletonDOMElementFactorySpy;
            this.scenarioHeaderTextBoxSingletonDOMElementFactory = scenarioHeaderTextBoxSingletonDOMElementFactorySpy;
            this.scenarioExpressionCellTextAreaSingletonDOMElementFactory = scenarioExpressionCellTextAreaSingletonDOMElementFactorySpy;
            this.eventBus = eventBusMock;
        }

        @Override
        protected void commonAddColumn(int index, GridColumn<?> column) {
        // 
        }

        @Override
        protected void commonAddColumn(final int index, final GridColumn<?> column, ExpressionIdentifier ei) {
        // 
        }

        @Override
        protected void commonAddRow(int rowIndex) {
        // 
        }

        @Override
        public List<GridColumn<?>> getColumns() {
            return columns;
        }

        @Override
        public Range getInstanceLimits(int columnIndex) {
            return range;
        }

        @Override
        public int getFirstIndexLeftOfGroup(String groupName) {
            return FIRST_INDEX_LEFT;
        }

        @Override
        public int getFirstIndexRightOfGroup(String groupName) {
            return FIRST_INDEX_RIGHT;
        }

        @Override
        public GridColumn<?> getSelectedColumn() {
            return gridColumnMock;
        }

        @Override
        public void deleteColumn(final GridColumn<?> column) {
        // 
        }

        @Override
        public Range deleteRow(int rowIndex) {
            return range;
        }

        @Override
        public void insertRowGridOnly(final int rowIndex, final GridRow row, final Scenario scenario) {
        // 
        }

        @Override
        public void insertRow(int rowIndex, GridRow row) {
        }

        @Override
        public List<GridRow> getRows() {
            return rowsMock;
        }

        @Override
        public Range setCellValue(int rowIndex, int columnIndex, GridCellValue<?> value) {
            return range;
        }

        @Override
        public void validateInstanceHeaderUpdate(String instanceHeaderCellValue, int columnIndex, boolean isADataType) {
        // 
        }

        @Override
        public void validatePropertyHeaderUpdate(String propertyHeaderCellValue, int columnIndex, boolean isPropertyType) {
        // 
        }
    });
    when(scenarioGridMock.getEventBus()).thenReturn(eventBusMock);
    when(scenarioGridMock.getModel()).thenReturn(scenarioGridModelMock);
    when(scenarioGridMock.getLayer()).thenReturn(scenarioGridLayerMock);
    when(scenarioGridMock.getType()).thenReturn(ScenarioSimulationModel.Type.RULE);
    when(scenarioGridMock.getGridWidget()).thenReturn(GridWidget.SIMULATION);
    when(scenarioGridLayerMock.getScenarioGrid()).thenReturn(scenarioGridMock);
    when(scenarioGridPanelMock.getScenarioGridLayer()).thenReturn(scenarioGridLayerMock);
    when(scenarioGridPanelMock.getScenarioGrid()).thenReturn(scenarioGridMock);
    when(backgroundGridMock.getEventBus()).thenReturn(eventBusMock);
    when(backgroundGridMock.getModel()).thenReturn(backgroundGridModelMock);
    when(backgroundGridMock.getLayer()).thenReturn(backgroundGridLayerMock);
    when(backgroundGridMock.getType()).thenReturn(ScenarioSimulationModel.Type.RULE);
    when(backgroundGridMock.getGridWidget()).thenReturn(GridWidget.BACKGROUND);
    when(backgroundGridModelMock.getGridWidget()).thenReturn(GridWidget.BACKGROUND);
    when(backgroundGridLayerMock.getScenarioGrid()).thenReturn(backgroundGridMock);
    when(backgroundGridPanelMock.getScenarioGridLayer()).thenReturn(backgroundGridLayerMock);
    when(backgroundGridPanelMock.getScenarioGrid()).thenReturn(backgroundGridMock);
    final Point2D computedLocation = mock(Point2D.class);
    when(computedLocation.getX()).thenReturn(0.0);
    when(computedLocation.getY()).thenReturn(0.0);
    when(scenarioGridMock.getComputedLocation()).thenReturn(computedLocation);
    scenarioSimulationContextLocal = new ScenarioSimulationContext(scenarioGridWidgetSpy, backgroundGridWidgetSpy);
    scenarioSimulationContextLocal.setScenarioSimulationEditorPresenter(scenarioSimulationEditorPresenterMock);
    scenarioSimulationContextLocal.getStatus().setSimulation(simulationMock);
    scenarioSimulationContextLocal.getStatus().setBackground(backgroundMock);
    scenarioSimulationContextLocal.getStatus().setFullPackage(FULL_PACKAGE);
    scenarioSimulationContextLocal.setScenarioSimulationEditorPresenter(scenarioSimulationEditorPresenterMock);
    scenarioSimulationContextLocal.setDataObjectFieldsMap(dataObjectFieldsMapMock);
    when(backgroundGridWidgetSpy.getScenarioSimulationContext()).thenReturn(scenarioSimulationContextLocal);
    when(scenarioGridWidgetSpy.getScenarioSimulationContext()).thenReturn(scenarioSimulationContextLocal);
    when(scenarioSimulationEditorPresenterMock.getView()).thenReturn(scenarioSimulationViewMock);
    when(scenarioSimulationEditorPresenterMock.getModel()).thenReturn(scenarioSimulationModelMock);
    scenarioSimulationContextLocal.setScenarioSimulationEditorPresenter(scenarioSimulationEditorPresenterMock);
    when(scenarioSimulationEditorPresenterMock.getDataManagementStrategy()).thenReturn(dataManagementStrategyMock);
    when(scenarioSimulationEditorPresenterMock.getContext()).thenReturn(scenarioSimulationContextLocal);
    when(simulationMock.cloneModel()).thenReturn(clonedSimulationMock);
    when(backgroundMock.cloneModel()).thenReturn(clonedBackgroundMock);
    scenarioSimulationContextLocal.getStatus().setSimulation(simulationMock);
    when(scenarioSimulationModelMock.getSimulation()).thenReturn(simulationMock);
    when(scenarioSimulationModelMock.getBackground()).thenReturn(backgroundMock);
    when(scenarioSimulationModelMock.getSettings()).thenReturn(settingsLocal);
    when(scenarioCommandRegistryManagerMock.undo(scenarioSimulationContextLocal)).thenReturn(CommandResultBuilder.SUCCESS);
    when(scenarioCommandRegistryManagerMock.redo(scenarioSimulationContextLocal)).thenReturn(CommandResultBuilder.SUCCESS);
    appendRowCommandMock = spy(new AppendRowCommand(GridWidget.SIMULATION) {

        {
            this.restorableStatus = scenarioSimulationContextLocal.getStatus();
        }

        @Override
        public CommandResult<ScenarioSimulationViolation> execute(ScenarioSimulationContext context) {
            return CommandResultBuilder.SUCCESS;
        }

        @Override
        public CommandResult<ScenarioSimulationViolation> undo(ScenarioSimulationContext context) {
            return CommandResultBuilder.SUCCESS;
        }
    });
    when(informationHeaderMetaDataMock.getTitle()).thenReturn(MULTIPART_VALUE);
    when(informationHeaderMetaDataMock.getColumnGroup()).thenReturn(COLUMN_GROUP);
    when(propertyHeaderMetaDataMock.getMetadataType()).thenReturn(ScenarioHeaderMetaData.MetadataType.PROPERTY);
    when(propertyHeaderMetaDataMock.getTitle()).thenReturn(GRID_PROPERTY_TITLE);
    when(propertyHeaderMetaDataMock.getColumnGroup()).thenReturn(GRID_COLUMN_GROUP);
    when(propertyHeaderMetaDataMock.getColumnId()).thenReturn(GRID_COLUMN_ID);
    when(headerMetaDatasMock.get(anyInt())).thenReturn(informationHeaderMetaDataMock);
    when(gridColumnMock.getHeaderMetaData()).thenReturn(headerMetaDatasMock);
    when(gridColumnMock.getInformationHeaderMetaData()).thenReturn(informationHeaderMetaDataMock);
    when(gridColumnMock.getPropertyHeaderMetaData()).thenReturn(propertyHeaderMetaDataMock);
    when(gridColumnMock.getFactIdentifier()).thenReturn(factIdentifierMock);
    settingsLocal.setType(ScenarioSimulationModel.Type.RULE);
    IntStream.range(0, COLUMN_NUMBER).forEach(columnIndex -> {
        gridColumns.add(gridColumnMock);
        factMappingValuesLocal.add(factMappingValueMock);
        factIdentifierSet.add(factIdentifierMock);
        factMappingLocal.add(factMappingMock);
        when(simulationDescriptorMock.getFactMappingByIndex(columnIndex)).thenReturn(factMappingMock);
    });
    when(factIdentifierMock.getClassNameWithoutPackage()).thenReturn(CLASS_NAME);
    when(factIdentifierMock.getPackageWithoutClassName()).thenReturn(FULL_PACKAGE);
    when(factIdentifierMock.getClassName()).thenReturn(FULL_CLASS_NAME);
    when(factIdentifierMock.getName()).thenReturn(FACT_IDENTIFIER_NAME);
    when(simulationDescriptorMock.getFactIdentifiers()).thenReturn(factIdentifierSet);
    when(simulationDescriptorMock.getUnmodifiableFactMappings()).thenReturn(factMappingLocal);
    when(simulationDescriptorMock.getFactMappingsByFactName(anyString())).thenReturn(Stream.empty());
    when(scenarioGridModelMock.nextColumnCount()).thenReturn(factMappingValuesLocal.size());
    when(factMappingMock.getFactIdentifier()).thenReturn(factIdentifierMock);
    when(factMappingMock.getFactAlias()).thenReturn(FACT_ALIAS);
    when(factMappingMock.getGenericTypes()).thenReturn(new ArrayList<>());
    doReturn(factMappingMock).when(simulationDescriptorMock).addFactMapping(anyInt(), anyString(), anyObject(), anyObject());
    when(scenarioSimulationViewMock.getScenarioGridWidget()).thenReturn(scenarioGridWidgetSpy);
}

Example 7 with ExpressionIdentifier

use of org.drools.scenariosimulation.api.model.ExpressionIdentifier in project drools-wb by kiegroup.

the class AbstractScesimGridModel method setCell.

/**
 * This method <i>set</i> a cell value to the grid <b>and</b> to the underlying model
 * @param rowIndex
 * @param columnIndex
 * @param cellSupplier
 */
@Override
public Range setCell(int rowIndex, int columnIndex, Supplier<GridCell<?>> cellSupplier) {
    checkSimulation();
    Range toReturn = super.setCell(rowIndex, columnIndex, cellSupplier);
    try {
        Optional<?> optionalValue = getCellValue(getCell(rowIndex, columnIndex));
        Object rawValue = optionalValue.orElse(null);
        String cellValue = (rawValue instanceof String) ? (String) rawValue : null;
        E scenarioByIndex = abstractScesimModel.getDataByIndex(rowIndex);
        FactMapping factMappingByIndex = abstractScesimModel.getScesimModelDescriptor().getFactMappingByIndex(columnIndex);
        FactIdentifier factIdentifier = factMappingByIndex.getFactIdentifier();
        ExpressionIdentifier expressionIdentifier = factMappingByIndex.getExpressionIdentifier();
        scenarioByIndex.addOrUpdateMappingValue(factIdentifier, expressionIdentifier, cellValue);
    } catch (Exception e) {
        toReturn = super.deleteCell(rowIndex, columnIndex);
        eventBus.fireEvent(new ScenarioGridReloadEvent(getGridWidget()));
    }
    return toReturn;
}

Example 8 with ExpressionIdentifier

use of org.drools.scenariosimulation.api.model.ExpressionIdentifier in project drools-wb by kiegroup.

the class SimulationSettingsCreationStrategy method createEmptyColumn.

/**
 * Create an empty column using factMappingType defined. The new column will be added as last column of
 * the group (GIVEN/EXPECT) (see findLastIndexOfGroup)
 *
 * @param simulationDescriptor
 * @param scesimDataWithIndex
 * @param placeholderId
 * @param factMappingType
 * @param columnIndex
 */
default void createEmptyColumn(ScesimModelDescriptor simulationDescriptor, ScesimDataWithIndex scesimDataWithIndex, int placeholderId, FactMappingType factMappingType, int columnIndex) {
    int row = scesimDataWithIndex.getIndex();
    final ExpressionIdentifier expressionIdentifier = ExpressionIdentifier.create(row + "|" + placeholderId, factMappingType);
    final FactMapping factMapping = simulationDescriptor.addFactMapping(columnIndex, FactMapping.getInstancePlaceHolder(placeholderId), FactIdentifier.EMPTY, expressionIdentifier);
    factMapping.setExpressionAlias(FactMapping.getPropertyPlaceHolder(placeholderId));
    scesimDataWithIndex.getScesimData().addMappingValue(FactIdentifier.EMPTY, expressionIdentifier, null);
}

Example 9 with ExpressionIdentifier

use of org.drools.scenariosimulation.api.model.ExpressionIdentifier in project drools-wb by kiegroup.

the class AbstractScenarioSimulationEditorTest method getSimulation.

protected Simulation getSimulation() {
    Simulation toReturn = new Simulation();
    ScesimModelDescriptor simulationDescriptor = toReturn.getScesimModelDescriptor();
    simulationDescriptor.addFactMapping(FactIdentifier.INDEX.getName(), FactIdentifier.INDEX, ExpressionIdentifier.INDEX);
    simulationDescriptor.addFactMapping(FactIdentifier.DESCRIPTION.getName(), FactIdentifier.DESCRIPTION, ExpressionIdentifier.DESCRIPTION);
    Scenario scenario = toReturn.addData();
    int row = toReturn.getUnmodifiableData().indexOf(scenario);
    scenario.setDescription(null);
    // Add GIVEN Fact
    int id = 1;
    ExpressionIdentifier givenExpression = ExpressionIdentifier.create(row + "|" + id, FactMappingType.GIVEN);
    final FactMapping givenFactMapping = simulationDescriptor.addFactMapping(FactMapping.getInstancePlaceHolder(id), FactIdentifier.EMPTY, givenExpression);
    givenFactMapping.setExpressionAlias(FactMapping.getPropertyPlaceHolder(id));
    scenario.addMappingValue(FactIdentifier.EMPTY, givenExpression, null);
    // Add EXPECT Fact
    id = 2;
    ExpressionIdentifier expectedExpression = ExpressionIdentifier.create(row + "|" + id, FactMappingType.EXPECT);
    final FactMapping expectedFactMapping = simulationDescriptor.addFactMapping(FactMapping.getInstancePlaceHolder(id), FactIdentifier.EMPTY, expectedExpression);
    expectedFactMapping.setExpressionAlias(FactMapping.getPropertyPlaceHolder(id));
    scenario.addMappingValue(FactIdentifier.EMPTY, expectedExpression, null);
    return toReturn;
}

Example 10 with ExpressionIdentifier

use of org.drools.scenariosimulation.api.model.ExpressionIdentifier in project drools by kiegroup.

the class AbstractRunnerHelper method getParamsForBean.

protected Map<List<String>, Object> getParamsForBean(ScesimModelDescriptor scesimModelDescriptor, FactIdentifier factIdentifier, List<FactMappingValue> factMappingValues, ExpressionEvaluatorFactory expressionEvaluatorFactory) {
    Map<List<String>, Object> paramsForBean = new HashMap<>();
    boolean hasError = false;
    for (FactMappingValue factMappingValue : factMappingValues) {
        ExpressionIdentifier expressionIdentifier = factMappingValue.getExpressionIdentifier();
        FactMapping factMapping = scesimModelDescriptor.getFactMapping(factIdentifier, expressionIdentifier).orElseThrow(() -> new IllegalStateException("Wrong expression, this should not happen"));
        List<String> pathToField = factMapping.getExpressionElementsWithoutClass().stream().map(ExpressionElement::getStep).collect(toList());
        ExpressionEvaluator expressionEvaluator = expressionEvaluatorFactory.getOrCreate(factMappingValue);
        try {
            Object value = expressionEvaluator.evaluateLiteralExpression((String) factMappingValue.getRawValue(), factMapping.getClassName(), factMapping.getGenericTypes());
            paramsForBean.put(pathToField, value);
        } catch (RuntimeException e) {
            factMappingValue.setExceptionMessage(e.getMessage());
            hasError = true;
        }
    }
    if (hasError) {
        throw new ScenarioException("Error in one or more input values");
    }
    return paramsForBean;
}