Metacat

/**

 *  '$RCSfile$'

 *  Copyright: 2000 Regents of the University of California and the

 *              National Center for Ecological Analysis and Synthesis

 *    Authors: @tao@

 *    Release: @release@

 *

 *   '$Author: tao $'

 *     '$Date: 2002-11-05 10:00:53 -0800 (Tue, 05 Nov 2002) $'

 * '$Revision: 1326 $'

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 */

package edu.ucsb.nceas.metacat;

import edu.ucsb.nceas.morpho.datapackage.PackageUtil;

import edu.ucsb.nceas.morpho.datapackage.Triple;

import edu.ucsb.nceas.morpho.datapackage.TripleCollection;

import java.io.FileOutputStream;

import java.io.PrintWriter;

import java .io.StringReader;

import java.sql.ResultSet;

import java.sql.PreparedStatement;

import java.sql.SQLException;

import java.util.Vector;

import org.apache.xerces.parsers.DOMParser;

import org.apache.xpath.XPathAPI;

import org.w3c.dom.Attr;

import org.w3c.dom.NamedNodeMap;

import org.w3c.dom.NodeList;

import org.w3c.dom.Document;

import org.w3c.dom.Node;

import org.w3c.dom.NodeList;

import org.w3c.dom.DocumentType;

import org.xml.sax.InputSource;

/**

 * This class is used to clean up access table in knb. It will delete any access

 * control rules which are not in access xml doc (someone add them into table

 * directly). It will update data set doc according new triples in access table.

 */

public class CleanupAccessTable

{

  /**

   * A method to add a new triple to a data set doc and update data set doc

   * in metacat db

   *

   * @param accessionNumber  the accession number of the data set doc

   * @param newTripleVector  the vector containing new triples need to be added 

   *                      into the data set doc

   */

  private static final String TRIPLESTAG = "//triple";

  private static final String IDENTIFIER = "//identifier";

  private static final String RELATIONSHIP = "provides access control rules for";

  public  static final String DELIMITER = "!";

  private static final String DOT = ".";

  private static final String LOGFILENAME = "log";

  public static void addNewTripleIntoDataset(String accessionNumber, 

                                             Vector newTripleVector)

  {

    String docidWithoutVersion = null;

    int rev = 0;

    // check parameter

    if (newTripleVector.size()==0 || accessionNumber == null || 

        accessionNumber.equals(""))

    {

      return;

    }

    DocumentImpl doc = null;

    try

    {

      docidWithoutVersion = MetaCatUtil.getDocIdFromString(accessionNumber); 

      rev = MetaCatUtil.getVersionFromString(accessionNumber);

      doc = new DocumentImpl(accessionNumber);

    }

    catch (Exception e)

    {

      MetaCatUtil.debugMessage("error in create an document: "

                              + e.getMessage(), 30);

      return;

    }

    String xmlDoc = doc.toString();

    //System.out.println("orginal xml file: "+xmlDoc);

    // create new triple collection

    TripleCollection newTripleForDataSet = new TripleCollection();

    for (int i = 0; i<newTripleVector.size(); i++)

    {

      //Add new tripe

      Triple triple = (Triple)newTripleVector.elementAt(i);

      System.out.println("New triple: "+triple.toString());

      newTripleForDataSet.addTriple(triple);

    }

    xmlDoc = addTriplesToTriplesString(newTripleForDataSet, xmlDoc, TRIPLESTAG);

    // Update accessNumber

    Vector oldAccessNumberVector = new Vector();

    Vector newAccessNumberVector = new Vector();

    oldAccessNumberVector.addElement(accessionNumber);

    //increase rev number

    rev++;

    accessionNumber = docidWithoutVersion + "." + rev;

    newAccessNumberVector.addElement(accessionNumber);

    xmlDoc = incRevInTriples(xmlDoc, oldAccessNumberVector, 

                             newAccessNumberVector, TRIPLESTAG);

    // update database

    StringReader xml = new StringReader(xmlDoc);

    String pub = "no";

    StringReader dtd = null;

    String doAction = "UPDATE";

    boolean validate = true;

    DBConnection dbConn = null;

    int serialNumber = -1;

    try

    {

      dbConn=DBConnectionPool.

                  getDBConnection("DBQuery.getDataPackageId");

      serialNumber=dbConn.getCheckOutSerialNumber();

      DocumentImpl.write(dbConn, xml, pub, dtd, doAction,

                       accessionNumber, null, null, validate);

      System.out.println("update data set file: "+ accessionNumber);

      writeToLogFile("Update data set file: " + accessionNumber);

      writeToLogFile("New triples added are: "+ newTripleVector.toString());

    }

    catch (Exception e)

    {

      System.out.println("error in addNewTripleIntoDataset: "+e.getMessage());

    }

    finally

    {

      DBConnectionPool.returnDBConnection(dbConn, serialNumber);

    }

  }

