Metacat

import java.io.IOException;

   // Indicator of inline data

   private boolean handleInlineData = false;

   private Stack   inlineDataNodeStack = null;

   private Hashtable inlineDataNameSpace = null;

   private FileWriter inlineDataFileWriter = null;

   private String inlineDataFileName = null;

   private int inLineDataIndex = 0;

    // for element <eml:eml...> qname is "eml:eml", local name is "eml"            

    // for element <acl....> both qname and local name is "eml"

    // uri is namesapce

    MetaCatUtil.debugMessage("Start ELEMENT(qName) " + qName, 50);

    MetaCatUtil.debugMessage("Start ELEMENT(localName) " + localName, 50);

    MetaCatUtil.debugMessage("Start ELEMENT(uri) " + uri, 50);

    DBSAXNode parentNode = null;

    DBSAXNode currentNode = null;

   if (!handleInlineData)

   {

     //start handle inline data

     if (localName.equals(INLINE))

     {

       handleInlineData = true;

       inLineDataIndex ++;

       //intitialize namespace hash for in line data

       inlineDataNameSpace = new Hashtable();

       //initialize file writer

       String docidWithoutRev = MetaCatUtil.getDocIdFromString(docid);

       String seperator = MetaCatUtil.getOption("accNumSeparator");

       // the new file name will look like docid.rev.2

       inlineDataFileName = docidWithoutRev + seperator+revision+seperator +

                         inLineDataIndex;

       inlineDataFileWriter = createInlineDataFileWriter(inlineDataFileName);

     }

        endNodeId = writeTextForDBSAXNode(endNodeId, textBuffer, parentNode);

   }//not inline data

   else

   {

       // we don't buffer the inline data in characters() method

       // so start character don't need to hand text node.

       // inline data may be the xml format.

       StringBuffer inlineElements = new StringBuffer();

       inlineElements.append("<").append(qName);

       // append attributes

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

       {

         String attributeName = atts.getQName(i);

         String attributeValue = atts.getValue(i);

         inlineElements.append(" ");

         inlineElements.append(attributeName);

         inlineElements.append("=\"");

         inlineElements.append(attributeValue);

         inlineElements.append("\"");

       }

       // append namespace

       String prefix =null;

       String nsuri = null;

       Enumeration prefixes = inlineDataNameSpace.keys();

       while ( prefixes.hasMoreElements() ) 

       {

         prefix = (String)prefixes.nextElement();

         nsuri = (String)namespaces.get(prefix);

         inlineElements.append(" ");

         inlineElements.append("xmlns:");

         inlineElements.append(prefix);

         inlineElements.append("=\"");

         inlineElements.append(nsuri);

         inlineElements.append("\"");

       }

       inlineElements.append(">");

       //reset inline data name space

       inlineDataNameSpace = null;

       inlineDataNameSpace = new Hashtable();

       //write inline data into file

       MetaCatUtil.debugMessage("the inline element data is: "+ 

                                 inlineElements.toString(), 50);

       writeInlineDataIntoFile(inlineDataFileWriter, inlineElements);

   }//else

  /** SAX Handler that is called for each XML text node */

  public void characters(char[] cbuf, int start, int len) throws SAXException 

  {

     MetaCatUtil.debugMessage("CHARACTERS", 50);

     if (!handleInlineData)

     {

        // buffer all text nodes for same element. This is for text was splited

        // into different nodes

        textBuffer.append(new String(cbuf, start,len));

        // set hittextnode true

        hitTextNode = true;

        // if text buffer .size is greater than max, write it to db. 

        // so we can save memory

        if (textBuffer.length() > MAXDATACHARS)

        {

          MetaCatUtil.debugMessage("Write text into DB in charaters" + 

                   " when text buffer size is greater than maxmum number", 50);

          DBSAXNode currentNode = (DBSAXNode)nodeStack.peek();

          endNodeId = writeTextForDBSAXNode(endNodeId, textBuffer, currentNode);

          textBuffer = null;

          textBuffer = new StringBuffer();

        }

     }

     else

     {

       // this is inline data and write file system directly

       // we don't need to buffered it.

       StringBuffer inlineText = new StringBuffer();

       inlineText.append(new String(cbuf, start,len));

       MetaCatUtil.debugMessage("The inline text data write into file system: "

                                 + inlineText.toString(), 50);

       writeInlineDataIntoFile(inlineDataFileWriter, inlineText);

     }

  }

    MetaCatUtil.debugMessage("End ELEMENT " + qName, 50);

     if (localName.equals(INLINE) && handleInlineData)

     {

          // Get the node from the stack

          DBSAXNode currentNode = (DBSAXNode)nodeStack.pop();

          String currentTag = currentNode.getTagName();

          MetaCatUtil.debugMessage("End of inline data", 35);

          // close file writer

          try

          {

           inlineDataFileWriter.close();

           handleInlineData = false;

          }

          catch (IOException ioe)

          {

            throw new SAXException(ioe.getMessage());

          }

          //check if user changed inine data or not if user doesn't have

          // write permission

          if (startCriticalSubTree)

          {

            NodeRecord node = null;

            String inlineData;

            try

            {

              node = (NodeRecord)currentUnChangedableSubtreeNodeStack.pop();

              // get file name from db

              String fileName = node.getNodeData();

              MetaCatUtil.debugMessage("in handle inline data", 35);

              MetaCatUtil.debugMessage("the inline data file name from node is: "+

                                      fileName, 40);

              if (!compareInlineDataFiles(fileName, inlineDataFileName))

              {

                MetaCatUtil.debugMessage("inline data was changed by a user" +

                                       " who doesn't have permission", 30);

                throw new SAXException(PERMISSIONERROR);

              }

            }

            catch (EmptyStackException ee)

            {

              MetaCatUtil.debugMessage("the stack is empty for text data", 32);

              throw new SAXException(PERMISSIONERROR);

            }

            catch (McdbException eee)

            {

              throw new SAXException(eee.getMessage());

            }

            finally

            {

              // delete the inline data file already in file system

              deleteInlineDataFile(inlineDataFileName);

            }

          }//if

          // write put inline data file name into text buffer (without path)

          textBuffer = new StringBuffer(inlineDataFileName);

          // write file name into db

          endNodeId = writeTextForDBSAXNode(endNodeId, textBuffer, currentNode);

          return;

    }

    if (!handleInlineData)

    {

       //if (!localName.equals(INLINE))

          endNodeId = writeTextForDBSAXNode(endNodeId, textBuffer, currentNode);

    }

    else

    {

      // this is in inline part

      StringBuffer endElement = new StringBuffer();

      endElement.append("</");

      endElement.append(qName);

      endElement.append(">");

      MetaCatUtil.debugMessage("inline endElement: " +

                                endElement.toString(), 50);

      writeInlineDataIntoFile(inlineDataFileWriter, endElement);

    }

  }

   public void comment(char[] ch, int start, int length) throws SAXException 

   {

     if ( !handleInlineData)

       if ( !processingDTD ) 

       {

         DBSAXNode currentNode = (DBSAXNode)nodeStack.peek();

         String str = new String(ch, start, length);

         //compare comment if need

         if (startCriticalSubTree)

         {

           compareCommentNode(currentUnChangedableSubtreeNodeStack, str, 

         }//if

         //compare top level access module

         if (processTopLeverAccess && needCheckingAccessModule)

         {

           compareCommentNode(currentUnchangableAccessModuleNodeStack, str,

         }

         endNodeId = currentNode.writeChildNodeToDB("COMMENT", null, str, docid);

         if (needCheckingAccessModule && 

         (processAdditionalAccess || processOtherAccess || processTopLeverAccess))

         {

          // stored the pull out nodes into storedNode stack

          NodeRecord nodeElement = new NodeRecord(-2, -2, -2, "COMMENT", 

          storedAccessNodeStack.push(nodeElement);

        }

       }

     else

     {

       // inline data comment

       StringBuffer inlineComment = new StringBuffer();

       inlineComment.append("<!--");

       inlineComment.append(new String(ch, start, length));

       inlineComment.append("-->");

       MetaCatUtil.debugMessage("inline data comment: "+ 

                                 inlineComment.toString(), 50);

       writeInlineDataIntoFile(inlineDataFileWriter, inlineComment);

     }

   /**

    * SAX Handler called once for each processing instruction found:

    * node that PI may occur before or after the root element.

    */

   public void processingInstruction(String target, String data)

          throws SAXException 

  {

     MetaCatUtil.debugMessage("PI", 50);

     if (!handleInlineData)

     {

       DBSAXNode currentNode = (DBSAXNode)nodeStack.peek();

       endNodeId = currentNode.writeChildNodeToDB("PI", target, data, docid);

     }

     else

     {

       StringBuffer inlinePI = new StringBuffer();

       inlinePI.append("<?");

       inlinePI.append(target);

       inlinePI.append(" ");

       inlinePI.append(data);

       inlinePI.append("?>");

       MetaCatUtil.debugMessage("inline data pi is: " + 

                                 inlinePI.toString(), 50);

       writeInlineDataIntoFile(inlineDataFileWriter, inlinePI);

     }

   }

  /** SAX Handler that is called at the start of Namespace */

   public void startPrefixMapping(String prefix, String uri)

                                          throws SAXException

   {

    MetaCatUtil.debugMessage("NAMESPACE", 50);

    if (!handleInlineData)

    {

      namespaces.put(prefix, uri);

    }

    else

    {

      inlineDataNameSpace.put(prefix, uri);

    }

   }

     if (!handleInlineData)

     {

       DBSAXNode currentNode = (DBSAXNode)nodeStack.peek();

       String data = null;

       int leftover = len;

       int offset = start;

       boolean moredata = true;

       // This loop deals with the case where there are more characters

       // than can fit in a single database text field (limit is

       // MAXDATACHARS).  If the text to be inserted exceeds MAXDATACHARS,

       // write a series of nodes that are MAXDATACHARS long, and then the

       // final node contains the remainder

       while (moredata) 

         if (leftover > MAXDATACHARS) 

         {

           data = new String(cbuf, offset, MAXDATACHARS);

           leftover -= MAXDATACHARS;

           offset += MAXDATACHARS;

         } 

         else 

         {

           data = new String(cbuf, offset, leftover);

           moredata = false;

         }

         //compare whitespace if need

         if (startCriticalSubTree)

         {

           compareWhiteSpace(currentUnChangedableSubtreeNodeStack, data, 

         }//if

         //compare whitespace in access top module

         if (processTopLeverAccess && needCheckingAccessModule)

         {

           compareWhiteSpace(currentUnchangableAccessModuleNodeStack, data, 

         }

         // Write the content of the node to the database

         if (needCheckingAccessModule && 

         (processAdditionalAccess || processOtherAccess || processTopLeverAccess))

         {

          // stored the pull out nodes into storedNode stack

          NodeRecord nodeElement = new NodeRecord(-2, -2, -2, "TEXT", 

          storedAccessNodeStack.push(nodeElement);

         }

         endNodeId = currentNode.writeChildNodeToDB("TEXT", null, data, docid);

     else

     {

       //This is inline data write to file directly

       StringBuffer inlineWhiteSpace = new 

                                     StringBuffer(new String(cbuf, start, len));

       writeInlineDataIntoFile(inlineDataFileWriter, inlineWhiteSpace);

     }

  // open a file writer for writing inline data to file

  private FileWriter createInlineDataFileWriter(String fileName) 

    FileWriter writer = null;

    File newFile = new File(inlineDataDirectory, fileName);

      // true means append

      writer = new FileWriter(newFile, true);

    }

    catch (IOException ioe)

    {

      throw new SAXException(ioe.getMessage());

    }

    return writer;

  }

  // write inline data into file system and return file name(without path)

  private void writeInlineDataIntoFile(FileWriter writer, 

                                               StringBuffer data) 

                                               throws SAXException

  {

    try

    {

      writer.flush();

  }

  /* In eml2, the inline data wouldn't store in db, it store in file system

   * The db stores file name(without path). We got the old file name from db

   * and compare to the new in line data file

   */

  public boolean compareInlineDataFiles(String oldFileName, String newFileName)

                                                throws McdbException

  {

    // this method need to be testing

    boolean same = true;

    String data = null;

    String path = MetaCatUtil.getOption("inlinedatafilepath");

    // the new file name will look like path/docid.rev.2

    File inlineDataDirectory = new File(path);

    File oldDataFile = new File(inlineDataDirectory, oldFileName);

    File newDataFile = new File(inlineDataDirectory, newFileName);

    try

    {

      FileReader oldFileReader = new FileReader(oldDataFile);

      BufferedReader oldStringReader = new BufferedReader(oldFileReader);

      FileReader newFileReader = new FileReader(newDataFile);

      BufferedReader newStringReader = new BufferedReader(newFileReader);

      // read first line of data

      String oldString = oldStringReader.readLine();

      String newString = newStringReader.readLine();

      // at the end oldstring will be null

      while (oldString != null)

      {

        oldString = oldStringReader.readLine();

        newString = newStringReader.readLine();

        if (!oldString.equals(newString))

        {

          same = false;

          break;

        }

      }

      // if oldString is null but newString is not null, they are same

      if (same)

      {

         if (newString != null)

         {

           same = false;

         }

      }

    }

    catch (Exception e)

    {

      throw new McdbException(e.getMessage());

    }

    MetaCatUtil.debugMessage("the inline data retrieve from file: "+data, 50);

    return same;

  }

  /* delete the inline data file */

  private void deleteInlineDataFile(String fileName)

  {

     String path = MetaCatUtil.getOption("inlinedatafilepath");

     File inlineDataDirectory = new File(path);

     File newFile = new File(inlineDataDirectory, fileName);

     newFile.delete();

   /* In eml2, the inline data wouldn't store in db, it store in file system