Metacat

import edu.ucsb.nceas.utilities.PropertyNotFoundException;

/**

 * call when processing the XML stream and generating events

 * Here is the rules for user which has write permission in top level access

 * rules(he can update metadata but can't update access module) try to update

 * a document:

 * 1. Checking access part (both in top level and additional level, node by node)

 *    If something was modified, reject the document. Note: for additional part

 *    This is because make sure ids wouldn't be mess up by user.

 * 2. Checking ids in additional access part, if they points a distribution

 *    module with online or inline. If some ids don't, reject the documents.

 *    If user can't read the inline data, the empty string in inline element

 *    will be send to user if he read this eml document(user has read access

 *    at top level - metadata, but user couldn't read inline data).

 *    permission in top level access rules(for metadata)

 *    but 1) user doesn't have read and write permission in inline data block,

 *    so if user update the document with some inline data rather than

 *    empty string in same inline data block(same distribution inline id),

 *    this means user updated the inline data. So the document should be

 *    rejected.

 *    inline data block. If user send back inline data block with empty

 *    string, we will think user doesn't update inline data and we will

 *    copy old inline data back to the new one. If user send something

public class Eml200SAXHandler extends DBSAXHandler implements

        AccessControlInterface

{

    // now additionalAccess will be explained as distribution access control

    // - data file

    private boolean processAdditionalAccess = false;

    private boolean processOtherAccess = false;

    private AccessSection accessObject = null;

    private AccessRule accessRule = null;

    private Vector describesId = new Vector(); // store the ids in

    // temporarily store distribution id

    private String distributionId = null;

    private boolean proccessDistribution = false;

    // a hash table to stored the distribution which is a reference and this

    // id (300) will be stored in above distribution lists.

    private Hashtable distributionReferenceList = new Hashtable();

    private AccessSection topAccessSection;

    private Vector additionalAccessVector = new Vector();

    private Vector inlineFileIDList = new Vector();

    //user has unwritable inline data object when it updates a document

    private boolean unWritableInlineDataObject = false;

            //unChangableSubTreeHash = getUnchangableSubTree(control, user,

            // groups);

            // we need to check if user update access subtree

            if (action != null && action.equals("UPDATE")

                    && !control.hasPermission(user, groups,

                            AccessControlInterface.ALLSTRING) 

                            && !AuthUtil.isAdministrator(user, groups))

            {

                                         getAdditionalAccessSubTreeListFromDB();

                                         getReferencedAccessSubTreeListFromDB();

            }

            //start handle inline data

            //=====================================================

            {

                handleInlineData = true;

                inLineDataIndex++;

            {

                    // stored the pull out nodes into storedNode stack

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

                            null, null, MetacatUtil.normalize(textBuffer

              }

              else if (attributeName != null && attributeName.equals(ID) &&

                       currentNode.getTagName().equals(DISTRIBUTION) &&

              {

                 // this is a distribution element and the id is distributionID

                 distributionId = attributeValue;

                // put parent node back

                nodeStack.push(tmpNode);

                String grandParentTag = grandParentNode.getTagName();

                {

                }

                {

                  // process other access embedded into resource level

                  // module

                }

                else

                {

                  processAdditionalAccess = true;

                }

                  accessObject.setStartedDescribesNodeId(firstDescribesNodeId);

                  accessObject.setControlLevel(DATAACCESSLEVEL);

                }

                {

                  accessObject.setControlLevel(TOPLEVEL);

                }

            nodeIndex.addElement(currentNode);

            // store access module element and attributes into stored stack

            {

                // stored the pull out nodes into storedNode stack

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

            if (currentNode.getTagName().equals(ADDITIONALMETADATA))

            {

            }

            else if (currentNode.getTagName().equals(DESCRIBES) &&

                     parentNode.getTagName().equals(ADDITIONALMETADATA) &&

              processAdditionalAccess = true;

              logMetacat.info("set processAdditonalAccess true when meet describe");

            }

                     parentNode.getTagName().equals(ADDITIONALMETADATA) &&

                     !currentNode.getTagName().equals(DESCRIBES) &&

                     !currentNode.getTagName().equals(ACCESS))

               logMetacat.warn("set processAddtionAccess false if the there is no access in additional");

            }

            else if (currentNode.getTagName().equals(DISTRIBUTION) &&

            {

              proccessDistribution = true;

            }

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

                endNodeId = writeTextForDBSAXNode(endNodeId, textBuffer,

                        currentNode);

                {

                     // stored the pull out nodes into storedNode stack

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

                    //firstDescribesNodeId = 0;

                }

                else if (currentTag.equals(REFERENCES)

                {

                    // get reference

                    data = (textBuffer.toString()).trim();

                  }

                }

                {

                    //handle online data, make sure its'parent is online

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

                 endNodeId = writeTextForDBSAXNode(endNodeId, textBuffer,

                            currentNode);

                    // stored the pull out nodes into storedNode stack

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

                            null, null, MetacatUtil.normalize(textBuffer

                if (newAccessObject != null)

                {

                    {

                       topAccessSection = newAccessObject;

                // reset flag

                processAdditionalAccess = false;

                processOtherAccess = false;

            }//access element

                //reset describesId

                describesId = null;

                describesId = new Vector();

                firstDescribesNodeId = -1;

                // reset tmp stored node stack

                storedAccessNodeStack = null;

            }

            {

               //reset distribution id

               distributionId = null;

               proccessDistribution = false;

            }

            {

               if (distributionId != null)

               {

               }

            }

            else if ((currentTag.equals(CONNECTION) || currentTag.equals(CONNECTIONDEFINITION))

            {

              //handle online data, make sure its'parent is online

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

                            str, PERMISSIONERROR);

                }//if*/

                //compare top level access module

                    /*compareCommentNode(currentUnchangableAccessModuleNodeStack,

                            str, UPDATEACCESSERROR);*/

                }

                endNodeId = currentNode.writeChildNodeToDB("COMMENT", null,

                        str, docid);

                    // stored the pull out nodes into storedNode stack

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

                            "COMMENT", null, null, MetacatUtil.normalize(str));

            String data = new String(cbuf, start, len);

                //compare whitespace in access top module

                    /*compareWhiteSpace(currentUnchangableAccessModuleNodeStack,

                            data, UPDATEACCESSERROR);*/

                }

                // Write the content of the node to the database

                    // stored the pull out nodes into storedNode stack

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

                            null, null, MetacatUtil.normalize(data));

    public void endDocument() throws SAXException

    {

        logMetacat.info("end Document");

        {

          compareAllAccessModules();

        }

    private void compareAllAccessModules() throws SAXException

    {

      //compare top level

      //compare additional level

      int newSize = additionalAccessVector.size();

      // if size is different, use deleted or added rules, so throw a exception

      if (oldSize != newSize)

      for ( int i = 0; i < newSize; i++)

      {

        AccessSection fromDB = (AccessSection)

        AccessSection fromParser = (AccessSection)

                                additionalAccessVector.elementAt(i);

        compareAccessSubtree(fromDB, fromParser);

      }

      //compare referenced level

      while (em.hasMoreElements())

      {

        String id = (String)em.nextElement();

        AccessSection fromDB = (AccessSection)

        AccessSection fromParser = (AccessSection)

                               possibleReferencedAccessHash.get(id);

        compareAccessSubtree(fromDB, fromParser);

     //System.out.println("in write additional");

     // we should delete all inline access rules in xml_access if

     // user has all permission

     {

       deleteAllInlineDataAccessRules();

     }