JaxWSSourcesHandler.java

package org.easysoa.discovery.code.handler;

import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

import javax.jws.WebService;
import javax.xml.ws.WebServiceClient;
import javax.xml.ws.WebServiceProvider;

import org.apache.commons.lang.StringUtils;
import org.apache.maven.plugin.logging.Log;
import org.easysoa.discovery.code.CodeDiscoveryMojo;
import org.easysoa.discovery.code.CodeDiscoveryRegistryClient;
import org.easysoa.discovery.code.ParsingUtils;
import org.easysoa.discovery.code.handler.consumption.ImportedServicesConsumptionFinder;
import org.easysoa.discovery.code.model.JavaServiceConsumptionInformation;
import org.easysoa.discovery.code.model.JavaServiceImplementationInformation;
import org.easysoa.discovery.code.model.JavaServiceInterfaceInformation;
import org.easysoa.registry.rest.SoaNodeInformation;
import org.easysoa.registry.rest.SoaNodeInformations;
import org.easysoa.registry.rest.client.types.InformationServiceInformation;
import org.easysoa.registry.rest.client.types.java.MavenDeliverableInformation;
import org.easysoa.registry.types.InformationService;
import org.easysoa.registry.types.OperationInformation;
import org.easysoa.registry.types.Platform;
import org.easysoa.registry.types.ids.ServiceImplementationName;
import org.easysoa.registry.types.ids.ServiceNameType;
import org.easysoa.registry.types.java.JavaServiceImplementation;

import com.thoughtworks.qdox.model.JavaClass;
import com.thoughtworks.qdox.model.JavaMethod;
import com.thoughtworks.qdox.model.JavaParameter;
import com.thoughtworks.qdox.model.JavaSource;
import com.thoughtworks.qdox.model.Type;


/**
 * In project & current deliverable, reports :
 * * JAXWS service impl and their impl'd service interface (from impl and also by themselves),
 * both by being annotated by @WebService
 * * thanks to InterfaceHandlerBase, member (field or bean setter)-injected service :
 * typed by @WebService annotated interfaces or @WebServiceClient annotated classes)
 *
 * For JAXWS, the documentation handler take the documention contained in the interface.
 *
 * @author mdutoo
 *
 */
public class JaxWSSourcesHandler extends AbstractJavaSourceHandler implements SourcesHandler {

    private static final String SOAP_CONTENT_TYPE = "application/soap+xml"; // ; charset=utf-8 http://www.w3schools.com/soap/soap_httpbinding.asp

    /* jaxws annotations */
    private static final String ANN_WSPROVIDER = "javax.jws.WebServiceProvider";
    private static final String ANN_WS = "javax.jws.WebService";
    private static final String ANN_WEBRESULT = "javax.jws.WebResult";
    private static final String ANN_WEBMETHOD = "javax.jws.WebMethod";
    private static final String ANN_WEBPARAM = "javax.jws.WebParam";

    /* injection annotations */
    private static final String ANN_XML_WSCLIENT = "javax.xml.ws.WebServiceClient";
    private static final String ANN_XML_WSREF = "javax.xml.ws.WebServiceRef";
    private static final String ANN_XML_WSPROVIDER = "javax.xml.ws.WebServiceProvider";

    private Map<Type, String> implsToInterfaces = new HashMap<Type, String>();

    public JaxWSSourcesHandler(CodeDiscoveryMojo codeDiscovery) {
        super(codeDiscovery);
        this.addAnnotationToDetect(ANN_WSPROVIDER);
        this.addAnnotationToDetect(ANN_XML_WSCLIENT);
        this.addAnnotationToDetect(ANN_XML_WSREF);
        this.addAnnotationToDetect(ANN_XML_WSPROVIDER);
    }