    /**

   * method to add a collection of triples to a triples string.  this method

   * searches for any triples already in the string and appends the new

   * ones after the existing ones.  

   * @param triples the collection of triples to add

   * @param dataPackageString the xml document of data set

   * @param triplesTag the trip tag in xml docment

   */

  private static String addTriplesToTriplesString(TripleCollection triples,

                                               String dataPackageString, 

                                               String triplesTag)

  {

    //String triplesTag = morpho.getConfiguration().get("triplesTag", 0);

    Document doc = null;

    DOMParser parser = new DOMParser();

    InputSource in;

    StringReader sr;

    try

    { //parse the wizard created file with existing triples

      sr = new StringReader(dataPackageString);

      in = new InputSource(sr);

    }

    catch(Exception fnf)

    {

      fnf.printStackTrace();

      return null;

    }

    try

    {

      parser.parse(in);

      sr.close();

    }

    catch(Exception e1)

    {

      System.err.println(e1.toString());

    }

    doc = parser.getDocument();

    //get the DOM rep of the document with existing triples

    NodeList tripleNodeList = triples.getNodeList();

    NodeList docTriplesNodeList = null;

    try

    {

      //find where the triples go in the file

      docTriplesNodeList = XPathAPI.selectNodeList(doc, triplesTag);

    }

    catch(Exception se)

    {

      System.err.println(se.toString());

    }

    Node docNode = doc.getDocumentElement();

    for(int j=0; j<tripleNodeList.getLength(); j++)

    { //add the triples to the appropriate position in the file

      Node n = doc.importNode(tripleNodeList.item(j), true);

      int end = docTriplesNodeList.getLength() - 1;

      Node triplesNode = docTriplesNodeList.item(end);

      Node parent = triplesNode.getParentNode();

      if(triplesNode.getNextSibling() == null)

      {

        parent.appendChild(n);

      }

      else

      {

        parent.insertBefore(n, triplesNode.getNextSibling());

      }

    }

    String docString = PackageUtil.printDoctype(doc);

    docString += PackageUtil.print(doc.getDocumentElement());

    return docString;

  }

  private static String incRevInTriples(String xml, Vector oldid, 

                                        Vector newid, String triplePath)

  {

    System.out.println("oldid: " + oldid.toString() + " newid: " + newid.toString());

    Document doc = null;

    DOMParser parser = new DOMParser();

    InputSource in;

    StringReader sr;

     try

    { //parse the wizard created file with existing triples

      sr = new StringReader(xml);

      in = new InputSource(sr);

    }

    catch(Exception fnf)

    {

      fnf.printStackTrace();

      return null;

    }

    try

    {

      parser.parse(in);

      sr.close();

    }

    catch(Exception e1)

    {

      System.err.println(e1.toString());

    }

    doc = parser.getDocument();

    NodeList tripleList = null;

    try

    {

      //find where the triples go in the file

      tripleList = XPathAPI.selectNodeList(doc, triplePath);

    }

    catch(Exception se)

    {

      System.err.println("incRevInTriples() : parse threw: " + 

                         se.toString());

    }

    for(int i=0; i<tripleList.getLength(); i++)

    {

      Node triple = tripleList.item(i);

      NodeList children = triple.getChildNodes();

      String sub = null;

      String rel = null;

      String obj = null;

      if(children.getLength() > 2)

      {

        for(int j=0; j<children.getLength(); j++)

        {

          Node childNode = children.item(j);

          String nodename = childNode.getNodeName().trim().toUpperCase();

          if(nodename.equals("SUBJECT") || nodename.equals("OBJECT"))

          {

            String nodeval;

            try

            {

              nodeval = childNode.getFirstChild().getNodeValue().trim();

            }

            catch(NullPointerException npe)

            {

              continue;

            }

            if(oldid.contains(nodeval.trim()))

            {

              String newidS = "";

              for(int k=0; k<newid.size(); k++)

              {

                newidS = (String)newid.elementAt(k);

                if(nodeval.trim().equals(oldid.elementAt(k)))

                {

                  break;

                }

              }

              System.out.println("replacing: " + nodeval + " with " + newidS);

              childNode.getFirstChild().setNodeValue(newidS);

            }

          }

        }

      }

    }

    //increase the identifier

    NodeList identiferList = null; 

    try

    {

      //find where the triples go in the file

      identiferList = XPathAPI.selectNodeList(doc, IDENTIFIER);

    }

    catch(Exception se)

    {

      System.err.println("incRevInTriples() : parse threw: " + 

                         se.toString());

    }

    for(int i=0; i<identiferList.getLength(); i++)

    {

      Node identifierNode = identiferList.item(i);

      String nodeName = identifierNode.getNodeName().trim().toUpperCase();

      if (nodeName.equals("IDENTIFIER"))

      {

        String nodeValue = null;

        try

        {

           nodeValue = identifierNode.getFirstChild().getNodeValue().trim();

        }

        catch(NullPointerException npe)

        {

          continue;

        }

        if(oldid.contains(nodeValue.trim()))

        {

           String newidS = "";

            for(int k=0; k<newid.size(); k++)

            {

               newidS = (String)newid.elementAt(k);

               if(nodeValue.trim().equals(oldid.elementAt(k)))

               {

                  break;

               }

            }

            System.out.println("replacing: " + nodeValue + " with " + newidS);

            identifierNode.getFirstChild().setNodeValue(newidS);

         }

      }

    }

    return PackageUtil.printDoctype(doc) + 

           PackageUtil.print(doc.getDocumentElement());

  }

