/*
    * Copyright 2001-2004 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.function;
  
  import java.util.Vector;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.apache.juddi.datastore.DataStore;
  import org.apache.juddi.datastore.DataStoreFactory;
  import org.apache.juddi.datatype.RegistryObject;
  import org.apache.juddi.datatype.request.FindPublisher;
  import org.apache.juddi.datatype.request.FindQualifier;
  import org.apache.juddi.datatype.request.FindQualifiers;
  import org.apache.juddi.datatype.response.PublisherInfos;
  import org.apache.juddi.datatype.response.PublisherList;
  import org.apache.juddi.error.NameTooLongException;
  import org.apache.juddi.error.RegistryException;
  import org.apache.juddi.error.UnsupportedException;
  import org.apache.juddi.registry.RegistryEngine;
  import org.apache.juddi.util.Config;
  
  /***
   * "This [FindPublisher] API call returns a publisherList on success. This
   * structure contains information about each matching publisher. In the
   * event that no matches were located for the specified criteria, a
   * publisherList structure with zero publisher structures is returned. If
   * no arguments are passed, a zero-match result set will be returned."
   *
   * In the event of a large number of matches, (as determined by each
   * Operator Site), or if the number of matches exceeds the value of the
   * 'maxRows' attribute, the Operator Site will truncate the result set.
   * If this occurs, the publisherList will contain the 'truncated' attribute
   * with the value 'true'.
   *
   * @author Steve Viens (sviens@apache.org)
   */
  public class FindPublisherFunction extends AbstractFunction
  {
    // private reference to jUDDI Logger
    private static Log log = LogFactory.getLog(FindPublisherFunction.class);
  
    /***
     *
     */
    public FindPublisherFunction(RegistryEngine registry)
    {
      super(registry);
    }
  
    /***
     *
     */
    public RegistryObject execute(RegistryObject regObject)
      throws RegistryException
    {
      FindPublisher request = (FindPublisher)regObject;
      String generic = request.getGeneric();
      String name = request.getNameString();
      FindQualifiers qualifiers = request.getFindQualifiers();
      int maxRows = request.getMaxRows();
  
      // make sure we need to continue with this request. If
      // no arguments were passed in then we'll simply return
      // an empty PublisherList (aka "a zero match result set").
      if ((name == null) || (name.length() == 0))
      {
        PublisherList list = new PublisherList();
        list.setGeneric(generic);
        list.setPublisherInfos(new PublisherInfos());
        list.setOperator(Config.getOperator());
        list.setTruncated(false);
        return list;
      }
  
      // aquire a jUDDI datastore instance
      DataStore dataStore = DataStoreFactory.getDataStore();
  
      try
      {
        dataStore.beginTrans();
  
        // validate the 'name' parameters as much as possible up-front before
        // calling into the data layer for relational validation.
        if (name != null)
        {
         // names can not exceed the maximum character length specified by the
         // UDDI specification (v2.0 specifies a max character length of 255). This
         // value is configurable in jUDDI.
         int maxNameLength = Config.getMaxNameLengthAllowed();
         if (name.length() > maxNameLength)
           throw new NameTooLongException("find_publisher: "+
               "name="+name+", "+
               "length="+name.length()+", "+
               "maxNameLength="+maxNameLength);
       }
 
       // validate the 'qualifiers' parameter as much as possible up-front before
       // calling into the data layer for relational validation.
       if (qualifiers != null)
       {
         Vector qVector = qualifiers.getFindQualifierVector();
         if ((qVector!=null) && (qVector.size() > 0))
         {
           for (int i=0; i<qVector.size(); i++)
           {
             FindQualifier qualifier = (FindQualifier)qVector.elementAt(i);
             String qValue = qualifier.getValue();
 
             if ((!qValue.equals(FindQualifier.EXACT_NAME_MATCH)) &&
                 (!qValue.equals(FindQualifier.CASE_SENSITIVE_MATCH)) &&
                 (!qValue.equals(FindQualifier.OR_ALL_KEYS)) &&
                 (!qValue.equals(FindQualifier.OR_LIKE_KEYS)) &&
                 (!qValue.equals(FindQualifier.AND_ALL_KEYS)) &&
                 (!qValue.equals(FindQualifier.SORT_BY_NAME_ASC)) &&
                 (!qValue.equals(FindQualifier.SORT_BY_NAME_DESC)) &&
                 (!qValue.equals(FindQualifier.SORT_BY_DATE_ASC)) &&
                 (!qValue.equals(FindQualifier.SORT_BY_DATE_DESC)) &&
                 (!qValue.equals(FindQualifier.SERVICE_SUBSET)) &&
                 (!qValue.equals(FindQualifier.COMBINE_CATEGORY_BAGS)))
               throw new UnsupportedException("find_publisher: "+
                   "findQualifier="+qValue);
           }
         }
       }
 
       Vector infoVector = null;
       boolean truncatedResults = false;
 
       // perform the search for matching technical models (return only keys in requested order)
       Vector idVector = dataStore.findPublisher(name,qualifiers);
       if ((idVector != null) && (idVector.size() > 0))
       {
         // if a maxRows value has been specified and it's less than
         // the number of rows we are about to return then only return
         // maxRows specified.
         int rowCount = idVector.size();
         if ((maxRows > 0) && (maxRows < rowCount))
         {
           rowCount = maxRows;
           truncatedResults = true;
         }
 
         // iterate through the publisher IDs fetching
         // each associated PublisherInfo in sequence.
         infoVector = new Vector(rowCount);
         for (int i=0; i<rowCount; i++)
           infoVector.addElement(dataStore.fetchPublisherInfo((String)idVector.elementAt(i)));
       }
 
       dataStore.commit();
 
       // create a new PublisherInfos instance and stuff
       // the new Vector of PublisherInfos into it.
       PublisherInfos infos = new PublisherInfos();
       infos.setPublisherInfoVector(infoVector);
 
       // create a new PublisherList instance and
       // stuff the new PublisherInfoVector into it.
       PublisherList list = new PublisherList();
       list.setGeneric(generic);
       list.setPublisherInfos(infos);
       list.setOperator(Config.getOperator());
       list.setTruncated(truncatedResults);
       return list;
     }
     catch(NameTooLongException ntlex)
     {
       try { dataStore.rollback(); } catch(Exception e) { }
       log.info(ntlex.getMessage());
       throw (RegistryException)ntlex;
     }
     catch(UnsupportedException suppex)
     {
       try { dataStore.rollback(); } catch(Exception e) { }
       log.info(suppex.getMessage());
       throw (RegistryException)suppex;
     }
     catch(RegistryException regex)
     {
       try { dataStore.rollback(); } catch(Exception e) { }
       log.error(regex);
       throw (RegistryException)regex;
     }
     catch(Exception ex)
     {
       try { dataStore.rollback(); } catch(Exception e) { }
       log.error(ex);
       throw new RegistryException(ex);
     }
     finally
     {
       if (dataStore != null)
         dataStore.release();
     }
   }
 
   /****************************************************************************/
   /****************************** TEST DRIVER *********************************/
   /****************************************************************************/
 
   public static void main(String[] args)
   {
     // initialize the registry
     RegistryEngine reg = new RegistryEngine();
     reg.init();
 
     try
     {
     }
     catch (Exception ex)
     {
       // write execption to the console
       ex.printStackTrace();
     }
     finally
     {
       // destroy the registry
       reg.dispose();
     }
   }
 }