    // Pass 1 : Find all WS clients/interfaces
    public Map<String, JavaServiceInterfaceInformation> findWSInterfaces(JavaSource source,
            MavenDeliverableInformation mavenDeliverable,
            CodeDiscoveryRegistryClient registryClient, Log log) throws Exception {
        Map<String, JavaServiceInterfaceInformation> wsInjectableTypeSet
                = new HashMap<String, JavaServiceInterfaceInformation>();
        JavaClass[] classes = source.getClasses();
        for (JavaClass c : classes) {
            if (isWsInterface(c)) {
            	String wsName = getWsName(c);
            	String wsNamespace = getWsNamespace(c);
            	Map<String, OperationInformation> operations = getOperationsInformation(c, null);
                wsInjectableTypeSet.put(c.getFullyQualifiedName(),
                        new JavaServiceInterfaceInformation(this.codeDiscovery.getSubproject(),
                                mavenDeliverable.getGroupId(), mavenDeliverable.getArtifactId(),
                                c.getFullyQualifiedName(), wsNamespace, wsName, operations));
            }
        }

        return wsInjectableTypeSet;
    }

    public JavaServiceInterfaceInformation findWSInterfaceInClasspath(Class<?> c,
            MavenDeliverableInformation mavenDeliverable, CodeDiscoveryRegistryClient registryClient, Log log)
            throws Exception {
        if (isWsInterface(c)) {
        	String wsName = getWsName(c);
        	String wsNamespace = getWsNamespace(c);
        	Map<String, OperationInformation> operations = getOperationsInformation(c);
            return new JavaServiceInterfaceInformation(this.codeDiscovery.getSubproject(),
                    mavenDeliverable.getGroupId(), mavenDeliverable.getArtifactId(),
                    c.getName(), wsNamespace, wsName, operations);
        }
        else {
            return null;
        }
    }

    @Override
    public Collection<SoaNodeInformation> findWSImplementations(JavaSource[] sources,
            Map<String, JavaServiceInterfaceInformation> wsInterfaces,
            MavenDeliverableInformation mavenDeliverable, CodeDiscoveryRegistryClient registryClient, Log log)
            throws Exception {
        // Pass 2 : Explore each impl
        List<SoaNodeInformation> discoveredNodes = new ArrayList<SoaNodeInformation>();
        for (JavaSource source : sources) {
            JavaClass[] classes = source.getClasses();
            for (JavaClass c : classes) {
                if (isWsImplementation(c, wsInterfaces)) {
                    JavaServiceInterfaceInformation interfaceInfo = null;

                    // Extract interface info
                    //System.out.println("\ncp:\n" + System.getProperty("java.class.path"));
                    JavaClass itfClass = getWsItf(c, wsInterfaces);
                    if (itfClass != null) {
                        implsToInterfaces.put(c.asType(), itfClass.asType().getFullyQualifiedName());
                        interfaceInfo = wsInterfaces.get(itfClass.getFullyQualifiedName());
                    }
                    else {
                        log.warn("Couldn't find interface for class " + c.getFullyQualifiedName());
                    }

                    // Extract WS info
                    JavaServiceImplementationInformation serviceImpl = createServiceImplementation(c, itfClass, interfaceInfo);
                    serviceImpl.addParentDocument(mavenDeliverable.getSoaNodeId());

                    if (itfClass != null) {
                        // Extract operations info
                        Map<String, OperationInformation> itfOperationsInfo = interfaceInfo.getOperations();
                        Map<String, OperationInformation> implOperationsInfo = getOperationsInformation(c, itfOperationsInfo);
                        for (Entry<String, OperationInformation> implOperation : implOperationsInfo.entrySet()) {
                            if (itfOperationsInfo.containsKey(implOperation.getKey())) {
                                OperationInformation opInfo = itfOperationsInfo.get(implOperation.getKey());
                                opInfo.mergeWith(implOperation.getValue());
                            }
                        }
                        List<OperationInformation> operations = new ArrayList<OperationInformation>(itfOperationsInfo.values());

                        // Extract service info
                    	// TODO Cleaner porttype discovery
                        if (this.codeDiscovery.isDiscoverInterfaces()) {
                            InformationServiceInformation informationService = this.createInformationService(itfClass, interfaceInfo);
                            informationService.setOperations(operations);
                            discoveredNodes.add(informationService);
                        }

                        serviceImpl.setOperations(operations); //TODO or only code (signature) plus any info pointing to iserv operations ??
                    }

                    if (this.codeDiscovery.isDiscoverImplementations()) {
                        discoveredNodes.add(serviceImpl);
                    }
                }
            }
        }
        return discoveredNodes;
    }

