This is an automated email from the ASF dual-hosted git repository.
ntimofeev pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/cayenne.git
The following commit(s) were added to refs/heads/master by this push:
new 34d417e CAY-2677 Custom Class Generation Templates for Embeddables
and DataMaps applying patch from Stefan S, see JIRA issue
34d417e is described below
commit 34d417e206a9d375cdbc6f4bc194395c2b7e1c21
Author: Nikita Timofeev <[email protected]>
AuthorDate: Tue Feb 2 17:12:45 2021 +0300
CAY-2677 Custom Class Generation Templates for Embeddables and DataMaps
applying patch from Stefan S, see JIRA issue
---
RELEASE-NOTES.txt | 1 +
.../org/apache/cayenne/gen/CgenConfiguration.java | 6 ++
.../apache/cayenne/gen/xml/CgenConfigHandler.java | 82 +++++++++++--------
.../org/apache/cayenne/schema/10/cgen.xsd | 4 +
.../cayenne/modeler/CodeTemplateManager.java | 92 +++++++++++++--------
.../modeler/editor/cgen/CustomModeController.java | 75 +++++++++++++++++
.../modeler/editor/cgen/CustomModePanel.java | 93 +++++++++++++++++++++-
7 files changed, 285 insertions(+), 68 deletions(-)
diff --git a/RELEASE-NOTES.txt b/RELEASE-NOTES.txt
index 3874d10..6ab024c 100644
--- a/RELEASE-NOTES.txt
+++ b/RELEASE-NOTES.txt
@@ -13,6 +13,7 @@ Date:
----------------------------------
Changes/New Features:
+CAY-2677 Custom Class Generation Templates for Embeddables and DataMaps
CAY-2689 ServerRuntime API: missing some variants of the
performInTransaction() method
CAY-2692 Add entity lifecycle callbacks via annotated methods
diff --git
a/cayenne-cgen/src/main/java/org/apache/cayenne/gen/CgenConfiguration.java
b/cayenne-cgen/src/main/java/org/apache/cayenne/gen/CgenConfiguration.java
index 1912b95..9aab326 100644
--- a/cayenne-cgen/src/main/java/org/apache/cayenne/gen/CgenConfiguration.java
+++ b/cayenne-cgen/src/main/java/org/apache/cayenne/gen/CgenConfiguration.java
@@ -412,6 +412,12 @@ public class CgenConfiguration implements Serializable,
XMLSerializable {
.simpleTag("mode", this.artifactsGenerationMode.getLabel())
.simpleTag("template", this.template)
.simpleTag("superTemplate", this.superTemplate)
+ .simpleTag("template", this.template)
+ .simpleTag("superTemplate", this.superTemplate)
+ .simpleTag("embeddableTemplate", this.embeddableTemplate)
+ .simpleTag("embeddableSuperTemplate",
this.embeddableSuperTemplate)
+ .simpleTag("queryTemplate", this.queryTemplate)
+ .simpleTag("querySuperTemplate", this.querySuperTemplate)
.simpleTag("outputPattern", this.outputPattern)
.simpleTag("makePairs", Boolean.toString(this.makePairs))
.simpleTag("usePkgPath", Boolean.toString(this.usePkgPath))
diff --git
a/cayenne-cgen/src/main/java/org/apache/cayenne/gen/xml/CgenConfigHandler.java
b/cayenne-cgen/src/main/java/org/apache/cayenne/gen/xml/CgenConfigHandler.java
index 6a80f91..aabbf2c 100644
---
a/cayenne-cgen/src/main/java/org/apache/cayenne/gen/xml/CgenConfigHandler.java
+++
b/cayenne-cgen/src/main/java/org/apache/cayenne/gen/xml/CgenConfigHandler.java
@@ -43,6 +43,10 @@ public class CgenConfigHandler extends
NamespaceAwareNestedTagHandler{
private static final String GENERATION_MODE_TAG = "mode";
private static final String SUBCLASS_TEMPLATE_TAG = "template";
private static final String SUPERCLASS_TEMPLATE_TAG = "superTemplate";
+ private static final String EMBEDDABLE_TEMPLATE_TAG = "embeddableTemplate";
+ private static final String EMBEDDABLE_SUPER_TEMPLATE_TAG =
"embeddableSuperTemplate";
+ private static final String QUERY_TEMPLATE_TAG = "queryTemplate";
+ private static final String QUERY_SUPER_TEMPLATE_TAG =
"querySuperTemplate";
private static final String OUTPUT_PATTERN_TAG = "outputPattern";
private static final String MAKE_PAIRS_TAG = "makePairs";
private static final String USE_PKG_PATH_TAG = "usePkgPath";
@@ -97,6 +101,17 @@ public class CgenConfigHandler extends
NamespaceAwareNestedTagHandler{
case SUPERCLASS_TEMPLATE_TAG:
createSuperclassTemplate(data);
break;
+ case EMBEDDABLE_TEMPLATE_TAG:
+ createEmbeddableTemplate(data);
+ break;
+ case EMBEDDABLE_SUPER_TEMPLATE_TAG:
+ createEmbeddableSuperTemplate(data);
+ case QUERY_TEMPLATE_TAG:
+ createQueryTemplate(data);
+ break;
+ case QUERY_SUPER_TEMPLATE_TAG:
+ createQuerySuperTemplate(data);
+ break;
case OUTPUT_PATTERN_TAG:
createOutputPattern(data);
break;
@@ -165,6 +180,34 @@ public class CgenConfigHandler extends
NamespaceAwareNestedTagHandler{
}
configuration.setSuperTemplate(template);
}
+
+ private void createEmbeddableTemplate(String template) {
+ if(template.trim().length() == 0) {
+ return;
+ }
+ configuration.setEmbeddableTemplate(template);
+ }
+
+ private void createEmbeddableSuperTemplate(String template) {
+ if(template.trim().length() == 0) {
+ return;
+ }
+ configuration.setEmbeddableSuperTemplate(template);
+ }
+
+ private void createQueryTemplate(String template) {
+ if(template.trim().length() == 0) {
+ return;
+ }
+ configuration.setQueryTemplate(template);
+ }
+
+ private void createQuerySuperTemplate(String template) {
+ if(template.trim().length() == 0) {
+ return;
+ }
+ configuration.setQuerySuperTemplate(template);
+ }
private void createOutputPattern(String pattern) {
if(pattern.trim().length() == 0) {
@@ -177,69 +220,42 @@ public class CgenConfigHandler extends
NamespaceAwareNestedTagHandler{
if (makePairs.trim().length() == 0) {
return;
}
-
- if (makePairs.equals(TRUE)) {
- configuration.setMakePairs(true);
- } else {
- configuration.setMakePairs(false);
- }
+ configuration.setMakePairs(makePairs.equals(TRUE));
}
private void createUsePkgPath(String data) {
if(data.trim().length() == 0) {
return;
}
- if(data.equals(TRUE)) {
- configuration.setUsePkgPath(true);
- } else {
- configuration.setUsePkgPath(false);
- }
+ configuration.setUsePkgPath(data.equals(TRUE));
}
private void createOverwriteSubclasses(String data) {
if(data.trim().length() == 0) {
return;
}
-
- if(data.equals(TRUE)) {
- configuration.setOverwrite(true);
- } else {
- configuration.setOverwrite(false);
- }
+ configuration.setOverwrite(data.equals(TRUE));
}
private void createPropertyNamesTag(String data) {
if(data.trim().length() == 0) {
return;
}
- if(data.equals(TRUE)) {
- configuration.setCreatePropertyNames(true);
- } else {
- configuration.setCreatePropertyNames(false);
- }
+ configuration.setCreatePropertyNames(data.equals(TRUE));
}
private void createPkPropertiesTag(String data) {
if(data.trim().length() == 0) {
return;
}
-
- if(data.equals(TRUE)) {
- configuration.setCreatePKProperties(true);
- } else {
- configuration.setCreatePKProperties(false);
- }
+ configuration.setCreatePKProperties(data.equals(TRUE));
}
private void createClient(String data) {
if(data.trim().length() == 0) {
return;
}
- if(data.equals(TRUE)) {
- configuration.setClient(true);
- } else {
- configuration.setClient(false);
- }
+ configuration.setClient(data.equals(TRUE));
}
private void createSuperPkg(String data) {
diff --git
a/cayenne-server/src/main/resources/org/apache/cayenne/schema/10/cgen.xsd
b/cayenne-server/src/main/resources/org/apache/cayenne/schema/10/cgen.xsd
index 4212db1..31a407d 100644
--- a/cayenne-server/src/main/resources/org/apache/cayenne/schema/10/cgen.xsd
+++ b/cayenne-server/src/main/resources/org/apache/cayenne/schema/10/cgen.xsd
@@ -32,6 +32,10 @@
<xs:element name="mode" minOccurs="0" type="xs:string"/>
<xs:element name="template" minOccurs="0"
type="xs:string"/>
<xs:element name="superTemplate" minOccurs="0"
type="xs:string"/>
+ <xs:element name="embeddableTemplate" minOccurs="0"
type="xs:string"/>
+ <xs:element name="embeddableSuperTemplate" minOccurs="0"
type="xs:string"/>
+ <xs:element name="queryTemplate" minOccurs="0"
type="xs:string"/>
+ <xs:element name="querySuperTemplate" minOccurs="0"
type="xs:string"/>
<xs:element name="outputPattern" minOccurs="0"
type="xs:string"/>
<xs:element name="makePairs" minOccurs="0"
type="xs:boolean"/>
<xs:element name="skipRelationshipsLoading" minOccurs="0"
type="xs:boolean"/>
diff --git
a/modeler/cayenne-modeler/src/main/java/org/apache/cayenne/modeler/CodeTemplateManager.java
b/modeler/cayenne-modeler/src/main/java/org/apache/cayenne/modeler/CodeTemplateManager.java
index f9f6108..09ea39a 100644
---
a/modeler/cayenne-modeler/src/main/java/org/apache/cayenne/modeler/CodeTemplateManager.java
+++
b/modeler/cayenne-modeler/src/main/java/org/apache/cayenne/modeler/CodeTemplateManager.java
@@ -43,17 +43,19 @@ public class CodeTemplateManager {
public static final String STANDARD_SERVER_SUPERCLASS = "Standard
Server Superclass";
public static final String STANDARD_SERVER_SUBCLASS = "Standard Server
Subclass";
- public static final String SINGLE_SERVER_CLASS = "Single Server class";
+ public static final String SINGLE_SERVER_CLASS = "Single Server Class";
static final String STANDARD_CLIENT_SUPERCLASS = "Standard Client
Superclass";
static final String STANDARD_CLIENT_SUBCLASS = "Standard Client
Subclass";
- private static final String STANDART_EMBEDDABLE_SUPERCLASS = "Standart
Embeddable Superclass";
- private static final String STANDART_EMBEDDABLE_SUBCLASS = "Standart
Embeddable Subclass";
- private static final String SINGLE_EMBEDDABLE_CLASS = "Single
Embeddable class";
+ private static final String STANDARD_EMBEDDABLE_SUPERCLASS = "Standard
Embeddable Superclass";
+ private static final String STANDARD_EMBEDDABLE_SUBCLASS = "Standard
Embeddable Subclass";
+ private static final String SINGLE_EMBEDDABLE_CLASS = "Single
Embeddable Class";
- private static final String STANDART_DATAMAP_SUPERCLASS = "Standart
DataMap Superclass";
- private static final String STANDART_DATAMAP_SUBCLASS = "Standart
DataMap Subclass";
- private static final String SINGLE_DATAMAP_CLASS = "Single DataMap
class";
+ private static final String STANDARD_SERVER_DATAMAP_SUPERCLASS =
"Standard Server DataMap Superclass";
+ private static final String STANDARD_SERVER_DATAMAP_SUBCLASS =
"Standard Server DataMap Subclass";
+ private static final String STANDARD_CLIENT_DATAMAP_SUPERCLASS =
"Standard Client DataMap Superclass";
+ private static final String STANDARD_CLIENT_DATAMAP_SUBCLASS =
"Standard Client DataMap Subclass";
+ private static final String SINGLE_DATAMAP_CLASS = "Single DataMap
Class";
public static final String NODE_NAME = "codeTemplateManager";
@@ -65,11 +67,13 @@ public class CodeTemplateManager {
private Map<String, String> reverseCustomTemplate;
private Map<String, String> standardTemplates;
- private List<String> standartEmbeddableTemplates;
- private List<String> standartEmbeddableSuperclassTemplates;
+ private List<String> standardEmbeddableTemplates;
+ private List<String> standardEmbeddableSuperclassTemplates;
- private List<String> standartDataMapTemplates;
- private List<String> standartDataMapSuperclassTemplates;
+ private List<String> standardServerDataMapTemplates;
+ private List<String> standardServerDataMapSuperclassTemplates;
+ private List<String> standardClientDataMapTemplates;
+ private List<String> standardClientDataMapSuperclassTemplates;
private Map<String, String> reverseStandartTemplates;
@@ -93,19 +97,25 @@ public class CodeTemplateManager {
standardClientSubclassTemplates = new ArrayList<>();
standardClientSubclassTemplates.add(STANDARD_CLIENT_SUBCLASS);
- standartEmbeddableTemplates = new ArrayList<>();
- standartEmbeddableTemplates.add(SINGLE_EMBEDDABLE_CLASS);
- standartEmbeddableTemplates.add(STANDART_EMBEDDABLE_SUBCLASS);
+ standardEmbeddableTemplates = new ArrayList<>();
+ standardEmbeddableTemplates.add(STANDARD_EMBEDDABLE_SUBCLASS);
+ standardEmbeddableTemplates.add(SINGLE_EMBEDDABLE_CLASS);
- standartEmbeddableSuperclassTemplates = new ArrayList<>();
-
standartEmbeddableSuperclassTemplates.add(STANDART_EMBEDDABLE_SUPERCLASS);
+ standardEmbeddableSuperclassTemplates = new ArrayList<>();
+
standardEmbeddableSuperclassTemplates.add(STANDARD_EMBEDDABLE_SUPERCLASS);
- standartDataMapTemplates = new ArrayList<>();
- standartDataMapTemplates.add(STANDART_DATAMAP_SUBCLASS);
- standartDataMapTemplates.add(SINGLE_DATAMAP_CLASS);
+ standardServerDataMapTemplates = new ArrayList<>();
+
standardServerDataMapTemplates.add(STANDARD_SERVER_DATAMAP_SUBCLASS);
+ standardServerDataMapTemplates.add(SINGLE_DATAMAP_CLASS);
- standartDataMapSuperclassTemplates = new ArrayList<>();
-
standartDataMapSuperclassTemplates.add(STANDART_DATAMAP_SUPERCLASS);
+ standardServerDataMapSuperclassTemplates = new ArrayList<>();
+
standardServerDataMapSuperclassTemplates.add(STANDARD_SERVER_DATAMAP_SUPERCLASS);
+
+ standardClientDataMapTemplates = new ArrayList<>();
+
standardClientDataMapTemplates.add(STANDARD_CLIENT_DATAMAP_SUBCLASS);
+
+ standardClientDataMapSuperclassTemplates = new ArrayList<>();
+
standardClientDataMapSuperclassTemplates.add(STANDARD_CLIENT_DATAMAP_SUPERCLASS);
updateCustomTemplates(getTemplatePreferences(application));
reverseCustomTemplate = new HashMap<>();
@@ -120,13 +130,15 @@ public class CodeTemplateManager {
standardTemplates.put(STANDARD_CLIENT_SUBCLASS,
ClientClassGenerationAction.SUBCLASS_TEMPLATE);
standardTemplates.put(SINGLE_SERVER_CLASS,
ClassGenerationAction.SINGLE_CLASS_TEMPLATE);
- standardTemplates.put(STANDART_EMBEDDABLE_SUPERCLASS,
ClassGenerationAction.EMBEDDABLE_SUPERCLASS_TEMPLATE);
- standardTemplates.put(STANDART_EMBEDDABLE_SUBCLASS,
ClassGenerationAction.EMBEDDABLE_SUBCLASS_TEMPLATE);
+ standardTemplates.put(STANDARD_EMBEDDABLE_SUPERCLASS,
ClassGenerationAction.EMBEDDABLE_SUPERCLASS_TEMPLATE);
+ standardTemplates.put(STANDARD_EMBEDDABLE_SUBCLASS,
ClassGenerationAction.EMBEDDABLE_SUBCLASS_TEMPLATE);
standardTemplates.put(SINGLE_EMBEDDABLE_CLASS,
ClassGenerationAction.EMBEDDABLE_SINGLE_CLASS_TEMPLATE);
- standardTemplates.put(STANDART_DATAMAP_SUBCLASS,
ClassGenerationAction.DATAMAP_SUBCLASS_TEMPLATE);
+ standardTemplates.put(STANDARD_SERVER_DATAMAP_SUBCLASS,
ClassGenerationAction.DATAMAP_SUBCLASS_TEMPLATE);
+ standardTemplates.put(STANDARD_CLIENT_DATAMAP_SUBCLASS,
ClientClassGenerationAction.DMAP_SUBCLASS_TEMPLATE);
standardTemplates.put(SINGLE_DATAMAP_CLASS,
ClassGenerationAction.DATAMAP_SINGLE_CLASS_TEMPLATE);
- standardTemplates.put(STANDART_DATAMAP_SUPERCLASS,
ClassGenerationAction.DATAMAP_SUPERCLASS_TEMPLATE);
+ standardTemplates.put(STANDARD_SERVER_DATAMAP_SUPERCLASS,
ClassGenerationAction.DATAMAP_SUPERCLASS_TEMPLATE);
+ standardTemplates.put(STANDARD_CLIENT_DATAMAP_SUPERCLASS,
ClientClassGenerationAction.DMAP_SUPERCLASS_TEMPLATE);
reverseStandartTemplates = new HashMap<>();
reverseStandartTemplates.put(ClassGenerationAction.SUBCLASS_TEMPLATE,
STANDARD_SERVER_SUBCLASS);
@@ -135,13 +147,15 @@ public class CodeTemplateManager {
reverseStandartTemplates.put(ClientClassGenerationAction.SUPERCLASS_TEMPLATE,
STANDARD_CLIENT_SUPERCLASS);
reverseStandartTemplates.put(ClassGenerationAction.SUPERCLASS_TEMPLATE,
STANDARD_SERVER_SUPERCLASS);
-
reverseStandartTemplates.put(ClassGenerationAction.EMBEDDABLE_SUPERCLASS_TEMPLATE,
STANDART_EMBEDDABLE_SUPERCLASS);
-
reverseStandartTemplates.put(ClassGenerationAction.EMBEDDABLE_SUBCLASS_TEMPLATE,
STANDART_EMBEDDABLE_SUBCLASS);
+
reverseStandartTemplates.put(ClassGenerationAction.EMBEDDABLE_SUPERCLASS_TEMPLATE,
STANDARD_EMBEDDABLE_SUPERCLASS);
+
reverseStandartTemplates.put(ClassGenerationAction.EMBEDDABLE_SUBCLASS_TEMPLATE,
STANDARD_EMBEDDABLE_SUBCLASS);
reverseStandartTemplates.put(ClassGenerationAction.EMBEDDABLE_SINGLE_CLASS_TEMPLATE,
SINGLE_EMBEDDABLE_CLASS);
-
reverseStandartTemplates.put(ClassGenerationAction.DATAMAP_SUBCLASS_TEMPLATE,
STANDART_DATAMAP_SUBCLASS);
+
reverseStandartTemplates.put(ClassGenerationAction.DATAMAP_SUBCLASS_TEMPLATE,
STANDARD_SERVER_DATAMAP_SUBCLASS);
+
reverseStandartTemplates.put(ClientClassGenerationAction.DMAP_SUBCLASS_TEMPLATE,
STANDARD_CLIENT_DATAMAP_SUBCLASS);
reverseStandartTemplates.put(ClassGenerationAction.DATAMAP_SINGLE_CLASS_TEMPLATE,
SINGLE_DATAMAP_CLASS);
-
reverseStandartTemplates.put(ClassGenerationAction.DATAMAP_SUPERCLASS_TEMPLATE,
STANDART_DATAMAP_SUPERCLASS);
+
reverseStandartTemplates.put(ClassGenerationAction.DATAMAP_SUPERCLASS_TEMPLATE,
STANDARD_SERVER_DATAMAP_SUPERCLASS);
+
reverseStandartTemplates.put(ClientClassGenerationAction.DMAP_SUPERCLASS_TEMPLATE,
STANDARD_CLIENT_DATAMAP_SUPERCLASS);
}
/**
@@ -212,14 +226,26 @@ public class CodeTemplateManager {
}
public List<String> getStandartEmbeddableTemplates() {
- return standartEmbeddableTemplates;
+ return standardEmbeddableTemplates;
}
public List<String> getStandartEmbeddableSuperclassTemplates() {
- return standartEmbeddableSuperclassTemplates;
+ return standardEmbeddableSuperclassTemplates;
}
- public List<String> getStandartDataMapTemplates() { return
standartDataMapTemplates; }
+ public List<String> getStandartDataMapTemplates() {
+ return standardServerDataMapTemplates;
+ }
- public List<String> getStandartDataMapSuperclassTemplates() { return
standartDataMapSuperclassTemplates; }
+ public List<String> getStandartDataMapSuperclassTemplates() {
+ return standardServerDataMapSuperclassTemplates;
+ }
+
+ public List<String> getStandardClientDataMapTemplates() {
+ return standardClientDataMapTemplates;
+ }
+
+ public List<String> getStandardClientDataMapSuperclassTemplates() {
+ return standardClientDataMapSuperclassTemplates;
+ }
}
diff --git
a/modeler/cayenne-modeler/src/main/java/org/apache/cayenne/modeler/editor/cgen/CustomModeController.java
b/modeler/cayenne-modeler/src/main/java/org/apache/cayenne/modeler/editor/cgen/CustomModeController.java
index d051015..b6d7651 100644
---
a/modeler/cayenne-modeler/src/main/java/org/apache/cayenne/modeler/editor/cgen/CustomModeController.java
+++
b/modeler/cayenne-modeler/src/main/java/org/apache/cayenne/modeler/editor/cgen/CustomModeController.java
@@ -82,8 +82,32 @@ public class CustomModeController extends
GeneratorController {
Collections.sort(subTemplates);
subTemplates.addAll(customTemplates);
+ List<String> querySuperTemplates = isClient ?
+ new
ArrayList<>(templateManager.getStandardClientDataMapSuperclassTemplates()) :
+ new
ArrayList<>(templateManager.getStandartDataMapSuperclassTemplates());
+ Collections.sort(querySuperTemplates);
+ querySuperTemplates.addAll(customTemplates);
+
+ List<String> queryTemplates = isClient ?
+ new
ArrayList<>(templateManager.getStandardClientDataMapTemplates()) :
+ new ArrayList<>(templateManager.getStandartDataMapTemplates());
+ Collections.sort(queryTemplates);
+ queryTemplates.addAll(customTemplates);
+
+ List<String> embeddableSuperTemplates = new
ArrayList<>(templateManager.getStandartEmbeddableSuperclassTemplates());
+ Collections.sort(embeddableSuperTemplates);
+ embeddableSuperTemplates.addAll(customTemplates);
+
+ List<String> embeddableTemplates = new
ArrayList<>(templateManager.getStandartEmbeddableTemplates());
+ Collections.sort(embeddableTemplates);
+ embeddableTemplates.addAll(customTemplates);
+
this.view.getSubclassTemplate().getComboBox().setModel(new
DefaultComboBoxModel<>(subTemplates.toArray(new String[0])));
this.view.getSuperclassTemplate().getComboBox().setModel(new
DefaultComboBoxModel<>(superTemplates.toArray(new String[0])));
+ this.view.getQueryTemplate().getComboBox().setModel(new
DefaultComboBoxModel<>(queryTemplates.toArray(new String[0])));
+ this.view.getQuerySuperTemplate().getComboBox().setModel(new
DefaultComboBoxModel<>(querySuperTemplates.toArray(new String[0])));
+ this.view.getEmbeddableTemplate().getComboBox().setModel(new
DefaultComboBoxModel<>(embeddableTemplates.toArray(new String[0])));
+ this.view.getEmbeddableSuperTemplate().getComboBox().setModel(new
DefaultComboBoxModel<>(embeddableSuperTemplates.toArray(new String[0])));
}
public void missTemplateDialog(CgenConfiguration cgenConfiguration, String
template, String superTemplate) {
@@ -107,8 +131,22 @@ public class CustomModeController extends
GeneratorController {
cgenConfiguration.getTemplate(),
cgenConfiguration.getRootPath());
String superTemplateName =
getApplication().getCodeTemplateManager().getNameByPath(
cgenConfiguration.getSuperTemplate(),
cgenConfiguration.getRootPath());
+ String embeddableTemplateName =
getApplication().getCodeTemplateManager().getNameByPath(
+ cgenConfiguration.getEmbeddableTemplate(),
cgenConfiguration.getRootPath());
+ String embeddableSuperTemplateName =
getApplication().getCodeTemplateManager().getNameByPath(
+ cgenConfiguration.getEmbeddableSuperTemplate(),
cgenConfiguration.getRootPath());
+ String queryTemplateName =
getApplication().getCodeTemplateManager().getNameByPath(
+ cgenConfiguration.getQueryTemplate(),
cgenConfiguration.getRootPath());
+ String querySuperTemplateName =
getApplication().getCodeTemplateManager().getNameByPath(
+ cgenConfiguration.getQuerySuperTemplate(),
cgenConfiguration.getRootPath());
+
String path =
cgenConfiguration.getRootPath().resolve(Paths.get(cgenConfiguration.getTemplate())).normalize().toString();
String superPath =
cgenConfiguration.getRootPath().resolve(Paths.get(cgenConfiguration.getSuperTemplate())).normalize().toString();
+ String embeddableTemplatePath =
cgenConfiguration.getRootPath().resolve(Paths.get(cgenConfiguration.getEmbeddableTemplate())).normalize().toString();
+ String embeddableSuperTemplatePath =
cgenConfiguration.getRootPath().resolve(Paths.get(cgenConfiguration.getEmbeddableSuperTemplate())).normalize().toString();
+ String queryTemplatePath =
cgenConfiguration.getRootPath().resolve(Paths.get(cgenConfiguration.getQueryTemplate())).normalize().toString();
+ String querySuperTemplatePath =
cgenConfiguration.getRootPath().resolve(Paths.get(cgenConfiguration.getQuerySuperTemplate())).normalize().toString();
+
if(templateName == null && superTemplateName == null) {
view.getSubclassTemplate().setItem(null);
view.getSuperclassTemplate().setItem(null);
@@ -123,6 +161,27 @@ public class CustomModeController extends
GeneratorController {
view.getSubclassTemplate().setItem(templateName);
view.getSuperclassTemplate().setItem(superTemplateName);
}
+
+ if(embeddableTemplateName == null && embeddableSuperTemplateName ==
null) {
+ missTemplateDialog(cgenConfiguration, embeddableTemplatePath,
embeddableSuperTemplatePath);
+ } else if(embeddableTemplateName == null) {
+ missTemplateDialog(cgenConfiguration, embeddableTemplatePath,
null);
+ } else if(embeddableSuperTemplateName == null) {
+ missTemplateDialog(cgenConfiguration, null,
embeddableSuperTemplatePath);
+ }
+ view.getEmbeddableTemplate().setItem(embeddableTemplateName);
+ view.getEmbeddableSuperTemplate().setItem(embeddableSuperTemplateName);
+
+ if(queryTemplateName == null && querySuperTemplateName == null) {
+ missTemplateDialog(cgenConfiguration, queryTemplatePath,
querySuperTemplatePath);
+ } else if(queryTemplateName == null) {
+ missTemplateDialog(cgenConfiguration, queryTemplatePath, null);
+ } else if(querySuperTemplateName == null) {
+ missTemplateDialog(cgenConfiguration, null,
querySuperTemplatePath);
+ }
+ view.getQueryTemplate().setItem(queryTemplateName);
+ view.getQuerySuperTemplate().setItem(querySuperTemplateName);
+
view.setDisableSuperComboBoxes(view.getPairs().isSelected());
}
@@ -168,9 +227,13 @@ public class CustomModeController extends
GeneratorController {
if(isSelected) {
cgenConfiguration.setTemplate(ClientClassGenerationAction.SUBCLASS_TEMPLATE);
cgenConfiguration.setSuperTemplate(ClientClassGenerationAction.SUPERCLASS_TEMPLATE);
+
cgenConfiguration.setQueryTemplate(ClientClassGenerationAction.DMAP_SUBCLASS_TEMPLATE);
+
cgenConfiguration.setQuerySuperTemplate(ClientClassGenerationAction.DMAP_SUPERCLASS_TEMPLATE);
} else {
cgenConfiguration.setTemplate(ClassGenerationAction.SUBCLASS_TEMPLATE);
cgenConfiguration.setSuperTemplate(ClassGenerationAction.SUPERCLASS_TEMPLATE);
+
cgenConfiguration.setQueryTemplate(ClassGenerationAction.DATAMAP_SUBCLASS_TEMPLATE);
+
cgenConfiguration.setQuerySuperTemplate(ClassGenerationAction.DATAMAP_SUPERCLASS_TEMPLATE);
}
updateTemplates();
String templateName =
getApplication().getCodeTemplateManager().getNameByPath(
@@ -183,8 +246,20 @@ public class CustomModeController extends
GeneratorController {
ClientClassGenerationAction.SUBCLASS_TEMPLATE :
ClassGenerationAction.SUBCLASS_TEMPLATE,
cgenConfiguration.getRootPath());
+ String queryTemplateName =
getApplication().getCodeTemplateManager().getNameByPath(
+ isSelected ?
+
ClientClassGenerationAction.DMAP_SUBCLASS_TEMPLATE :
+
ClassGenerationAction.DATAMAP_SUBCLASS_TEMPLATE,
+
cgenConfiguration.getRootPath());
+ String querySuperTemplateName =
getApplication().getCodeTemplateManager().getNameByPath(
+ isSelected ?
+
ClientClassGenerationAction.DMAP_SUPERCLASS_TEMPLATE :
+
ClassGenerationAction.DATAMAP_SUPERCLASS_TEMPLATE,
+
cgenConfiguration.getRootPath());
view.getSubclassTemplate().setItem(templateName);
view.getSuperclassTemplate().setItem(superTemplateName);
+ view.getQueryTemplate().setItem(queryTemplateName);
+ view.getQuerySuperTemplate().setItem(querySuperTemplateName);
getParentController().checkCgenConfigDirty();
});
}
diff --git
a/modeler/cayenne-modeler/src/main/java/org/apache/cayenne/modeler/editor/cgen/CustomModePanel.java
b/modeler/cayenne-modeler/src/main/java/org/apache/cayenne/modeler/editor/cgen/CustomModePanel.java
index 9b7e265..8773561 100644
---
a/modeler/cayenne-modeler/src/main/java/org/apache/cayenne/modeler/editor/cgen/CustomModePanel.java
+++
b/modeler/cayenne-modeler/src/main/java/org/apache/cayenne/modeler/editor/cgen/CustomModePanel.java
@@ -44,6 +44,10 @@ public class CustomModePanel extends
GeneratorControllerPanel {
private ComboBoxAdapter<String> subclassTemplate;
private ComboBoxAdapter<String> superclassTemplate;
+ private ComboBoxAdapter<String> embeddableTemplate;
+ private ComboBoxAdapter<String> embeddableSuperTemplate;
+ private ComboBoxAdapter<String> queryTemplate;
+ private ComboBoxAdapter<String> querySuperTemplate;
private JCheckBox pairs;
private JCheckBox overwrite;
private JCheckBox usePackagePath;
@@ -57,6 +61,7 @@ public class CustomModePanel extends GeneratorControllerPanel
{
CustomModePanel(ProjectController projectController,
CodeGeneratorController codeGeneratorControllerBase) {
super(projectController, codeGeneratorControllerBase);
+
JComboBox<String> superclassField = new JComboBox<>();
this.superclassTemplate = new ComboBoxAdapter<String>(superclassField)
{
@Override
@@ -82,6 +87,58 @@ public class CustomModePanel extends
GeneratorControllerPanel {
}
}
};
+
+ JComboBox<String> embeddableField = new JComboBox<>();
+ this.embeddableTemplate = new ComboBoxAdapter<String>(embeddableField)
{
+ @Override
+ protected void updateModel(String item) throws
ValidationException {
+ CgenConfiguration cgenConfiguration =
getCgenByDataMap();
+
cgenConfiguration.setEmbeddableTemplate(Application.getInstance().getCodeTemplateManager().getTemplatePath(item,
+
cgenConfiguration.getDataMap().getConfigurationSource()));
+ if(!codeGeneratorControllerBase.isInitFromModel()) {
+ projectController.setDirty(true);
+ }
+ }
+ };
+
+ JComboBox<String> embeddableSuperField = new JComboBox<>();
+ this.embeddableSuperTemplate = new
ComboBoxAdapter<String>(embeddableSuperField) {
+ @Override
+ protected void updateModel(String item) throws
ValidationException {
+ CgenConfiguration cgenConfiguration =
getCgenByDataMap();
+
cgenConfiguration.setEmbeddableSuperTemplate(Application.getInstance().getCodeTemplateManager().getTemplatePath(item,
+
cgenConfiguration.getDataMap().getConfigurationSource()));
+ if(!codeGeneratorControllerBase.isInitFromModel()) {
+ projectController.setDirty(true);
+ }
+ }
+ };
+
+ JComboBox<String> queryField = new JComboBox<>();
+ this.queryTemplate = new ComboBoxAdapter<String>(queryField) {
+ @Override
+ protected void updateModel(String item) throws
ValidationException {
+ CgenConfiguration cgenConfiguration =
getCgenByDataMap();
+
cgenConfiguration.setQueryTemplate(Application.getInstance().getCodeTemplateManager().getTemplatePath(item,
+
cgenConfiguration.getDataMap().getConfigurationSource()));
+ if(!codeGeneratorControllerBase.isInitFromModel()) {
+ projectController.setDirty(true);
+ }
+ }
+ };
+
+ JComboBox<String> querySuperField = new JComboBox<>();
+ this.querySuperTemplate = new ComboBoxAdapter<String>(querySuperField)
{
+ @Override
+ protected void updateModel(String item) throws
ValidationException {
+ CgenConfiguration cgenConfiguration =
getCgenByDataMap();
+
cgenConfiguration.setQuerySuperTemplate(Application.getInstance().getCodeTemplateManager().getTemplatePath(item,
+
cgenConfiguration.getDataMap().getConfigurationSource()));
+ if(!codeGeneratorControllerBase.isInitFromModel()) {
+ projectController.setDirty(true);
+ }
+ }
+ };
this.pairs = new JCayenneCheckBox();
this.overwrite = new JCayenneCheckBox();
@@ -121,7 +178,7 @@ public class CustomModePanel extends
GeneratorControllerPanel {
// assemble
FormLayout layout = new FormLayout(
- "right:74dlu, 1dlu, fill:240:grow, 1dlu, left:100dlu, 100dlu",
"");
+ "right:105dlu, 1dlu, fill:240:grow, 1dlu, left:100dlu,
100dlu", "");
DefaultFormBuilder builder = new DefaultFormBuilder(layout);
builder.setDefaultDialogBorder();
@@ -133,6 +190,18 @@ public class CustomModePanel extends
GeneratorControllerPanel {
builder.append("Superclass Template:",
superclassTemplate.getComboBox());
builder.nextLine();
+
+ builder.append("Embeddable Template:",
embeddableTemplate.getComboBox());
+ builder.nextLine();
+
+ builder.append("Embeddable Superclass Template:",
embeddableSuperTemplate.getComboBox());
+ builder.nextLine();
+
+ builder.append("DataMap Template:", queryTemplate.getComboBox());
+ builder.nextLine();
+
+ builder.append("DataMap Superclass Template:",
querySuperTemplate.getComboBox());
+ builder.nextLine();
builder.append("Output Pattern:", outputPattern.getComponent());
builder.nextLine();
@@ -167,17 +236,37 @@ public class CustomModePanel extends
GeneratorControllerPanel {
public void setDisableSuperComboBoxes(boolean val){
superclassTemplate.getComboBox().setEnabled(val);
+ embeddableSuperTemplate.getComboBox().setEnabled(val);
+ querySuperTemplate.getComboBox().setEnabled(val);
}
public JButton getManageTemplatesLink() {
return manageTemplatesLink;
}
- public ComboBoxAdapter<String> getSubclassTemplate() { return
subclassTemplate; }
+ public ComboBoxAdapter<String> getSubclassTemplate() {
+ return subclassTemplate;
+ }
public ComboBoxAdapter<String> getSuperclassTemplate() {
return superclassTemplate;
}
+
+ public ComboBoxAdapter<String> getEmbeddableTemplate() {
+ return embeddableTemplate;
+ }
+
+ public ComboBoxAdapter<String> getEmbeddableSuperTemplate() {
+ return embeddableSuperTemplate;
+ }
+
+ public ComboBoxAdapter<String> getQueryTemplate() {
+ return queryTemplate;
+ }
+
+ public ComboBoxAdapter<String> getQuerySuperTemplate() {
+ return querySuperTemplate;
+ }
public JCheckBox getOverwrite() {
return overwrite;
