EjbRelationshipRoleDesc.java

package org.objectweb.jonas_ejb.deployment.api;

import java.util.HashMap;
import java.util.Iterator;

import org.objectweb.jonas_ejb.deployment.xml.EjbRelationshipRole;
import org.objectweb.jonas_ejb.deployment.xml.ForeignKeyJdbcMapping;
import org.objectweb.jonas_ejb.deployment.xml.JonasEjbRelationshipRole;
import org.objectweb.jonas_lib.deployment.api.DeploymentDescException;
import org.objectweb.util.monolog.api.BasicLevel;
import org.objectweb.util.monolog.api.Logger;

public class EjbRelationshipRoleDesc {

    private Logger logger = null;

    public static final byte INDEX = 1;

    public static final byte SOURCE = 2;

    public static final byte TARGET = 4;

    public static final byte OOU = 0;

    public static final byte OOB = 1;

    public static final byte OMU = 2;

    public static final byte OMB = OMU + OOB;

    public static final byte MOU = 4;

    public static final byte MOB = MOU + OOB;

    public static final byte MMU = OMU + MOU;

    public static final byte MMB = MMU + OOB;

    private String rsrName;

    private String ejbSourceName;

    private EjbRelationDesc ejbRelationDesc;

    private EntityCmp2Desc sourceEntityCmp2Desc;

    private boolean isSourceMultiple;

    private EntityCmp2Desc targetEntityCmp2Desc;

    private boolean isTargetMultiple;

    private boolean isSlave;

    protected String cmrFieldName = null;

    protected Class cmrFieldType = null;

    protected boolean isJOnASCMR = false;

    private byte relationType = -1;

    private boolean mustCascade;

    // Zeus objects for the associated mapping information (needed in
    // fillMappingInfo);
    // They may be null.
    private JonasEjbRelationshipRole jSourceRsRole = null;

    // mapping information build by fillMappingInfo and
    // fillMappingInfoWithDefault
    private HashMap foreignKeyMap = new HashMap();

    private boolean hasJdbcMapping = false;

    public EjbRelationshipRoleDesc(EjbRelationDesc rd, String name, EjbRelationshipRole role,
            JonasEjbRelationshipRole jrole, EjbRelationshipRole opposite, boolean isSlave, Logger logger)
            throws DeploymentDescException {

        this.logger = logger;
        ejbRelationDesc = rd;
        this.isSlave = isSlave;
        rsrName = name;
        mustCascade = opposite.isCascadeDelete();
        ejbSourceName = role.getRelationshipRoleSource().getEjbName();

        // mutiplicity is One or Many
        if (opposite.getMultiplicity().equalsIgnoreCase("Many")) {
            isTargetMultiple = true;
            if (role.isCascadeDelete()) {
                throw new DeploymentDescException("Cascade delete not allowed for relationshipRole for relationship '"
                        + rd.getName() + "(because opposite role has a multiplicity of Many)");
            }
        } else if (opposite.getMultiplicity().equalsIgnoreCase("One")) {
            isTargetMultiple = false;
        } else {
            throw new DeploymentDescException("Invalid multiplicity value for relationshipRole for relationship '"
                    + rd.getName() + "'(must be One or Many)");
        }
        if (role.getMultiplicity().equalsIgnoreCase("Many")) {
            isSourceMultiple = true;
        } else if (role.getMultiplicity().equalsIgnoreCase("One")) {
            isSourceMultiple = false;
        } else {
            throw new DeploymentDescException("Invalid multiplicity value for relationshipRole for relationship '"
                    + rd.getName() + "'(must be One or Many)");
        }

        // store cmr field if any
        if (role.getCmrField() != null) {
            setCmrFieldName(role.getCmrField().getCmrFieldName());
            if (isTargetMultiple) {
                String type = role.getCmrField().getCmrFieldType();
                if (type == null) {
                    throw new DeploymentDescException(
                            "You must specify a cmr-field-type in case where the relation is 'Many' in the cmr-field '"
                                    + cmrFieldName + "' of bean " + ejbSourceName);
                }
                setCmrFieldType(type);
            }
        }

        // store the JonasEjbRelationshipRole
        jSourceRsRole = jrole;
    }