  /*

   *Give a docid to find a package accesssionNumber for it.

   */

   private static String getDataPackageAccessionNumber(String docId)

  {

    String accessNumber = null;

    String packageIdWithoutVersion = null;

    String rev = null;

    PreparedStatement pStmt = null;

    ResultSet rs=null;

    String query="SELECT docId from xml_relation where subject = ?";

    DBConnection dbConn = null;

    int serialNumber = -1;

    try

    {

      dbConn=DBConnectionPool.

                  getDBConnection("DBQuery.getDataPackageId");

      serialNumber=dbConn.getCheckOutSerialNumber();

      pStmt=dbConn.prepareStatement(query);

      //bind the value to query

      pStmt.setString(1, docId);

      //execute the query

      pStmt.execute();

      rs=pStmt.getResultSet();

      //process the result

      if (rs.next()) //There are some records for the id in docId fields

      {

        packageIdWithoutVersion=rs.getString(1);//get data package id

      }

      pStmt.close();

      rev = getRevNumber(packageIdWithoutVersion);

      accessNumber = packageIdWithoutVersion+"."+rev;

      MetaCatUtil.debugMessage("DataPackageId: "+accessNumber, 50);

    }//try

    catch (SQLException e)

    {

      MetaCatUtil.debugMessage("Error in isDataPackageId: "

                            +e.getMessage(), 30);

    }

    finally

    {

      try

      {

        pStmt.close();

      }//try

      catch (SQLException ee)

      {

        MetaCatUtil.debugMessage("Error in isDataPackageId: "

                                                        + ee.getMessage(), 30);

      }//catch

      finally

      {

        DBConnectionPool.returnDBConnection(dbConn, serialNumber);

      }//finally

    }//finally

    return accessNumber;

  }//isDataPackageId()

  /**

   * Get a dev number from a given docid(without dev)

   */

  public static String getRevNumber(String docId) 

  {

    DBConnection dbConn = null;

    int serialNumber = -1;

    String query = "SELECT rev from xml_documents where docid = ?";

    PreparedStatement pStmt = null;

    ResultSet rs = null;

    String rev = null;

    try

    {

      dbConn=DBConnectionPool.

                  getDBConnection("DBQuery.getDataPackageId");

      serialNumber=dbConn.getCheckOutSerialNumber();

      pStmt=dbConn.prepareStatement(query);

      //bind the value to query

      pStmt.setString(1, docId);

      //execute the query

      pStmt.execute();

      rs=pStmt.getResultSet();

      //process the result

      if (rs.next()) //There are some records for the id in docId fields

      {

        rev=rs.getString(1);//get data package id

      }

      pStmt.close();

    }

    catch (SQLException e)

    {

      System.out.println("the error in getRevNumber: "+e.getMessage());

    }

    finally

    {

      try

      {

        pStmt.close();

      }

      catch (SQLException ee)

      {

        System.out.println("the error in getRevNumber2: "+ee.getMessage());

      }

      finally

      {

        DBConnectionPool.returnDBConnection(dbConn, serialNumber);

        return rev;

      }

    }

  }

  /**

   * Delete a access control rule which is not in access xml document 

   */

  public static void deleteAccessRule(String aclDocid, String accessRule)

