Haiti/haiti-utils-field-constants
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Compare commits

base: Haiti:develop
Branches Tags
Haiti:develop
Haiti:master
Haiti:v.1.2.0
Haiti:v.2.0.0
Haiti:v.1.1.1
Haiti:v.1.0.0
Haiti:v.0.0.11
Haiti:v.0.0.10
Haiti:v.0.0.9
Haiti:v.0.0.8
Haiti:v.0.0.7
Haiti:v.0.0.6
Haiti:v.0.0.4
Haiti:v.0.0.3
Haiti:v.0.0.2
Haiti:v.0.0.1
..
compare: Haiti:master
Branches Tags
Haiti:develop
Haiti:master
Haiti:v.1.2.0
Haiti:v.2.0.0
Haiti:v.1.1.1
Haiti:v.1.0.0
Haiti:v.0.0.11
Haiti:v.0.0.10
Haiti:v.0.0.9
Haiti:v.0.0.8
Haiti:v.0.0.7
Haiti:v.0.0.6
Haiti:v.0.0.4
Haiti:v.0.0.3
Haiti:v.0.0.2
Haiti:v.0.0.1

No commits in common. "develop" and "master" have entirely different histories.
develop ... master

18 changed files with 188 additions and 518 deletions
Show Stats Expand all files Collapse all files

111
.drone.yml
View File

@ -1,111 +0,0 @@
---
kind: pipeline
type: docker
name: snapshot-publish
trigger:
branch:
- develop
volumes:
- name: m2
host:
path: /drone/volume/m2
image_pull_secrets:
- DOCKER_AUTH
steps:
- name: publish
image: hub.docker.struchkov.dev/maven:3.9-eclipse-temurin-17-alpine
privileged: true
volumes:
- name: m2
path: /root/.m2/repository
environment:
MAVEN_SETTINGS:
from_secret: MAVEN_SETTINGS
commands:
- echo "$MAVEN_SETTINGS" >> maven-settings.xml
- mvn --settings maven-settings.xml -U -P snapshot clean deploy
---
kind: pipeline
type: docker
name: release-maven-central
trigger:
ref:
- refs/tags/v.*.*.*
volumes:
- name: m2
host:
path: /drone/volume/m2
image_pull_secrets:
- DOCKER_AUTH
steps:
- name: publish maven central
image: hub.docker.struchkov.dev/maven:3.9-eclipse-temurin-17-alpine
privileged: true
volumes:
- name: m2
path: /root/.m2/repository
environment:
GPG_PRIVATE_KEY:
from_secret: GPG_PRIVATE_KEY
MAVEN_SETTINGS:
from_secret: MAVEN_SETTINGS
GPG_PASSPHRASE:
from_secret: GPG_PASSPHRASE
commands:
- apk add gnupg
- echo "$GPG_PRIVATE_KEY" >> gpg.key
- echo "$MAVEN_SETTINGS" >> maven-settings.xml
- gpg --pinentry-mode loopback --passphrase $GPG_PASSPHRASE --import gpg.key
- mvn --settings maven-settings.xml -U -P ossrh,release clean deploy
---
kind: pipeline
type: docker
name: release-struchkov-nexus
trigger:
ref:
- refs/tags/v.*.*.*
volumes:
- name: m2
host:
path: /drone/volume/m2
image_pull_secrets:
- DOCKER_AUTH
steps:
- name: publish struchkov nexus
image: hub.docker.struchkov.dev/maven:3.9-eclipse-temurin-17-alpine
privileged: true
volumes:
- name: m2
path: /root/.m2/repository
environment:
GPG_PRIVATE_KEY:
from_secret: GPG_PRIVATE_KEY
MAVEN_SETTINGS:
from_secret: MAVEN_SETTINGS
GPG_PASSPHRASE:
from_secret: GPG_PASSPHRASE
commands:
- apk add gnupg
- echo "$GPG_PRIVATE_KEY" >> gpg.key
- echo "$MAVEN_SETTINGS" >> maven-settings.xml
- gpg --pinentry-mode loopback --passphrase $GPG_PASSPHRASE --import gpg.key
- mvn --settings maven-settings.xml -U -P ossrh,release-struchkov-nexus clean deploy
---
kind: signature
hmac: 62899422b538523cb09e3756b7bebe1658e4093f6c6a3e2dd8c9c8f872558e54
...

21
.gitignore vendored
View File