    protected void fillMappingInfo() throws DeploymentDescException {
        logger.log(BasicLevel.DEBUG, "" + (jSourceRsRole != null) + " for " + rsrName);
        if (jSourceRsRole != null) {
            for (Iterator i = jSourceRsRole.getForeignKeyJdbcMappingList().iterator(); i.hasNext();) {
                ForeignKeyJdbcMapping fkMapping = (ForeignKeyJdbcMapping) i.next();
                String fkc = fkMapping.getForeignKeyJdbcName();
                String kc = null;
                if (fkMapping.getKeyJdbcName() != null) {
                    kc = fkMapping.getKeyJdbcName();
                }
                if (kc == null) {
                    // if the target bean has a primary-key-field, this value
                    // may not be defined
                    // in this case, this is the column name of the
                    // primary-key-field
                    if (targetEntityCmp2Desc.hasSimplePkField()) {
                        kc = ((FieldJdbcDesc) targetEntityCmp2Desc.getSimplePkField()).getJdbcFieldName();
                    } else {
                        // error
                        throw new DeploymentDescException(
                                "key-jdbc-name must be provided for foreign-key-jdbc-mapping " + fkc
                                        + " of relation-ship role " + rsrName + "of relation "
                                        + ejbRelationDesc.getName());
                    }
                }
                logger.log(BasicLevel.DEBUG, "explicit fk mapping = " + fkc + " for " + kc);
                foreignKeyMap.put(kc, fkc);
            }
            hasJdbcMapping = true;
        }
    }

    protected void fillMappingInfoWithDefault() {
        logger.log(BasicLevel.DEBUG, "" + hasJdbcMapping);
        if (!hasJdbcMapping) {
            if (targetEntityCmp2Desc.hasSimplePkField()) {
                // target entity has a simple pk (primary-key-field)
                String fn = targetEntityCmp2Desc.getSimplePkFieldName();
                FieldJdbcDesc fd = (FieldJdbcDesc) targetEntityCmp2Desc.getCmpFieldDesc(fn);
                String kc = fd.getJdbcFieldName();
                String fkc = targetEntityCmp2Desc.getAbstractSchemaName() + "_" + kc;
                logger.log(BasicLevel.DEBUG, "default fk mapping = " + fkc + " for " + kc);
                foreignKeyMap.put(kc, fkc);
            } else {
                // target entity has a composite pk
                for (Iterator i = targetEntityCmp2Desc.getCmpFieldDescIterator(); i.hasNext();) {
                    FieldJdbcDesc fd = (FieldJdbcDesc) i.next();
                    String kc = fd.getJdbcFieldName();
                    String fkc = targetEntityCmp2Desc.getAbstractSchemaName() + "_" + kc;
                    logger.log(BasicLevel.DEBUG, "default fk mapping = " + fkc + " for " + kc);
                    foreignKeyMap.put(kc, fkc);
                }
            }
            hasJdbcMapping = true;
        }
    }

    public String getName() {
        return rsrName;
    }

    protected void setCmrFieldName(String name) throws DeploymentDescException {
        cmrFieldName = name;
    }

    protected void setCmrFieldType(String type) throws DeploymentDescException {
        try {
            cmrFieldType = Class.forName(type);
        } catch (ClassNotFoundException e) {
            throw new DeploymentDescException("class name not found for cmr-field " + cmrFieldName + " of bean "
                    + ejbSourceName, e);
        }
        if (!(cmrFieldType.getName().equals("java.util.Collection") || cmrFieldType.getName().equals("java.util.Set"))) {
            throw new DeploymentDescException("value of cmr-field-type " + cmrFieldName + " of bean " + ejbSourceName
                    + " should be java.util.Set or java.util.Collection if set");
        }
    }

