Metacat

 * 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:

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

 *    The access subtree startnode starts at "<describ>" rather than <access>.

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

 *    The new rules.

 *

 *

 *  The data access rules format looks like:

 *  <additionalMetadata>

 *    <describes>100</describes>

    private AccessSection topAccessSection;

    // key is subtree id and value is accessSection object

    private Hashtable possibleReferencedAccessHash = new Hashtable();

    private Vector inlineFileIDList = new Vector();

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

    private boolean unWritableInlineDataObject = false;

    //This hashtable will stored the id which already has additional access

    // control. So the top level access control will ignore them.

    // additional access module will be in additionalMetadata part. Its format

    // look like

        catch (SQLException e)

        {

            throw new SAXException(

                            + e.getMessage());

        }//catch

        finally

            //start handle inline data

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

            {

                handleInlineData = true;

                inLineDataIndex++;

              }

              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();

                {

                  processTopLeverAccess = true;

                }

                {

                  // process other access embedded into resource level

                  // module

                  // described element. If it has a descirbed element,

                  // this code would hurt any thing

                  processAdditionalAccess = true;

                }

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

            {

            }

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

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

                        localName, prefix, MetacatUtil.normalize(null));

              storedAccessNodeStack.push(nodeElement);

              processAdditionalAccess = true;

            }

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

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

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

            {

               // in additionalMetadata. So this is possible, there are

               // "describes" but not "access". So here is try to terminate

               // processAddionalAccess. In this situation, there another element

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

            }

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

            {

              proccessDistribution = true;

            }

                  }

                }

                {

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

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

                        // put discribesId into the accessobject and put this

                        // access object into vector

                        newAccessObject.setDescribedIdList(describesId);

                    }//if

                    else if (processOtherAccess)

                //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();

      //compare additional level

      int oldSize = unChangebleAdditionalAccessSubTreeVector.size();

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

      if (oldSize != newSize)

      {

        AccessSection fromDB = (AccessSection)

                          unChangebleAdditionalAccessSubTreeVector.elementAt(i);

        AccessSection fromParser = (AccessSection)

        compareAccessSubtree(fromDB, fromParser);

      }

        //write additional access rule, and old records in xml_access will be

        //deleted too

        //System.out.println("before write additional access rules");

        //System.out.println("after write additional access rules");

        //write top leve access rule, and old records in xml_access will be

        //deleted too

       else

       {

           // search it the additional access

           {

             AccessSection additionalAccess = (AccessSection)

             String additionId = additionalAccess.getSubTreeId();

             if (additionId != null && additionId.equals(reference))

             {

   * deleted

   * If no describedId in the access object, this access rules will be ingorned

   */

  {

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

     // user has all permission

     if (!needCheckingAccessModule)

     {

       deleteAllInlineDataAccessRules();

     }

     {

       Vector describeIdList = access.getDescribedIdList();

       // if this access is a reference, a new access object will be created

       // which contains the real access rules referenced. Also, each access tree

               // put the id into a hashtalbe. So when we run wirtetop level

               // access, those id will be ignored because they already has

               // additional access rules

             }

           }//elseif

         }//if

   }//writeAdditonalLevelAccessRuletoDB

    private void writeTopLevelAccessRuleToDB() throws SAXException

    {

       // if top access is reference, we need figure out the real access rules

       while (em.hasMoreElements())

       {

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

         {

            String url =

                       (String)onlineURLDistributionIdList.get(onlineSubtreeId);

            long startNodeId = -1;

            if (level != null && level.equals(DATAACCESSLEVEL))

            {

              // descirbes element id

              startNodeId = accessSection.getStartedDescribesNodeId();

              // if in additional access, there is not describes element,

		}// if

	}// comparingNodeStacks

	private void writeAdditionalAccessRulesToDB() throws SAXException {

		// Iterate through every distribution and write access sections for data and inline