	@Override
    public Collection<SoaNodeInformation> handleAdditionalDiscovery(JavaSource[] sources,
            Map<String, JavaServiceInterfaceInformation> wsInterfaces,
            MavenDeliverableInformation mavenDeliverable, CodeDiscoveryRegistryClient registryClient, Log log)
            throws Exception {
         List<SoaNodeInformation> discoveredNodes = new ArrayList<SoaNodeInformation>();

        // Additional pass : Find WS tests
        for (JavaSource source : sources) {
            JavaClass[] classes = source.getClasses();
            for (JavaClass c : classes) {
                if (!c.isInterface() && c.getSource().getURL().getPath().contains("src/test/")) {
                	boolean isUnitTestingClass = false;
                	for (JavaMethod method : c.getMethods()) {
                		isUnitTestingClass = isUnitTestingClass(isUnitTestingClass, method);
                		if (isUnitTestingClass) {
                			break;
                		}
                	}
                	if (isUnitTestingClass) {
                	    ImportedServicesConsumptionFinder importedServiceFinders = new ImportedServicesConsumptionFinder();
                	    List<JavaServiceConsumptionInformation> foundConsumptions = importedServiceFinders.find(
                	            c, mavenDeliverable, wsInterfaces);
                	    for (JavaServiceConsumptionInformation foundConsumption : foundConsumptions) {
                            // Try to attach test to existing non-mock impls
                            boolean foundOriginalImplementation = false;
                            SoaNodeInformations matchingRegistryImpls = registryClient
                                    .findImplsByInterface(this.codeDiscovery.getSubproject(),
                                            foundConsumption.getConsumedInterface());
                            for (SoaNodeInformation matchingRegistryImpl : matchingRegistryImpls.getSoaNodeInformationList()) {
                                foundOriginalImplementation = true;
                                discoveredNodes.add(createTestDiscovery(
                                        matchingRegistryImpl.getSoaName(),
                                        c.getFullyQualifiedName()));
                            }

                            // Otherwise, attach test info to all known implementations of the interface
                            if (!foundOriginalImplementation) {
                                for (Entry<Type, String> implToInterface : implsToInterfaces.entrySet()) {
                                    if (foundConsumption.getConsumedInterface().equals(implToInterface)) {
                                        discoveredNodes.add(createTestDiscovery(
                                                implToInterface.getKey().toGenericString(),
                                                c.getFullyQualifiedName()));
                                    }
                                }
                            }
                	    }
                	}
                }
            }
        }

        return discoveredNodes;
    }

	public JavaServiceImplementationInformation createTestDiscovery(String serviceImplName, String testName) throws Exception {
        JavaServiceImplementationInformation serviceImpl = new JavaServiceImplementationInformation(
                this.codeDiscovery.getSubproject(), serviceImplName);
        List<String> tests = new ArrayList<String>();
        tests.add(testName);
        serviceImpl.setTests(tests);
        return serviceImpl;
    }

	private String getWsNamespace(JavaClass c) {
	    String wsNamespace = null;
        wsNamespace = ParsingUtils.getAnnotationPropertyString(c, ANN_WS, "targetNamespace");
        if (wsNamespace == null) {
            wsNamespace = ParsingUtils.getAnnotationPropertyString(c, ANN_XML_WSCLIENT, "targetNamespace");
        }
        if (wsNamespace == null) {
            wsNamespace = ParsingUtils.getAnnotationPropertyString(c, ANN_XML_WSPROVIDER, "targetNamespace");
        }
        if (wsNamespace == null) {
            // defaults to package ex. http://ws.apv.dps.axxx.com/ // TODO or only for itfs and not impls ??
            wsNamespace = "http://" + StringUtils.reverseDelimited(c.getPackageName(), '.') + '/';
        }
        return wsNamespace;
	}