    protected void setIsJOnASCmrField() {
        isJOnASCMR = true;
    }

    protected void setSourceBean(EntityCmp2Desc led) {
        sourceEntityCmp2Desc = led;
    }

    protected void setTargetBean(EntityCmp2Desc led) {
        targetEntityCmp2Desc = led;
        if (cmrFieldType == null) {
            cmrFieldType = led.getLocalClass();
        }
    }

    public EjbRelationDesc getRelation() {
        return ejbRelationDesc;
    }

    public EjbRelationshipRoleDesc getOppositeRelationshipRole() {
        EjbRelationshipRoleDesc res = ejbRelationDesc.getRelationshipRole1();
        if (res == this) {
            return ejbRelationDesc.getRelationshipRole2();
        } else {
            return res;
        }
    }

    public String getSourceBeanName() {
        return ejbSourceName;
    }

    public EntityCmp2Desc getSourceBean() {
        return sourceEntityCmp2Desc;
    }

    public EntityCmp2Desc getTargetBean() {
        return targetEntityCmp2Desc;
    }

    public boolean isSourceMultiple() {
        return isSourceMultiple;
    }

    public boolean isTargetMultiple() {
        return isTargetMultiple;
    }

    public boolean mustCascade() {
        return mustCascade;
    }

    public boolean isJOnASCmrField() {
        return isJOnASCMR;
    }

    // TODO: is this method really needed (return always true??)
    public boolean hasCmrField() {
        return cmrFieldName != null;
    }

    public String getCmrFieldName() {
        return cmrFieldName;
    }

    public Class getCmrFieldType() {
        return cmrFieldType;
    }

    public byte getRelationType() {
        if (relationType == -1) {
            relationType = OOU;
            EjbRelationshipRoleDesc rsr2 = getOppositeRelationshipRole();
            if (rsr2.hasCmrField() && hasCmrField()) {
                relationType += OOB;
            }
            if (isTargetMultiple()) {
                relationType += OMU;
            }
            if (rsr2.isTargetMultiple()) {
                relationType += MOU;
            }
        }
        return relationType;
    }

    public boolean hasJdbcMapping() {
        return hasJdbcMapping;
    }

    public boolean isSlave() {
        return isSlave;
    }

    public String getForeignKeyJdbcName(String jdbcFieldName) {
        return (String) foreignKeyMap.get(jdbcFieldName);
    }

    public String toString() {
        StringBuffer ret = new StringBuffer();
        ret.append("\ngetName() = " + getName());
        ret.append("\ngetRelation().getName() = " + getRelation().getName());
        ret.append("\ngetOppositeRelationshipRole().getName() = " + getOppositeRelationshipRole().getName());
        ret.append("\ngetSourceBeanName() = " + getSourceBeanName());
        ret.append("\ngetTargetBean().getName() = " + getTargetBean().getEjbName());
        ret.append("\nisSourceMultiple() = " + isSourceMultiple());
        ret.append("\nisTargetMultiple() = " + isTargetMultiple());
        ret.append("\nmustCascade() = " + mustCascade());
        ret.append("\nisJOnASCmrField() = " + isJOnASCmrField());
        ret.append("\ngetCmrFieldName() = " + getCmrFieldName());
        ret.append("\ngetCmrFieldType() = " + getCmrFieldType());
        ret.append("\ngetRelationType() = " + getRelationType());
        if (hasJdbcMapping()) {
            for (Iterator i = foreignKeyMap.keySet().iterator(); i.hasNext();) {
                String key = (String) i.next();
                String fkey = (String) foreignKeyMap.get(key);
                ret.append("\ngetForeignKeyJdbcName(" + key + ")=" + fkey);
            }
        }
        return ret.toString();
    }

}

---