@ -20,16 +20,34 @@ dependency-reduced-pom.xml
buildNumber.properties
.mvn/timing.properties
.mvn/wrapper/maven-wrapper.jar
.idea/
.idea/**/workspace.xml
.idea/**/tasks.xml
.idea/**/usage.statistics.xml
.idea/**/dictionaries
.idea/**/shelf
.idea/**/contentModel.xml
.idea/**/dataSources/
.idea/**/dataSources.ids
.idea/**/dataSources.local.xml
.idea/**/sqlDataSources.xml
.idea/**/dynamic.xml
.idea/**/uiDesigner.xml
.idea/**/dbnavigator.xml
.idea/**/gradle.xml
.idea/**/libraries
cmake-build-*/
.idea/**/mongoSettings.xml
*.iws
out/
.idea_modules/
atlassian-ide-plugin.xml
.idea/replstate.xml
com_crashlytics_export_strings.xml
crashlytics.properties
crashlytics-build.properties
fabric.properties
.idea/httpRequests
.idea/caches/build_file_checksums.ser
*~
.fuse_hidden*
.directory
@ -65,4 +83,3 @@ Icon
Network Trash Folder
Temporary Items
.apdisk
/haiti-field-constants-utils.iml

17
.gitlab-ci.yml Normal file
View File

@ -0,0 +1,17 @@
image: maven:3.8.4-openjdk-11
variables:
MAVEN_OPTS: "-Dmaven.repo.local=./.m2/repository"
stages:
- deploy
deploy:
stage: deploy
only:
- /^v.*$/
except:
- branches
before_script:
- gpg --pinentry-mode loopback --passphrase $GPG_PASSPHRASE --import $GPG_PRIVATE_KEY
script:
- 'mvn --settings $MAVEN_SETTINGS -U -P ossrh,release clean deploy'

29
pom.xml
View File

@ -1,15 +1,17 @@
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>dev.struchkov.haiti</groupId>
<artifactId>haiti-dependencies</artifactId>
<version>3.0.3</version>
<artifactId>haiti</artifactId>
<version>0.0.4</version>
</parent>
<groupId>dev.struchkov.haiti.utils</groupId>
<artifactId>haiti-utils-field-constants</artifactId>
<version>1.2.1-SNAPSHOT</version>
<version>0.0.4</version>
<name>Haiti Field Name Constants Utils</name>
<description>Generating class field names</description>
@ -20,7 +22,7 @@
</issueManagement>
<properties>
<java.version>17</java.version>
<java.version>11</java.version>
<maven.compiler.source>${java.version}</maven.compiler.source>
<maven.compiler.target>${java.version}</maven.compiler.target>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
@ -33,8 +35,8 @@
<artifactId>haiti-utils</artifactId>
</dependency>
<dependency>
<groupId>jakarta.persistence</groupId>
<artifactId>jakarta.persistence-api</artifactId>
<groupId>javax.persistence</groupId>
<artifactId>javax.persistence-api</artifactId>
</dependency>
<dependency>
<groupId>com.google.auto.service</groupId>
@ -52,11 +54,9 @@
<path>
<groupId>com.google.auto.service</groupId>
<artifactId>auto-service</artifactId>
<version>${google.auto.service.version}</version>
<version>1.0.1</version>
</path>
</annotationProcessorPaths>
<source>17</source>
<target>17</target>
</configuration>
</plugin>
<plugin>
@ -71,10 +71,9 @@
</build>
<scm>
<connection>scm:git:https://git.struchkov.dev/Haiti/haiti-utils-field-constants.git</connection>
<url>https://git.struchkov.dev/Haiti/haiti-utils-field-constants</url>
<developerConnection>scm:git:https://git.struchkov.dev/Haiti/haiti-utils-field-constants.git</developerConnection>
<tag>HEAD</tag>
</scm>
<connection>scm:git:https://github.com/haiti-projects/haiti-utils-field-constants.git</connection>
<url>https://github.com/haiti-projects/haiti-utils-field-constants</url>
<developerConnection>scm:git:https://github.com/haiti-projects/haiti-utils-field-constants.git</developerConnection>
</scm>
</project>

55
src/main/java/dev/struchkov/haiti/utils/fieldconstants/creator/CreatorClassTableMode.java → src/main/java/dev/struchkov/haiti/utils/fieldconstants/CreatorClassTableMode.java
View File