	private String getWsName(JavaClass c) {
        String wsName = null;
        wsName = ParsingUtils.getAnnotationPropertyString(c, ANN_WS, "name");
        if (wsName == null) {
            wsName = ParsingUtils.getAnnotationPropertyString(c, ANN_XML_WSCLIENT, "name");
        }
        if (wsName == null) {
            wsName = ParsingUtils.getAnnotationPropertyString(c, ANN_XML_WSPROVIDER, "serviceName");
        }
        if (wsName == null) {
            // defaults to java itf // TODO if itf ! impl ??
            wsName = c.getName();
        }
		return wsName;
	}

	private String getWsServiceName(JavaClass c) {
	    // service implementation name (used for binding & port)
        String serviceName = null;
        serviceName = ParsingUtils.getAnnotationPropertyString(c, ANN_WS, "serviceName");
        if (serviceName == null) {
            serviceName = ParsingUtils.getAnnotationPropertyString(c, ANN_XML_WSCLIENT, "name");
        }
		if (serviceName == null) {
		    // defaults to java impl + "Service" // TODO for impls ! itfs ??
			serviceName = c.getName() + "Service";
		}
		return serviceName;
	}

	/**
	 * For (qdox-parsed) source
	 * @param c
	 * @param existingOperationsInfo
	 * @return
	 */
	private Map<String, OperationInformation> getOperationsInformation(JavaClass c,
			Map<String, OperationInformation> existingOperationsInfo) {
        Map<String, OperationInformation> operations = new HashMap<String, OperationInformation>();

        boolean acceptNewNonExistingOperations = isWsServerInterface(c);
        // NB. for interface inheritance, since jaxws 2.1 https://issues.apache.org/jira/browse/OPENEJB-1020
        //TODO check that this is enough to support it

        for (JavaMethod method : c.getMethods()) {

            String operationName = ParsingUtils.getAnnotationPropertyString(method, ANN_WEBMETHOD, "operationName");
            if (operationName == null) {
                operationName = method.getName(); // even non-@WebMethod annotated interface methods are exposed
            }
            boolean doesOperationExist = false;
			if (/*operationName == null && */existingOperationsInfo != null) {
        		for (Entry<String, OperationInformation> operation : existingOperationsInfo.entrySet()) {
        			if (operation.getKey().equals(method.getName())) {
        			    operationName = operation.getValue().getName();
        			    doesOperationExist = true;
        			}
        		}
        	}

            if (acceptNewNonExistingOperations || doesOperationExist/*operationName != null*/) {
                // Extract parameters info
                StringBuilder parametersInfo = new StringBuilder();
                int noNameArgIndex = 0;
                for (JavaParameter parameter : method.getParameters()) {
                    String webParameterName = ParsingUtils.getAnnotationPropertyString(parameter, ANN_WEBPARAM, "name");
                    if (webParameterName == null) {
                        webParameterName = "arg" + noNameArgIndex;
                    }
                    noNameArgIndex++;
                    String webParameterType = getParameterType(parameter.getType());
                    parametersInfo.append(formatParameter(webParameterName, webParameterType) + ", ");
                }
                // removing trailing ", "
                if (parametersInfo.length() > 2) {
                    parametersInfo.delete(parametersInfo.length()-2, parametersInfo.length());
                }

                // extract return parameter info
                String webResultName = ParsingUtils.getAnnotationPropertyString(method, ANN_WEBRESULT, "name");
                if (webResultName == null) {
                    webResultName = operationName + "Response";
                }
                String returnParameterType = getReturnParameterType(method);
                String returnParametersInfo = formatParameter(webResultName, returnParameterType);
                //TODO LATER one-way, async...

                String operationInContentType = SOAP_CONTENT_TYPE;
                String operationOutContentType = SOAP_CONTENT_TYPE;
                // "in message" way of presenting parameters :
                //parametersInfo.insert(0, SOAP_CONTENT_TYPE + ": " + operationName + "{ ");
                //parametersInfo.append(" }");
                // "out message" way of presenting return :
                //returnParametersInfo = SOAP_CONTENT_TYPE + ": " + returnParametersInfo;

                //TODO LATER also bare signature (or method.getName() ?) :
                //String signature = method.getCallSignature();
                operations.put(method.getName(), new OperationInformation(operationName,
                        parametersInfo.toString(), returnParametersInfo, formatDoc(method),
                        operationInContentType, operationOutContentType));
            }
        }
        return operations;
	}