  {

    String principal  = null;

    String allowType  = null;

    String permission = null;

    String allowOrder = null;

    String [] parseAccessRuleArray = null;

     DBConnection dbConn = null;

    int serialNumber = -1;

    String query = "delete from xml_access where accessfileid = ? " +

                   "and principal_name = ? and perm_type = ? "+

                   "and permission = ? and perm_order = ?";

    PreparedStatement pStmt = null;

    String rev = null;

    // parse the access rule 

    parseAccessRuleArray = parseAccessRule(accessRule);

    if ( parseAccessRuleArray == null)

    {

      System.out.println("couldn't parse docid: "+aclDocid);

      return;

    }

    else

    {

      principal  = parseAccessRuleArray[0];

      allowType  = parseAccessRuleArray[1];

      permission = parseAccessRuleArray[2];

      allowOrder = parseAccessRuleArray[3];

    }

    try

    {

      dbConn=DBConnectionPool.

                  getDBConnection("DBQuery.getDataPackageId");

      serialNumber=dbConn.getCheckOutSerialNumber();

      pStmt=dbConn.prepareStatement(query);

      //bind the value to query

      pStmt.setString(1, aclDocid);

      pStmt.setString(2, principal);

      pStmt.setString(3, allowType);

      pStmt.setInt(4, (new Integer(permission)).intValue());

      pStmt.setString(5, allowOrder);

      //execute the query

      pStmt.execute();

      pStmt.close();

      System.out.println("delete rules: "+accessRule+" for "

                          +aclDocid+" in table");

      writeToLogFile("Delete rules: "+accessRule+" for "

                     +aclDocid+" in xml_access table");

    }

    catch (SQLException e)

    {

      System.out.println("the error in deleteAccessRule(): "+e.getMessage());

    }

    finally

    {

      try

      {

        pStmt.close();

      }

      catch (SQLException ee)

      {

        System.out.println("the error in getRevNumber2: "+ee.getMessage());

      }

      finally

      {

        DBConnectionPool.returnDBConnection(dbConn, serialNumber);

      }

    }

  }

  /*

   * parse the string and get a array cotains principle name(index 0),

   * allow type (index1), permission (index2), and allow order(index, 4)

   */

  private static String[] parseAccessRule(String accessRule)

  {

    String principal  = null;

    String allowType  = null;

    String permission = null;

    String allowOrder = null;

    String [] result  = new String[4];

    int count = 0;

    int index = 0;

    char delimiter = DELIMITER.charAt(0);

    if (accessRule== null)

    {

      return result;

    }

    for (int i=0; i<accessRule.length(); i++)

    {

      char charInString = accessRule.charAt(i);

      // find a symbol !

      if (charInString == delimiter)

      {

        count ++;

      }

      else

      {

        continue;

      }

      switch (count)

      {

        case 1:

        {

          // get principal

          principal = accessRule.substring(0, i);

          // remeber the index

          index = i;

          break;

        }

        case 2:

        {

          allowType = accessRule.substring(index+1, i);

          index = i;

          break;

        }

        case 3:

        {

          permission = accessRule.substring(index+1, i);

          index = i;

          allowOrder = accessRule.substring(index+1, accessRule.length());

          break;

        }

      }//switch

    }//for

    // if the string exactly has 3 !, add it to array

    if ( count == 3)

    {

      result[0] = principal;

      result[1] = allowType;

      result[2] = permission;

      result[3] = allowOrder;

    }//if

    return result;

  }

  /**

   * A method get acl docid list from xml_access table

   */

  public static Vector readAccessDocIdFromDB()

  {

    Vector docidList = new Vector();

    String docid = null;

    DBConnection conn = null;

    int serialNumber = -1;

    PreparedStatement pstmt = null;

    try

    {

      //get connection from DBConnectionPool

      conn = DBConnectionPool.

              getDBConnection("CleanupAccessTable.readAccessDocIdFromDB");

      serialNumber=conn.getCheckOutSerialNumber();

      // delete all acl records for resources related to @aclid if any

      pstmt = conn.prepareStatement("SELECT accessfileid FROM xml_access");

      pstmt.execute();

      ResultSet rs = pstmt.getResultSet();

      boolean hasRows = rs.next();

      int i = 0;

      while (hasRows) 

      {

        docid  = rs.getString(1);

        // if hashtable doesn't has the rule add to hashtable

        if (docid !=null && !docidList.contains(docid))

        {

          docidList.addElement(docid);

        }

        hasRows = rs.next();

        // reset value

        docid = null;

      }//while

    }

    catch (SQLException e)

    {

      System.out.println("error in readAccessDocIdFromDB: "+e.getMessage());

    }

    finally

    {

      try

      {

        pstmt.close();

      }

      catch (SQLException ee)

      {

        System.out.println("error in readAccessDocIdFromDB: "+ee.getMessage());

      }

      finally

      {

        //retrun DBConnection

        DBConnectionPool.returnDBConnection(conn,serialNumber);

        return docidList;

      }

    }

  }

