Package com.impetus.kundera.validation.rules

Source Code of com.impetus.kundera.validation.rules.RelationAttributeRule

/*******************************************************************************
* * Copyright 2013 Impetus Infotech.
*  *
*  * 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.impetus.kundera.validation.rules;

import java.lang.annotation.Annotation;
import java.lang.reflect.Field;
import java.util.EnumSet;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.persistence.AssociationOverride;
import javax.persistence.ElementCollection;
import javax.persistence.Embedded;
import javax.persistence.EmbeddedId;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.ManyToMany;
import javax.persistence.ManyToOne;
import javax.persistence.MapKeyClass;
import javax.persistence.MapKeyJoinColumn;
import javax.persistence.OneToMany;
import javax.persistence.OneToOne;

import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.impetus.kundera.metadata.validator.InvalidEntityDefinitionException;
import com.impetus.kundera.property.PropertyAccessorHelper;

/**
* @author Chhavi Gangwal
*
*/
public class RelationAttributeRule extends AbstractFieldRule implements FieldRule
{

    /** The Constant log. */
    private static final Logger log = LoggerFactory.getLogger(RelationAttributeRule.class);

    /** The relation type map. */
    static enum RelationType
    {

        MANY_TO_MANY(ManyToMany.class.getSimpleName()), MANY_TO_ONE(ManyToOne.class.getSimpleName()), ONE_TO_MANY(
                OneToMany.class.getSimpleName()), ONE_TO_ONE(OneToOne.class.getSimpleName()), ELEMENT_COLLECTION(
                ElementCollection.class.getSimpleName()), EMBEDDED_ID(EmbeddedId.class.getSimpleName()), EMBEDDED(
                Embedded.class.getSimpleName());

        private String clazz;

        private static final Map<String, RelationType> lookup = new HashMap<String, RelationType>();

        static
        {
            for (RelationType s : EnumSet.allOf(RelationType.class))
            {
                lookup.put(s.getClazz(), s);
            }
        }

        /**
         * @param clazz
         */
        private RelationType(String clazz)
        {
            this.clazz = clazz;
        }

        /**
         * @return
         */
        public String getClazz()
        {
            return clazz;
        }

        /**
         * @param clazz
         * @return
         */
        public static RelationType get(String clazz)
        {
            return lookup.get(clazz);
        }
    }

    /**
     * @param annotationType
     * @return
     */
    private RelationType getRuleType(String annotationType)
    {

        if (RelationType.get(annotationType) != null)
        {
            return RelationType.get(annotationType);
        }
        else
        {
            return null;
        }

    }

    /* (non-Javadoc)
     * @see com.impetus.kundera.validation.rules.AbstractFieldRule#validate(java.lang.reflect.Field)
     */
    @Override
    public boolean validate(Field f) throws RuleValidationException
    {

        boolean checkvalidation = true;
        for (Annotation annotate : f.getDeclaredAnnotations())
        {
            RelationType eruleType = getRuleType(annotate.annotationType().getSimpleName());

            if (eruleType != null)
            {

                switch (eruleType)
                {
                case MANY_TO_MANY:
                    checkvalidation = validateManyToMany(f, annotate);
                    break;
                case MANY_TO_ONE:
                    checkvalidation = validateManyToOne(f, annotate);
                    break;
                case ONE_TO_MANY:
                    checkvalidation = validateOneToMany(f, annotate);
                    break;
                case ONE_TO_ONE:
                    checkvalidation = validateOneToOne(f, annotate);
                    break;

                }

            }
        }

        return checkvalidation;
    }

    /**
     * @param relationField
     * @param annotate
     * @return
     */
    private Boolean validateOneToOne(Field relationField, Annotation annotate)
    {
      

        boolean isJoinedByTable = relationField.isAnnotationPresent(JoinTable.class);

        if (relationField.isAnnotationPresent(AssociationOverride.class))
        {
            AssociationOverride annotation = relationField.getAnnotation(AssociationOverride.class);
            JoinColumn[] joinColumns = annotation.joinColumns();

            validateJoinColumns(joinColumns);

            JoinTable joinTable = annotation.joinTable();
            onJoinTable(joinTable);
        }
        else if (isJoinedByTable)
        {
            throw new UnsupportedOperationException("@JoinTable not supported for one to one association");
        }
        return true;
    }

    /**
     * @param relationField
     * @param annotate
     * @return
     * @throws RuleValidationException
     */
    private Boolean validateOneToMany(Field relationField, Annotation annotate) throws RuleValidationException
    {

        OneToMany ann = (OneToMany) annotate;
        Class<?> targetEntity = PropertyAccessorHelper.getGenericClass(relationField);

        // now, check annotations
        if (null != ann.targetEntity() && !ann.targetEntity().getSimpleName().equals("void"))
        {
            targetEntity = ann.targetEntity();
        }

        boolean isJoinedByTable = relationField.isAnnotationPresent(JoinTable.class);

        if (isJoinedByTable)
        {
            throw new UnsupportedOperationException("@JoinTable not supported for one to many association");
        }

        boolean isJoinedByColumn = relationField.isAnnotationPresent(JoinTable.class);

        return true;
    }

