Move REST lookup support to Scout
diff --git a/eclipse-scout-core/src/index.js b/eclipse-scout-core/src/index.js
index 891e156..1a3c1d3 100644
--- a/eclipse-scout-core/src/index.js
+++ b/eclipse-scout-core/src/index.js
@@ -62,6 +62,7 @@
export {default as AjaxError} from './ajax/AjaxError';
export {default as LookupCall} from './lookup/LookupCall';
export {default as LookupRow} from './lookup/LookupRow';
+export {default as RestLookupCall} from './lookup/RestLookupCall';
export {default as RemoteLookupCall} from './lookup/RemoteLookupCall';
export {default as RemoteLookupRequest} from './lookup/RemoteLookupRequest';
export {default as QueryBy} from './lookup/QueryBy';
diff --git a/eclipse-scout-core/src/lookup/RestLookupCall.js b/eclipse-scout-core/src/lookup/RestLookupCall.js
new file mode 100644
index 0000000..b176426
--- /dev/null
+++ b/eclipse-scout-core/src/lookup/RestLookupCall.js
@@ -0,0 +1,164 @@
+/*
+ * Copyright (c) 2010-2020 BSI Business Systems Integration AG.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * BSI Business Systems Integration AG - initial API and implementation
+ */
+import {arrays, LookupCall, scout} from '../index';
+import $ from 'jquery';
+
+export default class RestLookupCall extends LookupCall {
+
+ constructor() {
+ super();
+ this.resourceUrl = null;
+ this.maxTextLength = null;
+
+ // for predefined restrictions only (e.g. in JSON or sub-classes), don't change this attribute! this instance is shared with all clones!
+ this.restriction = null;
+
+ // dynamically added restrictions. after setting this attribute, this instance is shared with all following clones!
+ this._restriction = null;
+
+ this._ajaxCall = null;
+ this._deferred = null;
+
+ // RestLookupCall implements getByKeys
+ this.batch = true;
+ }
+
+ /**
+ * Use this function with caution! Added restrictions will be shared among cloned instances
+ * and the current instance if this function was also called before cloning!
+ */
+ addRestriction(key, value) {
+ if (!this._restriction) {
+ this._restriction = {};
+ }
+ this._restriction[key] = value;
+ }
+
+ _getAll() {
+ return this._call();
+ }
+
+ _getByText(text) {
+ this.addRestriction('text', text);
+ return this._call();
+ }
+
+ _getByKey(key) {
+ this.addRestriction('ids', arrays.ensure(key));
+ return this._call();
+ }
+
+ _getByKeys(keys) {
+ this.addRestriction('ids', arrays.ensure(keys));
+ return this._call();
+ }
+
+ cloneForAll() {
+ let clone = super.cloneForAll();
+ clone.addRestriction('active', true);
+ return clone;
+ }
+
+ cloneForText(text) {
+ let clone = super.cloneForText(text);
+ clone.addRestriction('active', true);
+ return clone;
+ }
+
+ _acceptLookupRow(lookupRowDo) {
+ return true;
+ }
+
+ _createLookupRowFromDo(lookupRowDo) {
+ // propagate all properties from lookup row do to scout lookup row (there might be custom ones on specific lookup row dos)
+ let clonedLookupRowDo = $.extend({}, lookupRowDo);
+ // text, enabled and active are the same for Scout LookupRow and Studio LookupRowDo
+
+ // id -> key
+ clonedLookupRowDo.key = clonedLookupRowDo.id;
+ delete clonedLookupRowDo.id;
+
+ // parentId -> parentKey
+ clonedLookupRowDo.parentKey = clonedLookupRowDo.parentId;
+ delete clonedLookupRowDo.parentId;
+
+ // unused on Scout LookupRow
+ delete clonedLookupRowDo._type;
+
+ if (this.maxTextLength) {
+ let text = clonedLookupRowDo.text;
+ if (text.length > this.maxTextLength) {
+ clonedLookupRowDo.text = text.substr(0, this.maxTextLength) + '...';
+ clonedLookupRowDo.tooltipText = text;
+ }
+ }
+
+ return scout.create('LookupRow', clonedLookupRowDo);
+ }
+
+ _call() {
+ this._deferred = $.Deferred();
+ this._ajaxCall = this._createAjaxCall();
+
+ this._ajaxCall.call()
+ .then((data, textStatus, jqXHR) => {
+ let lookupRows = arrays.ensure(data ? data.rows : null)
+ .filter(this._acceptLookupRow.bind(this))
+ .map(this._createLookupRowFromDo.bind(this));
+ this._deferred.resolve({
+ queryBy: this.queryBy,
+ text: this.searchText,
+ key: this.key,
+ lookupRows: lookupRows
+ });
+ })
+ .catch(ajaxError => {
+ this._deferred.resolve({
+ queryBy: this.queryBy,
+ text: this.searchText,
+ key: this.key,
+ lookupRows: [],
+ exception: this.session.text('ErrorWhileLoadingData')
+ });
+ });
+
+ return this._deferred.promise();
+ }
+
+ abort() {
+ this._deferred.reject({
+ canceled: true
+ });
+ this._ajaxCall.abort();
+ super.abort();
+ }
+
+ _createAjaxCall() {
+ let url = this.resourceUrl;
+ let data = this.restriction || this._restriction ? JSON.stringify($.extend({}, this.restriction, this._restriction)) : null;
+ let ajaxOptions = {
+ type: 'POST',
+ data: data,
+ dataType: 'json',
+ contentType: 'application/json; charset=UTF-8',
+ cache: false,
+ url: url,
+ timeout: 0
+ };
+ return scout.create('AjaxCall', {
+ ajaxOptions: ajaxOptions,
+ name: 'RestLookupCall',
+ retryIntervals: [100, 500, 500, 500]
+ }, {
+ ensureUniqueId: false
+ });
+ }
+}
diff --git a/license_files/scoutLicenceHeaderJava.xml b/license_files/scoutLicenceHeaderJava.xml
index 7dd3858..c664d7c 100644
--- a/license_files/scoutLicenceHeaderJava.xml
+++ b/license_files/scoutLicenceHeaderJava.xml
@@ -13,7 +13,7 @@
-->
<additionalHeaders>
<scout_javadoc_style>
- <firstLine>/*******************************************************************************</firstLine>
+ <firstLine>/*</firstLine>
<beforeEachLine> * </beforeEachLine>
<endLine> */</endLine>
<!-- <afterEachLine></afterEachLine> -->
diff --git a/org.eclipse.scout.rt.client.test/org.eclipse.scout.rt.client.test.iml b/org.eclipse.scout.rt.client.test/org.eclipse.scout.rt.client.test.iml
index 1388edf..10f2155 100644
--- a/org.eclipse.scout.rt.client.test/org.eclipse.scout.rt.client.test.iml
+++ b/org.eclipse.scout.rt.client.test/org.eclipse.scout.rt.client.test.iml
@@ -19,7 +19,6 @@
<orderEntry type="library" name="Maven: org.quartz-scheduler:quartz:2.3.2" level="project" />
<orderEntry type="module" module-name="org.eclipse.scout.rt.shared" />
<orderEntry type="module" module-name="org.eclipse.scout.rt.security" />
- <orderEntry type="module" module-name="org.eclipse.scout.rt.dataobject" />
<orderEntry type="library" name="Maven: com.google.http-client:google-http-client:1.34.2" level="project" />
<orderEntry type="library" name="Maven: org.apache.httpcomponents:httpcore:4.4.13" level="project" />
<orderEntry type="library" name="Maven: com.google.code.findbugs:jsr305:3.0.2" level="project" />
@@ -37,13 +36,20 @@
<orderEntry type="library" name="Maven: org.slf4j:jcl-over-slf4j:1.7.25" level="project" />
<orderEntry type="module" module-name="org.eclipse.scout.rt.shared.test" />
<orderEntry type="module" module-name="org.eclipse.scout.rt.platform.test" />
+ <orderEntry type="library" name="Maven: org.apache.commons:commons-math3:3.6.1" level="project" />
+ <orderEntry type="module" module-name="org.eclipse.scout.rt.dataobject.test" scope="TEST" />
+ <orderEntry type="module" module-name="org.eclipse.scout.rt.dataobject" />
<orderEntry type="library" name="Maven: junit:junit:4.12" level="project" />
<orderEntry type="library" name="Maven: org.hamcrest:hamcrest-core:1.3" level="project" />
<orderEntry type="library" name="Maven: org.mockito:mockito-core:2.23.4" level="project" />
<orderEntry type="library" name="Maven: net.bytebuddy:byte-buddy:1.9.3" level="project" />
<orderEntry type="library" name="Maven: net.bytebuddy:byte-buddy-agent:1.9.3" level="project" />
<orderEntry type="library" name="Maven: org.objenesis:objenesis:2.6" level="project" />
- <orderEntry type="library" name="Maven: org.apache.commons:commons-math3:3.6.1" level="project" />
+ <orderEntry type="module" module-name="org.eclipse.scout.rt.jackson.test" scope="TEST" />
+ <orderEntry type="module" module-name="org.eclipse.scout.rt.jackson" scope="TEST" />
+ <orderEntry type="library" scope="TEST" name="Maven: com.fasterxml.jackson.core:jackson-databind:2.9.10.3" level="project" />
+ <orderEntry type="library" scope="TEST" name="Maven: com.fasterxml.jackson.core:jackson-annotations:2.9.10" level="project" />
+ <orderEntry type="library" scope="TEST" name="Maven: com.fasterxml.jackson.core:jackson-core:2.9.10" level="project" />
<orderEntry type="library" scope="TEST" name="Maven: ch.qos.logback:logback-classic:1.2.3" level="project" />
<orderEntry type="library" scope="TEST" name="Maven: ch.qos.logback:logback-core:1.2.3" level="project" />
<orderEntry type="library" name="Maven: org.slf4j:slf4j-api:1.7.25" level="project" />
diff --git a/org.eclipse.scout.rt.client.test/pom.xml b/org.eclipse.scout.rt.client.test/pom.xml
index 46df4b1..8055eb1 100644
--- a/org.eclipse.scout.rt.client.test/pom.xml
+++ b/org.eclipse.scout.rt.client.test/pom.xml
@@ -43,6 +43,16 @@
</dependency>
<dependency>
+ <groupId>org.eclipse.scout.rt</groupId>
+ <artifactId>org.eclipse.scout.rt.dataobject.test</artifactId>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.eclipse.scout.rt</groupId>
+ <artifactId>org.eclipse.scout.rt.jackson.test</artifactId>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
<groupId>ch.qos.logback</groupId>
<artifactId>logback-classic</artifactId>
<scope>test</scope>
diff --git a/org.eclipse.scout.rt.client.test/src/test/java/org/eclipse/scout/rt/client/services/lookup/AbstractRestLookupCallTest.java b/org.eclipse.scout.rt.client.test/src/test/java/org/eclipse/scout/rt/client/services/lookup/AbstractRestLookupCallTest.java
new file mode 100644
index 0000000..7dde902
--- /dev/null
+++ b/org.eclipse.scout.rt.client.test/src/test/java/org/eclipse/scout/rt/client/services/lookup/AbstractRestLookupCallTest.java
@@ -0,0 +1,98 @@
+/*
+ * Copyright (c) 2010-2020 BSI Business Systems Integration AG.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * BSI Business Systems Integration AG - initial API and implementation
+ */
+package org.eclipse.scout.rt.client.services.lookup;
+
+import static org.junit.Assert.*;
+import java.util.function.Function;
+
+import org.eclipse.scout.rt.dataobject.fixture.FixtureUuId;
+import org.eclipse.scout.rt.dataobject.lookup.AbstractLookupRowDo;
+import org.eclipse.scout.rt.dataobject.lookup.LookupResponse;
+import org.eclipse.scout.rt.platform.IgnoreBean;
+import org.eclipse.scout.rt.platform.util.TriState;
+import org.eclipse.scout.rt.testing.platform.runner.PlatformTestRunner;
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+@RunWith(PlatformTestRunner.class)
+public class AbstractRestLookupCallTest {
+
+ public static final FixtureUuId TEST_SETTING_ID_1 = FixtureUuId.of("06469416-545c-449b-8440-4acffcf69063");
+ public static final FixtureUuId TEST_SETTING_ID_2 = FixtureUuId.of("0768a234-bbaf-47fa-a174-f25a92855f20");
+
+ @Test
+ public void testClone() {
+ P_FixtureUuIdLookupCall call = new P_FixtureUuIdLookupCall();
+ call.setText("ABC");
+ P_FixtureUuIdLookupCall call2 = (P_FixtureUuIdLookupCall) call.copy();
+ assertNotSame(call, call2);
+ assertNotSame(call.getRestriction(), call2.getRestriction());
+ Assert.assertEquals("ABC", call2.getText());
+ }
+
+ @Test
+ public void testSetters() {
+ P_FixtureUuIdLookupCall call = new P_FixtureUuIdLookupCall();
+
+ call.setText("ABC");
+ Assert.assertEquals("ABC", call.getText());
+
+ call.setKey(TEST_SETTING_ID_1);
+ Assert.assertEquals(1, call.getKeys().size());
+ Assert.assertEquals(TEST_SETTING_ID_1, call.getKey());
+
+ call.setKey(TEST_SETTING_ID_2);
+ Assert.assertEquals(1, call.getKeys().size());
+ Assert.assertEquals(TEST_SETTING_ID_2, call.getKey());
+
+ call.setKeys(TEST_SETTING_ID_1, TEST_SETTING_ID_2);
+ Assert.assertEquals(2, call.getKeys().size());
+ Assert.assertEquals(TEST_SETTING_ID_1, call.getKey());
+
+ call.setKey(TEST_SETTING_ID_2);
+ Assert.assertEquals(1, call.getKeys().size());
+ Assert.assertEquals(TEST_SETTING_ID_2, call.getKey());
+
+ call.setKey(null);
+ assertNull(call.getKey());
+ Assert.assertEquals(0, call.getKeys().size());
+
+ assertFalse(call.getRestriction().active().exists());
+ call.setActive(null);
+ Assert.assertEquals(TriState.UNDEFINED, call.getActive());
+ assertTrue(call.getRestriction().active().exists());
+ assertNull(call.getRestriction().active().get());
+ call.setActive(TriState.TRUE);
+ Assert.assertEquals(TriState.TRUE, call.getActive());
+ assertTrue(call.getRestriction().active().exists());
+ Assert.assertEquals(Boolean.TRUE, call.getRestriction().active().get());
+ call.setActive(TriState.FALSE);
+ Assert.assertEquals(TriState.FALSE, call.getActive());
+ assertTrue(call.getRestriction().active().exists());
+ Assert.assertEquals(Boolean.FALSE, call.getRestriction().active().get());
+ call.setActive(TriState.UNDEFINED);
+ Assert.assertEquals(TriState.UNDEFINED, call.getActive());
+ assertTrue(call.getRestriction().active().exists());
+ assertNull(call.getRestriction().active().get());
+ }
+
+ @IgnoreBean
+ static class P_FixtureUuIdLookupCall extends AbstractRestLookupCall<FixtureUuIdLookupRestrictionDo, FixtureUuId> {
+ private static final long serialVersionUID = 1L;
+
+ @Override
+ protected Function<FixtureUuIdLookupRestrictionDo, LookupResponse<? extends AbstractLookupRowDo<?, FixtureUuId>>> remoteCall() {
+ // Not used in this test
+ return null;
+ }
+ }
+}
diff --git a/org.eclipse.scout.rt.client.test/src/test/java/org/eclipse/scout/rt/client/services/lookup/FixtureUuIdLookupRestrictionDo.java b/org.eclipse.scout.rt.client.test/src/test/java/org/eclipse/scout/rt/client/services/lookup/FixtureUuIdLookupRestrictionDo.java
new file mode 100644
index 0000000..1683475
--- /dev/null
+++ b/org.eclipse.scout.rt.client.test/src/test/java/org/eclipse/scout/rt/client/services/lookup/FixtureUuIdLookupRestrictionDo.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2010-2020 BSI Business Systems Integration AG.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * BSI Business Systems Integration AG - initial API and implementation
+ */
+package org.eclipse.scout.rt.client.services.lookup;
+
+import org.eclipse.scout.rt.dataobject.DoList;
+import org.eclipse.scout.rt.dataobject.TypeName;
+import org.eclipse.scout.rt.dataobject.fixture.FixtureUuId;
+import org.eclipse.scout.rt.dataobject.lookup.AbstractLookupRestrictionDo;
+
+@TypeName("scout.FixtureUuIdLookupRestriction")
+public class FixtureUuIdLookupRestrictionDo extends AbstractLookupRestrictionDo<FixtureUuIdLookupRestrictionDo, FixtureUuId> {
+
+ @Override
+ public DoList<FixtureUuId> ids() {
+ return createIdsAttribute(this);
+ }
+}
diff --git a/org.eclipse.scout.rt.client.test/src/test/java/org/eclipse/scout/rt/client/services/lookup/FixtureUuIdLookupRowDo.java b/org.eclipse.scout.rt.client.test/src/test/java/org/eclipse/scout/rt/client/services/lookup/FixtureUuIdLookupRowDo.java
new file mode 100644
index 0000000..d8d7f65
--- /dev/null
+++ b/org.eclipse.scout.rt.client.test/src/test/java/org/eclipse/scout/rt/client/services/lookup/FixtureUuIdLookupRowDo.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2010-2020 BSI Business Systems Integration AG.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * BSI Business Systems Integration AG - initial API and implementation
+ */
+package org.eclipse.scout.rt.client.services.lookup;
+
+import org.eclipse.scout.rt.dataobject.DoValue;
+import org.eclipse.scout.rt.dataobject.TypeName;
+import org.eclipse.scout.rt.dataobject.fixture.FixtureUuId;
+import org.eclipse.scout.rt.dataobject.lookup.AbstractLookupRowDo;
+
+@TypeName("scout.FixtureUuIdLookupRow")
+public class FixtureUuIdLookupRowDo extends AbstractLookupRowDo<FixtureUuIdLookupRowDo, FixtureUuId> {
+
+ @Override
+ public DoValue<FixtureUuId> id() {
+ return createIdAttribute(this);
+ }
+}
diff --git a/org.eclipse.scout.rt.client.test/src/test/java/org/eclipse/scout/rt/client/ui/basic/table/columns/AbstractRestLookupSmartColumnTest.java b/org.eclipse.scout.rt.client.test/src/test/java/org/eclipse/scout/rt/client/ui/basic/table/columns/AbstractRestLookupSmartColumnTest.java
new file mode 100644
index 0000000..bf5d203
--- /dev/null
+++ b/org.eclipse.scout.rt.client.test/src/test/java/org/eclipse/scout/rt/client/ui/basic/table/columns/AbstractRestLookupSmartColumnTest.java
@@ -0,0 +1,214 @@
+/*
+ * Copyright (c) 2010-2020 BSI Business Systems Integration AG.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * BSI Business Systems Integration AG - initial API and implementation
+ */
+
+package org.eclipse.scout.rt.client.ui.basic.table.columns;
+
+import static org.junit.Assert.*;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+import org.eclipse.scout.rt.client.testenvironment.TestEnvironmentClientSession;
+import org.eclipse.scout.rt.client.ui.basic.table.AbstractTable;
+import org.eclipse.scout.rt.client.ui.basic.table.ITableRow;
+import org.eclipse.scout.rt.client.ui.form.fields.smartfield.ISmartField;
+import org.eclipse.scout.rt.dataobject.fixture.FixtureUuId;
+import org.eclipse.scout.rt.dataobject.lookup.AbstractLookupRowDo;
+import org.eclipse.scout.rt.dataobject.lookup.LookupResponse;
+import org.eclipse.scout.rt.platform.BEANS;
+import org.eclipse.scout.rt.platform.BeanMetaData;
+import org.eclipse.scout.rt.platform.IBean;
+import org.eclipse.scout.rt.platform.IgnoreBean;
+import org.eclipse.scout.rt.platform.util.StringUtility;
+import org.eclipse.scout.rt.client.services.lookup.AbstractRestLookupCall;
+import org.eclipse.scout.rt.testing.client.runner.ClientTestRunner;
+import org.eclipse.scout.rt.testing.client.runner.RunWithClientSession;
+import org.eclipse.scout.rt.testing.platform.BeanTestingHelper;
+import org.eclipse.scout.rt.testing.platform.runner.RunWithSubject;
+import org.eclipse.scout.rt.client.services.lookup.FixtureUuIdLookupRestrictionDo;
+import org.eclipse.scout.rt.client.services.lookup.FixtureUuIdLookupRowDo;
+import org.junit.AfterClass;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import org.eclipse.scout.rt.client.ui.basic.table.columns.AbstractRestLookupSmartColumnTest.P_Table.Column;
+
+@RunWith(ClientTestRunner.class)
+@RunWithSubject("default")
+@RunWithClientSession(TestEnvironmentClientSession.class)
+public class AbstractRestLookupSmartColumnTest {
+
+ public static final FixtureUuId TEST_FIXTURE_ID_1 = FixtureUuId.of("bc47c139-994f-4c9f-a1a0-0489fdc10ee7");
+ public static final FixtureUuId TEST_FIXTURE_ID_2 = FixtureUuId.of("779b73b4-6c49-4aa7-b7f5-ad06f6ecfa6b");
+ public static final FixtureUuId TEST_FIXTURE_ID_3 = FixtureUuId.of("032d2759-1164-415f-af19-fabd100b4229");
+ public static final FixtureUuId TEST_FIXTURE_ID_4 = FixtureUuId.of("19dc4190-0e0f-4d6f-bf73-92f7656dde24");
+
+ private static final List<IBean<?>> TEST_BEANS = new ArrayList<>();
+ private static final P_RemoteService REMOTE_SERVICE = new P_RemoteService();
+ private static final Set<P_FixtureUuIdLookupCall> USED_LOOKUP_CALL_INSTANCES = new HashSet<>();
+
+ private P_Table m_table;
+
+ @BeforeClass
+ public static void setUpClass() {
+ TEST_BEANS.add(BeanTestingHelper.get().registerBean(new BeanMetaData(P_FixtureUuIdLookupCall.class)));
+ }
+
+ @AfterClass
+ public static void tearDownClass() {
+ BeanTestingHelper.get().unregisterBeans(TEST_BEANS);
+ }
+
+ @Before
+ public void setUp() {
+ REMOTE_SERVICE.resetCalls();
+ USED_LOOKUP_CALL_INSTANCES.clear();
+ m_table = new P_Table();
+ }
+
+ @Test
+ public void testCallRemoteServiceOnlyOnce() {
+ m_table.addRowsByArray(new FixtureUuId[]{TEST_FIXTURE_ID_3, TEST_FIXTURE_ID_1});
+
+ assertEquals(2, m_table.getRowCount());
+ assertEquals("Test-Fixture #3", m_table.getColumn().getDisplayText(m_table.getRow(0)));
+ assertEquals("Test-Fixture #1", m_table.getColumn().getDisplayText(m_table.getRow(1)));
+ assertEquals(1, REMOTE_SERVICE.getTotalCalls());
+ }
+
+ @Test
+ public void testEditCell() {
+ m_table.addRowsByArray(new FixtureUuId[]{null, null});
+ assertEquals(2, m_table.getRowCount());
+ assertNull(m_table.getColumn().getDisplayText(m_table.getRow(0)));
+ assertNull(m_table.getColumn().getDisplayText(m_table.getRow(1)));
+ assertEquals(0, REMOTE_SERVICE.getTotalCalls());
+ assertEquals(0, USED_LOOKUP_CALL_INSTANCES.size());
+
+ parseAndSetValue(0, "Test-Fixture #4");
+ parseAndSetValue(1, "Test-Fixture #2");
+
+ assertEquals(2, m_table.getRowCount());
+ // The following tests fail when the REST lookup call accumulates keys.
+ // When calling setKey(), the previous key should be cleared.
+ assertEquals("Test-Fixture #4", m_table.getColumn().getDisplayText(m_table.getRow(0)));
+ assertEquals("Test-Fixture #2", m_table.getColumn().getDisplayText(m_table.getRow(1)));
+ assertEquals(6, REMOTE_SERVICE.getTotalCalls());
+ assertEquals(4, REMOTE_SERVICE.getCallsByKey());
+ assertEquals(2, REMOTE_SERVICE.getCallsByText());
+ // The following test fails when the batch lookup did not create a clone of the prototype lookup call.
+ assertEquals(6, USED_LOOKUP_CALL_INSTANCES.size());
+ }
+
+ private void parseAndSetValue(int rowIndex, String text) {
+ ITableRow row = m_table.getRow(rowIndex);
+ Column column = m_table.getColumn();
+
+ ISmartField<?> cellEditor = (ISmartField<?>) column.prepareEdit(row);
+ cellEditor.parseAndSetValue(text);
+ column.completeEdit(row, cellEditor);
+ }
+
+ static class P_Table extends AbstractTable {
+
+ public Column getColumn() {
+ return getColumnSet().getColumnByClass(Column.class);
+ }
+
+ public static class Column extends AbstractRestLookupSmartColumn<FixtureUuId> {
+
+ @Override
+ protected Class<? extends AbstractRestLookupCall<?, FixtureUuId>> getConfiguredLookupCall() {
+ return P_FixtureUuIdLookupCall.class;
+ }
+
+ @Override
+ protected boolean getConfiguredEditable() {
+ return true;
+ }
+ }
+ }
+
+ @IgnoreBean
+ static class P_FixtureUuIdLookupCall extends AbstractRestLookupCall<FixtureUuIdLookupRestrictionDo, FixtureUuId> {
+ private static final long serialVersionUID = 1L;
+
+ @Override
+ protected Function<FixtureUuIdLookupRestrictionDo, LookupResponse<? extends AbstractLookupRowDo<?, FixtureUuId>>> remoteCall() {
+ USED_LOOKUP_CALL_INSTANCES.add(this); // cloning an object does not necessarily call the constructor
+ return REMOTE_SERVICE::lookupRows;
+ }
+ }
+
+ static class P_RemoteService {
+
+ private int m_callsByKey = 0;
+ private int m_callsByText = 0;
+ private int m_callsByAll = 0;
+ private final List<FixtureUuIdLookupRowDo> m_allRows;
+
+ public P_RemoteService() {
+ m_allRows = Arrays.asList(
+ BEANS.get(FixtureUuIdLookupRowDo.class).withId(TEST_FIXTURE_ID_1).withText("Test-Fixture #1"),
+ BEANS.get(FixtureUuIdLookupRowDo.class).withId(TEST_FIXTURE_ID_2).withText("Test-Fixture #2"),
+ BEANS.get(FixtureUuIdLookupRowDo.class).withId(TEST_FIXTURE_ID_3).withText("Test-Fixture #3"),
+ BEANS.get(FixtureUuIdLookupRowDo.class).withId(TEST_FIXTURE_ID_4).withText("Test-Fixture #4"));
+ }
+
+ public LookupResponse<FixtureUuIdLookupRowDo> lookupRows(FixtureUuIdLookupRestrictionDo restriction) {
+ if (restriction.getIds().size() > 0) {
+ m_callsByKey++;
+ return LookupResponse.create(m_allRows.stream()
+ .filter(row -> restriction.getIds().contains(row.getId()))
+ .collect(Collectors.toList()));
+ }
+ else if (StringUtility.hasText(restriction.getText())) {
+ m_callsByText++;
+ final String filterText = restriction.getText().replaceAll("\\*", "").toLowerCase();
+ return LookupResponse.create(m_allRows.stream()
+ .filter(row -> row.getText().toLowerCase().contains(filterText))
+ .collect(Collectors.toList()));
+ }
+ else {
+ m_callsByAll++;
+ return LookupResponse.create(m_allRows);
+ }
+ }
+
+ public int getTotalCalls() {
+ return m_callsByKey + m_callsByText + m_callsByAll;
+ }
+
+ public int getCallsByKey() {
+ return m_callsByKey;
+ }
+
+ public int getCallsByText() {
+ return m_callsByText;
+ }
+
+ public int getCallsByAll() {
+ return m_callsByAll;
+ }
+
+ public void resetCalls() {
+ m_callsByKey = 0;
+ m_callsByText = 0;
+ m_callsByAll = 0;
+ }
+ }
+}
diff --git a/org.eclipse.scout.rt.client/src/main/java/org/eclipse/scout/rt/client/services/lookup/AbstractRestLookupCall.java b/org.eclipse.scout.rt.client/src/main/java/org/eclipse/scout/rt/client/services/lookup/AbstractRestLookupCall.java
new file mode 100644
index 0000000..d96ae96
--- /dev/null
+++ b/org.eclipse.scout.rt.client/src/main/java/org/eclipse/scout/rt/client/services/lookup/AbstractRestLookupCall.java
@@ -0,0 +1,301 @@
+/*
+ * Copyright (c) 2010-2020 BSI Business Systems Integration AG.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * BSI Business Systems Integration AG - initial API and implementation
+ */
+package org.eclipse.scout.rt.client.services.lookup;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.function.Function;
+import java.util.function.Supplier;
+import java.util.stream.Collectors;
+
+import org.eclipse.scout.rt.dataobject.DataObjectHelper;
+import org.eclipse.scout.rt.dataobject.lookup.AbstractLookupRestrictionDo;
+import org.eclipse.scout.rt.dataobject.lookup.AbstractLookupRowDo;
+import org.eclipse.scout.rt.dataobject.lookup.LookupResponse;
+import org.eclipse.scout.rt.platform.BEANS;
+import org.eclipse.scout.rt.platform.context.RunContext;
+import org.eclipse.scout.rt.platform.exception.PlatformException;
+import org.eclipse.scout.rt.platform.job.IFuture;
+import org.eclipse.scout.rt.platform.job.Jobs;
+import org.eclipse.scout.rt.platform.util.CollectionUtility;
+import org.eclipse.scout.rt.platform.util.NumberUtility;
+import org.eclipse.scout.rt.platform.util.TriState;
+import org.eclipse.scout.rt.platform.util.TypeCastUtility;
+import org.eclipse.scout.rt.shared.services.lookup.ILookupCall;
+import org.eclipse.scout.rt.shared.services.lookup.ILookupRow;
+import org.eclipse.scout.rt.shared.services.lookup.ILookupRowFetchedCallback;
+import org.eclipse.scout.rt.shared.services.lookup.LookupRow;
+
+/**
+ * IMPORTANT: If you use subclasses of this lookup call in a smart column, make sure to use an
+ * {@code org.eclipse.scout.rt.client.ui.basic.table.columns.AbstractRestLookupSmartColumn}, not
+ * {@code org.eclipse.scout.rt.client.ui.basic.table.columns.AbstractSmartColumn}. Otherwise, batch lookups are
+ * performed via service tunnel instead of calling a REST service.
+ */
+public abstract class AbstractRestLookupCall<RESTRICTION extends AbstractLookupRestrictionDo<?, ID>, ID> implements ILookupCall<ID> {
+ private static final long serialVersionUID = 1L;
+
+ protected RESTRICTION m_restrictionDo;
+
+ protected AbstractRestLookupCall() {
+ m_restrictionDo = BEANS.get(resolveRestrictionClass());
+ }
+
+ /**
+ * Overwrite to resolve to a specific restriction class.
+ * <p>
+ * By default, the super hierarchy is looked for the restriction class type in the generic type declaration.
+ */
+ @SuppressWarnings("unchecked")
+ protected Class<RESTRICTION> resolveRestrictionClass() {
+ return TypeCastUtility.getGenericsParameterClass(getClass(), AbstractRestLookupCall.class, 0);
+ }
+
+ /**
+ * @return the live restriction object (not {@code null})
+ */
+ public RESTRICTION getRestriction() {
+ return m_restrictionDo;
+ }
+
+ @Override
+ public ID getKey() {
+ return CollectionUtility.firstElement(m_restrictionDo.getIds());
+ }
+
+ @Override
+ public void setKey(ID key) {
+ m_restrictionDo.getIds().clear();
+ if (key != null) {
+ m_restrictionDo.getIds().add(key);
+ }
+ }
+
+ public List<ID> getKeys() {
+ return m_restrictionDo.getIds();
+ }
+
+ /**
+ * @deprecated will be removed in 1.3, use {@link #getKeys()} instead
+ */
+ @Deprecated
+ public List<ID> getIds() {
+ return getKeys();
+ }
+
+ public void setKeys(Collection<? extends ID> keys) {
+ m_restrictionDo.withIds(keys);
+ }
+
+ @SafeVarargs
+ public final void setKeys(@SuppressWarnings("unchecked") ID... keys) {
+ m_restrictionDo.withIds(keys);
+ }
+
+ @Override
+ public void setText(String text) {
+ m_restrictionDo.withText(text);
+ }
+
+ @Override
+ public void setAll(String s) {
+ // NOP - unsupported
+ }
+
+ @Override
+ public String getAll() {
+ return null;
+ }
+
+ @Override
+ public void setRec(ID parent) {
+ // NOP - unsupported
+ }
+
+ @Override
+ public ID getRec() {
+ return null;
+ }
+
+ @Override
+ public void setMaster(Object master) {
+ // NOP - unsupported
+ }
+
+ @Override
+ public Object getMaster() {
+ return null;
+ }
+
+ @Override
+ public void setActive(TriState activeState) {
+ m_restrictionDo.withActive(activeState == null ? null : activeState.getBooleanValue());
+ }
+
+ @Override
+ public TriState getActive() {
+ return TriState.parse(m_restrictionDo.getActive());
+ }
+
+ @Override
+ public String getText() {
+ return m_restrictionDo.getText();
+ }
+
+ @Override
+ public List<? extends ILookupRow<ID>> getDataByKey() {
+ if (!m_restrictionDo.ids().exists() || m_restrictionDo.ids().isEmpty()) {
+ return Collections.emptyList();
+ }
+ return getData();
+ }
+
+ @Override
+ public IFuture<Void> getDataByKeyInBackground(RunContext runContext, ILookupRowFetchedCallback<ID> callback) {
+ return loadDataInBackground(this::getDataByKey, runContext, callback);
+ }
+
+ @Override
+ public List<? extends ILookupRow<ID>> getDataByText() {
+ return getData();
+ }
+
+ @Override
+ public IFuture<Void> getDataByTextInBackground(RunContext runContext, ILookupRowFetchedCallback<ID> callback) {
+ return loadDataInBackground(this::getDataByText, runContext, callback);
+ }
+
+ @Override
+ public List<? extends ILookupRow<ID>> getDataByAll() {
+ return getData();
+ }
+
+ @Override
+ public IFuture<Void> getDataByAllInBackground(RunContext runContext, ILookupRowFetchedCallback<ID> callback) {
+ return loadDataInBackground(this::getDataByAll, runContext, callback);
+ }
+
+ @Override
+ public List<? extends ILookupRow<ID>> getDataByRec() {
+ throw new UnsupportedOperationException("not implemented");
+ }
+
+ @Override
+ public IFuture<Void> getDataByRecInBackground(RunContext runContext, ILookupRowFetchedCallback<ID> callback) {
+ throw new UnsupportedOperationException("not implemented");
+ }
+
+ @Override
+ public int getMaxRowCount() {
+ return NumberUtility.nvl(m_restrictionDo.getMaxRowCount(), 0);
+ }
+
+ @Override
+ public void setMaxRowCount(int n) {
+ m_restrictionDo.withMaxRowCount(n);
+ }
+
+ @Override
+ public String getWildcard() {
+ return null;
+ }
+
+ @Override
+ public void setWildcard(String wildcard) {
+ // NOP - unsupported
+ }
+
+ @Override
+ public void setMultilineText(boolean b) {
+ // NOP - unsupported
+ }
+
+ @Override
+ public boolean isMultilineText() {
+ return false;
+ }
+
+ protected List<? extends ILookupRow<ID>> getData() {
+ execPrepareRestriction(m_restrictionDo);
+ LookupResponse<? extends AbstractLookupRowDo<?, ID>> response = remoteCall().apply(m_restrictionDo);
+ return transformLookupResponse(response);
+ }
+
+ /**
+ * Called before remote call to lookup service resource
+ */
+ protected void execPrepareRestriction(RESTRICTION restriction) {
+ }
+
+ /**
+ * Return function to fetch {@link LookupResponse} from remote
+ */
+ protected abstract Function<RESTRICTION, LookupResponse<? extends AbstractLookupRowDo<?, ID>>> remoteCall();
+
+ /**
+ * Loads data asynchronously, and calls the specified callback once completed.
+ */
+ protected IFuture<Void> loadDataInBackground(final Supplier<List<? extends ILookupRow<ID>>> supplier, final RunContext runContext, final ILookupRowFetchedCallback<ID> callback) {
+ return Jobs.schedule(() -> loadData(supplier, callback), Jobs.newInput()
+ .withRunContext(runContext)
+ .withName("Fetching lookup data [lookupCall={}]", getClass().getName()));
+ }
+
+ /**
+ * Loads data synchronously, and calls the specified callback once completed.
+ */
+ protected void loadData(final Supplier<List<? extends ILookupRow<ID>>> supplier, final ILookupRowFetchedCallback<ID> callback) {
+ try {
+ callback.onSuccess(supplier.get());
+ }
+ catch (RuntimeException e) {
+ callback.onFailure(e);
+ }
+ }
+
+ /**
+ * Transforms {@link LookupResponse} with a list of {@link AbstractLookupRowDo} into a list of {@link ILookupRow}.
+ */
+ protected List<? extends ILookupRow<ID>> transformLookupResponse(LookupResponse<? extends AbstractLookupRowDo<?, ID>> response) {
+ return response.getRows().stream()
+ .map(this::transformLookupRow)
+ .collect(Collectors.toList());
+ }
+
+ /**
+ * Transforms one {@link AbstractLookupRowDo} into a {@link ILookupRow}.
+ */
+ protected ILookupRow<ID> transformLookupRow(AbstractLookupRowDo<?, ID> row) {
+ return new LookupRow<>(row.getId(), row.getText())
+ .withActive(row.isActive())
+ .withEnabled(row.isEnabled())
+ .withParentKey(row.getParentId());
+ }
+
+ @Override
+ public AbstractRestLookupCall<RESTRICTION, ID> copy() {
+ try {
+ @SuppressWarnings("unchecked")
+ AbstractRestLookupCall<RESTRICTION, ID> clone = (AbstractRestLookupCall<RESTRICTION, ID>) super.clone();
+ clone.m_restrictionDo = BEANS.get(DataObjectHelper.class).clone(m_restrictionDo);
+ return clone;
+ }
+ catch (CloneNotSupportedException e) {
+ throw new PlatformException("could not clone rest lookup call", e);
+ }
+ }
+
+ @Override
+ public String toString() {
+ return getClass().getSimpleName() + "[ m_restrictionDo=" + m_restrictionDo + "]";
+ }
+}
diff --git a/org.eclipse.scout.rt.client/src/main/java/org/eclipse/scout/rt/client/ui/basic/table/columns/AbstractRestLookupSmartColumn.java b/org.eclipse.scout.rt.client/src/main/java/org/eclipse/scout/rt/client/ui/basic/table/columns/AbstractRestLookupSmartColumn.java
new file mode 100644
index 0000000..7541cab
--- /dev/null
+++ b/org.eclipse.scout.rt.client/src/main/java/org/eclipse/scout/rt/client/ui/basic/table/columns/AbstractRestLookupSmartColumn.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) 2010-2020 BSI Business Systems Integration AG.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * BSI Business Systems Integration AG - initial API and implementation
+ */
+package org.eclipse.scout.rt.client.ui.basic.table.columns;
+
+import java.util.List;
+import java.util.Objects;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+import org.eclipse.scout.rt.client.ui.basic.table.ITableRow;
+import org.eclipse.scout.rt.platform.BEANS;
+import org.eclipse.scout.rt.platform.classid.ClassId;
+import org.eclipse.scout.rt.platform.exception.ExceptionHandler;
+import org.eclipse.scout.rt.platform.util.ObjectUtility;
+import org.eclipse.scout.rt.client.services.lookup.AbstractRestLookupCall;
+import org.eclipse.scout.rt.shared.services.lookup.ILookupCall;
+import org.eclipse.scout.rt.shared.services.lookup.ILookupRow;
+
+/**
+ * Abstract smart column implementation with support for batch lookup calls using a {@link AbstractRestLookupCall}
+ * implementation.
+ * <p>
+ * <b>Note:</b> This implementation uses one single lookup call instance for batch lookups, therefore
+ * {@link #execPrepareLookup(ILookupCall, ITableRow)} is never called. Use
+ * {@link #execPrepareLookup(AbstractRestLookupCall)} instead.
+ */
+@ClassId("f8f5dfa4-cca7-4c61-8d40-641e70154641")
+public abstract class AbstractRestLookupSmartColumn<VALUE> extends AbstractSmartColumn<VALUE> {
+
+ @Override
+ protected abstract Class<? extends AbstractRestLookupCall<?, VALUE>> getConfiguredLookupCall();
+
+ @SuppressWarnings("unchecked")
+ @Override
+ public AbstractRestLookupCall<?, VALUE> getLookupCall() {
+ return (AbstractRestLookupCall<?, VALUE>) super.getLookupCall();
+ }
+
+ @Override
+ public void updateDisplayTexts(List<ITableRow> rows) {
+ if (rows.isEmpty()) {
+ return;
+ }
+ // No need to call remove service when no non-null keys are present
+ final Set<VALUE> keys = getValues().stream()
+ .filter(Objects::nonNull)
+ .collect(Collectors.toSet());
+ if (keys.isEmpty()) {
+ return;
+ }
+ AbstractRestLookupCall<?, VALUE> call = getLookupCall();
+ if (call == null) {
+ return;
+ }
+ try {
+ // Create a copy of the prototype call before modifying it
+ AbstractRestLookupCall<?, VALUE> lookupCall = call.copy();
+ execPrepareLookup(lookupCall);
+ lookupCall.setKeys(keys);
+ List<? extends ILookupRow<VALUE>> dataByKey = lookupCall.getDataByKey();
+
+ for (ITableRow row : rows) {
+ List<? extends ILookupRow<VALUE>> lookupResult = dataByKey.stream()
+ .filter(lookupRow -> ObjectUtility.equals(lookupRow.getKey(), row.getCell(this).getValue()))
+ .collect(Collectors.toList());
+ applyLookupResult(row, lookupResult);
+ }
+ }
+ catch (RuntimeException e) {
+ BEANS.get(ExceptionHandler.class).handle(e);
+ }
+ }
+
+ /**
+ * Called before lookup is performed. This method may be used to set any custom restrictions to lookup call.
+ */
+ protected void execPrepareLookup(AbstractRestLookupCall<?, VALUE> call) {
+ }
+}
diff --git a/org.eclipse.scout.rt.dataobject.test/src/test/java/org/eclipse/scout/rt/dataobject/lookup/LookupHelperTest.java b/org.eclipse.scout.rt.dataobject.test/src/test/java/org/eclipse/scout/rt/dataobject/lookup/LookupHelperTest.java
new file mode 100644
index 0000000..45e61f5
--- /dev/null
+++ b/org.eclipse.scout.rt.dataobject.test/src/test/java/org/eclipse/scout/rt/dataobject/lookup/LookupHelperTest.java
@@ -0,0 +1,239 @@
+/*
+ * Copyright (c) 2010-2020 BSI Business Systems Integration AG.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * BSI Business Systems Integration AG - initial API and implementation
+ */
+package org.eclipse.scout.rt.dataobject.lookup;
+
+import static org.eclipse.scout.rt.testing.platform.util.ScoutAssert.assertThrows;
+import static org.junit.Assert.*;
+
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Function;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
+
+import org.eclipse.scout.rt.dataobject.fixture.FixtureEnum;
+import org.eclipse.scout.rt.platform.BEANS;
+import org.eclipse.scout.rt.platform.util.Assertions.AssertionException;
+import org.eclipse.scout.rt.testing.platform.runner.PlatformTestRunner;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import org.eclipse.scout.rt.dataobject.lookup.fixture.FixtureData;
+import org.eclipse.scout.rt.dataobject.lookup.fixture.FixtureDataLookupRestrictionDo;
+import org.eclipse.scout.rt.dataobject.lookup.fixture.FixtureDataLookupRowDo;
+import org.eclipse.scout.rt.dataobject.lookup.fixture.FixtureEnumLookupRestrictionDo;
+import org.eclipse.scout.rt.dataobject.lookup.fixture.FixtureEnumLookupRowDo;
+
+@RunWith(PlatformTestRunner.class)
+public class LookupHelperTest {
+
+ protected final Map<Long, FixtureData> m_testData = new LinkedHashMap<>();
+
+ private LookupHelper m_helper;
+
+ @Before
+ public void before() {
+ m_helper = new LookupHelper();
+ m_testData.clear();
+ m_testData.put(1L, new FixtureData(1L, "foo", "additional foo data", true));
+ m_testData.put(2L, new FixtureData(2L, "bar", "additional bar data", false));
+ m_testData.put(3L, new FixtureData(3L, "baz", "additional baz data", null));
+ }
+
+ @Test
+ public void testFilterData() {
+ LongLookupRestrictionDo restriction = BEANS.get(LongLookupRestrictionDo.class);
+
+ // get all, no restrictions
+ LookupResponse<LongLookupRowDo> lookupResponse = m_helper.filterData(restriction, m_testData.values().stream(), FixtureData::getId, FixtureData::getText, FixtureData::getActive, LongLookupRowDo.class);
+ assertLookupResponse(lookupResponse, 2L, 3L, 1L);
+
+ // get by id
+ restriction = BEANS.get(LongLookupRestrictionDo.class).withIds(1L, 3L);
+ lookupResponse = m_helper.filterData(restriction, m_testData.values().stream(), FixtureData::getId, FixtureData::getText, FixtureData::getActive, LongLookupRowDo.class);
+ assertLookupResponse(lookupResponse, 3L, 1L);
+
+ // get by text (full)
+ restriction = BEANS.get(LongLookupRestrictionDo.class).withText("bar");
+ lookupResponse = m_helper.filterData(restriction, m_testData.values().stream(), FixtureData::getId, FixtureData::getText, FixtureData::getActive, LongLookupRowDo.class);
+ assertLookupResponse(lookupResponse, 2L);
+
+ // get by text (b*)
+ restriction = BEANS.get(LongLookupRestrictionDo.class).withText("b*");
+ lookupResponse = m_helper.filterData(restriction, m_testData.values().stream(), FixtureData::getId, FixtureData::getText, FixtureData::getActive, LongLookupRowDo.class);
+ assertLookupResponse(lookupResponse, 2L, 3L);
+
+ // get by text (*a*)
+ restriction = BEANS.get(LongLookupRestrictionDo.class).withText("*a*");
+ lookupResponse = m_helper.filterData(restriction, m_testData.values().stream(), FixtureData::getId, FixtureData::getText, FixtureData::getActive, LongLookupRowDo.class);
+ assertLookupResponse(lookupResponse, 2L, 3L);
+
+ // get by text (*o)
+ restriction = BEANS.get(LongLookupRestrictionDo.class).withText("*o");
+ lookupResponse = m_helper.filterData(restriction, m_testData.values().stream(), FixtureData::getId, FixtureData::getText, FixtureData::getActive, LongLookupRowDo.class);
+ assertLookupResponse(lookupResponse, 1L);
+
+ // get by text (*)
+ restriction = BEANS.get(LongLookupRestrictionDo.class).withText("*");
+ lookupResponse = m_helper.filterData(restriction, m_testData.values().stream(), FixtureData::getId, FixtureData::getText, FixtureData::getActive, LongLookupRowDo.class);
+ assertLookupResponse(lookupResponse, 2L, 3L, 1L);
+
+ // get by active true
+ restriction = BEANS.get(LongLookupRestrictionDo.class).withActive(true);
+ lookupResponse = m_helper.filterData(restriction, m_testData.values().stream(), FixtureData::getId, FixtureData::getText, FixtureData::getActive, LongLookupRowDo.class);
+ assertLookupResponse(lookupResponse, 1L);
+
+ // get by active false
+ restriction = BEANS.get(LongLookupRestrictionDo.class).withActive(false);
+ lookupResponse = m_helper.filterData(restriction, m_testData.values().stream(), FixtureData::getId, FixtureData::getText, FixtureData::getActive, LongLookupRowDo.class);
+ assertLookupResponse(lookupResponse, 2L);
+ }
+
+ @Test
+ public void testFilterData_additionalFilter() {
+ LookupHelper helper = new LookupHelper();
+ FixtureDataLookupRestrictionDo restriction = BEANS.get(FixtureDataLookupRestrictionDo.class);
+ restriction.withStartsWith("f");
+
+ // get all, custom filter for text start with "f"
+ LookupResponse<LongLookupRowDo> lookupResponse = helper.filterData(restriction,
+ m_testData.values().stream(),
+ FixtureData::getId,
+ FixtureData::getText,
+ FixtureData::getActive,
+ data -> data.getText().startsWith(restriction.getStartsWith()),
+ LongLookupRowDo.class);
+ assertLookupResponse(lookupResponse, 1L);
+ }
+
+ @Test
+ public void testFilterData_additionalMapperAndComparator() {
+ LookupHelper helper = new LookupHelper();
+ FixtureDataLookupRestrictionDo restriction = BEANS.get(FixtureDataLookupRestrictionDo.class);
+
+ // get all, no restrictions, custom additional data mapper
+ LookupResponse<FixtureDataLookupRowDo> lookupResponse = helper.filterData(restriction,
+ m_testData.values().stream(),
+ FixtureData::getId,
+ FixtureData::getText,
+ FixtureData::getActive,
+ LookupHelper.truePredicate(),
+ FixtureDataLookupRowDo.class,
+ (row, data) -> row.withAdditionalData(data.getAdditionalData()),
+ Comparator.comparing(AbstractLookupRowDo::getText, Comparator.reverseOrder())); // alphabetically in reverse order
+ assertLookupResponse(lookupResponse, 1L, 3L, 2L);
+
+ assertEquals("additional foo data", lookupResponse.getRows().get(0).getAdditionalData());
+ assertEquals("additional baz data", lookupResponse.getRows().get(1).getAdditionalData());
+ assertEquals("additional bar data", lookupResponse.getRows().get(2).getAdditionalData());
+ }
+
+ protected void assertLookupResponse(LookupResponse<LongLookupRowDo> lookupResponse, boolean expectAdditionalData, Long... expectedIds) {
+ for (int i = 0; i < expectedIds.length; i++) {
+ Long id = expectedIds[i];
+ assertEquals(id, lookupResponse.getRows().get(i).getId());
+ assertEquals(m_testData.get(id).getText(), lookupResponse.getRows().get(i).getText());
+ }
+ }
+
+ @Test
+ @SuppressWarnings("ResultOfMethodCallIgnored")
+ public void testLookupRowDoComparatorByText() {
+ assertThrows(NullPointerException.class, () -> LookupHelper.lookupRowDoComparatorByText().compare(null, null));
+
+ FixtureEnumLookupRowDo r1 = BEANS.get(FixtureEnumLookupRowDo.class);
+ FixtureEnumLookupRowDo r2 = BEANS.get(FixtureEnumLookupRowDo.class);
+ assertThrows(NullPointerException.class, () -> LookupHelper.lookupRowDoComparatorByText().compare(r1, r2));
+
+ r1.withText("a");
+ assertThrows(NullPointerException.class, () -> LookupHelper.lookupRowDoComparatorByText().compare(r1, r2));
+
+ r2.withText("b");
+ assertEquals(-1, LookupHelper.lookupRowDoComparatorByText().compare(r1, r2));
+ assertEquals(0, LookupHelper.lookupRowDoComparatorByText().compare(r1, r1));
+ assertEquals(1, LookupHelper.lookupRowDoComparatorByText().compare(r2, r1));
+ }
+
+ @Test
+ public void testEnumTextResolver() {
+ assertNull(LookupHelper.enumTextResolver().apply(null));
+ }
+
+ @Test
+ public void testFilterEnum() {
+ LookupHelper helper = new LookupHelper();
+
+ // get all
+ FixtureEnumLookupRestrictionDo restriction = BEANS.get(FixtureEnumLookupRestrictionDo.class);
+ assertLookupResponse(helper.filterEnumKeepSorting(restriction, FixtureEnum.class, FixtureEnumLookupRowDo.class),
+ FixtureEnum.ONE, FixtureEnum.TWO, FixtureEnum.THREE);
+
+ // get by id
+ restriction = BEANS.get(FixtureEnumLookupRestrictionDo.class).withIds(FixtureEnum.THREE);
+ assertLookupResponse(helper.filterEnumKeepSorting(restriction, FixtureEnum.class, FixtureEnumLookupRowDo.class),
+ FixtureEnum.THREE);
+
+ // get by text
+ restriction = BEANS.get(FixtureEnumLookupRestrictionDo.class).withText("non-existing fixture enum text");
+ assertLookupResponse(helper.filterEnumKeepSorting(restriction, FixtureEnum.class, FixtureEnumLookupRowDo.class));
+
+ // get by text using wildcard
+ restriction = BEANS.get(FixtureEnumLookupRestrictionDo.class).withText("*");
+ assertLookupResponse(helper.filterEnumKeepSorting(restriction, FixtureEnum.class, FixtureEnumLookupRowDo.class),
+ FixtureEnum.ONE, FixtureEnum.TWO, FixtureEnum.THREE);
+ }
+
+ @Test
+ public void testTextPatternPredicate() {
+ Predicate<Object> nullTextPatternPredicate = m_helper.textPatternPredicate(null, null);
+ assertTrue(nullTextPatternPredicate.test(null));
+ assertTrue(nullTextPatternPredicate.test(new Object()));
+ assertTrue(nullTextPatternPredicate.test("foo"));
+
+ assertThrows(AssertionException.class, () -> m_helper.textPatternPredicate("a*", null));
+
+ Predicate<String> textPatternPredicateWithIdentity = m_helper.textPatternPredicate("a*", Function.identity());
+ assertFalse(textPatternPredicateWithIdentity.test(null));
+ assertFalse(textPatternPredicateWithIdentity.test(""));
+ assertFalse(textPatternPredicateWithIdentity.test("b"));
+ assertTrue(textPatternPredicateWithIdentity.test("a"));
+ assertTrue(textPatternPredicateWithIdentity.test("aa"));
+ assertTrue(textPatternPredicateWithIdentity.test("ab"));
+
+ Predicate<FixtureData> textPatternPredicateFixtureData = m_helper.textPatternPredicate("a*", FixtureData::getText);
+ assertFalse(textPatternPredicateFixtureData.test(null));
+ assertFalse(textPatternPredicateFixtureData.test(new FixtureData(1L, null, null, null)));
+ assertFalse(textPatternPredicateFixtureData.test(new FixtureData(1L, "b", null, null)));
+ assertTrue(textPatternPredicateFixtureData.test(new FixtureData(1L, "a", null, null)));
+ assertTrue(textPatternPredicateFixtureData.test(new FixtureData(1L, "aa", null, null)));
+ assertTrue(textPatternPredicateFixtureData.test(new FixtureData(1L, "ab", null, null)));
+ }
+
+ @SafeVarargs
+ protected final <ID, LOOKUP_ROW extends AbstractLookupRowDo<LOOKUP_ROW, ID>> void assertLookupResponse(LookupResponse<LOOKUP_ROW> response, @SuppressWarnings("unchecked") ID... expectedIds) {
+ assertNotNull(response);
+ List<ID> actualIds = response.rows().stream()
+ .map(AbstractLookupRowDo::getId)
+ .collect(Collectors.toList());
+ assertEquals(Arrays.asList(expectedIds), actualIds);
+ }
+
+ @Test
+ public void testMaxRowCount() {
+ assertEquals(LookupHelper.DEFAULT_MAX_ROWS, m_helper.maxRowCount(BEANS.get(FixtureEnumLookupRestrictionDo.class)));
+ assertEquals(LookupHelper.DEFAULT_MAX_ROWS, m_helper.maxRowCount(BEANS.get(FixtureEnumLookupRestrictionDo.class).withMaxRowCount(null)));
+ assertEquals(42, m_helper.maxRowCount(BEANS.get(FixtureEnumLookupRestrictionDo.class).withMaxRowCount(42)));
+ }
+}
diff --git a/org.eclipse.scout.rt.dataobject.test/src/test/java/org/eclipse/scout/rt/dataobject/lookup/fixture/FixtureData.java b/org.eclipse.scout.rt.dataobject.test/src/test/java/org/eclipse/scout/rt/dataobject/lookup/fixture/FixtureData.java
new file mode 100644
index 0000000..9ab9a67
--- /dev/null
+++ b/org.eclipse.scout.rt.dataobject.test/src/test/java/org/eclipse/scout/rt/dataobject/lookup/fixture/FixtureData.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) BSI Business Systems Integration AG. All rights reserved.
+ * http://www.bsiag.com/
+ */
+package org.eclipse.scout.rt.dataobject.lookup.fixture;
+
+public class FixtureData {
+ private final Long m_id;
+ private final String m_text;
+ private final String m_additionalData;
+ private final Boolean m_active;
+
+ public FixtureData(Long id, String text, String additionalData, Boolean active) {
+ m_id = id;
+ m_text = text;
+ m_additionalData = additionalData;
+ m_active = active;
+ }
+
+ public Long getId() {
+ return m_id;
+ }
+
+ public String getText() {
+ return m_text;
+ }
+
+ public String getAdditionalData() {
+ return m_additionalData;
+ }
+
+ public Boolean getActive() {
+ return m_active;
+ }
+
+ @Override
+ public String toString() {
+ return "FixtureData [m_id=" + m_id + ", m_text=" + m_text + ", m_additionalData=" + m_additionalData + ", m_active=" + m_active + "]";
+ }
+}
diff --git a/org.eclipse.scout.rt.dataobject.test/src/test/java/org/eclipse/scout/rt/dataobject/lookup/fixture/FixtureDataLookupRestrictionDo.java b/org.eclipse.scout.rt.dataobject.test/src/test/java/org/eclipse/scout/rt/dataobject/lookup/fixture/FixtureDataLookupRestrictionDo.java
new file mode 100644
index 0000000..16ff8aa
--- /dev/null
+++ b/org.eclipse.scout.rt.dataobject.test/src/test/java/org/eclipse/scout/rt/dataobject/lookup/fixture/FixtureDataLookupRestrictionDo.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) BSI Business Systems Integration AG. All rights reserved.
+ * http://www.bsiag.com/
+ */
+package org.eclipse.scout.rt.dataobject.lookup.fixture;
+
+import javax.annotation.Generated;
+
+import org.eclipse.scout.rt.dataobject.DoList;
+import org.eclipse.scout.rt.dataobject.DoValue;
+import org.eclipse.scout.rt.dataobject.TypeName;
+import org.eclipse.scout.rt.dataobject.lookup.AbstractLookupRestrictionDo;
+
+@TypeName("start.FixtureDataLookupRestriction")
+public class FixtureDataLookupRestrictionDo extends AbstractLookupRestrictionDo<FixtureDataLookupRestrictionDo, Long> {
+
+ @Override
+ public DoList<Long> ids() {
+ return createIdsAttribute(this);
+ }
+
+ public DoValue<String> startsWith() {
+ return doValue("startsWith");
+ }
+
+ /* **************************************************************************
+ * GENERATED CONVENIENCE METHODS
+ * *************************************************************************/
+
+ @Generated("DoConvenienceMethodsGenerator")
+ public FixtureDataLookupRestrictionDo withStartsWith(String startsWith) {
+ startsWith().set(startsWith);
+ return this;
+ }
+
+ @Generated("DoConvenienceMethodsGenerator")
+ public String getStartsWith() {
+ return startsWith().get();
+ }
+}
diff --git a/org.eclipse.scout.rt.dataobject.test/src/test/java/org/eclipse/scout/rt/dataobject/lookup/fixture/FixtureDataLookupRowDo.java b/org.eclipse.scout.rt.dataobject.test/src/test/java/org/eclipse/scout/rt/dataobject/lookup/fixture/FixtureDataLookupRowDo.java
new file mode 100644
index 0000000..32f3eda
--- /dev/null
+++ b/org.eclipse.scout.rt.dataobject.test/src/test/java/org/eclipse/scout/rt/dataobject/lookup/fixture/FixtureDataLookupRowDo.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) BSI Business Systems Integration AG. All rights reserved.
+ * http://www.bsiag.com/
+ */
+package org.eclipse.scout.rt.dataobject.lookup.fixture;
+
+import javax.annotation.Generated;
+
+import org.eclipse.scout.rt.dataobject.DoValue;
+import org.eclipse.scout.rt.dataobject.TypeName;
+import org.eclipse.scout.rt.dataobject.lookup.AbstractLookupRowDo;
+
+@TypeName("start.FixtureDataLookupRow")
+public class FixtureDataLookupRowDo extends AbstractLookupRowDo<FixtureDataLookupRowDo, Long> {
+
+ @Override
+ public DoValue<Long> id() {
+ return createIdAttribute(this);
+ }
+
+ public DoValue<String> additionalData() {
+ return doValue("additionalData");
+ }
+
+ /* **************************************************************************
+ * GENERATED CONVENIENCE METHODS
+ * *************************************************************************/
+
+ @Generated("DoConvenienceMethodsGenerator")
+ public FixtureDataLookupRowDo withAdditionalData(String text) {
+ additionalData().set(text);
+ return this;
+ }
+
+ @Generated("DoConvenienceMethodsGenerator")
+ public String getAdditionalData() {
+ return additionalData().get();
+ }
+}
diff --git a/org.eclipse.scout.rt.dataobject.test/src/test/java/org/eclipse/scout/rt/dataobject/lookup/fixture/FixtureEnumLookupRestrictionDo.java b/org.eclipse.scout.rt.dataobject.test/src/test/java/org/eclipse/scout/rt/dataobject/lookup/fixture/FixtureEnumLookupRestrictionDo.java
new file mode 100644
index 0000000..ab1b4a5
--- /dev/null
+++ b/org.eclipse.scout.rt.dataobject.test/src/test/java/org/eclipse/scout/rt/dataobject/lookup/fixture/FixtureEnumLookupRestrictionDo.java
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) BSI Business Systems Integration AG. All rights reserved.
+ * http://www.bsiag.com/
+ */
+package org.eclipse.scout.rt.dataobject.lookup.fixture;
+
+import org.eclipse.scout.rt.dataobject.DoList;
+import org.eclipse.scout.rt.dataobject.TypeName;
+import org.eclipse.scout.rt.dataobject.fixture.FixtureEnum;
+import org.eclipse.scout.rt.dataobject.lookup.AbstractLookupRestrictionDo;
+
+@TypeName("start.FixtureEnumLookupRestriction")
+public class FixtureEnumLookupRestrictionDo extends AbstractLookupRestrictionDo<FixtureEnumLookupRestrictionDo, FixtureEnum> {
+
+ @Override
+ public DoList<FixtureEnum> ids() {
+ return createIdsAttribute(this);
+ }
+}
diff --git a/org.eclipse.scout.rt.dataobject.test/src/test/java/org/eclipse/scout/rt/dataobject/lookup/fixture/FixtureEnumLookupRowDo.java b/org.eclipse.scout.rt.dataobject.test/src/test/java/org/eclipse/scout/rt/dataobject/lookup/fixture/FixtureEnumLookupRowDo.java
new file mode 100644
index 0000000..40742ca
--- /dev/null
+++ b/org.eclipse.scout.rt.dataobject.test/src/test/java/org/eclipse/scout/rt/dataobject/lookup/fixture/FixtureEnumLookupRowDo.java
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) BSI Business Systems Integration AG. All rights reserved.
+ * http://www.bsiag.com/
+ */
+package org.eclipse.scout.rt.dataobject.lookup.fixture;
+
+import org.eclipse.scout.rt.dataobject.DoValue;
+import org.eclipse.scout.rt.dataobject.TypeName;
+import org.eclipse.scout.rt.dataobject.fixture.FixtureEnum;
+import org.eclipse.scout.rt.dataobject.lookup.AbstractLookupRowDo;
+
+@TypeName("start.FixtureEnumLookupRow")
+public class FixtureEnumLookupRowDo extends AbstractLookupRowDo<FixtureEnumLookupRowDo, FixtureEnum> {
+
+ @Override
+ public DoValue<FixtureEnum> id() {
+ return createIdAttribute(this);
+ }
+}
diff --git a/org.eclipse.scout.rt.dataobject/src/main/java/org/eclipse/scout/rt/dataobject/lookup/AbstractLookupRestrictionDo.java b/org.eclipse.scout.rt.dataobject/src/main/java/org/eclipse/scout/rt/dataobject/lookup/AbstractLookupRestrictionDo.java
new file mode 100644
index 0000000..760c894
--- /dev/null
+++ b/org.eclipse.scout.rt.dataobject/src/main/java/org/eclipse/scout/rt/dataobject/lookup/AbstractLookupRestrictionDo.java
@@ -0,0 +1,115 @@
+/*
+ * Copyright (c) 2010-2020 BSI Business Systems Integration AG.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * BSI Business Systems Integration AG - initial API and implementation
+ */
+package org.eclipse.scout.rt.dataobject.lookup;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+
+import javax.annotation.Generated;
+
+import org.eclipse.scout.rt.dataobject.DoEntity;
+import org.eclipse.scout.rt.dataobject.DoList;
+import org.eclipse.scout.rt.dataobject.DoValue;
+
+/**
+ * Abstract base class for lookup call restrictions
+ *
+ * @param <SELF>
+ * Type reference to concrete sub-class, used to implement with() methods returning concrete sub-class type
+ * @param <ID>
+ * Lookup row id type
+ */
+public abstract class AbstractLookupRestrictionDo<SELF extends AbstractLookupRestrictionDo<SELF, ID>, ID> extends DoEntity {
+
+ /**
+ * A subclass should implement this method to specify the concrete attribute type.
+ *
+ * @see AbstractLookupRestrictionDo#createIdsAttribute(AbstractLookupRestrictionDo)
+ */
+ public abstract DoList<ID> ids();
+
+ public DoValue<String> text() {
+ return doValue("text");
+ }
+
+ public DoValue<Boolean> active() {
+ return doValue("active");
+ }
+
+ public DoValue<Integer> maxRowCount() {
+ return doValue("maxRowCount");
+ }
+
+ /* **************************************************************************
+ * HELPER METHODS
+ * *************************************************************************/
+
+ @SuppressWarnings("unchecked")
+ protected SELF self() {
+ return (SELF) this;
+ }
+
+ protected static <ID> DoList<ID> createIdsAttribute(AbstractLookupRestrictionDo<?, ID> self) {
+ return self.doList("ids");
+ }
+
+ /* **************************************************************************
+ * CONVENIENCE METHODS
+ * *************************************************************************/
+
+ public List<ID> getIds() {
+ return ids().get();
+ }
+
+ public Boolean getActive() {
+ return active().get();
+ }
+
+ public SELF withIds(Collection<? extends ID> ids) {
+ ids().clear();
+ ids().get().addAll(ids);
+ return self();
+ }
+
+ public SELF withIds(@SuppressWarnings("unchecked") ID... ids) {
+ return withIds(Arrays.asList(ids));
+ }
+
+ public SELF withText(String text) {
+ text().set(text);
+ return self();
+ }
+
+ public SELF withActive(Boolean active) {
+ active().set(active);
+ return self();
+ }
+
+ public SELF withMaxRowCount(Integer maxRowCount) {
+ maxRowCount().set(maxRowCount);
+ return self();
+ }
+
+ /* **************************************************************************
+ * GENERATED CONVENIENCE METHODS
+ * *************************************************************************/
+
+ @Generated("DoConvenienceMethodsGenerator")
+ public String getText() {
+ return text().get();
+ }
+
+ @Generated("DoConvenienceMethodsGenerator")
+ public Integer getMaxRowCount() {
+ return maxRowCount().get();
+ }
+}
diff --git a/org.eclipse.scout.rt.dataobject/src/main/java/org/eclipse/scout/rt/dataobject/lookup/AbstractLookupRowDo.java b/org.eclipse.scout.rt.dataobject/src/main/java/org/eclipse/scout/rt/dataobject/lookup/AbstractLookupRowDo.java
new file mode 100644
index 0000000..e524326
--- /dev/null
+++ b/org.eclipse.scout.rt.dataobject/src/main/java/org/eclipse/scout/rt/dataobject/lookup/AbstractLookupRowDo.java
@@ -0,0 +1,126 @@
+/*
+ * Copyright (c) 2010-2020 BSI Business Systems Integration AG.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * BSI Business Systems Integration AG - initial API and implementation
+ */
+package org.eclipse.scout.rt.dataobject.lookup;
+
+import javax.annotation.Generated;
+
+import org.eclipse.scout.rt.dataobject.DoEntity;
+import org.eclipse.scout.rt.dataobject.DoValue;
+
+/**
+ * Abstract base class for lookup rows with generic key type T.
+ *
+ * @param <SELF>
+ * Type reference to concrete sub-class, used to implement with() methods returning concrete sub-class type
+ * @param <ID>
+ * Lookup row id type
+ */
+public abstract class AbstractLookupRowDo<SELF extends AbstractLookupRowDo<SELF, ID>, ID> extends DoEntity {
+
+ protected AbstractLookupRowDo() {
+ withEnabled(true); // lookup rows are enabled by default
+ withActive(true); // lookup rows are active by default
+ }
+
+ /**
+ * A subclass should implement this method to specify the concrete attribute type.
+ *
+ * @see AbstractLookupRowDo#createIdAttribute(AbstractLookupRowDo)
+ */
+ public abstract DoValue<ID> id();
+
+ public DoValue<String> text() {
+ return doValue("text");
+ }
+
+ public DoValue<Boolean> enabled() {
+ return doValue("enabled");
+ }
+
+ public DoValue<Boolean> active() {
+ return doValue("active");
+ }
+
+ public DoValue<ID> parentId() {
+ return doValue("parentId");
+ }
+
+ /* **************************************************************************
+ * HELPER METHODS
+ * *************************************************************************/
+
+ @SuppressWarnings("unchecked")
+ protected SELF self() {
+ return (SELF) this;
+ }
+
+ protected static <ID> DoValue<ID> createIdAttribute(AbstractLookupRowDo<?, ID> self) {
+ return self.doValue("id");
+ }
+
+ /* **************************************************************************
+ * CONVENIENCE METHODS
+ * *************************************************************************/
+
+ public SELF withId(ID id) {
+ id().set(id);
+ return self();
+ }
+
+ public SELF withText(String text) {
+ text().set(text);
+ return self();
+ }
+
+ public SELF withEnabled(Boolean enabled) {
+ enabled().set(enabled);
+ return self();
+ }
+
+ public SELF withActive(Boolean active) {
+ active().set(active);
+ return self();
+ }
+
+ public SELF withParentId(ID parentId) {
+ parentId().set(parentId);
+ return self();
+ }
+
+ /* **************************************************************************
+ * GENERATED CONVENIENCE METHODS
+ * *************************************************************************/
+
+ @Generated("DoConvenienceMethodsGenerator")
+ public ID getId() {
+ return id().get();
+ }
+
+ @Generated("DoConvenienceMethodsGenerator")
+ public String getText() {
+ return text().get();
+ }
+
+ @Generated("DoConvenienceMethodsGenerator")
+ public Boolean isEnabled() {
+ return enabled().get();
+ }
+
+ @Generated("DoConvenienceMethodsGenerator")
+ public Boolean isActive() {
+ return active().get();
+ }
+
+ @Generated("DoConvenienceMethodsGenerator")
+ public ID getParentId() {
+ return parentId().get();
+ }
+}
diff --git a/org.eclipse.scout.rt.dataobject/src/main/java/org/eclipse/scout/rt/dataobject/lookup/LongLookupRestrictionDo.java b/org.eclipse.scout.rt.dataobject/src/main/java/org/eclipse/scout/rt/dataobject/lookup/LongLookupRestrictionDo.java
new file mode 100644
index 0000000..4996050
--- /dev/null
+++ b/org.eclipse.scout.rt.dataobject/src/main/java/org/eclipse/scout/rt/dataobject/lookup/LongLookupRestrictionDo.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2010-2020 BSI Business Systems Integration AG.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * BSI Business Systems Integration AG - initial API and implementation
+ */
+package org.eclipse.scout.rt.dataobject.lookup;
+
+import org.eclipse.scout.rt.dataobject.DoList;
+import org.eclipse.scout.rt.dataobject.TypeName;
+import org.eclipse.scout.rt.platform.BEANS;
+import org.eclipse.scout.rt.platform.util.ObjectUtility;
+
+@TypeName("scout.LongLookupRestriction")
+public class LongLookupRestrictionDo extends AbstractLookupRestrictionDo<LongLookupRestrictionDo, Long> {
+
+ @Override
+ public DoList<Long> ids() {
+ return createIdsAttribute(this);
+ }
+
+ /**
+ * @return Specified {@code restriction} if not null, otherwise a new {@link LongLookupRestrictionDo} instance.
+ */
+ public static LongLookupRestrictionDo ensure(LongLookupRestrictionDo restriction) {
+ return ObjectUtility.nvl(restriction, BEANS.get(LongLookupRestrictionDo.class));
+ }
+}
diff --git a/org.eclipse.scout.rt.dataobject/src/main/java/org/eclipse/scout/rt/dataobject/lookup/LongLookupRowDo.java b/org.eclipse.scout.rt.dataobject/src/main/java/org/eclipse/scout/rt/dataobject/lookup/LongLookupRowDo.java
new file mode 100644
index 0000000..d559a59
--- /dev/null
+++ b/org.eclipse.scout.rt.dataobject/src/main/java/org/eclipse/scout/rt/dataobject/lookup/LongLookupRowDo.java
@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) 2010-2020 BSI Business Systems Integration AG.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * BSI Business Systems Integration AG - initial API and implementation
+ */
+package org.eclipse.scout.rt.dataobject.lookup;
+
+import org.eclipse.scout.rt.dataobject.DoValue;
+import org.eclipse.scout.rt.dataobject.TypeName;
+
+@TypeName("scout.LongLookupRow")
+public class LongLookupRowDo extends AbstractLookupRowDo<LongLookupRowDo, Long> {
+
+ @Override
+ public DoValue<Long> id() {
+ return createIdAttribute(this);
+ }
+}
diff --git a/org.eclipse.scout.rt.dataobject/src/main/java/org/eclipse/scout/rt/dataobject/lookup/LookupHelper.java b/org.eclipse.scout.rt.dataobject/src/main/java/org/eclipse/scout/rt/dataobject/lookup/LookupHelper.java
new file mode 100644
index 0000000..3dd745a
--- /dev/null
+++ b/org.eclipse.scout.rt.dataobject/src/main/java/org/eclipse/scout/rt/dataobject/lookup/LookupHelper.java
@@ -0,0 +1,400 @@
+/*
+ * Copyright (c) 2010-2020 BSI Business Systems Integration AG.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * BSI Business Systems Integration AG - initial API and implementation
+ */
+package org.eclipse.scout.rt.dataobject.lookup;
+
+import java.text.Collator;
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+import java.util.function.BiFunction;
+import java.util.function.Function;
+import java.util.function.Predicate;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import org.eclipse.scout.rt.dataobject.enumeration.IEnum;
+import org.eclipse.scout.rt.platform.ApplicationScoped;
+import org.eclipse.scout.rt.platform.BEANS;
+import org.eclipse.scout.rt.platform.nls.CollatorProvider;
+import org.eclipse.scout.rt.platform.text.TEXTS;
+import org.eclipse.scout.rt.platform.util.Assertions;
+import org.eclipse.scout.rt.platform.util.NumberUtility;
+import org.eclipse.scout.rt.platform.util.StreamUtility;
+import org.eclipse.scout.rt.platform.util.StringUtility;
+
+/**
+ * Helper class filtering and mapping a stream of (in-memory available) data items to list of lookup rows.
+ */
+@ApplicationScoped
+public class LookupHelper {
+
+ protected static final int DEFAULT_MAX_ROWS = 100;
+
+ protected static final String WILDCARD = "*";
+ protected static final String WILDCARD_REPLACE = "@wildcard@";
+ protected static final String MATCH_ALL_REGEX = ".*";
+
+ /**
+ * Filter stream of {@code data} according to specified {@code restriction} and converts the stream to a
+ * LookupResponse containing a list of mapped lookup rows.
+ *
+ * @param <LOOKUP_ROW>
+ * Type of lookup row (subclass of {@link AbstractLookupRowDo})
+ * @param <ID>
+ * Primary key type of data items
+ * @param <RESTRICTION>
+ * Type of lookup restriction (subclass of {@link AbstractLookupRestrictionDo}
+ * @param <DATA>
+ * Type of data items
+ * @param restriction
+ * Lookup call restriction object used to filter the stream of data
+ * @param data
+ * Stream of data items
+ * @param idAccessor
+ * Accessor method to get the ID of a data item
+ * @param textAccessor
+ * Accessor method to get the text of a data item
+ * @param rowClass
+ * Class type of lookup row to create
+ */
+ public <LOOKUP_ROW extends AbstractLookupRowDo<LOOKUP_ROW, ID>, ID, RESTRICTION extends AbstractLookupRestrictionDo<RESTRICTION, ID>, DATA> LookupResponse<LOOKUP_ROW>
+ filterData(RESTRICTION restriction,
+ Stream<DATA> data,
+ Function<DATA, ID> idAccessor,
+ Function<DATA, String> textAccessor,
+ Class<LOOKUP_ROW> rowClass) {
+ return filterData(restriction, data, idAccessor, textAccessor, null, truePredicate(), rowClass, identityMapper(), lookupRowDoComparatorByText());
+ }
+
+ /**
+ * Filter stream of {@code data} according to specified {@code restriction} and converts the stream to a
+ * LookupResponse containing a list of mapped lookup rows.
+ *
+ * @param <LOOKUP_ROW>
+ * Type of lookup row (subclass of {@link AbstractLookupRowDo})
+ * @param <ID>
+ * Primary key type of data items
+ * @param <RESTRICTION>
+ * Type of lookup restriction (subclass of {@link AbstractLookupRestrictionDo}
+ * @param <DATA>
+ * Type of data items
+ * @param restriction
+ * Lookup call restriction object used to filter the stream of data
+ * @param data
+ * Stream of data items
+ * @param idAccessor
+ * Accessor method to get the ID of a data item
+ * @param textAccessor
+ * Accessor method to get the text of a data item
+ * @param rowClass
+ * Class type of lookup row to create
+ */
+ public <LOOKUP_ROW extends AbstractLookupRowDo<LOOKUP_ROW, ID>, ID, RESTRICTION extends AbstractLookupRestrictionDo<RESTRICTION, ID>, DATA> LookupResponse<LOOKUP_ROW>
+ filterData(RESTRICTION restriction,
+ Stream<DATA> data,
+ Function<DATA, ID> idAccessor,
+ Function<DATA, String> textAccessor,
+ Class<LOOKUP_ROW> rowClass,
+ Comparator<LOOKUP_ROW> lookupRowDoComparator) {
+ return filterData(restriction, data, idAccessor, textAccessor, null, truePredicate(), rowClass, identityMapper(), lookupRowDoComparator);
+ }
+
+ /**
+ * Filter stream of {@code data} according to specified {@code restriction} and converts the stream to a
+ * LookupResponse containing a list of mapped lookup rows.
+ *
+ * @param <LOOKUP_ROW>
+ * Type of lookup row (subclass of {@link AbstractLookupRowDo})
+ * @param <ID>
+ * Primary key type of data items
+ * @param <RESTRICTION>
+ * Type of lookup restriction (subclass of {@link AbstractLookupRestrictionDo}
+ * @param <DATA>
+ * Type of data items
+ * @param restriction
+ * Lookup call restriction object used to filter the stream of data
+ * @param data
+ * Stream of data items
+ * @param idAccessor
+ * Accessor method to get the ID of a data item
+ * @param textAccessor
+ * Accessor method to get the text of a data item
+ * @param activeAccessor
+ * Accessor method to get the active state of a data item
+ * @param rowClass
+ * Class type of lookup row to create
+ */
+ public <LOOKUP_ROW extends AbstractLookupRowDo<LOOKUP_ROW, ID>, ID, RESTRICTION extends AbstractLookupRestrictionDo<RESTRICTION, ID>, DATA> LookupResponse<LOOKUP_ROW>
+ filterData(RESTRICTION restriction,
+ Stream<DATA> data,
+ Function<DATA, ID> idAccessor,
+ Function<DATA, String> textAccessor,
+ Function<DATA, Boolean> activeAccessor,
+ Class<LOOKUP_ROW> rowClass) {
+ return filterData(restriction, data, idAccessor, textAccessor, activeAccessor, truePredicate(), rowClass, identityMapper(), lookupRowDoComparatorByText());
+ }
+
+ /**
+ * Filter stream of {@code data} according to specified {@code restriction} and <b> using an additional custom filter
+ * {@code additionalFilter}</b> and converts the stream to a LookupResponse containing a list of mapped lookup rows.
+ *
+ * @see LookupHelper#filterData(AbstractLookupRestrictionDo, Stream, Function, Function, Class)
+ * @param additionalFilter
+ * Additional filter for stream of data
+ */
+ public <LOOKUP_ROW extends AbstractLookupRowDo<LOOKUP_ROW, ID>, ID, RESTRICTION extends AbstractLookupRestrictionDo<RESTRICTION, ID>, DATA> LookupResponse<LOOKUP_ROW>
+ filterData(RESTRICTION restriction,
+ Stream<DATA> data,
+ Function<DATA, ID> idAccessor,
+ Function<DATA, String> textAccessor,
+ Function<DATA, Boolean> activeAccessor,
+ Predicate<DATA> additionalFilter,
+ Class<LOOKUP_ROW> rowClass) {
+ return filterData(restriction, data, idAccessor, textAccessor, activeAccessor, additionalFilter, rowClass, identityMapper(), lookupRowDoComparatorByText());
+ }
+
+ /**
+ * Filter stream of {@code data} according to specified {@code restriction} and <b> using an additional custom filter
+ * {@code additionalFilter}</b>. Converts the stream to a LookupResponse containing a list of mapped lookup rows
+ * <b>using an additional custom {@code additionalMapper}</b>
+ *
+ * @see LookupHelper#filterData(AbstractLookupRestrictionDo, Stream, Function, Function, Class)
+ * @param additionalFilter
+ * Additional filter for stream of data
+ * @param additionalMapper
+ * Additional mapper to map custom properties from data object to lookup row type
+ * @param lookupRowDoComparator
+ * Comparator the resulting {@link AbstractLookupRowDo} as sorted with. No sorting if Comparator is null.
+ */
+ @SuppressWarnings("squid:S00107")
+ public <LOOKUP_ROW extends AbstractLookupRowDo<LOOKUP_ROW, ID>, ID, RESTRICTION extends AbstractLookupRestrictionDo<RESTRICTION, ID>, DATA> LookupResponse<LOOKUP_ROW>
+ filterData(RESTRICTION restriction,
+ Stream<DATA> dataStream,
+ Function<DATA, ID> idAccessor,
+ Function<DATA, String> textAccessor,
+ Function<DATA, Boolean> activeAccessor,
+ Predicate<DATA> additionalFilter,
+ Class<LOOKUP_ROW> rowClass,
+ BiFunction<LOOKUP_ROW, DATA, LOOKUP_ROW> additionalMapper,
+ Comparator<LOOKUP_ROW> lookupRowDoComparator) {
+
+ Stream<LOOKUP_ROW> stream = dataStream
+ .filter(restrictionPredicate(restriction, idAccessor, textAccessor, activeAccessor))
+ .filter(additionalFilter)
+ .map(data -> {
+ LOOKUP_ROW row = BEANS.get(rowClass)
+ .withId(idAccessor.apply(data))
+ .withText(textAccessor.apply(data));
+ return additionalMapper.apply(row, data);
+ });
+ if (lookupRowDoComparator != null) {
+ stream = stream.sorted(lookupRowDoComparator);
+ }
+ List<LOOKUP_ROW> rows = stream.collect(Collectors.toList());
+ return LookupResponse.create(rows);
+ }
+
+ /**
+ * Convenience method for filtering values of an {@link IEnum} and transforming them into
+ * {@link AbstractLookupRowDo}s.
+ * <p>
+ * This method does not support applying additional filters or mapping additional properties. Use one of the
+ * {@code filterData} methods instead.
+ *
+ * @param restriction
+ * Lookup call restriction object used to filter the stream of data
+ * @param enumClass
+ * {@link IEnum} class all values are taken from
+ * @param rowClass
+ * Class type of lookup row to create
+ */
+ public <LOOKUP_ROW extends AbstractLookupRowDo<LOOKUP_ROW, ENUM>, ENUM extends Enum<?> & IEnum, RESTRICTION extends AbstractLookupRestrictionDo<RESTRICTION, ENUM>> LookupResponse<LOOKUP_ROW>
+ filterEnum(RESTRICTION restriction,
+ Class<ENUM> enumClass,
+ Class<LOOKUP_ROW> rowClass) {
+ return filterData(restriction,
+ Arrays.stream(enumClass.getEnumConstants()),
+ Function.identity(),
+ enumTextResolver(),
+ rowClass);
+ }
+
+ /**
+ * Convenience method for filtering values of an {@link IEnum} and transforming them into
+ * {@link AbstractLookupRowDo}s. It keeps the natural sorting of the value as defined in {@link IEnum}.
+ * <p>
+ * This method does not support applying additional filters or mapping additional properties. Use one of the
+ * {@code filterData} methods instead.
+ *
+ * @param restriction
+ * Lookup call restriction object used to filter the stream of data
+ * @param enumClass
+ * {@link IEnum} class all values are taken from
+ * @param rowClass
+ * Class type of lookup row to create
+ */
+ public <LOOKUP_ROW extends AbstractLookupRowDo<LOOKUP_ROW, ENUM>, ENUM extends Enum<?> & IEnum, RESTRICTION extends AbstractLookupRestrictionDo<RESTRICTION, ENUM>> LookupResponse<LOOKUP_ROW>
+ filterEnumKeepSorting(RESTRICTION restriction,
+ Class<ENUM> enumClass,
+ Class<LOOKUP_ROW> rowClass) {
+ return filterData(restriction,
+ Arrays.stream(enumClass.getEnumConstants()),
+ Function.identity(),
+ enumTextResolver(),
+ null,
+ truePredicate(),
+ rowClass,
+ identityMapper(),
+ null);
+ }
+
+ /**
+ * @return {@link AbstractLookupRestrictionDo#maxRowCount()} if not {@code null}, {@link #DEFAULT_MAX_ROWS} otherwise.
+ */
+ public int maxRowCount(AbstractLookupRestrictionDo<?, ?> restriction) {
+ return NumberUtility.nvl(restriction.getMaxRowCount(), DEFAULT_MAX_ROWS);
+ }
+
+ /**
+ * {@link Predicate} which is always true
+ */
+ public static <T> Predicate<T> truePredicate() {
+ return t -> true;
+ }
+
+ /**
+ * Identity data mapper
+ */
+ public static <T, R> BiFunction<T, R, T> identityMapper() {
+ return (r, d) -> r;
+ }
+
+ /**
+ * {@link Function} that resolves the text of an {@link IEnum} using {@link IEnum#text()} and
+ * {@link TEXTS#get(String)}. Both, <code>null</code> enums as well as <code>null</code> textKeys are resolved to
+ * <code>null</code>.
+ */
+ public static <ENUM extends IEnum> Function<ENUM, String> enumTextResolver() {
+ return e -> e == null ? null : e.text();
+ }
+
+ /**
+ * {@link Comparator} working on {@link AbstractLookupRowDo#getText()}.
+ */
+ public static <LOOKUP_ROW extends AbstractLookupRowDo<?, ?>> Comparator<LOOKUP_ROW> lookupRowDoComparatorByText() {
+ Collator collator = BEANS.get(CollatorProvider.class).getInstance();
+ return (o1, o2) -> collator.compare(o1.getText(), o2.getText());
+ }
+
+ /**
+ * {@link Predicate} using the given {@code restriction} and the provided accessors {@code idAccessor} and
+ * {@code textAccessor}. The predicate reflects the restrictions provided with
+ * {@link AbstractLookupRestrictionDo#ids()} and {@link AbstractLookupRestrictionDo#text()}.
+ * <p>
+ * If {@code restriction} is {@code null}, {@link #truePredicate()} is returned.
+ */
+ public <ID, RESTRICTION extends AbstractLookupRestrictionDo<RESTRICTION, ID>, DATA> Predicate<DATA> restrictionPredicate(RESTRICTION restriction,
+ Function<DATA, ID> idAccessor,
+ Function<DATA, String> textAccessor,
+ Function<DATA, Boolean> activeAccessor) {
+ if (restriction == null) {
+ return truePredicate();
+ }
+ List<ID> ids = restriction.getIds();
+ Predicate<DATA> predicate = textPatternPredicate(restriction.getText(), textAccessor);
+ if (idAccessor != null && !ids.isEmpty()) {
+ predicate = predicate.and(data -> ids.contains(idAccessor.apply(data)));
+ }
+ if (activeAccessor != null) {
+ predicate = predicate.and(activePredicate(restriction.getActive(), activeAccessor));
+ }
+ return predicate;
+ }
+
+ /**
+ * {@link Predicate} using the given {@code textPattern} converted into a {@link Pattern} and the given
+ * {@code textAccessor} applied on the object the predicate is working on. If {@code textPattern} is {@code null},
+ * {@link #truePredicate()} is returned.
+ */
+ public <DATA> Predicate<DATA> textPatternPredicate(String textPattern, Function<DATA, String> textAccessor) {
+ if (textPattern == null) {
+ return truePredicate();
+ }
+ Assertions.assertNotNull(textAccessor, "textAccessor is required");
+ Pattern pattern = createTextSearchPattern(textPattern);
+ return data -> {
+ if (data == null) {
+ return false;
+ }
+ String text = textAccessor.apply(data);
+ return text != null && pattern.matcher(text).matches();
+ };
+ }
+
+ /**
+ * {@link Predicate} using the given {@code active} value to filter.
+ * <p>
+ * If {@code active} is {@code null}, {@link #truePredicate()} is returned.
+ */
+ public <DATA> Predicate<DATA> activePredicate(Boolean active, Function<DATA, Boolean> activeAccessor) {
+ if (active == null) {
+ return truePredicate();
+ }
+ Assertions.assertNotNull(activeAccessor, "activeAccessor is required");
+ boolean activeBoolean = active.booleanValue();
+ return data -> {
+ if (data == null) {
+ return false;
+ }
+ Boolean dataActive = activeAccessor.apply(data);
+ return dataActive != null && dataActive.booleanValue() == activeBoolean;
+ };
+ }
+
+ /**
+ * Text lookup pattern like CRM CoreUtility
+ */
+ protected Pattern createTextSearchPattern(String text) {
+ if (text == null) {
+ text = "";
+ }
+ text = text.replace(WILDCARD, WILDCARD_REPLACE);
+ text = StringUtility.escapeRegexMetachars(text);
+ text = text.replace(WILDCARD_REPLACE, MATCH_ALL_REGEX);
+ if (!text.contains(MATCH_ALL_REGEX)) {
+ text = text + MATCH_ALL_REGEX;
+ }
+ if (!text.startsWith(MATCH_ALL_REGEX)) {
+ text = MATCH_ALL_REGEX + text;
+ }
+ return Pattern.compile(text, Pattern.DOTALL | Pattern.CASE_INSENSITIVE | Pattern.UNICODE_CASE);
+ }
+
+ /**
+ * Extracts ids form the given values and resolves them.
+ */
+ public <V, ID> Map<ID, String> resolve(
+ Stream<V> values,
+ Function<V, ID> idExtractor,
+ Function<Set<ID>, List<? extends AbstractLookupRowDo<?, ID>>> textResolver) {
+ Set<ID> ids = values
+ .map(idExtractor)
+ .filter(Objects::nonNull)
+ .collect(Collectors.toSet());
+ return textResolver.apply(ids)
+ .stream()
+ .collect(StreamUtility.toMap(AbstractLookupRowDo::getId, AbstractLookupRowDo::getText));
+ }
+}
diff --git a/org.eclipse.scout.rt.dataobject/src/main/java/org/eclipse/scout/rt/dataobject/lookup/LookupResponse.java b/org.eclipse.scout.rt.dataobject/src/main/java/org/eclipse/scout/rt/dataobject/lookup/LookupResponse.java
new file mode 100644
index 0000000..7db5959
--- /dev/null
+++ b/org.eclipse.scout.rt.dataobject/src/main/java/org/eclipse/scout/rt/dataobject/lookup/LookupResponse.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2010-2020 BSI Business Systems Integration AG.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * BSI Business Systems Integration AG - initial API and implementation
+ */
+package org.eclipse.scout.rt.dataobject.lookup;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+
+import javax.annotation.Generated;
+
+import org.eclipse.scout.rt.dataobject.DoEntity;
+import org.eclipse.scout.rt.dataobject.DoList;
+import org.eclipse.scout.rt.dataobject.TypeName;
+import org.eclipse.scout.rt.platform.BEANS;
+
+@TypeName("scout.LookupResponse")
+@SuppressWarnings("unchecked")
+public class LookupResponse<T extends AbstractLookupRowDo<?, ?>> extends DoEntity {
+
+ public DoList<T> rows() {
+ return doList("rows");
+ }
+
+ /**
+ * Convenience method to create a {@link LookupResponse} with specified collection of rows.
+ */
+ public static <T extends AbstractLookupRowDo<?, ?>> LookupResponse<T> create(Collection<T> rows) {
+ return BEANS.get(LookupResponse.class).withRows(rows);
+ }
+
+ /* **************************************************************************
+ * GENERATED CONVENIENCE METHODS
+ * *************************************************************************/
+
+ @Generated("DoConvenienceMethodsGenerator")
+ public LookupResponse<T> withRows(Collection<T> rows) {
+ rows().clear();
+ rows().get().addAll(rows);
+ return this;
+ }
+
+ @Generated("DoConvenienceMethodsGenerator")
+ public LookupResponse<T> withRows(T... rows) {
+ return withRows(Arrays.asList(rows));
+ }
+
+ @Generated("DoConvenienceMethodsGenerator")
+ public List<T> getRows() {
+ return rows().get();
+ }
+}
diff --git a/org.eclipse.scout.rt.dataobject/src/main/java/org/eclipse/scout/rt/dataobject/lookup/StringLookupRestrictionDo.java b/org.eclipse.scout.rt.dataobject/src/main/java/org/eclipse/scout/rt/dataobject/lookup/StringLookupRestrictionDo.java
new file mode 100644
index 0000000..d1900a9
--- /dev/null
+++ b/org.eclipse.scout.rt.dataobject/src/main/java/org/eclipse/scout/rt/dataobject/lookup/StringLookupRestrictionDo.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2010-2020 BSI Business Systems Integration AG.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * BSI Business Systems Integration AG - initial API and implementation
+ */
+package org.eclipse.scout.rt.dataobject.lookup;
+
+import org.eclipse.scout.rt.dataobject.DoList;
+import org.eclipse.scout.rt.dataobject.TypeName;
+import org.eclipse.scout.rt.platform.BEANS;
+import org.eclipse.scout.rt.platform.util.ObjectUtility;
+
+@TypeName("scout.StringLookupRestriction")
+public class StringLookupRestrictionDo extends AbstractLookupRestrictionDo<StringLookupRestrictionDo, String> {
+
+ @Override
+ public DoList<String> ids() {
+ return createIdsAttribute(this);
+ }
+
+ /**
+ * @return Specified {@code restriction} if not null, otherwise a new {@link StringLookupRestrictionDo} instance.
+ */
+ public static StringLookupRestrictionDo ensure(StringLookupRestrictionDo restriction) {
+ return ObjectUtility.nvl(restriction, BEANS.get(StringLookupRestrictionDo.class));
+ }
+}
diff --git a/org.eclipse.scout.rt.dataobject/src/main/java/org/eclipse/scout/rt/dataobject/lookup/StringLookupRowDo.java b/org.eclipse.scout.rt.dataobject/src/main/java/org/eclipse/scout/rt/dataobject/lookup/StringLookupRowDo.java
new file mode 100644
index 0000000..ed3a22f
--- /dev/null
+++ b/org.eclipse.scout.rt.dataobject/src/main/java/org/eclipse/scout/rt/dataobject/lookup/StringLookupRowDo.java
@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) 2010-2020 BSI Business Systems Integration AG.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * BSI Business Systems Integration AG - initial API and implementation
+ */
+package org.eclipse.scout.rt.dataobject.lookup;
+
+import org.eclipse.scout.rt.dataobject.DoValue;
+import org.eclipse.scout.rt.dataobject.TypeName;
+
+@TypeName("scout.StringLookupRow")
+public class StringLookupRowDo extends AbstractLookupRowDo<StringLookupRowDo, String> {
+
+ @Override
+ public DoValue<String> id() {
+ return createIdAttribute(this);
+ }
+}
