* Licensed to the Apache Software Foundation (ASF) under one or more

* contributor license agreements. See the NOTICE file distributed with

* this work for additional information regarding copyright ownership.

* The ASF licenses this file to You 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.

*/

* standard "pull" ingestion agent.

*

* Each instance of this interface is used in only one thread at a time.  Connection Pooling

* on these kinds of objects is performed by the factory which instantiates repository connectors

* from symbolic names and config parameters, and is pooled by these parameters.  That is, a pooled connector

* handle is used only if all the connection parameters for the handle match.

*

* Implementers of this interface should provide a default constructor which has this signature:

*

* xxx();

*

* Connectors are either configured or not.  If configured, they will persist in a pool, and be

* reused multiple times.  Certain methods of a connector may be called before the connector is

* configured.  This includes basically all methods that permit inspection of the connector's

* capabilities.  The complete list is:

*

*

* The purpose of the repository connector is to allow documents to be fetched from the repository.

*

* Each repository connector describes a set of documents that are known only to that connector.

* It therefore establishes a space of document identifiers.  Each connector will only ever be

* asked to deal with identifiers that have in some way originated from the connector.

*

* Documents are fetched in three stages.  First, the getDocuments() method is called in the connector

* implementation.  This returns a set of document identifiers.  The document identifiers are used to

* obtain the current document version strings in the second stage, using the getDocumentVersions() method.

* The last stage is processDocuments(), which queues up any additional documents needed, and also ingests.

* This method will not be called if the document version seems to indicate that no document change took

* place.

