com.jaxio.celerio.model.support.jpa.JpaConfigHelper Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of celerio-engine Show documentation
Show all versions of celerio-engine Show documentation
Celerio Core Generation Engine
/*
* Copyright 2015 JAXIO http://www.jaxio.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.jaxio.celerio.model.support.jpa;
import com.jaxio.celerio.configuration.entity.*;
import com.jaxio.celerio.model.PackageImportAdder;
import com.jaxio.celerio.util.AttributeBuilder;
import org.springframework.util.Assert;
import javax.persistence.CascadeType;
import javax.persistence.FetchType;
import java.util.List;
import static com.google.common.collect.Lists.newArrayList;
public class JpaConfigHelper {
// ------------------------------------------
// OneToXConfig orphanRemoval
// ------------------------------------------
public static String orphanRemoval(OneToManyConfig... oneToManyConfigs) {
return hasTrueOrphanRemoval(oneToManyConfigs) ? "orphanRemoval = true" : "";
}
public static boolean hasTrueOrphanRemoval(OneToManyConfig... oneToManyConfigs) {
if (oneToManyConfigs == null) {
return false;
}
for (OneToManyConfig oneToManyConfig : oneToManyConfigs) {
if (oneToManyConfig != null && oneToManyConfig.getOrphanRemoval() != null) {
return oneToManyConfig.getOrphanRemoval().booleanValue();
}
}
return false; // false is the jpa default
}
public static String orphanRemoval(OneToOneConfig... oneToOneConfigs) {
return hasTrueOrphanRemoval(oneToOneConfigs) ? "orphanRemoval = true" : "";
}
public static boolean hasTrueOrphanRemoval(OneToOneConfig... oneToOneConfigs) {
if (oneToOneConfigs == null) {
return false;
}
for (OneToOneConfig oneToOneConfig : oneToOneConfigs) {
if (oneToOneConfig != null && oneToOneConfig.getOrphanRemoval() != null) {
return oneToOneConfig.getOrphanRemoval().booleanValue();
}
}
return false; // let jpa default applies
}
// ------------------------------------------
// CASCADE
// ------------------------------------------
public static String jpaCascade(PackageImportAdder importAdder, CascadeGetter... cascadeGetters) {
if (cascadeGetters == null) {
return "";
}
// we look for the first non empty conf.
// not that it could be a NONE conf => user does not want any cascade.
for (CascadeGetter cascadeGetter : cascadeGetters) {
if (cascadeGetter != null) {
List cascadeConf = cascadeGetter.getCascades();
if (cascadeConf != null && cascadeConf.size() > 0) {
List cascades = convertJpaCascade(cascadeConf);
// we could have removed the NONE element, so we check for emptiness.
if (!cascades.isEmpty()) {
for (CascadeType ct : cascades) {
importAdder.addImport("static javax.persistence.CascadeType." + ct.name());
}
AttributeBuilder ab = new AttributeBuilder();
ab.add("cascade", convertJpaCascadeToStrings(cascades));
return ab.getAttributes();
} else {
return ""; // there was 1 element: NONE => user does not want anything, we bail out.
}
}
}
}
return "";
}
private static String[] convertJpaCascadeToStrings(List cascadeTypes) {
if (cascadeTypes == null) {
return null;
}
String[] result = new String[cascadeTypes.size()];
int i = 0;
for (CascadeType ct : cascadeTypes) {
result[i++] = ct.name();
}
return result;
}
private static List convertJpaCascade(List cascades) {
if (cascades == null) {
return null;
}
List result = newArrayList();
for (Cascade c : cascades) {
if (c.getType().isJpaType()) {
result.add(c.getType().asJpaType());
}
}
return result;
}
// ------------------------------------------
// FETCH
// ------------------------------------------
public static String jpaFetch(PackageImportAdder adder, FetchTypeGetter... fetchTypeGetters) {
Assert.notNull(adder);
if (fetchTypeGetters == null) {
return "";
}
// we look for the first non empty conf.
// not that it could be a NONE conf => user does not want any fetch type.
for (FetchTypeGetter fetchTypeGetter : fetchTypeGetters) {
if (fetchTypeGetter != null) {
if (fetchTypeGetter.getFetch() != null) {
if (fetchTypeGetter.getFetch().isJpaType()) {
FetchType fetchType = fetchTypeGetter.getFetch().asJpaType();
adder.addImport("static javax.persistence.FetchType." + fetchType.name());
return "fetch = " + fetchType.name();
} else { // NONE
return ""; // user explicitly said he does not want any fetch type.
}
}
}
}
return "";
}
// ------------------------------------------
// ORDER BY
// ------------------------------------------
public static String orderByAnnotation(PackageImportAdder adder, OrderByGetter... orderByGetters) {
Assert.notNull(adder);
if (orderByGetters == null) {
return null;
}
// we look for the first non empty conf.
for (OrderByGetter getter : orderByGetters) {
if (getter != null) {
if (getter.getOrderBy() != null && !getter.getOrderBy().isEmpty()) {
adder.addImport("javax.persistence.OrderBy");
AttributeBuilder ab = new AttributeBuilder();
ab.addString(getter.getOrderBy());
return ab.bindAttributesTo("@OrderBy");
}
}
}
return null;
}
// ------------------------------------------
// CacheConfig
// ------------------------------------------
public static String getCacheAnnotation(PackageImportAdder packageImportAdder, CacheConfigGetter... cacheConfigGetters) {
if (cacheConfigGetters == null) {
return "";
}
for (CacheConfigGetter cacheConfigGetter : cacheConfigGetters) {
if (cacheConfigGetter != null) {
CacheConfig cacheConfig = cacheConfigGetter.getCacheConfig();
if (cacheConfig != null) {
if (cacheConfig.getUsage().isNone()) {
return ""; // cleaner than disabling the cache using @Cache (usage = NONE)
} else {
packageImportAdder.addImport("org.hibernate.annotations.Cache");
packageImportAdder.addImport("static org.hibernate.annotations.CacheConcurrencyStrategy." + cacheConfig.getUsage().name());
AttributeBuilder attr = new AttributeBuilder();
attr.add("usage = " + cacheConfig.getUsage().name());
if (cacheConfig.hasInclude()) {
attr.addString("include", cacheConfig.getInclude());
}
if (cacheConfig.hasRegion()) {
attr.addString("region", cacheConfig.getInclude());
}
return attr.bindAttributesTo("@Cache");
}
}
}
}
return "";
}
}