/*
    * $Id: BexeeProvider.java,v 1.1 2004/12/15 14:18:15 patforna Exp $
    *
    * Copyright (c) 2004 Patric Fornasier, Pawel Kowalski
    * Berne University of Applied Sciences
    * School of Engineering and Information Technology
    * All rights reserved.
    */
   package bexee.axis;
  
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.Map;
  import java.util.Vector;
  
  import javax.wsdl.Definition;
  import javax.wsdl.WSDLException;
  import javax.wsdl.factory.WSDLFactory;
  import javax.wsdl.xml.WSDLWriter;
  import javax.xml.namespace.QName;
  import javax.xml.soap.SOAPException;
  
  import org.apache.axis.AxisFault;
  import org.apache.axis.Message;
  import org.apache.axis.MessageContext;
  import org.apache.axis.description.OperationDesc;
  import org.apache.axis.description.ServiceDesc;
  import org.apache.axis.handlers.soap.SOAPService;
  import org.apache.axis.message.RPCElement;
  import org.apache.axis.message.RPCParam;
  import org.apache.axis.message.SOAPEnvelope;
  import org.apache.axis.providers.BasicProvider;
  import org.w3c.dom.Document;
  import org.w3c.dom.Element;
  import org.xml.sax.SAXException;
  
  import bexee.core.BexeeMessage;
  import bexee.core.Dispatcher;
  import bexee.core.DispatcherException;
  import bexee.dao.BPELProcessDAO;
  import bexee.dao.DAOException;
  import bexee.dao.DAOFactory;
  import bexee.model.process.BPELProcess;
  import bexee.wsdl.WSDLBindingFactory;
  import bexee.wsdl.extensions.partnerlinktype.PartnerLinkTypeExtensionRegistry;
  
  /***
   * This is the Axis provider (also commonly called pivot handler) used by all
   * deployed BPEL process web services.
   * <p>
   * This provider takes the incoming SOAP message, performs a number of checks
   * (e.g. verifying whether the requested operation can actually be performed by
   * our <code>ProcessController</code>), puts all the necessary information
   * into a new <code>BexeeMessage</code> and dispatches it to
   * <code>Dispatcher</code>.
   * <p>
   * As soon as the provider receives the result back from the dispatcher, it will
   * create a new SOAP response and hand it back to the Axis response flow, from
   * where it will eventually be sent back to the client that invoked the service.
   * 
   * @version $Revision: 1.1 $, $Date: 2004/12/15 14:18:15 $
   * @author Patric Fornasier
   * @author Pawel Kowalski
   */
  public class BexeeProvider extends BasicProvider {
  
      /***
       * The default URL for services
       */
      private static final String DEFAULT_SERVICES_URL = "http://localhost/bexee/services/";
  
      public void initServiceDesc(SOAPService service, MessageContext msgContext)
              throws AxisFault {
          // nothing to do here
      }
  
      /***
       * Creates a <code>BexeeMessage</code> from an incoming SOAP message and
       * passes it to the {@link Dispatcher}from where it will be dispatched to
       * the {@link bexee.core.ProcessController}.
       * <p>
       * Once the processing is completed, the result from the {@link Dispatcher}
       * is taken and put back into a SOAP message and passed back into the Axis
       * response flow.
       * <p>
       * Right now and Object of type {@link Element}is passed back into the
       * response flow, because we don't generate Java objects from complex XML
       * types.
       * <p>
       * TODO: This class needs some work, especially the message type stuff
       * (possible improvements: code generation from wsdl, serializing and
       * deserializing into Java objects)
       */
      public void invoke(MessageContext ctx) throws AxisFault {
  
          RPCElement body = null;
          String operation = null;
  
          // initialize some variables
         String service = ctx.getTargetService();
         SOAPEnvelope reqEnv = ctx.getRequestMessage().getSOAPEnvelope();
         ServiceDesc serviceDesc = ctx.getService().getServiceDescription();
         OperationDesc operationDesc = ctx.getOperation();
 
         // find the first 'root' body element, which is the RPC call
         Vector bodies = reqEnv.getBodyElements();
         for (int i = 0; body == null && i < bodies.size(); i++) {
             if (bodies.get(i) instanceof RPCElement) {
                 body = (RPCElement) bodies.get(i);
             }
         }
 
         // if we didn't find anything, throw an exception
         if (body == null) {
             throw new AxisFault("No RPCElement found in SOAP message");
         }
 
         // check if that service provides the requested operation
         if (operationDesc == null) {
             QName qname = new QName(body.getNamespaceURI(), body.getName());
             operationDesc = serviceDesc.getOperationByElementQName(qname);
         }
 
         // if not, throw an exception
         if (operationDesc == null) {
             throw new AxisFault("No such operation");
         }
 
         // get RPC parameters (parts) (checks also for too many params)
         Vector params = null;
         try {
             params = body.getParams();
         } catch (SAXException e) {
             throw new AxisFault("Possible cause: too many parameters", e);
         }
 
         // check if enough params provided
         if (operationDesc.getNumParams() > params.size()) {
             throw new AxisFault("Wrong number of parameters passed in");
         }
 
         // TODO check if parameter types match
 
         // looks ok, get name of invoked operation
         operation = body.getMethodName();
 
         // create message for bexee engine and dispatch
         BexeeMessage message = createBexeeMessage(service, operation, params);
         Object result;
         try {
             result = dispatch(message);
         } catch (DispatcherException e) {
             throw new AxisFault("Unable to dispatch message", e);
         }
         // create RPC response element
         RPCElement resBody = new RPCElement(operation + "Response");
         resBody.setPrefix(body.getPrefix());
         resBody.setNamespaceURI(body.getNamespaceURI());
         try {
             resBody.setEncodingStyle(ctx.getEncodingStyle());
         } catch (SOAPException e) {
             throw AxisFault.makeFault(e);
         }
 
         // create RPC parameter containing result and add it to result body
         RPCParam param = new RPCParam(operationDesc.getReturnQName(), result);
         resBody.addParam(param);
 
         // set up a SOAP envelope with appropriate SOAP and schema versions
         SOAPEnvelope resEnv = new SOAPEnvelope();
         resEnv.setSoapConstants(ctx.getSOAPConstants());
         resEnv.setSchemaVersion(ctx.getSchemaVersion());
 
         // add the result body to the SOAP response envelope
         resEnv.addBodyElement(resBody);
 
         // create the response message and put it into the message context
         ctx.setResponseMessage(new Message(resEnv));
     }
 
     /***
      * Gets WSDL associated with requested BPEL process from DAO and adds
      * binding information on the fly.
      * <p>
      * If the target service endpoint URL can not be determined, a constant
      * value with the default services root is assumed.
      */
     public void generateWSDL(MessageContext ctx) throws AxisFault {
 
         // the WSDL Document
         Document doc = null;
 
         // get the service location url used for binding
         String url = getLocationURL(ctx);
 
         // get WSDL from BPEL process
         BPELProcessDAO dao = DAOFactory.getInstance().createBPELProcessDAO();
         BPELProcess process;
         String name = getServiceName(ctx);
         try {
             process = dao.find(name);
         } catch (DAOException e) {
             throw new AxisFault("Error trying to find process", e);
         }
 
         if (process == null) {
             throw new AxisFault("No process " + name + " found");
         }
 
         Definition wsdlAbstract = process.getWSDL();
 
         try {
             // add binding information to wsdl
             WSDLBindingFactory bindingFactory = new WSDLBindingFactory();
             Definition wsdl = bindingFactory.addBinding(wsdlAbstract, url);
 
             // convert into org.w3c.dom.Document
             WSDLWriter writer = WSDLFactory.newInstance().newWSDLWriter();
             wsdl.setExtensionRegistry(new PartnerLinkTypeExtensionRegistry());
             doc = writer.getDocument(wsdl);
         } catch (WSDLException e) {
             throw AxisFault.makeFault(e);
         }
 
         // save WSDL Document in message context
         ctx.setProperty("WSDL", doc);
     }
 
     /***
      * Gets the service location URL.
      * 
      * @return a <code>String</code>
      */
     protected String getLocationURL(MessageContext ctx) {
         // location URL is whatever is explicitly set in the MC
         String url = ctx.getStrProp(MessageContext.WSDLGEN_SERV_LOC_URL);
 
         // If nothing, try what's explicitly set in the ServiceDesc
         if (url == null) {
             url = ctx.getService().getServiceDescription().getEndpointURL();
         }
 
         // If nothing, use the actual transport URL
         if (url == null) {
             url = ctx.getStrProp(MessageContext.TRANS_URL);
         }
 
         // if everything fails, hardcode it
         if (url == null) {
             url = DEFAULT_SERVICES_URL + getServiceName(ctx);
         }
 
         return url;
     }
 
     protected String getServiceName(MessageContext ctx) {
         String name = ctx.getService().getServiceDescription().getName();
         return name;
     }
 
     /***
      * Helper method to create the <code>BexeeMessage</code>
      */
     protected BexeeMessage createBexeeMessage(String service, String operation,
             Vector params) throws AxisFault {
 
         BexeeMessage message = new BexeeMessage();
 
         // create parts map
         Map parts = new HashMap();
         for (Iterator iter = params.iterator(); iter.hasNext();) {
             RPCParam rpcParam = (RPCParam) iter.next();
 
             // get the value out of the RPC param
             Object value = rpcParam.getObjectValue();
 
             // get the name we defined in the service description (we do not
             // care how the parameter was really called in the RPC call)
             String name = rpcParam.getParamDesc().getName();
 
             // store object
             parts.put(name, value);
         }
 
         // set fields on BexeeMessage
         message.setService(service);
         message.setOperation(operation);
         message.setParts(parts);
 
         return message;
     }
 
     /***
      * Call dispatcher to kick off the process controller and return result
      * 
      * @return the result from the {@link Dispatcher}
      */
     protected Object dispatch(BexeeMessage message) throws DispatcherException {
 
         Dispatcher dispatcher = new Dispatcher(message);
         return dispatcher.dispatch();
     }
 
 }