    private boolean isWsInterface(JavaClass c) {
        return isWsServerInterface(c) || isWsClientInterface(c);
    }
    private boolean isWsServerInterface(JavaClass c) {
        boolean isWs = ParsingUtils.hasAnnotation(c, ANN_WS);
        boolean isInterface = c.isInterface();
        return isWs && isInterface;
    }
    private boolean isWsClientInterface(JavaClass c) {
        return ParsingUtils.hasAnnotation(c, ANN_XML_WSCLIENT)
                || ParsingUtils.hasAnnotation(c, ANN_WSPROVIDER)
                || ParsingUtils.hasAnnotation(c, ANN_XML_WSPROVIDER);
    }

	private boolean isWsImplementation(JavaClass c, Map<String, JavaServiceInterfaceInformation> wsInterfaces) {
        JavaClass itfClass = getWsItf(c, wsInterfaces); // TODO several interfaces ???
        return !c.isInterface() && (ParsingUtils.hasAnnotation(c, ANN_WS) || itfClass != null); // TODO superclass ?
	}
	private JavaServiceImplementationInformation createServiceImplementation(JavaClass c,
			JavaClass itfClass, JavaServiceInterfaceInformation interfaceInfo) throws Exception {
	    String wsNamespace = getWsNamespace(c), wsName = getWsName(c), serviceName = getWsServiceName(c);

		String wsdlPortTypeName;
		if (interfaceInfo != null) {
		    wsdlPortTypeName = interfaceInfo.getWsPortTypeName();
		} else {
		    wsdlPortTypeName = toShortNsName(wsNamespace, wsName);
		}
		String wsdlServiceName = toShortNsName(wsNamespace, serviceName);

        JavaServiceImplementationInformation serviceImpl = new JavaServiceImplementationInformation(
                this.codeDiscovery.getSubproject(),
                new ServiceImplementationName(ServiceNameType.WEB_SERVICE, // ?????
                wsdlPortTypeName, c.getFullyQualifiedName())); // serviceName
        serviceImpl.setTitle(c.getName()); // c.getName() (shortcut) or serviceImpl.getSoaName() ?

		// TODO Cleaner porttype/servicename discovery + revert soanodeid
		serviceImpl.setProperty(JavaServiceImplementation.XPATH_WSDL_PORTTYPE_NAME, wsdlPortTypeName);
		serviceImpl.setProperty(JavaServiceImplementation.XPATH_WSDL_SERVICE_NAME, wsdlServiceName);

		serviceImpl.setProperty(JavaServiceImplementation.XPATH_IMPL_LANGUAGE, Platform.LANGUAGE_JAVA);
		serviceImpl.setProperty(JavaServiceImplementation.XPATH_IMPL_BUILD, Platform.BUILD_MAVEN);
		serviceImpl.setProperty(JavaServiceImplementation.XPATH_TECHNOLOGY, Platform.SERVICE_LANGUAGE_JAXWS);

		serviceImpl.setProperty(JavaServiceImplementation.XPATH_ISMOCK,
		        c.getSource().getURL().getPath().contains("src/test/"));
		serviceImpl.setProperty(JavaServiceImplementation.XPATH_IMPLEMENTATIONCLASS, c.getFullyQualifiedName());
		if (itfClass != null) {
		    serviceImpl.setProperty(JavaServiceImplementation.XPATH_IMPLEMENTEDINTERFACE, itfClass.getFullyQualifiedName());
		    if (interfaceInfo != null) {
		        serviceImpl.setProperty(JavaServiceImplementation.XPATH_IMPLEMENTEDINTERFACELOCATION,
		                interfaceInfo.getMavenDeliverableId().getName());
		    }
	        serviceImpl.setProperty(JavaServiceImplementation.XPATH_DOCUMENTATION, formatDoc(itfClass));
		}
		return serviceImpl;
	}

