| /** |
| * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany) |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License 2.0 |
| * which accompanies this distribution, and is available at |
| * https://www.eclipse.org/legal/epl-2.0/ |
| * |
| * SPDX-License-Identifier: EPL-2.0 |
| * |
| * Contributors: |
| * Florian Pirchner - Initial implementation |
| */ |
| package org.eclipse.osbp.dsl.entity.xtext.validation; |
| |
| import java.util.ArrayList; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| |
| import javax.persistence.Persistence; |
| import javax.persistence.PostPersist; |
| import javax.persistence.PostRemove; |
| import javax.persistence.PostUpdate; |
| import javax.persistence.PrePersist; |
| import javax.persistence.PreRemove; |
| import javax.persistence.PreUpdate; |
| |
| import org.eclipse.emf.ecore.EAttribute; |
| import org.eclipse.emf.ecore.util.EcoreUtil; |
| import org.eclipse.osbp.dsl.entity.xtext.extensions.ModelExtensions; |
| import org.eclipse.osbp.dsl.entity.xtext.util.PersistenceNamingUtils; |
| import org.eclipse.osbp.dsl.semantic.common.helper.Bounds; |
| import org.eclipse.osbp.dsl.semantic.common.types.LDataType; |
| import org.eclipse.osbp.dsl.semantic.common.types.LEnum; |
| import org.eclipse.osbp.dsl.semantic.common.types.LFeature; |
| import org.eclipse.osbp.dsl.semantic.common.types.LPackage; |
| import org.eclipse.osbp.dsl.semantic.common.types.LReference; |
| import org.eclipse.osbp.dsl.semantic.common.types.LScalarType; |
| import org.eclipse.osbp.dsl.semantic.common.types.LType; |
| import org.eclipse.osbp.dsl.semantic.common.types.LTypedPackage; |
| import org.eclipse.osbp.dsl.semantic.common.types.OSBPTypesPackage; |
| import org.eclipse.osbp.dsl.semantic.entity.LBean; |
| import org.eclipse.osbp.dsl.semantic.entity.LBeanFeature; |
| import org.eclipse.osbp.dsl.semantic.entity.LBeanReference; |
| import org.eclipse.osbp.dsl.semantic.entity.LDiscriminatorType; |
| import org.eclipse.osbp.dsl.semantic.entity.LEntity; |
| import org.eclipse.osbp.dsl.semantic.entity.LEntityAttribute; |
| import org.eclipse.osbp.dsl.semantic.entity.LEntityFeature; |
| import org.eclipse.osbp.dsl.semantic.entity.LEntityInheritanceStrategy; |
| import org.eclipse.osbp.dsl.semantic.entity.LEntityModel; |
| import org.eclipse.osbp.dsl.semantic.entity.LEntityPersistenceInfo; |
| import org.eclipse.osbp.dsl.semantic.entity.LEntityReference; |
| import org.eclipse.osbp.dsl.semantic.entity.LEntitySuperIndex; |
| import org.eclipse.osbp.dsl.semantic.entity.LIndex; |
| import org.eclipse.osbp.dsl.semantic.entity.LTablePerClassStrategy; |
| import org.eclipse.osbp.dsl.semantic.entity.LTablePerSubclassStrategy; |
| import org.eclipse.osbp.dsl.semantic.entity.OSBPEntityPackage; |
| import org.eclipse.osbp.preferences.EnumDatabaseVendor; |
| import org.eclipse.xtext.common.types.JvmAnnotationReference; |
| import org.eclipse.xtext.common.types.JvmGenericType; |
| import org.eclipse.xtext.common.types.JvmOperation; |
| import org.eclipse.xtext.common.types.TypesPackage; |
| import org.eclipse.xtext.common.types.util.TypeReferences; |
| import org.eclipse.xtext.naming.IQualifiedNameProvider; |
| import org.eclipse.xtext.resource.IContainer; |
| import org.eclipse.xtext.resource.IEObjectDescription; |
| import org.eclipse.xtext.resource.IResourceDescription; |
| import org.eclipse.xtext.resource.IResourceDescriptions; |
| import org.eclipse.xtext.resource.impl.ResourceDescriptionsProvider; |
| import org.eclipse.xtext.validation.Check; |
| import org.eclipse.xtext.validation.CheckType; |
| import org.eclipse.xtext.validation.NamesAreUniqueValidator; |
| import org.eclipse.xtext.validation.ValidationMessageAcceptor; |
| import org.eclipse.xtext.xbase.jvmmodel.IJvmModelAssociations; |
| import org.eclipse.xtext.xbase.lib.Extension; |
| |
| import com.google.inject.Inject; |
| |
| /** |
| * Custom validation rules. |
| * |
| * see http://www.eclipse.org/Xtext/documentation.html#validation |
| */ |
| @SuppressWarnings("restriction") |
| public class EntityGrammarValidator extends AbstractEntityGrammarValidator { |
| |
| public static final String CODE__DIFFERING_INHERITANCE_FROM_SUPERTYPE = "104"; |
| public static final String CODE__INHERITANCE_PROPERTY_IGNORED = "105"; |
| public static final String CODE__INHERITANCE_DISCRIMINATOR_VALUE_NOT_UNIQUE = "106"; |
| public static final String CODE__DUPLICATE_PERSISTENCE = "106"; |
| public static final String CODE__DUPLICATE_ID = "107"; |
| public static final String CODE__DUPLICATE_VERSION = "108"; |
| public static final String CODE__MISSING_ID = "109"; |
| public static final String CODE__DUPLICATE_PROPERTY_NAME = "110"; |
| public static final String CODE__MISSING_OPPOSITE_REFERENCE = "111"; |
| public static final String CODE__BIDIRECTIONAL_CASCADE_INVALID = "112"; |
| public static final String CODE__CASCADE_DIRECTION_INVALID = "113"; |
| public static final String CODE__UUID_WRONG_TYPE = "114"; |
| public static final String CODE__OPPOSITE_WITHOUT_CASCADE = "115"; |
| public static final String CODE__MISSING_ID_FOR_VERSIONED = "116"; |
| public static final String CODE__HISTORIZED_IN_SUBCLASS = "117"; |
| public static final String CODE__TIMEDEPENDENT_IN_SUBCLASS = "118"; |
| private static final String CODE__DUPLICATE_DOMAIN_KEY = "119"; |
| private static final String CODE__DUPLICATE_DOMAIN_DESCRIPTION = "120"; |
| private static final String CODE__DOMAIN_KEY__NO_MANY = "121"; |
| private static final String CODE__DOMAIN_DESCRIPTION__NO_MANY = "122"; |
| private static final String CODE__DOMAIN_KEY__TYPE = "123"; |
| private static final String CODE__DOMAIN_DESCRIPTION__TYPE = "124"; |
| private static final String CODE__BEAN_TO_ENTITY__NO_MANY_RELATION_SUPPORTED = "125"; |
| private static final String CODE__BEAN_TO_ENTITY__NO_OPPOSITE_RELATION_SUPPORTED = "126"; |
| private static final String CODE__ENTITY_TO_BEAN__NO_OPPOSITE_RELATION_SUPPORTED = "127"; |
| private static final String CODE__DUPLICATE__PERSISTENCE_ANNOTATION = "128"; |
| public static final String CODE__INHERITANCE_NO_SUB_TYPES = "129"; |
| |
| @Inject |
| private IQualifiedNameProvider qnp; |
| @Inject |
| private ModelExtensions extensions; |
| @Inject |
| private NamesAreUniqueValidator uniqueValidator; |
| @Inject |
| private IContainer.Manager containermanager; |
| @Inject |
| private ResourceDescriptionsProvider resourceDescriptionsProvider; |
| @Inject |
| private IJvmModelAssociations modelAssociations; |
| |
| @Check |
| public void checkDatatype_asPrimitive(LDataType dt) { |
| super.checkDatatype_asPrimitive(dt); |
| } |
| |
| @Check |
| public void checkJPA_MultiHasOppositeReference(LEntityReference prop) { |
| if (extensions.isToMany(prop)) { |
| if (prop.getOpposite() == null) { |
| error("A 'to-many' association needs an opposite reference.", |
| OSBPEntityPackage.Literals.LENTITY_REFERENCE__OPPOSITE, |
| ValidationMessageAcceptor.INSIGNIFICANT_INDEX, CODE__MISSING_OPPOSITE_REFERENCE, |
| (String[]) null); |
| } else if (prop.getOpposite().getOpposite() == null) { |
| error("Missing opposite reference", prop.getOpposite(), OSBPTypesPackage.Literals.LFEATURE__NAME, |
| ValidationMessageAcceptor.INSIGNIFICANT_INDEX, CODE__MISSING_OPPOSITE_REFERENCE, |
| (String[]) null); |
| } |
| } |
| } |
| |
| @Check |
| public void checkBean_MultiHasOppositeReference(LBeanReference prop) { |
| if (prop.getType() instanceof LEntity) { |
| if (extensions.isToMany(prop)) { |
| error("To-Many-Relations are not supported for bean->entity references.", |
| OSBPTypesPackage.Literals.LFEATURE__MULTIPLICITY, ValidationMessageAcceptor.INSIGNIFICANT_INDEX, |
| CODE__BEAN_TO_ENTITY__NO_MANY_RELATION_SUPPORTED, (String[]) null); |
| } |
| if (prop.getOpposite() != null) { |
| error("Opposite-Relations are not supported for bean->entity references.", |
| OSBPEntityPackage.Literals.LBEAN_REFERENCE__OPPOSITE, |
| ValidationMessageAcceptor.INSIGNIFICANT_INDEX, |
| CODE__BEAN_TO_ENTITY__NO_OPPOSITE_RELATION_SUPPORTED, (String[]) null); |
| } |
| } |
| } |
| |
| @Check |
| public void checkEntity_MultiHasOppositeReference(LEntityAttribute prop) { |
| if (prop.getType() instanceof LBean) { |
| if (prop.getOpposite() != null) { |
| error("Opposite-Relations are not supported for embeddables.", |
| OSBPEntityPackage.Literals.LENTITY_ATTRIBUTE__OPPOSITE, |
| ValidationMessageAcceptor.INSIGNIFICANT_INDEX, |
| CODE__ENTITY_TO_BEAN__NO_OPPOSITE_RELATION_SUPPORTED, (String[]) null); |
| } |
| } |
| } |
| |
| @Check |
| public void checkJPA_OppositeNotAlsoCascadeMergePersist(LEntityReference prop) { |
| if (prop.getOpposite() != null) { |
| if (prop.isCascadeMergePersist() && prop.getOpposite().isCascadeMergePersist()) { |
| error("Only one opposite may be specified as cascade", |
| OSBPTypesPackage.Literals.LFEATURE__CASCADE_MERGE_PERSIST, CODE__BIDIRECTIONAL_CASCADE_INVALID, |
| (String[]) null); |
| } |
| |
| if (extensions.isToMany(prop.getOpposite())) { |
| if (prop.isCascadeMergePersist()) { |
| error("Cascade must not affect the common parent in a many-to-one relation", prop, |
| OSBPTypesPackage.Literals.LFEATURE__CASCADE_MERGE_PERSIST, CODE__CASCADE_DIRECTION_INVALID, |
| new String[0]); |
| } |
| } |
| } |
| } |
| |
| @Check |
| public void checkJPA_OppositeNotAlsoCascadeRemove(LEntityReference prop) { |
| if (prop.getOpposite() != null) { |
| if (prop.isCascadeRemove() && prop.getOpposite().isCascadeRemove()) { |
| error("Only one opposite may be specified as cascade", |
| OSBPTypesPackage.Literals.LFEATURE__CASCADE_REMOVE, CODE__BIDIRECTIONAL_CASCADE_INVALID, |
| (String[]) null); |
| } |
| |
| if (extensions.isToMany(prop.getOpposite())) { |
| if (prop.isCascadeRemove()) { |
| error("Cascade must not affect the common parent in a many-to-one relation", prop, |
| OSBPTypesPackage.Literals.LFEATURE__CASCADE_REMOVE, CODE__CASCADE_DIRECTION_INVALID, |
| new String[0]); |
| } |
| } |
| } |
| } |
| |
| @Check |
| public void checkJPA_Opposite_OneIsCascadeMergePersist(LEntityReference prop) { |
| Bounds propBound = extensions.getBounds(prop); |
| Bounds oppositeBound = extensions.getBounds(prop.getOpposite()); |
| |
| if (propBound.isToMany() || oppositeBound.isToMany()) { |
| // no check required! |
| return; |
| } |
| |
| if (prop.getOpposite() != null) { |
| if (!prop.isCascadeMergePersist() && !prop.getOpposite().isCascadeMergePersist()) { |
| error("Opposite references may only defined for cascading relations.", prop, |
| OSBPTypesPackage.Literals.LFEATURE__CASCADE_MERGE_PERSIST, CODE__OPPOSITE_WITHOUT_CASCADE, |
| new String[0]); |
| } |
| } |
| } |
| |
| @Check |
| public void checkJPA_Opposite_OneIsCascadeRemove(LEntityReference prop) { |
| Bounds propBound = extensions.getBounds(prop); |
| Bounds oppositeBound = extensions.getBounds(prop.getOpposite()); |
| |
| if (propBound.isToMany() || oppositeBound.isToMany()) { |
| // no check required! |
| return; |
| } |
| |
| if (prop.getOpposite() != null) { |
| if (!prop.isCascadeRemove() && !prop.getOpposite().isCascadeRemove()) { |
| error("Opposite references may only defined for cascading relations.", prop, |
| OSBPTypesPackage.Literals.LFEATURE__CASCADE_REMOVE, CODE__OPPOSITE_WITHOUT_CASCADE, |
| new String[0]); |
| } |
| } |
| } |
| |
| @Check |
| public void checkBean_OppositeNotAlsoCascadeMergePersist(LBeanReference prop) { |
| if (prop.getType() instanceof LBean) { |
| if (prop.getOpposite() != null) { |
| if (prop.isCascadeMergePersist() && isCascading(prop)) { |
| error("Only one opposite may be specified as cascade", |
| OSBPTypesPackage.Literals.LFEATURE__CASCADE_MERGE_PERSIST, |
| CODE__BIDIRECTIONAL_CASCADE_INVALID, (String[]) null); |
| } |
| |
| if (extensions.isToMany(prop.getOpposite())) { |
| if (prop.isCascadeMergePersist()) { |
| error("Cascade must not affect the common parent in a many-to-one relation", prop, |
| OSBPTypesPackage.Literals.LFEATURE__CASCADE_MERGE_PERSIST, |
| CODE__CASCADE_DIRECTION_INVALID, new String[0]); |
| } |
| } |
| } |
| } |
| } |
| |
| @Check |
| public void checkBean_OppositeNotAlsoCascadeRemove(LBeanReference prop) { |
| if (prop.getType() instanceof LBean) { |
| if (prop.getOpposite() != null) { |
| if (prop.isCascadeRemove() && isCascading(prop)) { |
| error("Only one opposite may be specified as cascade", |
| OSBPTypesPackage.Literals.LFEATURE__CASCADE_REMOVE, CODE__BIDIRECTIONAL_CASCADE_INVALID, |
| (String[]) null); |
| } |
| |
| if (extensions.isToMany(prop.getOpposite())) { |
| if (prop.isCascadeRemove()) { |
| error("Cascade must not affect the common parent in a many-to-one relation", prop, |
| OSBPTypesPackage.Literals.LFEATURE__CASCADE_REMOVE, CODE__CASCADE_DIRECTION_INVALID, |
| new String[0]); |
| } |
| } |
| } |
| } |
| } |
| |
| protected boolean isCascading(LBeanReference prop) { |
| LFeature opposite = prop.getOpposite(); |
| if (opposite instanceof LReference) { |
| return ((LReference) opposite).isCascadeMergePersist() || ((LReference) opposite).isCascadeRemove(); |
| } else { |
| return false; |
| } |
| } |
| |
| @Check |
| public void checkProperties_JavaKeyWord(LFeature lprop) { |
| super.checkProperties_JavaKeyWord(lprop); |
| } |
| |
| @Check |
| public void checkDuplicatePackages_InFile(LEntityModel lmodel) { |
| Set<String> names = new HashSet<String>(); |
| int counter = -1; |
| for (LPackage pkg : lmodel.getPackages()) { |
| counter++; |
| String pkgName = qnp.getFullyQualifiedName(pkg).toString(); |
| if (names.contains(pkgName)) { |
| error(String.format("Package %s must not be defined twice!", pkgName), |
| OSBPEntityPackage.Literals.LENTITY_MODEL__PACKAGES, counter, CODE__DUPLICATE_LPACKAGE_IN_FILE, |
| (String[]) null); |
| } |
| names.add(pkgName); |
| } |
| } |
| |
| @Check(CheckType.NORMAL) |
| public void checkDuplicateType_InProject(LType type) { |
| if (type instanceof LDataType) { |
| return; |
| } |
| super.checkDuplicateType_InProject(type); |
| } |
| |
| @Check(CheckType.NORMAL) |
| public void checkDuplicateDatatypeInPackage(LTypedPackage pkg) { |
| super.checkDuplicateDatatypeInPackage(pkg); |
| } |
| |
| @Check(CheckType.NORMAL) |
| public void checkDuplicatePackage_InProject(LPackage lPackage) { |
| super.checkDuplicatePackage_InProject(lPackage); |
| } |
| |
| @Check |
| public void checkBeanManyToMany(LBeanReference prop) { |
| ModelExtensions extension = new ModelExtensions(); |
| if (prop.getOpposite() != null && extension.isToMany(prop) && extension.isToMany(prop.getOpposite())) { |
| error(String.format("ManyToMany relations are not permitted!", qnp.getFullyQualifiedName(prop).toString()), |
| OSBPEntityPackage.Literals.LBEAN_REFERENCE__OPPOSITE, ValidationMessageAcceptor.INSIGNIFICANT_INDEX, |
| CODE__MANY_TO_MANY__NOT_SUPPORTED, (String[]) null); |
| } |
| } |
| |
| @Check |
| public void checkManyToMany(LEntityReference prop) { |
| ModelExtensions extension = new ModelExtensions(); |
| if (prop.getOpposite() != null && extension.isToMany(prop) && extension.isToMany(prop.getOpposite())) { |
| error(String.format("ManyToMany relations are not permitted!", qnp.getFullyQualifiedName(prop).toString()), |
| OSBPEntityPackage.Literals.LENTITY_REFERENCE__OPPOSITE, |
| ValidationMessageAcceptor.INSIGNIFICANT_INDEX, CODE__MANY_TO_MANY__NOT_SUPPORTED, (String[]) null); |
| } |
| } |
| |
| @Check(CheckType.NORMAL) |
| public void checkJPA_ConsistentInheritanceStrategy(LEntity entity) { |
| // no checks required - inheritance is inherited |
| if (entity.getInheritanceStrategy() == null) { |
| return; |
| } |
| |
| LEntityInheritanceStrategy differingSuperStgy = searchDifferingSuperStrategy(entity.getInheritanceStrategy(), |
| entity); |
| if (differingSuperStgy != null) { |
| LEntity superType = (LEntity) differingSuperStgy.eContainer(); |
| warning(String.format( |
| "The supertype %s uses the inheritance strategy %s. The inheritance of this entity is ignored!", |
| qnp.getFullyQualifiedName(superType).toString(), getStrategyName(differingSuperStgy)), |
| OSBPEntityPackage.Literals.LENTITY__INHERITANCE_STRATEGY, |
| ValidationMessageAcceptor.INSIGNIFICANT_INDEX, CODE__DIFFERING_INHERITANCE_FROM_SUPERTYPE, |
| (String[]) null); |
| } |
| } |
| |
| @Check(CheckType.NORMAL) |
| public void checkJPA_Features(LEntityAttribute prop) { |
| if (prop.isUuid()) { |
| boolean typeOK = false; |
| if (prop.getType() instanceof LDataType) { |
| LDataType type = (LDataType) prop.getType(); |
| String typename = type.getJvmTypeReference().getQualifiedName(); |
| if (typename.equals("java.lang.String")) { |
| typeOK = true; |
| } |
| } |
| |
| if (!typeOK) { |
| error("UUIDs must be of type String.", OSBPTypesPackage.Literals.LATTRIBUTE__UUID, |
| CODE__UUID_WRONG_TYPE, new String[0]); |
| } |
| } |
| |
| if (prop.isDomainKey()) { |
| if (extensions.isToMany(prop)) { |
| error("DomainKey is not valid for one to many relations.", |
| OSBPTypesPackage.Literals.LATTRIBUTE__DOMAIN_KEY, CODE__DOMAIN_KEY__NO_MANY, new String[0]); |
| } |
| |
| if (prop.getType() instanceof LDataType) { |
| LDataType type = (LDataType) prop.getType(); |
| if (type.getJvmTypeReference() == null |
| || !"java.lang.String".equals(type.getJvmTypeReference().getQualifiedName())) { |
| error("DomainKey must be of type String.", OSBPTypesPackage.Literals.LATTRIBUTE__DOMAIN_KEY, |
| CODE__DOMAIN_KEY__TYPE, new String[0]); |
| } |
| } |
| } |
| |
| if (prop.isDomainDescription()) { |
| if (extensions.isToMany(prop)) { |
| error("DomainDescription is not valid for one to many relations.", |
| OSBPTypesPackage.Literals.LATTRIBUTE__DOMAIN_DESCRIPTION, CODE__DOMAIN_DESCRIPTION__NO_MANY, |
| new String[0]); |
| } |
| |
| if (prop.getType() instanceof LDataType) { |
| LDataType type = (LDataType) prop.getType(); |
| String typename = type.getJvmTypeReference().getQualifiedName(); |
| if (!typename.equals("java.lang.String")) { |
| error("DomainDescription must be of type String.", |
| OSBPTypesPackage.Literals.LATTRIBUTE__DOMAIN_DESCRIPTION, CODE__DOMAIN_DESCRIPTION__TYPE, |
| new String[0]); |
| } |
| } |
| } |
| } |
| |
| @Check(CheckType.NORMAL) |
| public void checkJPA_Historized(LEntity entity) { |
| if (entity.isHistorized()) { |
| if (entity.getSuperType() != null && !entity.getSuperType().isMappedSuperclass()) { |
| error("Keyword historized may only be used in toplevel entities of inheritance hierarchy", |
| OSBPEntityPackage.Literals.LENTITY__HISTORIZED, CODE__HISTORIZED_IN_SUBCLASS, new String[0]); |
| } |
| } |
| |
| if (entity.isTimedependent()) { |
| if (entity.getSuperType() != null && !entity.getSuperType().isMappedSuperclass()) { |
| error("Keyword timedependent may only be used in toplevel entities of inheritance hierarchy", |
| OSBPEntityPackage.Literals.LENTITY__TIMEDEPENDENT, CODE__TIMEDEPENDENT_IN_SUBCLASS, |
| new String[0]); |
| } |
| } |
| } |
| |
| @Check(CheckType.NORMAL) |
| public void checkIndex_Features(LIndex index) { |
| } |
| |
| @Check(CheckType.NORMAL) |
| public void checkEntity_Index(LEntity entity) { |
| } |
| |
| @Check(CheckType.NORMAL) |
| public void checkJPA_Features(LEntity entity) { |
| |
| int idCounter = 0; |
| int versionCounter = 0; |
| int domainKeyCounter = 0; |
| int domainDescriptionCounter = 0; |
| Map<String, Integer> attNames = new HashMap<String, Integer>(); |
| for (LEntityFeature feature : entity.getAllFeatures()) { |
| if (feature instanceof LEntityAttribute) { |
| LEntityAttribute att = (LEntityAttribute) feature; |
| if (att.isId() || att.isUuid()) { |
| idCounter++; |
| } |
| if (att.isVersion()) { |
| versionCounter++; |
| } |
| if (att.isDomainKey()) { |
| domainKeyCounter++; |
| } |
| if (att.isDomainDescription()) { |
| domainDescriptionCounter++; |
| } |
| } |
| |
| if (!attNames.containsKey(feature.getName())) { |
| attNames.put(feature.getName(), 1); |
| } else { |
| int value = attNames.get(feature.getName()); |
| attNames.put(feature.getName(), ++value); |
| } |
| } |
| |
| if (idCounter == 0 && (entity.isHistorized() || entity.isTimedependent())) { |
| error("An historized or timedependent entity must have an ID property", |
| OSBPEntityPackage.Literals.LENTITY__FEATURES, CODE__MISSING_ID_FOR_VERSIONED); |
| } else |
| |
| if (idCounter == 0) { |
| warning("An entity should have an ID property", OSBPEntityPackage.Literals.LENTITY__FEATURES, |
| CODE__MISSING_ID); |
| } else if (idCounter > 1) { |
| int i = 0; |
| for (LEntityFeature feature : entity.getFeatures()) { |
| if (feature instanceof LEntityAttribute) { |
| if (((LEntityAttribute) feature).isId() || ((LEntityAttribute) feature).isUuid()) { |
| error("An entity must only have one ID property.", OSBPEntityPackage.Literals.LENTITY__FEATURES, |
| i, CODE__DUPLICATE_ID, new String[0]); |
| break; |
| } |
| } |
| |
| i++; |
| } |
| } |
| if (versionCounter > 1) { |
| int i = 0; |
| for (LEntityFeature feature : entity.getFeatures()) { |
| if (feature instanceof LEntityAttribute) { |
| if (((LEntityAttribute) feature).isVersion()) { |
| error("An entity must only have one Version property.", |
| OSBPEntityPackage.Literals.LENTITY__FEATURES, i, CODE__DUPLICATE_VERSION, |
| new String[0]); |
| break; |
| } |
| } |
| i++; |
| } |
| } |
| |
| if (domainKeyCounter > 1) { |
| int i = 0; |
| for (LEntityFeature feature : entity.getFeatures()) { |
| if (feature instanceof LEntityAttribute) { |
| if (((LEntityAttribute) feature).isDomainKey()) { |
| error("An entity must only have one DomainKey property.", |
| OSBPEntityPackage.Literals.LENTITY__FEATURES, i, CODE__DUPLICATE_DOMAIN_KEY, |
| new String[0]); |
| break; |
| } |
| } |
| i++; |
| } |
| } |
| |
| if (domainDescriptionCounter > 1) { |
| int i = 0; |
| for (LEntityFeature feature : entity.getFeatures()) { |
| if (feature instanceof LEntityAttribute) { |
| if (((LEntityAttribute) feature).isDomainDescription()) { |
| error("An entity must only have one DomainDescription property.", |
| OSBPEntityPackage.Literals.LENTITY__FEATURES, i, CODE__DUPLICATE_DOMAIN_DESCRIPTION, |
| new String[0]); |
| break; |
| } |
| } |
| i++; |
| } |
| } |
| |
| for (Map.Entry<String, Integer> entry : attNames.entrySet()) { |
| if (entry.getValue() > 1) { |
| int i = 0; |
| for (LEntityFeature feature : entity.getFeatures()) { |
| if (feature.getName().equals(entry.getKey())) { |
| error(String.format("The property \"%s\" must only be defined once!", feature.getName()), |
| OSBPEntityPackage.Literals.LENTITY__FEATURES, i, CODE__DUPLICATE_PROPERTY_NAME, |
| new String[0]); |
| break; |
| } |
| i++; |
| } |
| } |
| } |
| } |
| |
| protected String getStrategyName(LEntityInheritanceStrategy stgy) { |
| if (LTablePerClassStrategy.class.isAssignableFrom(stgy.getClass())) { |
| return "Table-Per-Class"; |
| } else { |
| return "Table-Per-Subclass"; |
| } |
| } |
| |
| protected LEntityInheritanceStrategy searchDifferingSuperStrategy(LEntityInheritanceStrategy stgy, LEntity entity) { |
| LEntity superEntity = entity.getSuperType(); |
| if (superEntity == null) { |
| return null; |
| } |
| |
| LEntityInheritanceStrategy superStgy = superEntity.getInheritanceStrategy(); |
| if (superStgy == null) { |
| return searchDifferingSuperStrategy(stgy, superEntity); |
| } |
| |
| if (!stgy.getClass().getName().equals(superStgy.getClass().getName())) { |
| return superStgy; |
| } |
| |
| return searchDifferingSuperStrategy(stgy, superEntity); |
| } |
| |
| @Check(CheckType.NORMAL) |
| public void checkJPA_IgnoredInheritanceStrategyProperties(LEntity entity) { |
| // no checks required - inheritance is inherited |
| LEntityInheritanceStrategy stgy = entity.getInheritanceStrategy(); |
| if (stgy == null) { |
| return; |
| } |
| |
| if (entity.getSuperType() != null && !extensions.checkIsMappedSuperclass(entity.getSuperType())) { |
| if (LTablePerClassStrategy.class.isAssignableFrom(stgy.getClass())) { |
| LTablePerClassStrategy castStgy = (LTablePerClassStrategy) stgy; |
| if (castStgy.getDiscriminatorColumn() != null) { |
| sendIgnoredInheritancePropertyWarning(stgy, |
| OSBPEntityPackage.Literals.LTABLE_PER_CLASS_STRATEGY__DISCRIMINATOR_COLUMN); |
| } |
| if (castStgy.getDiscriminatorType() != LDiscriminatorType.INHERIT) { |
| sendIgnoredInheritancePropertyWarning(stgy, |
| OSBPEntityPackage.Literals.LTABLE_PER_CLASS_STRATEGY__DISCRIMINATOR_TYPE); |
| } |
| } else { |
| LTablePerSubclassStrategy castStgy = (LTablePerSubclassStrategy) stgy; |
| if (castStgy.getDiscriminatorColumn() != null) { |
| sendIgnoredInheritancePropertyWarning(stgy, |
| OSBPEntityPackage.Literals.LTABLE_PER_SUBCLASS_STRATEGY__DISCRIMINATOR_COLUMN); |
| } |
| if (castStgy.getDiscriminatorType() != LDiscriminatorType.INHERIT) { |
| sendIgnoredInheritancePropertyWarning(stgy, |
| OSBPEntityPackage.Literals.LTABLE_PER_SUBCLASS_STRATEGY__DISCRIMINATOR_TYPE); |
| } |
| } |
| } |
| } |
| |
| @Check(CheckType.NORMAL) |
| public void checkJPA_InheritanceStrategy_NotUniqueDiscriminatorValue(LEntity entity) { |
| if (entity.getSuperType() == null) { |
| return; |
| } |
| |
| String currentValue = extensions.toDiscriminatorValue(extensions.toInheritanceStrategy(entity)); |
| |
| // collect all super type strategies |
| List<LEntityInheritanceStrategy> stgies = extensions.collectAllInheritanceStrategies(entity.getSuperType()); |
| |
| for (LEntityInheritanceStrategy stgy : stgies) { |
| String value = extensions.toDiscriminatorValue(stgy); |
| if (value.equals(currentValue)) { |
| error(String.format("The discrimator value %s is already used by supertype!", value), entity, |
| OSBPEntityPackage.Literals.LENTITY__INHERITANCE_STRATEGY, |
| ValidationMessageAcceptor.INSIGNIFICANT_INDEX, CODE__INHERITANCE_DISCRIMINATOR_VALUE_NOT_UNIQUE, |
| (String[]) null); |
| } |
| } |
| } |
| |
| @Check(CheckType.NORMAL) |
| public void checkJPA_InheritanceStrategy(LEntity entity) { |
| LEntityInheritanceStrategy stgy = entity.getInheritanceStrategy(); |
| if (stgy == null) { |
| return; |
| } |
| |
| if (entity.getSubTypes().isEmpty()) { |
| error("Inheritance is only allowed for entities with sub types.", entity, |
| OSBPEntityPackage.Literals.LENTITY__INHERITANCE_STRATEGY, |
| ValidationMessageAcceptor.INSIGNIFICANT_INDEX, CODE__INHERITANCE_NO_SUB_TYPES, (String[]) null); |
| } |
| } |
| |
| @Check(CheckType.NORMAL) |
| public void checkFilteringAndRange(LEntityAttribute attribute) { |
| if (attribute.isFiltering() || attribute.isRangeFiltering()) { |
| LScalarType type = attribute.getType(); |
| if (type instanceof LDataType) { |
| LDataType dt = (LDataType) type; |
| if (!dt.isAsBlob() && !dt.isSyntheticFlag()) { |
| return; |
| } |
| } |
| if (attribute.isFiltering()) { |
| error("Filter keyword not allowed for this type", attribute, |
| OSBPTypesPackage.Literals.LATTRIBUTE__RANGE_FILTERING); |
| } else { |
| error("Range keyword not allowed for this type", attribute, |
| OSBPTypesPackage.Literals.LATTRIBUTE__FILTERING); |
| } |
| } |
| } |
| |
| @Check(CheckType.NORMAL) |
| public void checkDuplicatePersistentFQN_InProject(LEntity entity) { |
| LEntityPersistenceInfo info = entity.getPersistenceInfo(); |
| if (info == null) { |
| return; |
| } |
| Map<IContainer, List<LEntityPersistenceInfo>> lTypes = getAllPersistentFQNsFor(info); |
| for (Map.Entry<IContainer, List<LEntityPersistenceInfo>> temp : lTypes.entrySet()) |
| if (temp.getValue().size() > 1) { |
| error(String.format("Persistence type %s is already defined!", |
| qnp.getFullyQualifiedName(info).toString()), entity, |
| OSBPEntityPackage.Literals.LENTITY__PERSISTENCE_INFO, |
| ValidationMessageAcceptor.INSIGNIFICANT_INDEX, CODE__DUPLICATE_PERSISTENCE, (String[]) null); |
| } |
| } |
| |
| private void sendIgnoredInheritancePropertyWarning(LEntityInheritanceStrategy stgy, EAttribute att) { |
| warning("Inherited from parent entity. Will be ignored.", stgy, att, |
| ValidationMessageAcceptor.INSIGNIFICANT_INDEX, CODE__DIFFERING_INHERITANCE_FROM_SUPERTYPE, |
| (String[]) null); |
| } |
| |
| public Map<IContainer, List<LEntityPersistenceInfo>> getAllPersistentFQNsFor(LEntityPersistenceInfo info) { |
| Map<IContainer, List<LEntityPersistenceInfo>> allEntities = new HashMap<IContainer, List<LEntityPersistenceInfo>>(); |
| IResourceDescriptions resourceDescriptions = resourceDescriptionsProvider |
| .getResourceDescriptions(info.eResource()); |
| IResourceDescription resourceDescription = resourceDescriptions |
| .getResourceDescription(info.eResource().getURI()); |
| List<IContainer> visiblecontainers = containermanager.getVisibleContainers(resourceDescription, |
| resourceDescriptions); |
| for (IContainer container : visiblecontainers) { |
| List<LEntityPersistenceInfo> types = new ArrayList<LEntityPersistenceInfo>(); |
| allEntities.put(container, types); |
| for (IEObjectDescription eObjectDescription : container.getExportedObjects( |
| OSBPEntityPackage.Literals.LENTITY_PERSISTENCE_INFO, qnp.getFullyQualifiedName(info), true)) { |
| types.add((LEntityPersistenceInfo) eObjectDescription.getEObjectOrProxy()); |
| } |
| } |
| return allEntities; |
| } |
| |
| @Check |
| public void checkClassPath(LTypedPackage entityModel) { |
| TypeReferences typeReferences = getServices().getTypeReferences(); |
| final JvmGenericType listType = (JvmGenericType) typeReferences.findDeclaredType(List.class, entityModel); |
| if (listType == null || listType.getTypeParameters().isEmpty()) { |
| error("Couldn't find a JDK 1.5 or higher on the project's classpath.", entityModel, |
| OSBPTypesPackage.Literals.LPACKAGE__NAME, CODE__MISSING__JDK_1_5); |
| } |
| if (typeReferences.findDeclaredType(Persistence.class, entityModel) == null) { |
| error("Couldn't find the mandatory library 'javax.persistence' 2.1.0 or higher on the project's classpath.", |
| entityModel, OSBPTypesPackage.Literals.LPACKAGE__NAME, CODE__MISSING__JAVAX_PERSISTENCE); |
| } |
| if (typeReferences.findDeclaredType("org.eclipse.osbp.runtime.common.annotations.Dispose", |
| entityModel) == null) { |
| error("Couldn't find the mandatory library 'org.eclipse.osbp.runtime.common' on the project's classpath.", |
| entityModel, OSBPTypesPackage.Literals.LPACKAGE__NAME, CODE__MISSING__L_RUNTIME_COMMON); |
| } |
| if (typeReferences.findDeclaredType(Extension.class, entityModel) == null) { |
| error("Couldn't find the mandatory library 'org.eclipse.xtext.xbase.lib' 2.11.0 or higher on the project's classpath.", |
| entityModel, OSBPTypesPackage.Literals.LPACKAGE__NAME, CODE__MISSING__XBASE_LIB); |
| } |
| if (typeReferences.findDeclaredType("org.eclipse.osbp.dsl.common.datatypes.IDatatypeConstants", |
| entityModel) == null) { |
| warning("Couldn't find the optional library 'org.eclipse.osbp.dsl.datatype.lib' on the project's classpath. This may cause resolving problems.", |
| entityModel, OSBPTypesPackage.Literals.LPACKAGE__NAME, CODE__MISSING__DATATYPE_LIB); |
| } |
| if (typeReferences.findDeclaredType("javax.validation.Valid", entityModel) == null) { |
| error("Couldn't find the library 'javax.validation' on the project's classpath. This may cause resolving problems.", |
| entityModel, OSBPTypesPackage.Literals.LPACKAGE__NAME, CODE__MISSING__DATATYPE_LIB); |
| } |
| } |
| |
| @Check |
| public void checkDuplicatePersistenceAnnotation(LEntityModel entityModel) { |
| |
| for (JvmGenericType jvmType : EcoreUtil.<JvmGenericType>getObjectsByType(entityModel.eResource().getContents(), |
| TypesPackage.Literals.JVM_GENERIC_TYPE)) { |
| |
| int prePersist = 0; |
| JvmOperation op_prePersist = null; |
| int preUpdate = 0; |
| JvmOperation op_preUpdate = null; |
| int preRemove = 0; |
| JvmOperation op_preRemove = null; |
| int postPersist = 0; |
| JvmOperation op_postPersist = null; |
| int postUpdate = 0; |
| JvmOperation op_postUpdate = null; |
| int postRemove = 0; |
| JvmOperation op_postRemove = null; |
| |
| for (JvmOperation op : jvmType.getDeclaredOperations()) { |
| for (JvmAnnotationReference ann : op.getAnnotations()) { |
| String fqn = ann.getAnnotation().getIdentifier(); |
| if (fqn.equals(PrePersist.class.getCanonicalName())) { |
| prePersist++; |
| op_prePersist = op; |
| } else if (fqn.equals(PreUpdate.class.getCanonicalName())) { |
| preUpdate++; |
| op_preUpdate = op; |
| } else if (fqn.equals(PreRemove.class.getCanonicalName())) { |
| preRemove++; |
| op_preRemove = op; |
| } else if (fqn.equals(PostPersist.class.getCanonicalName())) { |
| postPersist++; |
| op_postPersist = op; |
| } else if (fqn.equals(PostUpdate.class.getCanonicalName())) { |
| postUpdate++; |
| op_postUpdate = op; |
| } else if (fqn.equals(PostRemove.class.getCanonicalName())) { |
| postRemove++; |
| op_postRemove = op; |
| } |
| } |
| } |
| |
| if (prePersist > 1) { |
| error("Only one @PrePersist allowed per entity.", |
| modelAssociations.getPrimarySourceElement(op_prePersist), |
| OSBPTypesPackage.Literals.LANNOTATION_TARGET__ANNOTATIONS, |
| CODE__DUPLICATE__PERSISTENCE_ANNOTATION); |
| } |
| if (preUpdate > 1) { |
| error("Only one @PreUpdate allowed per entity.", |
| modelAssociations.getPrimarySourceElement(op_preUpdate), |
| OSBPTypesPackage.Literals.LANNOTATION_TARGET__ANNOTATIONS, |
| CODE__DUPLICATE__PERSISTENCE_ANNOTATION); |
| } |
| if (preRemove > 1) { |
| error("Only one @PreRemove allowed per entity.", |
| modelAssociations.getPrimarySourceElement(op_preRemove), |
| OSBPTypesPackage.Literals.LANNOTATION_TARGET__ANNOTATIONS, |
| CODE__DUPLICATE__PERSISTENCE_ANNOTATION); |
| } |
| if (postPersist > 1) { |
| error("Only one @PostPersist allowed per entity.", |
| modelAssociations.getPrimarySourceElement(op_postPersist), |
| OSBPTypesPackage.Literals.LANNOTATION_TARGET__ANNOTATIONS, |
| CODE__DUPLICATE__PERSISTENCE_ANNOTATION); |
| } |
| if (postUpdate > 1) { |
| error("Only one @PostUpdate allowed per entity.", |
| modelAssociations.getPrimarySourceElement(op_postUpdate), |
| OSBPTypesPackage.Literals.LANNOTATION_TARGET__ANNOTATIONS, |
| CODE__DUPLICATE__PERSISTENCE_ANNOTATION); |
| } |
| if (postRemove > 1) { |
| error("Only one @PostRemove allowed per entity.", |
| modelAssociations.getPrimarySourceElement(op_postRemove), |
| OSBPTypesPackage.Literals.LANNOTATION_TARGET__ANNOTATIONS, |
| CODE__DUPLICATE__PERSISTENCE_ANNOTATION); |
| } |
| } |
| } |
| |
| @Check(CheckType.NORMAL) |
| public void check_KanbanState(LEntity entity) { |
| |
| int counter = 0; |
| for (LEntityFeature feature : entity.getAllFeatures()) { |
| if (feature instanceof LEntityAttribute) { |
| LEntityAttribute att = (LEntityAttribute) feature; |
| if (att.isAsKanbanState()) { |
| counter++; |
| } |
| } |
| } |
| |
| if (counter > 1) { |
| int i = 0; |
| for (LEntityFeature feature : entity.getFeatures()) { |
| if (feature instanceof LEntityAttribute) { |
| if (((LEntityAttribute) feature).isAsKanbanState()) { |
| error("An entity must only have one kanban state.", |
| OSBPEntityPackage.Literals.LENTITY__FEATURES, i, "", new String[0]); |
| } |
| } |
| i++; |
| } |
| } |
| } |
| |
| @Check(CheckType.NORMAL) |
| public void check_KanbanStateType(LEntityAttribute att) { |
| if (att.isAsKanbanState() && !(att.getType() instanceof LEnum)) { |
| error("Kanban states must be of type Enum", OSBPEntityPackage.Literals.LENTITY_ATTRIBUTE__AS_KANBAN_STATE, |
| "", new String[0]); |
| } |
| } |
| |
| @Check |
| public void check_PersistenceUnitTag(LEntity entity) { |
| if (!entity.isMappedSuperclass()) { |
| if (entity.getPersistenceUnit() == null) { |
| error("An entity must have a persistence unit.", OSBPEntityPackage.Literals.LENTITY__FEATURES); |
| } |
| if (entity.getPersistenceUnit() != null && entity.getPersistenceUnit().trim().isEmpty()) { |
| error("A persistence unit can't be empty.", entity, |
| OSBPEntityPackage.Literals.LENTITY__PERSISTENCE_UNIT); |
| } |
| } |
| } |
| |
| @Check |
| private void check_EntityIdentifiersLength(LEntity entity) { |
| if (entity != null && entity.getPersistenceUnit() != null && !entity.getPersistenceUnit().isEmpty()) { |
| int maxTableNameLength = EnumDatabaseVendor.getMaxTableNameLength(); |
| int maxColumnNameLength = EnumDatabaseVendor.getMaxColumnNameLength(); |
| int maxIndexNameLength = EnumDatabaseVendor.getMaxIndexNameLength(); |
| |
| String expectedFeatureName = PersistenceNamingUtils.camelCaseToUpperCase(entity.getName()); |
| |
| if (entity.getName() != null && !entity.getName().isEmpty() && expectedFeatureName.length() >= maxTableNameLength) { |
| warning("The entity name '" + entity.getName() + "' results to the table name '" + expectedFeatureName |
| + "', which should not exceed " + maxTableNameLength |
| + " characters. Please rename this entity according to the OS.bee naming conventions: http://download.osbee.org/documentation/index.php/Entity_DSL", entity, |
| OSBPEntityPackage.Literals.LENTITY__PERSISTENCE_INFO); |
| } |
| for (LEntityFeature attr : entity.getFeatures()) { |
| if (attr.getName() != null && !attr.getName().isEmpty()) { |
| |
| expectedFeatureName = PersistenceNamingUtils.camelCaseToUpperCase(attr.getName()); |
| |
| if (expectedFeatureName.length() >= maxColumnNameLength && attr instanceof LEntityReference) { |
| warning("The reference name '" + attr.getName() + "' results to the column name '" |
| + expectedFeatureName + "', which should not exceed " + maxColumnNameLength |
| + " characters. Please rename this reference according to the OS.bee naming conventions: http://download.osbee.org/documentation/index.php/Entity_DSL", attr, |
| OSBPEntityPackage.Literals.LENTITY_REFERENCE__TYPE); |
| } else if (expectedFeatureName.length() >= maxColumnNameLength && attr instanceof LEntityAttribute) { |
| warning("The attribute name '" + attr.getName() + "' results to the column name '" |
| + expectedFeatureName + "', which should not exceed " + maxColumnNameLength |
| + " characters. Please rename this attribute according to the OS.bee naming conventions: http://download.osbee.org/documentation/index.php/Entity_DSL", attr, |
| OSBPEntityPackage.Literals.LENTITY_ATTRIBUTE__TYPED_NAME); |
| |
| } else if (attr.getName().length() < maxColumnNameLength && attr instanceof LEntityAttribute) { |
| LScalarType type = ((LEntityAttribute) attr).getType(); |
| |
| if (type instanceof LBean) { |
| for (LBeanFeature feature : ((LBean) type).getFeatures()) { |
| |
| expectedFeatureName = type.getName().toUpperCase() + "_" + feature.getName().toUpperCase(); |
| |
| if (feature.getName() != null && !feature.getName().isEmpty() |
| && expectedFeatureName.length() >= maxColumnNameLength) { |
| |
| warning("The attribute name '" + attr.getName() |
| + "' combined with the bean feature name '" + feature.getName() |
| + "' results to the column name '" + expectedFeatureName |
| + "', which should not exceed " + maxColumnNameLength |
| + " characters. Please rename this attribute according to the OS.bee naming conventions: http://download.osbee.org/documentation/index.php/Entity_DSL", attr, |
| OSBPEntityPackage.Literals.LENTITY_ATTRIBUTE__TYPED_NAME); |
| } |
| } |
| } |
| } |
| } |
| } |
| for (LIndex idx : entity.getIndexes()) { |
| expectedFeatureName = PersistenceNamingUtils.camelCaseToUpperCase(entity.getName() + idx.getName()); |
| if (idx.getName() != null && !idx.getName().isEmpty() |
| && expectedFeatureName.length() >= maxIndexNameLength) { |
| warning("The index id '" + idx.getName() + "' results to the column name '" + expectedFeatureName |
| + "', which should not exceed " + maxIndexNameLength |
| + " characters. Please rename this index according to the OS.bee naming conventions: http://download.osbee.org/documentation/index.php/Entity_DSL", idx, OSBPEntityPackage.Literals.LINDEX__NAME); |
| } |
| } |
| for (LEntitySuperIndex superidx : entity.getSuperIndex()) { |
| // TODO check naming policy after super indexes fully implemented |
| expectedFeatureName = PersistenceNamingUtils |
| .camelCaseToUpperCase(entity.getName() + superidx.getName()); |
| if (superidx.getName() != null && !superidx.getName().isEmpty() |
| && expectedFeatureName.length() >= maxIndexNameLength) { |
| warning("The super index id '" + superidx.getName() + "' results to the column name '" |
| + expectedFeatureName + "', which should not exceed " + maxIndexNameLength |
| + " characters. Please rename this super index according to the OS.bee naming conventions: http://download.osbee.org/documentation/index.php/Entity_DSL", superidx, |
| OSBPEntityPackage.Literals.LENTITY_SUPER_INDEX__NAME); |
| } |
| } |
| } |
| } |
| } |
