AnnotationProcessor.java

/*
 * Copyright 2001-2010 The Apache Software Foundation.
 * 
 * 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 org.apache.juddi.v3.annotations;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Properties;

import javax.jws.WebService;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.juddi.api_v3.AccessPointType;
import org.apache.juddi.v3.client.ClassUtil;
import org.apache.juddi.v3.client.config.TokenResolver;
import org.uddi.api_v3.AccessPoint;
import org.uddi.api_v3.BindingTemplate;
import org.uddi.api_v3.BindingTemplates;
import org.uddi.api_v3.BusinessService;
import org.uddi.api_v3.CategoryBag;
import org.uddi.api_v3.Description;
import org.uddi.api_v3.KeyedReference;
import org.uddi.api_v3.Name;
import org.uddi.api_v3.TModelInstanceDetails;
import org.uddi.api_v3.TModelInstanceInfo;

public class AnnotationProcessor {
	
	private static final String KEYED_REFERENCE="keyedReference=";
	private static final String KEY_NAME="keyName=";
	private static final String KEY_VALUE="keyValue=";
	private static final String TMODEL_KEY="tModelKey=";
	
	private Log log = LogFactory.getLog(AnnotationProcessor.class);
	
	public Collection<BusinessService> readServiceAnnotations(String[] classesWithAnnotations, Properties properties) {
		Collection<BusinessService> services = new ArrayList<BusinessService>();
		for (String className : classesWithAnnotations) {
			try {		
				BusinessService service = readServiceAnnotations(className, properties);
				services.add(service);
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		return services;
	}
	
	public BusinessService readServiceAnnotations(String classWithAnnotations, Properties properties) throws ClassNotFoundException {
		
		BusinessService service = new BusinessService();
		Class<?> clazz = ClassUtil.forName(classWithAnnotations, this.getClass());
		UDDIService uddiService= (UDDIService) clazz.getAnnotation(UDDIService.class);
		WebService webServiceAnnotation = (WebService) clazz.getAnnotation(WebService.class);
		
		if (uddiService!=null) {
			//service
			String lang = "en"; //default to english
			if (uddiService.lang()!=null) {
				lang = uddiService.lang();
			}
			Name name = new Name();
			name.setLang(lang); 
			service.setBusinessKey(TokenResolver.replaceTokens(uddiService.businessKey(),properties));
			service.setServiceKey(TokenResolver.replaceTokens(uddiService.serviceKey(),properties));
			if (!"".equals(uddiService.serviceName())) {
				name.setValue(TokenResolver.replaceTokens(uddiService.serviceName(),properties));
			} else if (webServiceAnnotation!=null && !"".equals(webServiceAnnotation.serviceName())) {
				name.setValue(webServiceAnnotation.serviceName());
			} else {
				name.setValue(clazz.getSimpleName());
			}
			service.getName().add(name);
			Description description = new Description();
			description.setLang(lang);
			description.setValue(TokenResolver.replaceTokens(uddiService.description(),properties));
			service.getDescription().add(description);
			
			//categoryBag on the service
			if (!"".equals(uddiService.categoryBag())) {
				CategoryBag categoryBag = parseCategoryBag(uddiService.categoryBag());
		        service.setCategoryBag(categoryBag);
			}
			
			//bindingTemplate on service
			BindingTemplate bindingTemplate = parseServiceBinding(clazz, lang, webServiceAnnotation, properties);
			if (bindingTemplate!=null) {
				bindingTemplate.setServiceKey(service.getServiceKey());
				if (service.getBindingTemplates()==null) {
					service.setBindingTemplates(new BindingTemplates());
				}
				service.getBindingTemplates().getBindingTemplate().add(bindingTemplate);
			}
			
			
		} else {
			log.error("Missing UDDIService annotation in class " + classWithAnnotations);
		}
			
		return service;
	}
	
	protected BindingTemplate parseServiceBinding(Class<?> classWithAnnotations, String lang, 
			WebService webServiceAnnotation, Properties properties) {
		
		BindingTemplate bindingTemplate = null;
		UDDIServiceBinding uddiServiceBinding= (UDDIServiceBinding) classWithAnnotations.getAnnotation(UDDIServiceBinding.class);
		//binding
		if (uddiServiceBinding!=null) {
			bindingTemplate = new BindingTemplate();
			
			bindingTemplate.setBindingKey(TokenResolver.replaceTokens(uddiServiceBinding.bindingKey(), properties));
			
			String bindingLang = String.valueOf(lang);
			if (uddiServiceBinding.lang()!=null) {
				bindingLang = TokenResolver.replaceTokens(uddiServiceBinding.lang(),properties);
			}
			Description bindingDescription = new Description();
			bindingDescription.setLang(bindingLang);
			bindingDescription.setValue(TokenResolver.replaceTokens(uddiServiceBinding.description(),properties));
			bindingTemplate.getDescription().add(bindingDescription);
			
			AccessPoint accessPoint = new AccessPoint();
			accessPoint.setUseType(AccessPointType.WSDL_DEPLOYMENT.toString());
			if (!"".equals(uddiServiceBinding.accessPointType())) {
				accessPoint.setUseType(uddiServiceBinding.accessPointType());
			}
			if (!"".equals(uddiServiceBinding.accessPoint())) {
				String endPoint = uddiServiceBinding.accessPoint();
				endPoint = TokenResolver.replaceTokens(endPoint, properties);
                log.debug("AccessPoint EndPoint=" + endPoint);
				accessPoint.setValue(endPoint);
			} else if (webServiceAnnotation!=null && webServiceAnnotation.wsdlLocation()!=null) {
				accessPoint.setValue(webServiceAnnotation.wsdlLocation());
			}
			bindingTemplate.setAccessPoint(accessPoint);
			
			//tModelKeys on the binding
			if (!"".equals(uddiServiceBinding.tModelKeys())) {
				String[] tModelKeys= uddiServiceBinding.tModelKeys().split(",");
				for (String tModelKey : tModelKeys) {
					TModelInstanceInfo instanceInfo = new TModelInstanceInfo();
					instanceInfo.setTModelKey(tModelKey);
					if (bindingTemplate.getTModelInstanceDetails()==null) {
						bindingTemplate.setTModelInstanceDetails(new TModelInstanceDetails());
					}
					bindingTemplate.getTModelInstanceDetails().getTModelInstanceInfo().add(instanceInfo);
				}
			}
			//categoryBag on the binding
			if (!"".equals(uddiServiceBinding.categoryBag())) {
				CategoryBag categoryBag = parseCategoryBag(uddiServiceBinding.categoryBag());
		        bindingTemplate.setCategoryBag(categoryBag);
			}
		} else {
			log.error("Missing UDDIServiceBinding annotation in class " + classWithAnnotations);
		}
		return bindingTemplate;
	}
	/**
	 * parse something like: [keyName=uddi-org:types:wsdl,keyValue=wsdlDeployment,tModelKey=uddi:uddi.org:categorization:types]
							
	 * @param categoryBagStr
	 * @return a UDDI CategoryBag
         * @see CategoryBag
	 */
	protected CategoryBag parseCategoryBag(String categoryBagStr) {
		
		CategoryBag categoryBag = new CategoryBag();
		log.debug("CategoryBag Annotation=" + categoryBagStr);
		if (!"".equals(categoryBagStr)) {
			String[] sections = categoryBagStr.split(",");
	        for (String section : sections) {
	        	if (section.startsWith(KEYED_REFERENCE)) {
		            String keyedReferenceStr = section.substring(KEYED_REFERENCE.length(),section.length());
		            log.debug("Found KeyedReference=" + keyedReferenceStr);
		            String[] keyedReferences = keyedReferenceStr.split(";");
		            KeyedReference keyedReference = new KeyedReference();
		            for (String key : keyedReferences) {
						if (key.startsWith(KEY_NAME)) keyedReference.setKeyName(key.substring(KEY_NAME.length(),key.length()));
						if (key.startsWith(KEY_VALUE)) keyedReference.setKeyValue(key.substring(KEY_VALUE.length(),key.length()));
						if (key.startsWith(TMODEL_KEY)) keyedReference.setTModelKey(key.substring(TMODEL_KEY.length(),key.length()));
					}
		            log.debug("KeyedReference = " + KEY_NAME + keyedReference.getKeyName() + " " 
		            		                      + KEY_VALUE + keyedReference.getKeyValue() + " "
		            		                      + TMODEL_KEY + keyedReference.getTModelKey());
		            categoryBag.getKeyedReference().add(keyedReference);
	        	} else {
	        		log.warn("Ignoring " + section);
	                 //TODO add support for KeyedReferenceGroups?
	        	}
	        }
        }
        return categoryBag;
	}
}