@ -1,10 +1,10 @@
package dev.struchkov.haiti.utils.fieldconstants.creator;
package dev.struchkov.haiti.utils.fieldconstants;
import dev.struchkov.haiti.utils.fieldconstants.domain.mode.table.ClassTableDto;
import dev.struchkov.haiti.utils.fieldconstants.domain.mode.table.JoinElemCollectionDto;
import dev.struchkov.haiti.utils.fieldconstants.domain.mode.table.JoinFieldDto;
import dev.struchkov.haiti.utils.fieldconstants.domain.mode.table.JoinTableContainer;
import dev.struchkov.haiti.utils.fieldconstants.domain.mode.table.SimpleTableFieldDto;
import dev.struchkov.haiti.utils.fieldconstants.domain.mode.table.SimpleFieldTableDto;
import javax.annotation.processing.ProcessingEnvironment;
import javax.tools.JavaFileObject;
@ -13,7 +13,6 @@ import java.io.PrintWriter;
import java.util.Collection;
import java.util.List;
import static dev.struchkov.haiti.utils.Checker.checkNotEmpty;
import static dev.struchkov.haiti.utils.Exceptions.utilityClass;
import static java.text.MessageFormat.format;
@ -27,11 +26,6 @@ public final class CreatorClassTableMode {
private static final String TABLE_NAME_DEFAULT = "TABLE_NAME";
private static final String TABLE_NAME_DB = "DB_TABLE_NAME";
private static final String SCHEMA_NAME_DEFAULT = "SCHEMA_NAME";
private static final String SCHEMA_NAME_DB = "DB_SCHEMA_NAME";
private static final String SCHEMA_AND_TABLE = "SCHEMA_AND_TABLE";
private CreatorClassTableMode() {
utilityClass();
}
@ -39,7 +33,7 @@ public final class CreatorClassTableMode {
public static void record(ClassTableDto classDto, ProcessingEnvironment environment) {
JavaFileObject builderFile = null;
try {
builderFile = environment.getFiler().createSourceFile(classDto.getClassPackage() + "." + classDto.getClassName());
builderFile = environment.getFiler().createSourceFile(classDto.getClassName());
} catch (IOException e) {
e.printStackTrace();
}
@ -53,8 +47,6 @@ public final class CreatorClassTableMode {
out.println();
out.println();
generateTableName(classDto.getTableName(), classDto.getSimpleFields(), out);
generateTableSchema(classDto.getTableSchema(), classDto.getSimpleFields(), out);
generateTableSchemaAndTable(classDto.getTableSchema(), classDto.getTableName(), out);
generateSimpleNames(classDto.getSimpleFields(), out);
generateJoinNames(classDto.getJoinFields(), out);
generateElementCollectionNames(classDto.getJoinElemCollections(), out);
@ -71,42 +63,22 @@ public final class CreatorClassTableMode {
}
}
private static void generateTableName(String tableName, Collection<SimpleTableFieldDto> fields, PrintWriter out) {
private static void generateTableName(String tableName, Collection<SimpleFieldTableDto> fields, PrintWriter out) {
if (tableName != null) {
final boolean isTableNameField = fields.stream().anyMatch(simpleFieldTableDto -> simpleFieldTableDto.getFieldStringName().equalsIgnoreCase(TABLE_NAME_DEFAULT));
out.println(format(" public static final String {0} = \"{1}\";", isTableNameField ? TABLE_NAME_DB : TABLE_NAME_DEFAULT, tableName));
}
out.println();
}
private static void generateTableSchema(String tableSchema, Collection<SimpleTableFieldDto> fields, PrintWriter out) {
if (tableSchema != null && !"".equals(tableSchema)) {
final boolean isTableSchemaField = fields.stream().anyMatch(simpleFieldTableDto -> simpleFieldTableDto.getFieldStringName().equalsIgnoreCase(TABLE_NAME_DEFAULT));
out.println(format(" public static final String {0} = \"{1}\";", isTableSchemaField ? SCHEMA_NAME_DB : SCHEMA_NAME_DEFAULT, tableSchema));
}
}
private static void generateTableSchemaAndTable(String tableSchema, String tableName, PrintWriter out) {
if (tableSchema != null && tableName != null && !"".equals(tableSchema)) {
out.println(format(" public static final String {0} = \"{1}\";", SCHEMA_AND_TABLE, tableSchema + "." + tableName));
}
}
private static void generateSimpleNames(Collection<SimpleTableFieldDto> fields, PrintWriter out) {
if (checkNotEmpty(fields)) {
out.println();
}
for (SimpleTableFieldDto field : fields) {
private static void generateSimpleNames(Collection<SimpleFieldTableDto> fields, PrintWriter out) {
for (SimpleFieldTableDto field : fields) {
out.println(format(" public static final String {0} = \"{1}\";", field.getFieldStringName(), field.getFieldName()));
}
if (checkNotEmpty(fields)) {
out.println();
}
out.println();
}
private static void generateJoinNames(List<JoinFieldDto> joinFields, PrintWriter out) {
if (checkNotEmpty(joinFields)) {
out.println();
}
for (JoinFieldDto joinField : joinFields) {
final JoinTableContainer container = joinField.getContainer();
out.println(
@ -116,15 +88,10 @@ public final class CreatorClassTableMode {
)
);
}
if (checkNotEmpty(joinFields)) {
out.println();
}
out.println();
}
private static void generateElementCollectionNames(List<JoinElemCollectionDto> joinElemCollections, PrintWriter out) {
if (checkNotEmpty(joinElemCollections)) {
out.println();
}
for (JoinElemCollectionDto element : joinElemCollections) {
final String fieldName = element.getFieldName();
final JoinTableContainer firstContainer = element.getFirstContainer();
@ -134,9 +101,7 @@ public final class CreatorClassTableMode {
out.println(format(" JoinTable.ofLeft(\"{0}\", \"{1}\", \"{2}\")", secondContainer.getTable(), secondContainer.getBaseId(), secondContainer.getReference()));
out.println(" };");
}
if (checkNotEmpty(joinElemCollections)) {
out.println();
}
out.println();
}
}

59
src/main/java/dev/struchkov/haiti/utils/fieldconstants/creator/CreatorClassSimpleMode.java
View File

@ -1,59 +0,0 @@
package dev.struchkov.haiti.utils.fieldconstants.creator;
import dev.struchkov.haiti.utils.fieldconstants.domain.mode.simple.ClassSimpleDto;
import dev.struchkov.haiti.utils.fieldconstants.domain.mode.simple.SimpleFieldDto;
import javax.annotation.processing.ProcessingEnvironment;
import javax.tools.JavaFileObject;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Collection;
import static dev.struchkov.haiti.utils.Exceptions.utilityClass;
import static java.text.MessageFormat.format;
/**
* // TODO: 20.06.2021 Добавить описание.
*
* @author upagge 20.06.2021
*/
public final class CreatorClassSimpleMode {
private CreatorClassSimpleMode() {
utilityClass();
}
public static void record(ClassSimpleDto classDto, ProcessingEnvironment environment) {
JavaFileObject builderFile = null;
try {
builderFile = environment.getFiler().createSourceFile(classDto.getNewClassName());
} catch (IOException e) {
e.printStackTrace();
}
try (PrintWriter out = new PrintWriter(builderFile.openWriter())) {
out.println("package " + classDto.getClassPackage() + ";");
out.println();
out.println();
out.println(format("public class {0} '{'", classDto.getNewClassName()));
out.println();
out.println(format(" public static final String CLASS_NAME = \"{0}\";", classDto.getOldClassName()));
out.println(format(" public static final String PACKAGE_AND_CLASS_NAME = \"{0}\";", classDto.getClassPackage() + "." + classDto.getOldClassName()));
out.println();
generateSimpleNames(classDto.getSimpleFields(), out);
out.println("}");
out.println();
} catch (IOException e) {
e.printStackTrace();
}
}
private static void generateSimpleNames(Collection<SimpleFieldDto> fields, PrintWriter out) {
for (SimpleFieldDto field : fields) {
out.println(format(" public static final String {0} = \"{1}\";", field.getFieldName(), field.getFieldName()));
}
out.println();
}
}

44
src/main/java/dev/struchkov/haiti/utils/fieldconstants/domain/mode/simple/ClassSimpleDto.java
View File

@ -1,44 +0,0 @@
package dev.struchkov.haiti.utils.fieldconstants.domain.mode.simple;
import java.util.List;
public class ClassSimpleDto {
private String classPackage;
private String newClassName;
private String oldClassName;
private List<SimpleFieldDto> simpleFields;
public String getClassPackage() {
return classPackage;
}
public void setClassPackage(String classPackage) {
this.classPackage = classPackage;
}
public String getNewClassName() {
return newClassName;
}
public void setNewClassName(String newClassName) {
this.newClassName = newClassName;
}
public String getOldClassName() {
return oldClassName;
}
public void setOldClassName(String oldClassName) {
this.oldClassName = oldClassName;
}
public List<SimpleFieldDto> getSimpleFields() {
return simpleFields;
}
public void setSimpleFields(List<SimpleFieldDto> simpleFields) {
this.simpleFields = simpleFields;
}
}

24
src/main/java/dev/struchkov/haiti/utils/fieldconstants/domain/mode/simple/SimpleFieldDto.java
View File

@ -1,24 +0,0 @@
package dev.struchkov.haiti.utils.fieldconstants.domain.mode.simple;
/**
* // TODO: 07.06.2021 Добавить описание.
*
* @author upagge 07.06.2021
*/
public class SimpleFieldDto {
private final String fieldName;
private SimpleFieldDto(String fieldName) {
this.fieldName = fieldName;
}
public static SimpleFieldDto of(String fieldName) {
return new SimpleFieldDto(fieldName);
}
public String getFieldName() {
return fieldName;
}
}

15
src/main/java/dev/struchkov/haiti/utils/fieldconstants/domain/mode/table/ClassTableDto.java
View File

@ -7,8 +7,7 @@ public class ClassTableDto {
private String classPackage;
private String className;
private String tableName;
private String tableSchema;
private List<SimpleTableFieldDto> simpleFields;
private List<SimpleFieldTableDto> simpleFields;
private List<JoinFieldDto> joinFields;
private List<JoinElemCollectionDto> joinElemCollections;
@ -36,19 +35,11 @@ public class ClassTableDto {
this.tableName = tableName;
}
public String getTableSchema() {
return tableSchema;
}
public void setTableSchema(String tableSchema) {
this.tableSchema = tableSchema;
}
public List<SimpleTableFieldDto> getSimpleFields() {
public List<SimpleFieldTableDto> getSimpleFields() {
return simpleFields;
}
public void setSimpleFields(List<SimpleTableFieldDto> simpleFields) {
public void setSimpleFields(List<SimpleFieldTableDto> simpleFields) {
this.simpleFields = simpleFields;
}

4
src/main/java/dev/struchkov/haiti/utils/fieldconstants/domain/mode/table/JoinElemCollectionDto.java
View File

@ -1,6 +1,6 @@
package dev.struchkov.haiti.utils.fieldconstants.domain.mode.table;
import dev.struchkov.haiti.utils.Inspector;
import dev.struchkov.haiti.utils.Assert;
public class JoinElemCollectionDto {
@ -15,7 +15,7 @@ public class JoinElemCollectionDto {
}
public static JoinElemCollectionDto of(String fieldName, JoinTableContainer firstContainer, JoinTableContainer secondContainer) {
Inspector.isNotNull(fieldName, firstContainer, secondContainer);
Assert.isNotNull(fieldName, firstContainer, secondContainer);
return new JoinElemCollectionDto(fieldName, firstContainer, secondContainer);
}

4
src/main/java/dev/struchkov/haiti/utils/fieldconstants/domain/mode/table/JoinFieldDto.java
View File

@ -1,6 +1,6 @@
package dev.struchkov.haiti.utils.fieldconstants.domain.mode.table;
import dev.struchkov.haiti.utils.Inspector;
import dev.struchkov.haiti.utils.Assert;
public class JoinFieldDto {
@ -13,7 +13,7 @@ public class JoinFieldDto {
}
public static JoinFieldDto of(String fieldName, JoinTableContainer container) {
Inspector.isNotNull(fieldName, container);
Assert.isNotNull(fieldName, container);
return new JoinFieldDto(fieldName, container);
}

4
src/main/java/dev/struchkov/haiti/utils/fieldconstants/domain/mode/table/JoinTableContainer.java
View File

@ -1,6 +1,6 @@
package dev.struchkov.haiti.utils.fieldconstants.domain.mode.table;
import dev.struchkov.haiti.utils.Inspector;
import dev.struchkov.haiti.utils.Assert;
public class JoinTableContainer {
@ -15,7 +15,7 @@ public class JoinTableContainer {
}
public static JoinTableContainer of(String table, String baseId, String reference) {
Inspector.isNotNull(table, baseId, reference);
Assert.isNotNull(table, baseId, reference);
return new JoinTableContainer(table, baseId, reference);
}

8
src/main/java/dev/struchkov/haiti/utils/fieldconstants/domain/mode/table/SimpleTableFieldDto.java → src/main/java/dev/struchkov/haiti/utils/fieldconstants/domain/mode/table/SimpleFieldTableDto.java
View File

@ -5,18 +5,18 @@ package dev.struchkov.haiti.utils.fieldconstants.domain.mode.table;
*
* @author upagge 07.06.2021
*/
public class SimpleTableFieldDto {
public class SimpleFieldTableDto {
private final String fieldStringName;
private final String fieldName;
private SimpleTableFieldDto(String fieldStringName, String fieldName) {
private SimpleFieldTableDto(String fieldStringName, String fieldName) {
this.fieldStringName = fieldStringName;
this.fieldName = fieldName;
}
public static SimpleTableFieldDto of(String fieldStringName, String fieldName) {
return new SimpleTableFieldDto(fieldStringName, fieldName);
public static SimpleFieldTableDto of(String fieldStringName, String fieldName) {
return new SimpleFieldTableDto(fieldStringName, fieldName);
}
public String getFieldStringName() {

46
src/main/java/dev/struchkov/haiti/utils/fieldconstants/generator/GeneratorSimpleMode.java
View File

@ -1,46 +0,0 @@
package dev.struchkov.haiti.utils.fieldconstants.generator;
import dev.struchkov.haiti.utils.fieldconstants.creator.CreatorClassSimpleMode;
import dev.struchkov.haiti.utils.fieldconstants.domain.Mode;
import dev.struchkov.haiti.utils.fieldconstants.domain.mode.simple.ClassSimpleDto;
import dev.struchkov.haiti.utils.fieldconstants.domain.mode.simple.SimpleFieldDto;
import dev.struchkov.haiti.utils.fieldconstants.util.Generator;
import javax.annotation.processing.ProcessingEnvironment;
import javax.lang.model.element.Element;
import java.util.ArrayList;
import java.util.List;
import static dev.struchkov.haiti.utils.fieldconstants.util.Generator.getPackage;
public class GeneratorSimpleMode {
public static void generate(ProcessingEnvironment processingEnv, Element annotatedElement) {
final String oldClassName = annotatedElement.getSimpleName().toString();
final List<? extends Element> allFields = annotatedElement.getEnclosedElements().stream()
.filter(Generator::isField)
.filter(Generator::isNotIgnoreField)
.toList();
final List<SimpleFieldDto> simpleFields = getSimpleFields(allFields);
final ClassSimpleDto newClass = new ClassSimpleDto();
newClass.setNewClassName(oldClassName + Mode.SIMPLE.getDefaultPostfix());
newClass.setOldClassName(oldClassName);
newClass.setSimpleFields(simpleFields);
newClass.setClassPackage(getPackage(annotatedElement));
CreatorClassSimpleMode.record(newClass, processingEnv);
}
private static List<SimpleFieldDto> getSimpleFields(List<? extends Element> allFields) {
final List<SimpleFieldDto> resultList = new ArrayList<>();
for (Element field : allFields) {
final String fieldName = field.getSimpleName().toString();
resultList.add(SimpleFieldDto.of(fieldName));
}
return resultList;
}
}

115
src/main/java/dev/struchkov/haiti/utils/fieldconstants/generator/GeneratorTableMode.java
View File

@ -1,115 +0,0 @@
package dev.struchkov.haiti.utils.fieldconstants.generator;
import dev.struchkov.haiti.utils.fieldconstants.annotation.field.ElementCollectionField;
import dev.struchkov.haiti.utils.fieldconstants.annotation.field.JoinField;
import dev.struchkov.haiti.utils.fieldconstants.annotation.setting.TableModeSettings;
import dev.struchkov.haiti.utils.fieldconstants.creator.CreatorClassTableMode;
import dev.struchkov.haiti.utils.fieldconstants.domain.Mode;
import dev.struchkov.haiti.utils.fieldconstants.domain.mode.table.ClassTableDto;
import dev.struchkov.haiti.utils.fieldconstants.domain.mode.table.JoinElemCollectionDto;
import dev.struchkov.haiti.utils.fieldconstants.domain.mode.table.JoinFieldDto;
import dev.struchkov.haiti.utils.fieldconstants.domain.mode.table.JoinTableContainer;
import dev.struchkov.haiti.utils.fieldconstants.domain.mode.table.SimpleTableFieldDto;
import dev.struchkov.haiti.utils.fieldconstants.util.Generator;
import jakarta.persistence.CollectionTable;
import jakarta.persistence.Column;
import jakarta.persistence.ElementCollection;
import jakarta.persistence.Table;
import javax.annotation.processing.ProcessingEnvironment;
import javax.lang.model.element.Element;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;
import static dev.struchkov.haiti.utils.Checker.checkNotNull;
public class GeneratorTableMode {
public static void generate(ProcessingEnvironment processingEnv, TableModeSettings tableSettings, Element annotatedElement) {
final String annotatedElementName = annotatedElement.getSimpleName().toString();
final Table anTable = annotatedElement.getAnnotation(Table.class);
final String newClassName = annotatedElementName + Mode.TABLE.getDefaultPostfix();
final List<? extends Element> allFields = annotatedElement.getEnclosedElements().stream()
.filter(Generator::isField)
.filter(Generator::isNotIgnoreField)
.collect(Collectors.toList());
final List<SimpleTableFieldDto> simpleFields = getSimpleFields(allFields, anTable, tableSettings);
final List<JoinFieldDto> joinFields = getJoinFields(allFields);
final List<JoinElemCollectionDto> elementCollectionFields = getElementCollectionsFields(anTable, allFields);
final ClassTableDto newClass = new ClassTableDto();
newClass.setClassName(newClassName);
newClass.setSimpleFields(simpleFields);
newClass.setJoinFields(joinFields);
newClass.setJoinElemCollections(elementCollectionFields);
newClass.setClassPackage(Generator.getPackage(annotatedElement));
newClass.setTableName(checkNotNull(anTable) ? anTable.name() : null);
newClass.setTableSchema(checkNotNull(anTable) ? anTable.schema() : null);
CreatorClassTableMode.record(newClass, processingEnv);
}
private static List<JoinElemCollectionDto> getElementCollectionsFields(Table tableName, List<? extends Element> allFields) {
if (checkNotNull(tableName)) {
return allFields.stream()
.filter(
field -> field.getAnnotation(ElementCollectionField.class) != null &&
field.getAnnotation(CollectionTable.class) != null &&
field.getAnnotation(Column.class) != null
)
.map(field -> {
final String fieldName = field.getSimpleName().toString();
final ElementCollectionField elementCollectionField = field.getAnnotation(ElementCollectionField.class);
final CollectionTable collectionTable = field.getAnnotation(CollectionTable.class);
final Column column = field.getAnnotation(Column.class);
final JoinTableContainer firstContainer = JoinTableContainer.of(collectionTable.name(), tableName + "." + elementCollectionField.parentId(), collectionTable.joinColumns()[0].name());
final JoinTableContainer secondContainer = JoinTableContainer.of(elementCollectionField.childTable(), column.name(), elementCollectionField.childReference());
return JoinElemCollectionDto.of(fieldName, firstContainer, secondContainer);
}).collect(Collectors.toList());
}
return Collections.emptyList();
}
private static List<JoinFieldDto> getJoinFields(List<? extends Element> allFields) {
return allFields.stream()
.filter(
field -> field.getAnnotation(JoinField.class) != null &&
field.getAnnotation(ElementCollection.class) == null
)
.map(field -> {
final String fieldName = field.getSimpleName().toString();
final JoinField joinField = field.getAnnotation(JoinField.class);
final JoinTableContainer joinContainer = JoinTableContainer.of(joinField.table(), joinField.baseId(), joinField.reference());
return JoinFieldDto.of(fieldName, joinContainer);
})
.collect(Collectors.toList());
}
private static List<SimpleTableFieldDto> getSimpleFields(List<? extends Element> allFields, Table anTable, TableModeSettings tableSettings) {
final boolean prefixTableForColumn = tableSettings.prefixTableForColumn();
final List<SimpleTableFieldDto> resultList = new ArrayList<>();
allFields.stream()
.filter(
field -> field.getAnnotation(Column.class) != null &&
field.getAnnotation(ElementCollection.class) == null
)
.forEach(
field -> {
final String fieldName = field.getSimpleName().toString();
final String columnName = field.getAnnotation(Column.class).name();
if (prefixTableForColumn && checkNotNull(anTable)) {
final String tableNameAndColumnName = anTable.name() + "." + columnName;
resultList.add(SimpleTableFieldDto.of("t_" + fieldName, tableNameAndColumnName));
}
resultList.add(SimpleTableFieldDto.of(fieldName, columnName));
}
);
return resultList;
}
}

122
src/main/java/dev/struchkov/haiti/utils/fieldconstants/processor/FieldNameProcessor.java
View File

@ -1,11 +1,18 @@
package dev.struchkov.haiti.utils.fieldconstants.processor;
import com.google.auto.service.AutoService;
import dev.struchkov.haiti.utils.fieldconstants.CreatorClassTableMode;
import dev.struchkov.haiti.utils.fieldconstants.annotation.FieldNames;
import dev.struchkov.haiti.utils.fieldconstants.annotation.field.ElementCollectionField;
import dev.struchkov.haiti.utils.fieldconstants.annotation.field.IgnoreField;
import dev.struchkov.haiti.utils.fieldconstants.annotation.field.JoinField;
import dev.struchkov.haiti.utils.fieldconstants.annotation.setting.TableModeSettings;
import dev.struchkov.haiti.utils.fieldconstants.domain.Mode;
import dev.struchkov.haiti.utils.fieldconstants.generator.GeneratorSimpleMode;
import dev.struchkov.haiti.utils.fieldconstants.generator.GeneratorTableMode;
import dev.struchkov.haiti.utils.fieldconstants.domain.mode.table.ClassTableDto;
import dev.struchkov.haiti.utils.fieldconstants.domain.mode.table.JoinElemCollectionDto;
import dev.struchkov.haiti.utils.fieldconstants.domain.mode.table.JoinFieldDto;
import dev.struchkov.haiti.utils.fieldconstants.domain.mode.table.JoinTableContainer;
import dev.struchkov.haiti.utils.fieldconstants.domain.mode.table.SimpleFieldTableDto;
import javax.annotation.processing.AbstractProcessor;
import javax.annotation.processing.Processor;
@ -15,10 +22,19 @@ import javax.annotation.processing.SupportedSourceVersion;
import javax.lang.model.SourceVersion;
import javax.lang.model.element.Element;
import javax.lang.model.element.TypeElement;
import javax.lang.model.type.TypeMirror;
import javax.persistence.CollectionTable;
import javax.persistence.Column;
import javax.persistence.ElementCollection;
import javax.persistence.Table;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
@SupportedAnnotationTypes("dev.struchkov.haiti.utils.fieldconstants.annotation.FieldNames")
@SupportedSourceVersion(SourceVersion.RELEASE_17)
@SupportedSourceVersion(SourceVersion.RELEASE_11)
@AutoService(Processor.class)
public class FieldNameProcessor extends AbstractProcessor {
@ -27,20 +43,110 @@ public class FieldNameProcessor extends AbstractProcessor {
for (TypeElement annotation : set) {
Set<? extends Element> annotatedElements = roundEnvironment.getElementsAnnotatedWith(annotation);
for (Element annotatedElement : annotatedElements) {
final TypeMirror mirror = annotatedElement.asType();
final String annotatedElementName = annotatedElement.getSimpleName().toString();
final FieldNames settings = annotatedElement.getAnnotation(FieldNames.class);
final Set<Mode> modes = Set.of(settings.mode());
final Set<Mode> modes = Arrays.stream(settings.mode()).collect(Collectors.toUnmodifiableSet());
if (modes.contains(Mode.TABLE)) {
final TableModeSettings tableSettings = settings.tableSettings();
GeneratorTableMode.generate(processingEnv, tableSettings, annotatedElement);
}
if (modes.contains(Mode.SIMPLE)) {
GeneratorSimpleMode.generate(processingEnv, annotatedElement);
generateTableMode(tableSettings, annotatedElement, mirror, annotatedElementName);
}
}
}
return true;
}
private void generateTableMode(TableModeSettings tableSettings, Element annotatedElement, TypeMirror mirror, String annotatedElementName) {
final Table anTable = annotatedElement.getAnnotation(Table.class);
final String newClassName = annotatedElementName + Mode.TABLE.getDefaultPostfix();
final List<? extends Element> allFields = annotatedElement.getEnclosedElements().stream()
.filter(this::isField)
.filter(this::isNotIgnoreField)
.collect(Collectors.toList());
final List<SimpleFieldTableDto> simpleFields = getSimpleFields(allFields, anTable, tableSettings);
final List<JoinFieldDto> joinFields = getJoinFields(allFields);
final List<JoinElemCollectionDto> elementCollectionFields = getElementCollectionsFields(anTable.name(), allFields);
final ClassTableDto newClass = new ClassTableDto();
newClass.setClassName(newClassName);
newClass.setSimpleFields(simpleFields);
newClass.setJoinFields(joinFields);
newClass.setJoinElemCollections(elementCollectionFields);
newClass.setClassPackage(getPackage(mirror));
newClass.setTableName(anTable.name());
CreatorClassTableMode.record(newClass, processingEnv);
}
private List<JoinElemCollectionDto> getElementCollectionsFields(String tableName, List<? extends Element> allFields) {
return allFields.stream()
.filter(
field -> field.getAnnotation(ElementCollectionField.class) != null &&
field.getAnnotation(CollectionTable.class) != null &&
field.getAnnotation(Column.class) != null
)
.map(field -> {
final String fieldName = field.getSimpleName().toString();
final ElementCollectionField elementCollectionField = field.getAnnotation(ElementCollectionField.class);
final CollectionTable collectionTable = field.getAnnotation(CollectionTable.class);
final Column column = field.getAnnotation(Column.class);
final JoinTableContainer firstContainer = JoinTableContainer.of(collectionTable.name(), tableName + "." + elementCollectionField.parentId(), collectionTable.joinColumns()[0].name());
final JoinTableContainer secondContainer = JoinTableContainer.of(elementCollectionField.childTable(), column.name(), elementCollectionField.childReference());
return JoinElemCollectionDto.of(fieldName, firstContainer, secondContainer);
}).collect(Collectors.toList());
}
private List<JoinFieldDto> getJoinFields(List<? extends Element> allFields) {
return allFields.stream()
.filter(
field -> field.getAnnotation(JoinField.class) != null &&
field.getAnnotation(ElementCollection.class) == null
)
.map(field -> {
final String fieldName = field.getSimpleName().toString();
final JoinField joinField = field.getAnnotation(JoinField.class);
final JoinTableContainer joinContainer = JoinTableContainer.of(joinField.table(), joinField.baseId(), joinField.reference());
return JoinFieldDto.of(fieldName, joinContainer);
})
.collect(Collectors.toList());
}
private List<SimpleFieldTableDto> getSimpleFields(List<? extends Element> allFields, Table anTable, TableModeSettings tableSettings) {
final boolean prefixTableForColumn = tableSettings.prefixTableForColumn();
final List<SimpleFieldTableDto> resultList = new ArrayList<>();
allFields.stream()
.filter(
field -> field.getAnnotation(Column.class) != null &&
field.getAnnotation(ElementCollection.class) == null
)
.forEach(
field -> {
final String fieldName = field.getSimpleName().toString();
final String columnName = field.getAnnotation(Column.class).name();
if (prefixTableForColumn) {
final String tableNameAndColumnName = anTable.name() + "." + columnName;
resultList.add(SimpleFieldTableDto.of("t_" + fieldName, tableNameAndColumnName));
}
resultList.add(SimpleFieldTableDto.of(fieldName, columnName));
}
);
return resultList;
}
private boolean isNotIgnoreField(Element element) {
return element.getAnnotation(IgnoreField.class) == null;
}
public boolean isField(Element element) {
return element != null && element.getKind().isField();
}
public static String getPackage(TypeMirror typeMirror) {
final String[] split = typeMirror.toString().split("\\.");
return String.join(".", Arrays.copyOf(split, split.length - 1));
}
}

26
src/main/java/dev/struchkov/haiti/utils/fieldconstants/util/Generator.java
View File

@ -1,26 +0,0 @@
package dev.struchkov.haiti.utils.fieldconstants.util;
import dev.struchkov.haiti.utils.fieldconstants.annotation.field.IgnoreField;
import javax.lang.model.element.Element;
import javax.lang.model.element.ElementKind;
public class Generator {
public static boolean isNotIgnoreField(Element element) {
return element.getAnnotation(IgnoreField.class) == null;
}
public static boolean isField(Element element) {
return element != null && element.getKind().isField();
}
public static String getPackage(Element element) {
Element packageElem = element.getEnclosingElement();
while (!ElementKind.PACKAGE.equals(packageElem.getKind())) {
packageElem = packageElem.getEnclosingElement();
}
return packageElem.asType().toString();
}
}

2
src/main/java/module-info.java
View File

@ -6,6 +6,6 @@ module haiti.utils.fieldconstants {
requires java.compiler;
requires com.google.auto.service;
requires jakarta.persistence;
requires java.persistence;
requires haiti.utils;
}