/*

  * $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

  */

     /**

      * The default URL for services

      */

     private static final String DEFAULT_SERVICES_URL = "http://localhost/bexee/services/";

             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)

      */

         // initialize some variables

         // find the first 'root' body element, which is the RPC call

             }

         }

         // if we didn't find anything, throw an exception

         }

         // check if that service provides the requested operation

         }

         // if not, throw an exception

         }

         // get RPC parameters (parts) (checks also for too many params)

         } catch (SAXException e) {

         }

         // check if enough params provided

         }

         // TODO check if parameter types match

         // looks ok, get name of invoked operation

         // create message for bexee engine and dispatch

         } catch (DispatcherException e) {

         }

         // create RPC response element

         } catch (SOAPException e) {

         }

         // create RPC parameter containing result and add it to result body

         // set up a SOAP envelope with appropriate SOAP and schema versions

         // add the result body to the SOAP response envelope

         // create the response message and put it into the message context

     }

     /**

      * 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.

      */

         // the WSDL Document

         // get the service location url used for binding

         // get WSDL from BPEL process

         } catch (DAOException e) {

         }

         }

             // add binding information to wsdl

             // convert into org.w3c.dom.Document

         } catch (WSDLException e) {

         }

         // save WSDL Document in message context

     }

     /**

      * Gets the service location URL.

      * 

      * @return a <code>String</code>

      */

         // location URL is whatever is explicitly set in the MC

         // If nothing, try what's explicitly set in the ServiceDesc

         }

         // If nothing, use the actual transport URL

         }

         // if everything fails, hardcode it

         }

     }

     }

     /**

      * Helper method to create the <code>BexeeMessage</code>

      */

             Vector params) throws AxisFault {

         // create parts map

             // get the value out of the RPC param

             // get the name we defined in the service description (we do not

             // care how the parameter was really called in the RPC call)

             // store object

         }

         // set fields on BexeeMessage

     }

     /**

      * Call dispatcher to kick off the process controller and return result

      * 

      * @return the result from the {@link Dispatcher}

      */

     }

 }