	/**
	 * Creates a new InformationService from the given info.
	 * However operations are set outside.
	 * @param itfClass
	 * @param interfaceInfo
	 * @return
	 * @throws Exception
	 */
	private InformationServiceInformation createInformationService(JavaClass itfClass,
			JavaServiceInterfaceInformation interfaceInfo) throws Exception {
	    String wsNamespace = getWsNamespace(itfClass), wsName = getWsName(itfClass);
	    String itfClassName = itfClass.getName();
	    String itfSoaName = wsNamespace + ":" + wsName;
	    if (codeDiscovery.isMatchInterfacesFirst()) {
	        itfSoaName = "matchFirst:" + itfSoaName;
	    }
	    InformationServiceInformation informationService = new InformationServiceInformation(
	            this.codeDiscovery.getSubproject(), itfSoaName);
        // TODO LATER if refactoring to allow technical matching of service interfaces :
        /*informationService.setProperty(InformationService.XPATH_LANGUAGE, Platform.LANGUAGE_JAVA);
        informationService.setProperty(InformationService.XPATH_BUILD, Platform.BUILD_MAVEN);
        informationService.setProperty(InformationService.XPATH_TECHNOLOGY, Platform.SERVICE_LANGUAGE_JAXRS);*/
	    String wsdlPortTypeName = toShortNsName(wsNamespace, wsName);
	    informationService.setProperty(InformationService.XPATH_WSDL_PORTTYPE_NAME, wsdlPortTypeName);
	    informationService.setTitle(itfClassName.substring(itfClassName.lastIndexOf(".") + 1));
	    // NB. operations set outside
	    return informationService;
	}

	public static String toShortNsName(String ns, String name) {
	    return '{' + ns + '}' + name;
	}

	private String getWsNamespace(Class<?> c) {
    	if (ParsingUtils.hasAnnotation(c, ANN_WS)) {
    		WebService wsAnnotation = (WebService) ParsingUtils.getAnnotation(c, ANN_WS);
    		return wsAnnotation.name();
    	}
    	else if (ParsingUtils.hasAnnotation(c, ANN_XML_WSCLIENT)) {
    		WebServiceClient wsAnnotation = (WebServiceClient) ParsingUtils.getAnnotation(c, ANN_XML_WSCLIENT);
    		return wsAnnotation.name();
    	}
    	else if (ParsingUtils.hasAnnotation(c, ANN_XML_WSPROVIDER)) {
    		WebServiceProvider wsAnnotation = (WebServiceProvider) ParsingUtils.getAnnotation(c, ANN_XML_WSPROVIDER);
    		return wsAnnotation.serviceName();
    	}
    	return c.getName();
	}

	private String getWsName(Class<?> c) {
    	if (ParsingUtils.hasAnnotation(c, ANN_WS)) {
    		WebService wsAnnotation = (WebService) ParsingUtils.getAnnotation(c, ANN_WS);
    		return wsAnnotation.targetNamespace();
    	}
    	else if (ParsingUtils.hasAnnotation(c, ANN_XML_WSCLIENT)) {
    		WebServiceClient wsAnnotation = (WebServiceClient) ParsingUtils.getAnnotation(c, ANN_XML_WSCLIENT);
    		return wsAnnotation.targetNamespace();
    	}
    	else if (ParsingUtils.hasAnnotation(c, ANN_XML_WSPROVIDER)) {
    		WebServiceProvider wsAnnotation = (WebServiceProvider) ParsingUtils.getAnnotation(c, ANN_XML_WSPROVIDER);
    		return wsAnnotation.targetNamespace();
    	}
    	return null;
	}

