org.kuali.student.remote.impl.mojo.RemoteImplWriter Maven / Gradle / Ivy

Go to download
/*
 * Copyright 2009 The Kuali Foundation
 *
 * Licensed under the Educational Community 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.osedu.org/licenses/ECL-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 org.kuali.student.remote.impl.mojo;

import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.kuali.student.contract.model.Service;
import org.kuali.student.contract.model.ServiceContractModel;
import org.kuali.student.contract.model.ServiceMethod;
import org.kuali.student.contract.model.ServiceMethodError;
import org.kuali.student.contract.model.XmlType;
import org.kuali.student.contract.model.util.ServicesFilter;
import org.kuali.student.contract.model.validation.DictionaryValidationException;
import org.kuali.student.contract.model.validation.ServiceContractModelValidator;

/**
 *
 * @author nwright
 */
public class RemoteImplWriter {

    private ServiceContractModel model;
    private String directory;
    private String rootPackage;
    public static final String DEFAULT_ROOT_PACKAGE = "org.kuali.student.service.remote.impl";
    private ServicesFilter filter;

    public RemoteImplWriter(ServiceContractModel model,
            String directory,
            String rootPackage,
            ServicesFilter filter) {
        this.model = model;
        this.directory = directory;
        this.rootPackage = rootPackage;
        this.filter = filter;
    }

    /**
     * Write out the entire file
     * @param out
     */
    public void write() {
        this.validate();

        for (Service service : filterServices()) {
            new RemoteImplWriterForOneService(model, directory, rootPackage, service.getKey()).write();
        }
        
//        new RemoteImplServiceSpringBeanWriter (model, directory, rootPackage).write();

//        // the Info interfaces's
//        System.out.println("Generating common Info interfaces");
//        for (XmlType xmlType : getXmlTypesUsedByMoreThanOneByService()) {
//            System.out.println("Generating info interface for " + xmlType.getName());
//            new PureJavaInfcInfcWriter(model, directory, rootPackage, xmlType.getService(), xmlType).write();
//            new PureJavaInfcBeanWriter(model, directory, rootPackage, xmlType.getService(), xmlType).write();
//        }

//  exceptions
        // Decided to just use the exisiting exceptions that are hand crafted
        // no need to generate
//  for (ServiceMethodError error : getServiceMethodErrors ().values ())
//  {
//   System.out.println ("generating exception class: " + error.getType ());
//   new ServiceExceptionWriter (model, directory, rootPackage, error).write ();
//  }

    }

    private Set getXmlTypesUsedByMoreThanOneByService() {
        Set set = new HashSet();
        for (XmlType type : model.getXmlTypes()) {
            if (type.getService().contains(",")) {
                if (type.getPrimitive().equalsIgnoreCase(XmlType.COMPLEX)) {
                    System.out.println(type.getName() + "==>" + type.getService());
                    set.add(type);
                }
            }
        }
        return set;
    }

    private Map getServiceMethodErrors() {
        Map errors = new HashMap();
        for (ServiceMethod method : model.getServiceMethods()) {
            for (ServiceMethodError error : method.getErrors()) {
                errors.put(error.getType(), error);
            }
        }
        return errors;
    }

    private List filterServices() {
        if (filter == null) {
            return model.getServices();
        }
        return filter.filter(model.getServices());
    }

    private void validate() {
        Collection errors =
                new ServiceContractModelValidator(model).validate();
        if (errors.size() > 0) {
            StringBuffer buf = new StringBuffer();
            buf.append(errors.size() + " errors found while validating the data.");
            int cnt = 0;
            for (String msg : errors) {
                cnt++;
                buf.append("\n");
                buf.append("*error*" + cnt + ":" + msg);
            }

            throw new DictionaryValidationException(buf.toString());
        }
    }
}