    /**
     * @param relationField
     * @param annotate
     * @return
     */
    private Boolean validateManyToOne(Field relationField, Annotation annotate)
    {
        // taking field's type as foreign entity, ignoring "targetEntity"

        Class<?> targetEntity = relationField.getType();

        boolean isJoinedByTable = relationField.isAnnotationPresent(JoinTable.class);
         
        if (relationField.isAnnotationPresent(AssociationOverride.class))
        {
            AssociationOverride annotation = relationField.getAnnotation(AssociationOverride.class);
            JoinColumn[] joinColumns = annotation.joinColumns();
           
            //validate if more than one  join column is defined
            validateJoinColumns(joinColumns);

            JoinTable joinTable = annotation.joinTable();
            //validate if join table is null
            onJoinTable(joinTable);
        }
        // join table not valid for Many to one check
        else if (isJoinedByTable)
        {
            throw new UnsupportedOperationException("@JoinTable not supported for many to one association");
        }

        return true;
    }

    /**
     * @param relationField
     * @param annotate
     * @return
     * @throws RuleValidationException
     */
    private Boolean validateManyToMany(Field relationField, Annotation annotate) throws RuleValidationException
    {
        ManyToMany m2mAnnotation = (ManyToMany) annotate;

        boolean isJoinedByFK = relationField.isAnnotationPresent(JoinColumn.class);
        boolean isJoinedByTable = relationField.isAnnotationPresent(JoinTable.class);
        boolean isJoinedByMap = false;
        if (m2mAnnotation != null && relationField.getType().isAssignableFrom(Map.class))
        {
            isJoinedByMap = true;
        }

        Class<?> targetEntity = null;
        Class<?> mapKeyClass = null;

        if (!isJoinedByMap)
        {

            targetEntity = PropertyAccessorHelper.getGenericClass(relationField);
        }
        else
        {
            List<Class<?>> genericClasses = PropertyAccessorHelper.getGenericClasses(relationField);

            if (!genericClasses.isEmpty() && genericClasses.size() == 2)
            {
                mapKeyClass = genericClasses.get(0);
                targetEntity = genericClasses.get(1);
            }

            MapKeyClass mapKeyClassAnn = relationField.getAnnotation(MapKeyClass.class);

            // Check for Map key class specified at annotation
            if (mapKeyClass == null && mapKeyClassAnn != null && mapKeyClassAnn.value() != null
                    && !mapKeyClassAnn.value().getSimpleName().equals("void"))
            {
                mapKeyClass = mapKeyClassAnn.value();
            }

            if (mapKeyClass == null)
            {
                throw new InvalidEntityDefinitionException(
                        "For a Map relationship field,"
                                + " it is mandatory to specify Map key class either using @MapKeyClass annotation or through generics");
            }

        }

        // Check for target class specified at annotation
        if (targetEntity == null && null != m2mAnnotation.targetEntity()
                && !m2mAnnotation.targetEntity().getSimpleName().equals("void"))
        {
            targetEntity = m2mAnnotation.targetEntity();
        }
        //check if target entity is null
        if (targetEntity == null)
        {
            throw new InvalidEntityDefinitionException("Could not determine target entity class for relationship."
                    + " It should either be specified using targetEntity attribute of @ManyToMany or through generics");
        }
        //check if joined by foreign key
        if (isJoinedByFK)
        {
            throw new InvalidEntityDefinitionException(
                    "@JoinColumn not allowed for ManyToMany relationship. Use @JoinTable instead");

        }
      //check if joined by foreign key and join column name is set
        if (isJoinedByMap)
        {

            MapKeyJoinColumn mapKeyJoinColumnAnn = relationField.getAnnotation(MapKeyJoinColumn.class);
            if (mapKeyJoinColumnAnn != null)
            {
                String mapKeyJoinColumnName = mapKeyJoinColumnAnn.name();
                if (StringUtils.isEmpty(mapKeyJoinColumnName))
                {
                    throw new InvalidEntityDefinitionException(
                            "It's mandatory to specify name attribute with @MapKeyJoinColumn annotation");
                }
            }

        }
        //check if not joined by table in many to many
        if (!isJoinedByTable && !isJoinedByMap
                && (m2mAnnotation.mappedBy() == null || m2mAnnotation.mappedBy().isEmpty()))
        {
            throw new InvalidEntityDefinitionException(
                    "It's manadatory to use @JoinTable with parent side of ManyToMany relationship.");
        }
        return true;
    }

    /**
     * @param joinTable
     */
    private void onJoinTable(JoinTable joinTable)
    {
        if (joinTable != null)
        {
            throw new UnsupportedOperationException("@JoinTable not supported for many to one association");
        }
    }

    /**
     * @param joinColumns
     */
    private void validateJoinColumns(JoinColumn[] joinColumns)
    {
        if (joinColumns.length > 1)
        {
            throw new UnsupportedOperationException("More than one join columns are not supported.");
        }
    }

}
TOP

Related Classes of com.impetus.kundera.validation.rules.RelationAttributeRule

TOP
Copyright © 2018 www.massapi.com. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.