	private boolean isWsInterface(Class<?> c) {
		return isWsServerInterface(c) || isWsClientInterface(c);
	}
    private boolean isWsServerInterface(Class<?> c) {
        boolean isWs = ParsingUtils.hasAnnotation(c, ANN_WS);
        boolean isInterface = c.isInterface();
        return isWs && isInterface;
    }
    private boolean isWsClientInterface(Class<?> c) {
        return ParsingUtils.hasAnnotation(c, ANN_XML_WSCLIENT)
                || ParsingUtils.hasAnnotation(c, ANN_WSPROVIDER)
                || ParsingUtils.hasAnnotation(c, ANN_XML_WSPROVIDER);
    }

	/**
	 * For bytecode
	 * @param c
	 * @return
	 */
	private Map<String, OperationInformation> getOperationsInformation(Class<?> c) {
		Map<String, OperationInformation> operations = new HashMap<String, OperationInformation>();

        boolean acceptNewNonExistingOperations = isWsServerInterface(c);
        // NB. for interface inheritance, since jaxws 2.1 https://issues.apache.org/jira/browse/OPENEJB-1020
        //TODO check that this is enough to support it

        for (Method method : c.getMethods()) {
            String operationName = ParsingUtils.getAnnotationPropertyString(method, ANN_WEBMETHOD, "operationName");
            if (operationName == null) {
                operationName = method.getName(); // even non-@WebMethod annotated interface methods are exposed
            }

            boolean doesOperationExist = operationName != null;

            if (acceptNewNonExistingOperations || doesOperationExist/*operationName != null*/) {
                // Extract parameters info
                StringBuilder parametersInfo = new StringBuilder();
                int noNameArgIndex = 0;
                for (int i = 0; i < method.getParameterTypes().length; i++) {
                	Class<?> parameter = method.getParameterTypes()[i];
                	String webParameterName = ParsingUtils.getAnnotationPropertyString(parameter, ANN_WEBPARAM, "name");
                    if (webParameterName == null) {
                        webParameterName = "arg" + noNameArgIndex;
                    }
                    noNameArgIndex++;
                	/*java.lang.annotation.Annotation[] parameterAnnotations = method.getParameterAnnotations()[i];
                	String webParamName = null;
                	if (parameterAnnotations != null) {
                		for (java.lang.annotation.Annotation parameterAnnotation : parameterAnnotations) {
                			if (ANN_WEBPARAM.equals(parameterAnnotation.annotationType().getName())) {
                				WebParam webParamAnn = (WebParam) parameterAnnotation;
                				webParamName = webParamAnn.name();
                				break;
                            }
                		}
                	}*/
                	String webParameterType = getParameterType(parameter);
                    parametersInfo.append(formatParameter(webParameterName, webParameterType) + ", ");
                }
                // removing trailing ", "
                if (parametersInfo.length() > 2) {
                    parametersInfo.delete(parametersInfo.length()-2, parametersInfo.length());
                }

                // extract return parameter info
                String webResultName = ParsingUtils.getAnnotationPropertyString(method, ANN_WEBRESULT, "name");
                if (webResultName == null) {
                    webResultName = operationName + "Response";
                }
                String returnParameterType = getParameterType(method.getReturnType());//TODO test for void, if nullpointerexception copy code for qdox from above
                String returnParametersInfo = formatParameter(webResultName, returnParameterType);

                String operationInContentType = SOAP_CONTENT_TYPE;
                String operationOutContentType = SOAP_CONTENT_TYPE;
                // "in message" way of presenting parameters :
                //parametersInfo.insert(0, SOAP_CONTENT_TYPE + ": " + operationName + "{ ");
                //parametersInfo.append(" }");
                // "out message" way of presenting return :
                //returnParametersInfo = SOAP_CONTENT_TYPE + ": " + returnParametersInfo;

                //TODO LATER also bare signature (or method.getName() ?) :
                //String signature = method.getCallSignature();
                operations.put(method.getName(), new OperationInformation(webResultName,
                        parametersInfo.toString(), returnParametersInfo, null,
                        operationInContentType, operationOutContentType));
            }
        }
        return operations;
	}

}