*/

  public static final String _rcsid = "@(#)$Id: JDBCConnector.java 988245 2010-08-23 18:39:35Z kwright $";

  // Activities that we know about

  protected final static String ACTIVITY_EXTERNAL_QUERY = "external query";

  // Activities list

  protected static final String[] activitiesList = new String[]{ACTIVITY_EXTERNAL_QUERY};

  /** Deny access token for default authority */

  private final static String defaultAuthorityDenyToken = "DEAD_AUTHORITY";

  protected JDBCConnection connection = null;

  protected String jdbcProvider = null;

  protected String accessMethod = null;

  protected String host = null;

  protected String databaseName = null;

  protected String rawDriverString = null;

  protected String userName = null;

  protected String password = null;

  /** Constructor.

  */

  public JDBCConnector()

  {

  }

  /** Set up a session */

  protected void getSession()

    throws ManifoldCFException

  {

    if (connection == null)

    {

      if (jdbcProvider == null || jdbcProvider.length() == 0)

        throw new ManifoldCFException("Missing parameter '"+JDBCConstants.providerParameter+"'");

      if ((host == null || host.length() == 0) && (rawDriverString == null || rawDriverString.length() == 0))

        throw new ManifoldCFException("Missing parameter '"+JDBCConstants.hostParameter+"' or '"+JDBCConstants.driverStringParameter+"'");

      connection = new JDBCConnection(jdbcProvider,(accessMethod==null || accessMethod.equals("name")),host,databaseName,rawDriverString,userName,password);

    }

  }

  /** Return the list of activities that this connector supports (i.e. writes into the log).

  *@return the list.

  */

  @Override

  public String[] getActivitiesList()

  {

    return activitiesList;

  }

  /** Model.  Depending on what people enter for the seeding query, this could be either ALL or

  * could be less than that.  So, I've decided it will be at least the adds and changes, and

  * won't include the deletes.

  */

  @Override

  public int getConnectorModel()

  {

    return MODEL_ADD_CHANGE;

  }

  /** Connect.  The configuration parameters are included.

  *@param configParams are the configuration parameters for this connection.

  */

  @Override

  public void connect(ConfigParams configParams)

  {

    super.connect(configParams);

    jdbcProvider = configParams.getParameter(JDBCConstants.providerParameter);

    accessMethod = configParams.getParameter(JDBCConstants.methodParameter);

    host = configParams.getParameter(JDBCConstants.hostParameter);

    databaseName = configParams.getParameter(JDBCConstants.databaseNameParameter);

    rawDriverString = configParams.getParameter(JDBCConstants.driverStringParameter);

    userName= configParams.getParameter(JDBCConstants.databaseUserName);

    password = configParams.getObfuscatedParameter(JDBCConstants.databasePassword);

  }

  /** Check status of connection.

  */

  @Override

  public String check()

    throws ManifoldCFException

  {

    try

    {

      getSession();

      // Attempt to fetch a connection; if this succeeds we pass

      connection.testConnection();

      return super.check();

    }

    catch (ServiceInterruption e)

    {

      if (Logging.connectors.isDebugEnabled())

        Logging.connectors.debug("Service interruption in check(): "+e.getMessage(),e);

      return "Transient error: "+e.getMessage();

    }

  }

  /** Close the connection.  Call this before discarding the repository connector.

  */

  @Override

  public void disconnect()

    throws ManifoldCFException

  {

    connection = null;

    host = null;

    jdbcProvider = null;

    accessMethod = null;

    databaseName = null;

    rawDriverString = null;

    userName = null;

    password = null;

    super.disconnect();

  }

  /** Get the bin name string for a document identifier.  The bin name describes the queue to which the

  * document will be assigned for throttling purposes.  Throttling controls the rate at which items in a

  * given queue are fetched; it does not say anything about the overall fetch rate, which may operate on

  * multiple queues or bins.

  * For example, if you implement a web crawler, a good choice of bin name would be the server name, since

  * that is likely to correspond to a real resource that will need real throttle protection.

  *@param documentIdentifier is the document identifier.

  *@return the bin name.

  */

  @Override

  public String[] getBinNames(String documentIdentifier)

  {

    return new String[]{(rawDriverString==null||rawDriverString.length()==0)?host:rawDriverString};

  }

  /** Queue "seed" documents.  Seed documents are the starting places for crawling activity.  Documents

  * are seeded when this method calls appropriate methods in the passed in ISeedingActivity object.

  *

  * This method can choose to find repository changes that happen only during the specified time interval.

  * The seeds recorded by this method will be viewed by the framework based on what the

  * getConnectorModel() method returns.

  *

  * It is not a big problem if the connector chooses to create more seeds than are

  * strictly necessary; it is merely a question of overall work required.

  *

  * The times passed to this method may be interpreted for greatest efficiency.  The time ranges

  * any given job uses with this connector will not overlap, but will proceed starting at 0 and going

  * to the "current time", each time the job is run.  For continuous crawling jobs, this method will

  * be called once, when the job starts, and at various periodic intervals as the job executes.

  *

  * When a job's specification is changed, the framework automatically resets the seeding start time to 0.  The

  * seeding start time may also be set to 0 on each job run, depending on the connector model returned by

  * getConnectorModel().

  *

  * Note that it is always ok to send MORE documents rather than less to this method.

  *@param activities is the interface this method should use to perform whatever framework actions are desired.

  *@param spec is a document specification (that comes from the job).

  *@param startTime is the beginning of the time range to consider, inclusive.

  *@param endTime is the end of the time range to consider, exclusive.

  *@param jobMode is an integer describing how the job is being run, whether continuous or once-only.

  */

  @Override

  public void addSeedDocuments(ISeedingActivity activities, DocumentSpecification spec,

    long startTime, long endTime, int jobMode)

    throws ManifoldCFException, ServiceInterruption

  {

    getSession();

    // Set up the query

    TableSpec ts = new TableSpec(spec);

    VariableMap vm = new VariableMap();

    addConstant(vm,JDBCConstants.idReturnVariable,JDBCConstants.idReturnColumnName);

    addVariable(vm,JDBCConstants.startTimeVariable,startTime);

    addVariable(vm,JDBCConstants.endTimeVariable,endTime);

    // Do the substitution

    ArrayList paramList = new ArrayList();

    StringBuilder sb = new StringBuilder();

    substituteQuery(ts.idQuery,vm,sb,paramList);

    IDynamicResultSet idSet;

    String queryText = sb.toString();

    long startQueryTime = System.currentTimeMillis();

    // Contract for IDynamicResultset indicates that if successfully obtained, it MUST

    // be closed.

    try

    {

      idSet = connection.executeUncachedQuery(queryText,paramList,-1);

    }

    catch (ServiceInterruption e)

    {

      // If failure, record the failure.

      activities.recordActivity(new Long(startQueryTime), ACTIVITY_EXTERNAL_QUERY, null,

        createQueryString(queryText,paramList), "ERROR", e.getMessage(), null);

      throw e;

    }

    catch (ManifoldCFException e)

    {

      // If failure, record the failure.

      activities.recordActivity(new Long(startQueryTime), ACTIVITY_EXTERNAL_QUERY, null,

        createQueryString(queryText,paramList), "ERROR", e.getMessage(), null);

      throw e;

    }

    try

    {

      // If success, record that too.

      activities.recordActivity(new Long(startQueryTime), ACTIVITY_EXTERNAL_QUERY, null,

        createQueryString(queryText,paramList), "OK", null, null);

      while (true)

      {

        IDynamicResultRow row = idSet.getNextRow();

        if (row == null)

          break;

        try

        {

          Object o = row.getValue(JDBCConstants.idReturnColumnName);

          if (o == null)

            throw new ManifoldCFException("Bad seed query; doesn't return $(IDCOLUMN) column.  Try using quotes around $(IDCOLUMN) variable, e.g. \"$(IDCOLUMN)\".");

          String idValue = JDBCConnection.readAsString(o);

          activities.addSeedDocument(idValue);

        }

        finally

        {

          row.close();

        }

      }

    }

    finally

    {

      idSet.close();

    }

  }

  /** Get document versions given an array of document identifiers.

  * This method is called for EVERY document that is considered. It is

  * therefore important to perform as little work as possible here.

  *@param documentIdentifiers is the array of local document identifiers, as understood by this connector.

  *@param oldVersions is the corresponding array of version strings that have been saved for the document identifiers.

  *   A null value indicates that this is a first-time fetch, while an empty string indicates that the previous document

  *   had an empty version string.

  *@param activities is the interface this method should use to perform whatever framework actions are desired.

  *@param spec is the current document specification for the current job.  If there is a dependency on this

  * specification, then the version string should include the pertinent data, so that reingestion will occur

  * when the specification changes.  This is primarily useful for metadata.

  *@param jobMode is an integer describing how the job is being run, whether continuous or once-only.

  *@param usesDefaultAuthority will be true only if the authority in use for these documents is the default one.

  *@return the corresponding version strings, with null in the places where the document no longer exists.

  * Empty version strings indicate that there is no versioning ability for the corresponding document, and the document

  * will always be processed.

  */

  @Override

  public String[] getDocumentVersions(String[] documentIdentifiers, String[] oldVersions, IVersionActivity activities,

    DocumentSpecification spec, int jobMode, boolean usesDefaultAuthority)

    throws ManifoldCFException, ServiceInterruption

  {

    getSession();

    TableSpec ts = new TableSpec(spec);

    String[] acls = getAcls(spec);

    // Sort these,

    java.util.Arrays.sort(acls);

    String[] versionsReturned = new String[documentIdentifiers.length];

    // If there is no version query, then always return empty string for all documents.

    // This will mean that processDocuments will be called

    // for all.  ProcessDocuments will then be responsible for doing document deletes itself,

    // based on the query results.

    if (ts.versionQuery == null || ts.versionQuery.length() == 0)

    {

      int i = 0;

      while (i < versionsReturned.length)

      {

        versionsReturned[i++] = "";

      }

      return versionsReturned;

    }

    // If there IS a versions query, do it.  First set up the variables, then do the substitution.

    VariableMap vm = new VariableMap();

    addConstant(vm,JDBCConstants.idReturnVariable,JDBCConstants.idReturnColumnName);

    addConstant(vm,JDBCConstants.versionReturnVariable,JDBCConstants.versionReturnColumnName);

    if (!addIDList(vm,JDBCConstants.idListVariable,documentIdentifiers,null))

      return new String[0];

    // Do the substitution

    ArrayList paramList = new ArrayList();

    StringBuilder sb = new StringBuilder();

    substituteQuery(ts.versionQuery,vm,sb,paramList);

    // Now, build a result return, and a hash table so we can correlate the returned values with the place to put them.

    // We presume that if the row is missing, the document is gone.

    Map map = new HashMap();

    int j = 0;

    while (j < documentIdentifiers.length)

    {

      map.put(documentIdentifiers[j],new Integer(j));

      versionsReturned[j] = "";

      j++;

    }

    // Fire off the query!

    IDynamicResultSet result;

    String queryText = sb.toString();

    long startTime = System.currentTimeMillis();

    // Get a dynamic resultset.  Contract for dynamic resultset is that if

    // one is returned, it MUST be closed, or a connection will leak.

    try

    {

      result = connection.executeUncachedQuery(queryText,paramList,-1);

    }

    catch (ManifoldCFException e)

    {

      // If failure, record the failure.

      activities.recordActivity(new Long(startTime), ACTIVITY_EXTERNAL_QUERY, null,

        createQueryString(queryText,paramList), "ERROR", e.getMessage(), null);

      throw e;

    }

    try

    {

      // If success, record that too.

      activities.recordActivity(new Long(startTime), ACTIVITY_EXTERNAL_QUERY, null,

        createQueryString(queryText,paramList), "OK", null, null);

      // Now, go through resultset

      while (true)

      {

        IDynamicResultRow row = result.getNextRow();

        if (row == null)

          break;

        try

        {

          Object o = row.getValue(JDBCConstants.idReturnColumnName);

          if (o == null)

            throw new ManifoldCFException("Bad version query; doesn't return $(IDCOLUMN) column.  Try using quotes around $(IDCOLUMN) variable, e.g. \"$(IDCOLUMN)\".");

          String idValue = JDBCConnection.readAsString(o);

          o = row.getValue(JDBCConstants.versionReturnColumnName);

          String versionValue;

          // Null version is OK; make it a ""

          if (o == null)

            versionValue = "";

          else

          {

            // A real version string!  Any acls must be added to the front, if they are present...

            sb = new StringBuilder();

            packList(sb,acls,'+');

            if (acls.length > 0)

            {

              sb.append('+');

              pack(sb,defaultAuthorityDenyToken,'+');

            }

            else

              sb.append('-');

            sb.append(JDBCConnection.readAsString(o)).append("=").append(ts.dataQuery);

            versionValue = sb.toString();

          }

          // Versions that are "", when processed, will have their acls fetched at that time...

          versionsReturned[((Integer)map.get(idValue)).intValue()] = versionValue;

        }

        finally

        {

          row.close();

        }

      }

    }

    finally

    {

      result.close();

    }

    return versionsReturned;

  }

  /** Process a set of documents.

  * This is the method that should cause each document to be fetched, processed, and the results either added

  * to the queue of documents for the current job, and/or entered into the incremental ingestion manager.

  * The document specification allows this class to filter what is done based on the job.

  *@param documentIdentifiers is the set of document identifiers to process.

  *@param versions is the corresponding document versions to process, as returned by getDocumentVersions() above.

  *       The implementation may choose to ignore this parameter and always process the current version.

  *@param activities is the interface this method should use to queue up new document references

  * and ingest documents.

  *@param spec is the document specification.

  *@param scanOnly is an array corresponding to the document identifiers.  It is set to true to indicate when the processing

  * should only find other references, and should not actually call the ingestion methods.

  */

  @Override

  public void processDocuments(String[] documentIdentifiers, String[] versions, IProcessActivity activities, DocumentSpecification spec, boolean[] scanOnly)

    throws ManifoldCFException, ServiceInterruption

  {

    getSession();

    TableSpec ts = new TableSpec(spec);

    // For all the documents not marked "scan only", form a query and pick up the contents.

    // If the contents is not found, then explicitly call the delete action method.

    VariableMap vm = new VariableMap();

    addConstant(vm,JDBCConstants.idReturnVariable,JDBCConstants.idReturnColumnName);

    addConstant(vm,JDBCConstants.urlReturnVariable,JDBCConstants.urlReturnColumnName);

    addConstant(vm,JDBCConstants.dataReturnVariable,JDBCConstants.dataReturnColumnName);

    addConstant(vm,JDBCConstants.contentTypeReturnVariable,JDBCConstants.contentTypeReturnColumnName);

    if (!addIDList(vm,JDBCConstants.idListVariable,documentIdentifiers,scanOnly))

      return;

    // Do the substitution

    ArrayList paramList = new ArrayList();

    StringBuilder sb = new StringBuilder();

    substituteQuery(ts.dataQuery,vm,sb,paramList);

    int i;

    // Build a map of versions we are allowed to ingest

    Map map = new HashMap();

    i = 0;

    while (i < documentIdentifiers.length)

    {

      if (!scanOnly[i])

      {

        // Version strings at this point should never be null; the CF interprets nulls as

        // meaning that delete must occur.  Empty strings are possible though.

        map.put(documentIdentifiers[i],versions[i]);

      }

      i++;

    }

    // Execute the query

    IDynamicResultSet result;

    String queryText = sb.toString();

    long startTime = System.currentTimeMillis();

    // Get a dynamic resultset.  Contract for dynamic resultset is that if

    // one is returned, it MUST be closed, or a connection will leak.

    try

    {

      result = connection.executeUncachedQuery(queryText,paramList,-1);

    }

    catch (ManifoldCFException e)

    {

      // If failure, record the failure.

      activities.recordActivity(new Long(startTime), ACTIVITY_EXTERNAL_QUERY, null,

        createQueryString(queryText,paramList), "ERROR", e.getMessage(), null);

      throw e;

    }

    try

    {

      // If success, record that too.

      activities.recordActivity(new Long(startTime), ACTIVITY_EXTERNAL_QUERY, null,

        createQueryString(queryText,paramList), "OK", null, null);

      while (true)

      {

        IDynamicResultRow row = result.getNextRow();

        if (row == null)

          break;

        try

        {

          Object o = row.getValue(JDBCConstants.idReturnColumnName);

          if (o == null)

            throw new ManifoldCFException("Bad document query; doesn't return $(IDCOLUMN) column.  Try using quotes around $(IDCOLUMN) variable, e.g. \"$(IDCOLUMN)\".");

          String id = JDBCConnection.readAsString(o);

          String version = (String)map.get(id);

          if (version != null)

          {

            // This document was marked as "not scan only", so we expect to find it.

            if (Logging.connectors.isDebugEnabled())

              Logging.connectors.debug("JDBC: Document data result found for '"+id+"'");

            o = row.getValue(JDBCConstants.urlReturnColumnName);

            if (o != null)

            {

              // This is not right - url can apparently be a BinaryInput

              String url = JDBCConnection.readAsString(o);

              boolean validURL;

              try

              {

                // Check to be sure url is valid

                new java.net.URI(url);

                validURL = true;

              }

              catch (java.net.URISyntaxException e)

              {

                validURL = false;

              }

              if (validURL)

              {

                // Process the document itself

                Object contents = row.getValue(JDBCConstants.dataReturnColumnName);

                // Null data is allowed; we just ignore these

                if (contents != null)

                {

                  // We will ingest something, so remove this id from the map in order that we know what we still

                  // need to delete when all done.

                  map.remove(id);

                  String contentType;

                  o = row.getValue(JDBCConstants.contentTypeReturnColumnName);

                  if (o != null)

                    contentType = JDBCConnection.readAsString(o);

                  else

                    contentType = null;

                 

                  if (contentType == null || activities.checkMimeTypeIndexable(contentType))

                  {

                    if (contents instanceof BinaryInput)

                    {

                      // An ingestion will take place for this document.

                      RepositoryDocument rd = new RepositoryDocument();

                      // Default content type is application/octet-stream for binary data

                      if (contentType == null)

                        rd.setMimeType("application/octet-stream");

                      else

                        rd.setMimeType(contentType);

                     

                      applyAccessTokens(rd,version,spec);

                      applyMetadata(rd,row);

                      BinaryInput bi = (BinaryInput)contents;

                      try

                      {

                        // Read the stream

                        InputStream is = bi.getStream();

                        try

                        {

                          rd.setBinary(is,bi.getLength());

                          activities.ingestDocumentWithException(id, version, url, rd);

                        }

                        finally

                        {

                          is.close();

                        }

                      }

                      catch (java.net.SocketTimeoutException e)

                      {

                        throw new ManifoldCFException("Socket timeout reading database data: "+e.getMessage(),e);

                      }

                      catch (InterruptedIOException e)

                      {

                        throw new ManifoldCFException("Interrupted: "+e.getMessage(),e,ManifoldCFException.INTERRUPTED);

                      }

                      catch (IOException e)

                      {

                        throw new ManifoldCFException("Error reading database data: "+e.getMessage(),e);

                      }

                    }

                    else if (contents instanceof CharacterInput)

                    {

                      // An ingestion will take place for this document.

                      RepositoryDocument rd = new RepositoryDocument();

                      // Default content type is application/octet-stream for binary data

                      if (contentType == null)

                        rd.setMimeType("text/plain; charset=utf-8");

                      else

                        rd.setMimeType(contentType);

                     

                      applyAccessTokens(rd,version,spec);

                      applyMetadata(rd,row);

                      CharacterInput ci = (CharacterInput)contents;

                      try

                      {

                        // Read the stream

                        InputStream is = ci.getUtf8Stream();

                        try

                        {

                          rd.setBinary(is,ci.getUtf8StreamLength());

                          activities.ingestDocumentWithException(id, version, url, rd);

                        }

                        finally

                        {

                          is.close();

                        }

                      }

                      catch (java.net.SocketTimeoutException e)

                      {

                        throw new ManifoldCFException("Socket timeout reading database data: "+e.getMessage(),e);

                      }

                      catch (InterruptedIOException e)

                      {

                        throw new ManifoldCFException("Interrupted: "+e.getMessage(),e,ManifoldCFException.INTERRUPTED);

                      }

                      catch (IOException e)

                      {

                        throw new ManifoldCFException("Error reading database data: "+e.getMessage(),e);

                      }

                    }

                    else

                    {

                      // Turn it into a string, and then into a stream

                      String value = contents.toString();

                      try

                      {

                        byte[] bytes = value.getBytes(StandardCharsets.UTF_8);

                        RepositoryDocument rd = new RepositoryDocument();

                        // Default content type is text/plain for character data

                        if (contentType == null)

                          rd.setMimeType("text/plain");

                        else

                          rd.setMimeType(contentType);

                       

                        applyAccessTokens(rd,version,spec);

                        applyMetadata(rd,row);

                        InputStream is = new ByteArrayInputStream(bytes);

                        try

                        {

                          rd.setBinary(is,bytes.length);

                          activities.ingestDocumentWithException(id, version, url, rd);

                        }

                        finally

                        {

                          is.close();

                        }

                      }

                      catch (InterruptedIOException e)

                      {

                        throw new ManifoldCFException("Interrupted: "+e.getMessage(),e,ManifoldCFException.INTERRUPTED);

                      }

                      catch (IOException e)

                      {

                        throw new ManifoldCFException("Error reading database data: "+e.getMessage(),e);

                      }

                    }

                  }

                  else

                    Logging.connectors.warn("JDBC: Document '"+id+"' excluded because of mime type - skipping");

                }

                else

                  Logging.connectors.warn("JDBC: Document '"+id+"' seems to have null data - skipping");

              }

              else

                Logging.connectors.warn("JDBC: Document '"+id+"' has an illegal url: '"+url+"' - skipping");

            }

            else

              Logging.connectors.warn("JDBC: Document '"+id+"' has a null url - skipping");

          }

        }

        finally

        {

          row.close();

        }

      }

      // Now, go through the original id's, and see which ones are still in the map.  These

      // did not appear in the result and are presumed to be gone from the database, and thus must be deleted.

      i = 0;

      while (i < documentIdentifiers.length)

      {

        if (!scanOnly[i])

        {

          String documentIdentifier = documentIdentifiers[i];

          if (map.get(documentIdentifier) != null)

          {

            // This means we did not see it (or data for it) in the result set.  Delete it!

            activities.deleteDocument(documentIdentifier);

          }

        }

        i++;

      }

    }

    finally

    {

      result.close();

    }

  }

 

  // UI support methods.

  //

  // These support methods come in two varieties.  The first bunch is involved in setting up connection configuration information.  The second bunch

  // is involved in presenting and editing document specification information for a job.  The two kinds of methods are accordingly treated differently,

  // in that the first bunch cannot assume that the current connector object is connected, while the second bunch can.  That is why the first bunch

  // receives a thread context argument for all UI methods, while the second bunch does not need one (since it has already been applied via the connect()

  // method, above).

   

  /** Output the configuration header section.

  * This method is called in the head section of the connector's configuration page.  Its purpose is to add the required tabs to the list, and to output any

  * javascript methods that might be needed by the configuration editing HTML.

  *@param threadContext is the local thread context.

  *@param out is the output to which any HTML should be sent.

  *@param parameters are the configuration parameters, as they currently exist, for this connection being configured.

  *@param tabsArray is an array of tab names.  Add to this array any tab names that are specific to the connector.

  */

  @Override

  public void outputConfigurationHeader(IThreadContext threadContext, IHTTPOutput out,

    Locale locale, ConfigParams parameters, List<String> tabsArray)

    throws ManifoldCFException, IOException

  {

    tabsArray.add(Messages.getString(locale,"JDBCConnector.DatabaseType"));

    tabsArray.add(Messages.getString(locale,"JDBCConnector.Server"));

    tabsArray.add(Messages.getString(locale,"JDBCConnector.Credentials"));

    out.print(

    );

  }

 

  /** Output the configuration body section.

  * This method is called in the body section of the connector's configuration page.  Its purpose is to present the required form elements for editing.

  * The coder can presume that the HTML that is output from this configuration will be within appropriate <html>, <body>, and <form> tags.  The name of the

  * form is "editconnection".

  *@param threadContext is the local thread context.

  *@param out is the output to which any HTML should be sent.

  *@param parameters are the configuration parameters, as they currently exist, for this connection being configured.

  *@param tabName is the current tab name.

  */

  @Override

  public void outputConfigurationBody(IThreadContext threadContext, IHTTPOutput out,

    Locale locale, ConfigParams parameters, String tabName)

    throws ManifoldCFException, IOException

  {

    String jdbcProvider = parameters.getParameter(JDBCConstants.providerParameter);

    if (jdbcProvider == null)

      jdbcProvider = "oracle:thin:@";

    String accessMethod = parameters.getParameter(JDBCConstants.methodParameter);

    if (accessMethod == null)

      accessMethod = "name";

    String host = parameters.getParameter(JDBCConstants.hostParameter);

    if (host == null)

      host = "localhost";

    String databaseName = parameters.getParameter(JDBCConstants.databaseNameParameter);

    if (databaseName == null)

      databaseName = "database";

    String rawJDBCString = parameters.getParameter(JDBCConstants.driverStringParameter);

    if (rawJDBCString == null)

      rawJDBCString = "";

    String databaseUser = parameters.getParameter(JDBCConstants.databaseUserName);

    if (databaseUser == null)

      databaseUser = "";

    String databasePassword = parameters.getObfuscatedParameter(JDBCConstants.databasePassword);

    if (databasePassword == null)

      databasePassword = "";

    else

      databasePassword = out.mapPasswordToKey(databasePassword);

    // "Database Type" tab

    if (tabName.equals(Messages.getString(locale,"JDBCConnector.DatabaseType")))

    {

      out.print(

      );

    }

    else

    {

      out.print(

      );

    }

    // "Server" tab

    if (tabName.equals(Messages.getString(locale,"JDBCConnector.Server")))

    {

      out.print(

      );

    }

    else

    {

      out.print(

      );

    }

    // "Credentials" tab

    if (tabName.equals(Messages.getString(locale,"JDBCConnector.Credentials")))

    {

      out.print(

      );

    }

    else

    {

      out.print(

      );

    }

  }

 

  /** Process a configuration post.

  * This method is called at the start of the connector's configuration page, whenever there is a possibility that form data for a connection has been

  * posted.  Its purpose is to gather form information and modify the configuration parameters accordingly.

  * The name of the posted form is "editconnection".

  *@param threadContext is the local thread context.

  *@param variableContext is the set of variables available from the post, including binary file post information.

  *@param parameters are the configuration parameters, as they currently exist, for this connection being configured.

  *@return null if all is well, or a string error message if there is an error that should prevent saving of the connection (and cause a redirection to an error page).

  */

  @Override

  public String processConfigurationPost(IThreadContext threadContext, IPostParameters variableContext,

    Locale locale, ConfigParams parameters)

    throws ManifoldCFException

  {

    String type = variableContext.getParameter("databasetype");

    if (type != null)

      parameters.setParameter(JDBCConstants.providerParameter,type);

    String accessMethod = variableContext.getParameter("accessmethod");

    if (accessMethod != null)

      parameters.setParameter(JDBCConstants.methodParameter,accessMethod);

    String host = variableContext.getParameter("databasehost");

    if (host != null)

      parameters.setParameter(JDBCConstants.hostParameter,host);

    String databaseName = variableContext.getParameter("databasename");

    if (databaseName != null)

      parameters.setParameter(JDBCConstants.databaseNameParameter,databaseName);

    String rawJDBCString = variableContext.getParameter("rawjdbcstring");

    if (rawJDBCString != null)

      parameters.setParameter(JDBCConstants.driverStringParameter,rawJDBCString);

    String userName = variableContext.getParameter("username");

    if (userName != null)

      parameters.setParameter(JDBCConstants.databaseUserName,userName);

    String password = variableContext.getParameter("password");

    if (password != null)

      parameters.setObfuscatedParameter(JDBCConstants.databasePassword,variableContext.mapKeyToPassword(password));

   

    return null;

  }

 

  /** View configuration.

  * This method is called in the body section of the connector's view configuration page.  Its purpose is to present the connection information to the user.

  * The coder can presume that the HTML that is output from this configuration will be within appropriate <html> and <body> tags.

  *@param threadContext is the local thread context.

  *@param out is the output to which any HTML should be sent.

  *@param parameters are the configuration parameters, as they currently exist, for this connection being configured.

  */

  @Override

  public void viewConfiguration(IThreadContext threadContext, IHTTPOutput out,

    Locale locale, ConfigParams parameters)

    throws ManifoldCFException, IOException

  {

    out.print(

    );

    Iterator iter = parameters.listParameters();

    while (iter.hasNext())

    {

      String param = (String)iter.next();

      String value = parameters.getParameter(param);

      if (param.length() >= "password".length() && param.substring(param.length()-"password".length()).equalsIgnoreCase("password"))

      {

        out.print(

        );

      }

      else if (param.length() >="keystore".length() && param.substring(param.length()-"keystore".length()).equalsIgnoreCase("keystore"))

      {

        IKeystoreManager kmanager = KeystoreManagerFactory.make("",value);

        out.print(

        );

      }

      else

      {

        out.print(

        );

      }

    }

    out.print(

    );

  }

 

  /** Output the specification header section.

  * This method is called in the head section of a job page which has selected a repository connection of the current type.  Its purpose is to add the required tabs

  * to the list, and to output any javascript methods that might be needed by the job editing HTML.

  *@param out is the output to which any HTML should be sent.

  *@param ds is the current document specification for this job.

  *@param tabsArray is an array of tab names.  Add to this array any tab names that are specific to the connector.

  */

  @Override

  public void outputSpecificationHeader(IHTTPOutput out, Locale locale, DocumentSpecification ds, List<String> tabsArray)

    throws ManifoldCFException, IOException

  {

    tabsArray.add(Messages.getString(locale,"JDBCConnector.Queries"));

    tabsArray.add(Messages.getString(locale,"JDBCConnector.Security"));

    out.print(

    );

  }

 

  /** Output the specification body section.

  * This method is called in the body section of a job page which has selected a repository connection of the current type.  Its purpose is to present the required form elements for editing.

  * The coder can presume that the HTML that is output from this configuration will be within appropriate <html>, <body>, and <form> tags.  The name of the

  * form is "editjob".

  *@param out is the output to which any HTML should be sent.

  *@param ds is the current document specification for this job.

  *@param tabName is the current tab name.

  */

  @Override

  public void outputSpecificationBody(IHTTPOutput out, Locale locale, DocumentSpecification ds, String tabName)

    throws ManifoldCFException, IOException

  {

    String idQuery = "SELECT idfield AS $(IDCOLUMN) FROM documenttable WHERE modifydatefield > $(STARTTIME) AND modifydatefield <= $(ENDTIME)";

    String versionQuery = "SELECT idfield AS $(IDCOLUMN), versionfield AS $(VERSIONCOLUMN) FROM documenttable WHERE idfield IN $(IDLIST)";

    String dataQuery = "SELECT idfield AS $(IDCOLUMN), urlfield AS $(URLCOLUMN), datafield AS $(DATACOLUMN) FROM documenttable WHERE idfield IN $(IDLIST)";

    int i = 0;

    while (i < ds.getChildCount())

    {

      SpecificationNode sn = ds.getChild(i++);

      if (sn.getType().equals(JDBCConstants.idQueryNode))

      {

        idQuery = sn.getValue();

        if (idQuery == null)

          idQuery = "";

      }

      else if (sn.getType().equals(JDBCConstants.versionQueryNode))

      {

        versionQuery = sn.getValue();

        if (versionQuery == null)

          versionQuery = "";

      }

      else if (sn.getType().equals(JDBCConstants.dataQueryNode))

      {

        dataQuery = sn.getValue();

        if (dataQuery == null)

          dataQuery = "";

      }

    }

    // The Queries tab

    if (tabName.equals(Messages.getString(locale,"JDBCConnector.Queries")))

    {

      out.print(