org.kuali.student.datadictionary.util.Dictionary2BeanComparer Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of maven-kscontractdoc-plugin Show documentation
Generates documentation for Kuali Student service contracts
The newest version!
/*
 * Copyright 2011 The Kuali Foundation
 *
 * Licensed under the Educational Community License, Version 1.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.opensource.org/licenses/ecl1.php
 *
 * 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 org.kuali.student.datadictionary.util;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Stack;
import org.kuali.rice.krad.datadictionary.AttributeDefinition;
import org.kuali.rice.krad.datadictionary.ComplexAttributeDefinition;
import org.kuali.rice.krad.datadictionary.DataDictionaryDefinitionBase;
import org.kuali.rice.krad.datadictionary.DataObjectEntry;

public class Dictionary2BeanComparer {

    private String className;
    private DataObjectEntry osDict;

    public Dictionary2BeanComparer(String className, DataObjectEntry osDict) {
        this.className = className;
        this.osDict = osDict;
    }

    public List compare() {
        if (className == null) {
            return Arrays.asList(osDict.getFullClassName() + " does not have a corresponding java class");
        }
        Class clazz = null;
        try {
            clazz = Thread.currentThread().getContextClassLoader().loadClass(className);
            // had to change the standard Class.forName below to the above so it uses the right class loader
            // that is defined in KSDictionaryDocMojo.java
//            clazz = Class.forName(className);
        } catch (ClassNotFoundException ex) {
            return Arrays.asList("Cannot compare the dictionary entry to it's object because the object's class cannot be found");
        }
        Stack parentFields = new Stack();
        Stack> parentClasses = new Stack>();
        DataObjectEntry osBean = new Bean2DictionaryConverter(clazz, parentFields, parentClasses).convert();
        return compare(osDict, osBean);

    }

    private List compare(DataObjectEntry osDict,
            DataObjectEntry osBean) {
        List discrepancies = new ArrayList();
        compareAddDiscrepancy(discrepancies, "Java class name", osDict.getFullClassName(), osBean.getFullClassName());
        compareAddDiscrepancy(discrepancies, "Entry class", osDict.getEntryClass(), osBean.getEntryClass());
        for (AttributeDefinition adDict : osDict.getAttributes()) {
            AttributeDefinition adBean = findAttributeDefinition(adDict.getName(), osBean);
            if (adBean == null) {
//                if (!adDict.isDynamic()) {
                discrepancies.add("Field " + adDict.getName() + " does not exist in the corresponding java class");
//                }
                continue;
            }
            compareAddDiscrepancy(discrepancies, adDict.getName() + " dataType", adDict.getDataType(), adBean.getDataType());
            // TODO: deal with collections
//            compareAddDiscrepancy(discrepancies, adDict.getName() + " maxOccurs", adDict.getMaximumNumberOfElements(), adBean.getMaximumNumberOfElements());
        }
        for (ComplexAttributeDefinition cadDict : osDict.getComplexAttributes()) {
            ComplexAttributeDefinition cadBean = findComplexAttributeDefinition(cadDict.getName(), osBean);
            if (cadBean == null) {
//                if (!adDict.isDynamic()) {
                discrepancies.add("Field " + cadDict.getName() + " does not exist in the corresponding java class");
//                }
                continue;
            }
             // TODO: deal with collections
//            compareAddDiscrepancy(discrepancies, adDict.getName() + " maxOccurs", adDict.getMaximumNumberOfElements(), adBean.getMaximumNumberOfElements());
        }
        for (AttributeDefinition fdBean : osBean.getAttributes()) {
            AttributeDefinition fdDict = findAttributeDefinition(fdBean.getName(), osDict);
            if (fdDict == null) {
                discrepancies.add("Field " + fdBean.getName() + " missing from the dictictionary");
                continue;
            }
        }
        for (ComplexAttributeDefinition fdBean : osBean.getComplexAttributes()) {
            ComplexAttributeDefinition fdDict = findComplexAttributeDefinition(fdBean.getName(), osDict);
            if (fdDict == null) {
                discrepancies.add("Field " + fdBean.getName() + " missing from the dictictionary");
                continue;
            }
        }
        return discrepancies;
    }

    private AttributeDefinition findAttributeDefinition(String name, DataObjectEntry ode) {
        for (AttributeDefinition fd : ode.getAttributes()) {
            if (name.equals(fd.getName())) {
                return fd;
            }
        }
        return null;
    }

    private ComplexAttributeDefinition findComplexAttributeDefinition(String name, DataObjectEntry ode) {
        for (ComplexAttributeDefinition cad : ode.getComplexAttributes()) {
            if (name.equals(cad.getName())) {
                return cad;
            }
        }
        return null;
    }

    private void compareAddDiscrepancy(List discrepancies, String field, boolean value1,
            boolean value2) {
        String discrep = compare(field, value1, value2);
        if (discrep != null) {
            discrepancies.add(discrep);
        }
    }

    private void compareAddDiscrepancy(List discrepancies, String field, Object value1,
            Object value2) {
        String discrep = compare(field, value1, value2);
        if (discrep != null) {
            discrepancies.add(discrep);
        }
    }

    private String compare(String field, boolean value1, boolean value2) {
        if (value1) {
            if (value2) {
                return null;
            }
        }
        if (!value1) {
            if (!value2) {
                return null;
            }
        }
        return field + " inconsistent: dictionary='" + value1 + "', java class='" + value2 + "'";
    }

    private String compare(String field, Object value1, Object value2) {
        if (value1 == null) {
            if (value2 == null) {
                return null;
            }
        } else {
            if (value1.equals(value2)) {
                return null;
            }
        }
        return field + " inconsistent: dictionary='" + value1 + "'], java class='" + value2 + "'";
    }
}