  /**

   * Method to delete rules which is not in xml access file

   */

  public static void deleteRules(Vector aclDocList) 

  {

    String aclDocId = null;

    //checking for every acl id

    for (int i= 0; i<aclDocList.size(); i++)

    {

      try

      {

        aclDocId = (String)aclDocList.elementAt(i);

        AccessRulesFromDocument xmlDocument = new 

                                            AccessRulesFromDocument(aclDocId);

        Vector rules = xmlDocument.getAccessRuleVector();

        AccessRulesFromDB db = new AccessRulesFromDB(aclDocId);

        Vector rulesFromDB = db.getAccessRuleVector();

        //check for every rules

        for (int j=0; j< rulesFromDB.size(); j++)

        {

          String oneRule = (String)rulesFromDB.elementAt(j);

          // if onerules get from db not in xml_access, delete it

          if (!rules.contains(oneRule))

          {

            System.out.println("one rule: "+oneRule);

            deleteAccessRule(aclDocId, oneRule);

          }//if

          oneRule = null;

        }//for

        aclDocId = null;

      }

      catch (Exception e)

      {

        System.out.println("error delete rules: "+e.getMessage());

      } 

    }//for

  }

  /**

   * Method to updata data set files

   */

  public static void updateDataSetFiles(Vector aclDocList) 

  {

    String aclDocId = null;

    String aclAccessionNumber = null;

    String revForAcl = null;

    String packagAccessionNumber = null;

    //checking for every acl id

    for (int i= 0; i<aclDocList.size(); i++)

    {

      try

      {

        aclDocId = (String)aclDocList.elementAt(i);

        packagAccessionNumber = getDataPackageAccessionNumber(aclDocId);

        AccessRulesFromDocument xmlDocument = new 

                                            AccessRulesFromDocument(aclDocId);

        Vector docid = xmlDocument.getACLObjects();

        AccessRulesFromDB db = new AccessRulesFromDB(aclDocId);

        Vector docidFromDB = db.getDocidAccessRuleApplied();

        revForAcl = getRevNumber(aclDocId);

        aclAccessionNumber = aclDocId+DOT+revForAcl;

        //check for every docid in relation ship

        Vector newTripleVector = new Vector();

        for (int j=0; j<docidFromDB.size(); j++)

        {

          String objectId = (String)docidFromDB.elementAt(j);

          String objectAccessionNumber = null;

          String revForObject = null;

          // new triple

          if (!docid.contains(objectId))

          {

            revForObject = getRevNumber(objectId);

            objectAccessionNumber = objectId+DOT+revForObject;

            Triple newTriple = new Triple(aclAccessionNumber, RELATIONSHIP, 

                                        objectAccessionNumber);

            newTripleVector.add(newTriple);

            System.out.println("find a new triple");

          }//if

        }//for

        // add new trip into data set

        addNewTripleIntoDataset(packagAccessionNumber, newTripleVector);

        // reset value

        aclDocId = null;

        aclAccessionNumber = null;

        revForAcl = null;

        packagAccessionNumber = null;

      }

      catch (Exception e)

      {

        System.out.println("error in updataDatasetFiles(): "+e.getMessage());

      }

    }//for

  }

  /*

   * Method to write information into log file

   */

  private static void writeToLogFile(String message)

  {

    try

    {

      FileOutputStream fos = new FileOutputStream(LOGFILENAME, true);

      PrintWriter pw = new PrintWriter(fos);

      pw.println(message);

      pw.flush();

    }

    catch(Exception e)

    {

      System.out.println("error writing to log: " + e.getMessage());

    }

  }

  public static void main(String[] agus)

  {

    try

    {

      DBConnectionPool pool = DBConnectionPool.getInstance();

      Vector aclVector = readAccessDocIdFromDB();

      deleteRules(aclVector);

      Vector aclVector2 = readAccessDocIdFromDB();

      updateDataSetFiles(aclVector2);

    }

    catch(Exception e)

    {

      System.out.println("exception is: "+e.getMessage());

    }

  }

}//cleanupAccessTable