/ - Diff - Metacat - Ecoinformatics Redmine

« Previous | Next »

Revision 5098

Added by daigle about 15 years ago

change AccessControlForSingleFile to only be instantiated for one file. move ACL methods to AccessControlForSingleFile. Change format of access sections returned to EML 2.1.0.

     /**
      *  '$RCSfile$'
      *    Purpose: A Class that manages database access of scheduled task
      *    Purpose: A Class that manages database access of xml access
      *             information.
      *  Copyright: 2009 Regents of the University of California and the
      *             National Center for Ecological Analysis and Synthesis
-...
+    	}
     	/**
     	 * Add permissions for a given prinicpal on a given document. If the
     	 * prinicpal already exists, bitwise OR the permission to the existing
     	 * Add permissions for a given principal on a given document. If the
     	 * principal already exists, bitwise OR the permission to the existing
     	 * permission and update.
+    	 *
     	 * @param docId
-...
+    	}
     	/**
     	 * Insert an xml access record
     	 * Set permissions for a given document. This means first removing all access control for the
     	 * document and then adding the given rules.
+    	 *
     	 * @param docId
     	 *            document id
     	 * @param xmlAccessList
     	 *            list of xml access dao objects that hold new access for the document
     	 */
     	public void setXMLAccess(String docId, Vector<XMLAccessDAO> xmlAccessList) throws AccessException {
     		deleteXMLAccessForDoc(docId);
     		// if more than one record exists for this principal on this document with the same
     		// access type / access order combination, call cleanup to combine common access and then
     		// re-retrieve the access list.
     		for(XMLAccessDAO xmlAccessDAO : xmlAccessList) {
     			insertXMLAccess(docId, xmlAccessDAO.getPrincipalName(), xmlAccessDAO.getPermission(),
     					xmlAccessDAO.getPermType(), xmlAccessDAO.getPermOrder());
+    		}
+    	}
     	/**
     	 * Insert an xml access record.  It is assumed that the checks have already been made to
     	 * make sure the principal does not already have an access record for this document.  If
     	 * one does already exist, that record should be updated and this insert not called.
+    	 *
     	 * @param docId
     	 *            document id
     	 * @param principal
     	 *            principal credentials
     	 * @param permission
-...
+    	}
     	/**
     	 * Update existing xml access permissions in the db
     	 * Update existing xml access permissions in the db.  The permission value should be the combined
     	 * value of pre-existing permissions plus new permissions.
+    	 *
     	 * @param docId
     	 *            document id
     	 * @param principalName
-...
+    	}
     	/**
     	 * Delete xml access.  This modifies the access in the database for a principal
     	 * Remove xml access.  This modifies the access in the database for a principal
     	 * for a given document.  If the provided permission is exactly the same as what
     	 * the principal has, the record is removed from the database.
     	 * the principal has, the record is deleted from the database.
+    	 *
     	 * @param docId
     	 *            document id
     	 * @param principalName
     	 *            principal credentials
     	 */
     	private void removeXMLAccessForPrincipal(String docId, String principalName, Long permission) throws AccessException {
     	public void removeXMLAccessForPrincipal(String docId, String principalName, Long permission) throws AccessException {
     		if (docId == null) {
     			throw new AccessException("XMLAccessAccess.removeXMLAccessForPrincipal - docid is required when " +
     					"removing XML access");
-...
+    	}
     	/**
     	 * Delete xml access.  This removes all access records from the database for a given document
+    	 *
     	 * @param docId
     	 *            document id
     	 */
     	private void deleteXMLAccessForDoc(String docId) throws AccessException {
     		if (docId == null) {
     			throw new AccessException("XMLAccessAccess.deleteXMLAccessForPrincipal - docid is required when " +
     					"deleting XML access record");
+    		}
     	    PreparedStatement pstmt = null;
     		DBConnection conn = null;
     		int serialNumber = -1;
     		try {
     			// check out DBConnection
     			conn = DBConnectionPool.getDBConnection("XMLAccessAccess.deleteXMLAccessForDoc");
     			String sql = "DELETE FROM xml_access WHERE docid = ?";
     			pstmt = conn.prepareStatement(sql);
     			// Bind the values to the query
     			pstmt.setString(1, docId);
     			String sqlReport = "XMLAccessAccess.deleteXMLAccessForDoc - SQL: " + sql;
     			sqlReport += " [" + docId + "]";
     			logMetacat.info(sqlReport);
     			pstmt.execute();
     		} catch (SQLException sqle) {
     			throw new AccessException("XMLAccessAccess.deleteXMLAccessForDoc - SQL error when deleting"
     					+ "xml access permissions for doc id: " + docId + ":" + sqle.getMessage());
     		} finally {
     			try {
     				if (pstmt != null) {
     					pstmt.close();
+    				}
     			} catch (SQLException sqle) {
     				logMetacat.error("XMLAccessAccess.deleteXMLAccessForDoc - SQL error when closing prepared " +
     						"statement after deleting xml access permissions for doc id: " + ":" + sqle.getMessage());
     			} finally {
     				DBConnectionPool.returnDBConnection(conn, serialNumber);
+    			}
+    		}
+    	}
     	/**
     	 * Delete xml access.  This removes all access records from the database for a principal
     	 * for a given document
+    	 *
     	 * @param docId
     	 *            document id
     	 * @param principal
-...
+    		}
+    	}
     	/**
     	 * Make sure that only one record exists per principal/permType/document. If
     	 * more than one record exists, delete the existing records, consolidate the
     	 * permissions insert the new record.
+    	 *
     	 * @param xmlAccessList
     	 * @throws AccessException
     	 */
     	private void cleanupXMLAccessForPrincipal(Vector<XMLAccessDAO> xmlAccessList) throws AccessException{
     		long permissionMask = 0;
     		int numAllowRecords = 0;
     		int numDenyRecords = 0;
     		long allowPermissionMask = 0;
     		long denyPermissionMask = 0;
     		String docId = null;
     		String principalName = null;
     		String permType = null;
     		String permOrder = null;
     		if (xmlAccessList.size() == 1) {
     			return;
+    		}
     		// iterate through the list of access dao objects and bttwise or the permissions.  Most
     		// of this is just doing some error checking to make sure each record is valid.
-...
     							"principalName " + principalName + ". Database intervention required ");
+    				}
+    			}
     			permissionMask |= xmlAccessDAO.getPermission();
     			if (permType.equals(AccessControlInterface.ALLOW)) {
     				numAllowRecords++;
     				allowPermissionMask |= xmlAccessDAO.getPermission();
     			} else if (permType.equals(AccessControlInterface.DENY)) {
     				numDenyRecords++;
     				denyPermissionMask |= xmlAccessDAO.getPermission();
+    			}
+    		}
     		// remove all records for this user on this doc with this perm type and perm order
     		// then insert a single record
     		deleteXMLAccessForPrincipal(docId, principalName, permType, permOrder);
     		insertXMLAccess(docId, principalName, permissionMask, permType, permOrder);
     		// if there was more than one allow record, remove all allow records for this user on this doc
     		// with this perm type and perm order then insert a single record
     		if (numAllowRecords > 1) {
     			deleteXMLAccessForPrincipal(docId, principalName, AccessControlInterface.ALLOW, permOrder);
     			insertXMLAccess(docId, principalName, allowPermissionMask, AccessControlInterface.ALLOW, permOrder);
+    		}
     		// if there was more than one deny record, remove all deny records for this user on this doc
     		// with this perm type and perm order then insert a single record
     		if (numDenyRecords > 1) {
     			deleteXMLAccessForPrincipal(docId, principalName, AccessControlInterface.DENY, permOrder);
     			insertXMLAccess(docId, principalName, denyPermissionMask, AccessControlInterface.DENY, permOrder);
+    		}
+    	}
     	/**
+    	 *
     	 * @param xmlAccessList
     	 * @throws PermOrderException
     	 */
     	private void validateDocXMLAccessList(Vector<XMLAccessDAO> xmlAccessList) throws PermOrderException {
     		String permOrder = null;
     		for(XMLAccessDAO xmlAccessDAO : xmlAccessList) {
-...
     					". Database intervention required ");
+    		}
+    	}
     	/**
     	 * Check if the given list of XML access DAOs has redundant access.  This occurs if there is
     	 * more than one instance of any combination of access type and access order.  Note that we
     	 * assume that the list contains access records for one principal on one document.
     	 * @param xmlAccessList
     	 * @return
     	 * @throws AccessException
     	 */
     	private boolean hasRedundantPrincipalAccess(Vector<XMLAccessDAO> xmlAccessList) throws AccessException {
     		// These will hold counts of all combinations of access DAOs with different permission
     		// orders and permission types.
     		int allowFirstAllows = 0;
     		int allowFirstDenys = 0;
     		int denyFirstAllows = 0;
     		int denyFirstDenys = 0;
     		for(XMLAccessDAO xmlAccessDAO : xmlAccessList) {
     			if (xmlAccessDAO.getPermOrder().equals(AccessControlInterface.ALLOWFIRST)) {
     				if (xmlAccessDAO.getPermType().equals(AccessControlInterface.ALLOW)) {
     					allowFirstAllows++;
     				} else if (xmlAccessDAO.getPermType().equals(AccessControlInterface.DENY)) {
     					allowFirstDenys++;
     				} else {
     					throw new AccessException("XMLAccessAccess.validatePrincipalXMLAccessList - " +
     						"Invalid permission type: "+ xmlAccessDAO.getPermType() + " for document " +
     						xmlAccessDAO.getDocId() + ". Database intervention required ");
+    				}
     			} else if (xmlAccessDAO.getPermOrder().equals(AccessControlInterface.DENYFIRST)) {
     				if (xmlAccessDAO.getPermType().equals(AccessControlInterface.ALLOW)) {
     					denyFirstAllows++;
     				} else if (xmlAccessDAO.getPermType().equals(AccessControlInterface.DENY)) {
     					denyFirstDenys++;
     				} else {
     					throw new AccessException("XMLAccessAccess.validatePrincipalXMLAccessList - " +
     						"Invalid permission type: " + xmlAccessDAO.getPermType() + " for document "+
     						xmlAccessDAO.getDocId() + ". Database intervention required ");
+    				}
+    			}
+    		}
     		return (allowFirstAllows > 1) || (allowFirstDenys > 1) || (denyFirstAllows > 1)
     				|| (denyFirstDenys > 1);
+    	}
     	/**
     	 * Populate a job data object with the current row in a resultset

+    	}
     	public void setDocId(String docId) {
     		_docId = docId;
     		if (docId != null && docId.equals("")) {
     			docId = null;
     		} else {
     			_docId = docId;
+    		}
+    	}
     	public String getAccessFileId() {
-...
+    	}
     	public void setAccessFileId(String accessFileId) {
     		_accessFileId = accessFileId;
     		if(accessFileId != null && accessFileId.equals("")) {
     			_accessFileId = null;
     		} else {
     			_accessFileId = accessFileId;
+    		}
+    	}
     	public String getPrincipalName() {
-...
+    	}
     	public void setPrincipalName(String principalName) {
     		_principalName = principalName;
     		if (principalName != null && principalName.equals("")) {
     			_principalName = null;
     		} else {
     			_principalName = principalName;
+    		}
+    	}
     	public Long getPermission() {
-...
+    	}
     	public void setPermType(String permType) {
     		_permType = permType;
     		if (permType != null && permType.equals("")) {
     			_permType = null;
     		} else {
     			_permType = permType;
+    		}
+    	}
     	public String getPermOrder() {
-...
+    	}
     	public void setPermOrder(String permOrder) {
     		_permOrder = permOrder;
     		if (permOrder != null && permOrder.equals("")) {
     			_permOrder = null;
     		} else {
     			_permOrder = permOrder;
+    		}
+    	}
     	public Date getBeginTime() {
-...
+    	}
     	public void setSubTreeId(String subTreeId) {
     		_subTreeId = subTreeId;
     		if (subTreeId != null && subTreeId.equals("")) {
     			_subTreeId = null;
     		} else {
     			_subTreeId = subTreeId;
+    		}
+    	}
     	public String getStartNodeId() {
-...
+    	}
     	public void setStartNodeId(String startNodeId) {
     		_startNodeId = startNodeId;
     		if (startNodeId != null && startNodeId.equals("")) {
     			_startNodeId = null;
     		} else {
     			_startNodeId = startNodeId;
+    		}
+    	}
     	public String getEndNodeId() {
-...
+    	}
     	public void setEndNodeId(String endNodeId) {
     		_endNodeId = endNodeId;
     		if (endNodeId != null && endNodeId.equals("")) {
     			endNodeId = null;
     		} else {
     			_endNodeId = endNodeId;
+    		}
+    	}
+    }

     package edu.ucsb.nceas.metacat.accesscontrol;
     import java.sql.*;
     import java.io.IOException;
     import java.io.StringReader;
     import java.sql.PreparedStatement;
     import java.sql.ResultSet;
     import java.sql.SQLException;
     import java.util.Vector;
     import org.apache.log4j.Logger;
     import org.xml.sax.ContentHandler;
     import org.xml.sax.ErrorHandler;
     import org.xml.sax.InputSource;
     import org.xml.sax.SAXException;
     import org.xml.sax.XMLReader;
     import org.xml.sax.helpers.XMLReaderFactory;
     import edu.ucsb.nceas.metacat.DocInfoHandler;
     import edu.ucsb.nceas.metacat.DocumentImpl;
     import edu.ucsb.nceas.metacat.McdbException;
     import edu.ucsb.nceas.metacat.PermissionController;
     import edu.ucsb.nceas.metacat.database.DBConnection;
     import edu.ucsb.nceas.metacat.database.DBConnectionPool;
     import edu.ucsb.nceas.metacat.properties.PropertyService;
     import edu.ucsb.nceas.metacat.shared.AccessException;
     import edu.ucsb.nceas.metacat.util.DocumentUtil;
     import edu.ucsb.nceas.utilities.PropertyNotFoundException;
     /**
-...
     public class AccessControlForSingleFile implements AccessControlInterface
+    {
       private String docId;
       private String principal;
       private int    permission;
       private String permType;
       private String permOrder;
       private Logger logMetacat = Logger.getLogger(AccessControlForSingleFile.class);
       /**
        * Construct an instance of the AccessControlForSingleFile class.
        * @param myAccessNumber  the docid or docid with dev will be controlled
        * @param myprincipal  the principal will have permission
        * @param myPermission the permission will be given
        * @param myPermType  the permsission type, allow or deny
        * @param myPermOrder  the permission order, allowFirst or denyFirst
        */
       public AccessControlForSingleFile(String myAccessionNumber,
                                         String myPrincipalName,
                                         String myPermission,
                                         String myPermType,
                                         String myPermOrder)
                                        throws Exception
       public AccessControlForSingleFile(String accessionNumber) throws AccessControlException
+      {
         try
+        {
           //Get rid of dev if myaccessNumber has one;
           docId = DocumentUtil.getDocIdFromString(myAccessionNumber);
           docId = DocumentUtil.getDocIdFromString(accessionNumber);
           if (docId == null || docId.equals(""))
+          {
             throw new Exception("Docid couldn't be null");
             throw new AccessControlException("AccessControlForSingleFile() - Accession number " +
             		"can't be null in constructor");
+          }
           // Check principal
           principal = myPrincipalName;
           if (principal == null || principal.equals(""))
+          {
             throw new Exception("principal couldn't be null");
+          }
           // get permission value
           permission = AccessControlList.intValue(myPermission);
           if (permission == -1)
+          {
             throw new Exception("permission "+ myPermission + " is not valid");
+          }
           // check permission type
           permType = myPermType;
           // if permtype is not allow or deny, throw a exception
           if (permType == null
               || (!permType.equals(AccessControlInterface.ALLOW)
               && !permType.equals(AccessControlInterface.DENY)))
+          {
             throw new Exception("permtype should be "+AccessControlInterface.ALLOW+
                                 " or " +AccessControlInterface.DENY);
+          }
           // check permission order
           permOrder = myPermOrder;
           // If permission order is not allowFirst or denyFirst, default to denyFirst.
           if (permOrder == null || !permOrder.equals(AccessControlInterface.DENYFIRST)) {
             permOrder = AccessControlInterface.ALLOWFIRST;
+          }
           //debugMessage
           logMetacat.info("docid in AccessControlForSingleFiel: " +
                                     docId);
           logMetacat.info("principal in AccessControlForSingleFiel: " +
                                     principal);
           logMetacat.info("permission in AccessControlForSingleFiel: " +
                                     permission);
           logMetacat.info("permType in AccessControlForSingleFiel: " +
                                     permType);
           logMetacat.info("permOrder in AccessControlForSingleFiel: " +
                                     permOrder);
+        }
         catch (Exception e)
+        {
           logMetacat.error("Error in construct of AccessControlForSingle" +
                                    "File for docid: " + docId + " : " + e.getMessage());
           throw e;
+        }
           logMetacat.debug("AccessControlForSingleFile() - docid: " + docId);
+      }
       	/**
     	 * Insert a single access record into the database based on access DAO
     	 * object
+    	 *
     	 * @param xmlAccessDAO
     	 *            dao object holding info to insert
     	 */
     	public void insertPermissions(XMLAccessDAO xmlAccessDAO) throws AccessControlException{
     		insertPermissions(xmlAccessDAO.getPrincipalName(), xmlAccessDAO.getPermission(),
     				xmlAccessDAO.getPermType(), xmlAccessDAO.getPermOrder());
+    	}
       /**
        * Method to insert records into xml_access table
        */
       public void insertPermissions() throws AccessControlException {
     	/**
     	 * Insert a single access record into the database.
+    	 *
     	 * @param principalName
     	 * @param permission
     	 * @param permType
     	 * @param permOrder
     	 * @throws AccessControlException
     	 */
     	public void insertPermissions(String principalName, Long permission, String permType, String permOrder) throws AccessControlException {
     		try {
     			// The addXMLAccess method will create the permission record if it does not exist.
     			// It will bitwise OR to permissions if the principal already has a record for this
     			// doc id.
     			XMLAccessAccess xmlAccessAccess = new XMLAccessAccess();
     			xmlAccessAccess.addXMLAccess(docId, principal, new Long(permission), permType, permOrder);
     			xmlAccessAccess.addXMLAccess(docId, principalName, new Long(permission), permType, permOrder);
     		} catch (AccessException ae) {
     			throw new AccessControlException("AccessControlForSingleFile.insertPermissions - "
     					+ "DB access error when inserting permissions: " + ae.getMessage());
+    		}
+    	}
       /**
     	/**
     	 * Replace existing permissions with a given block of permissions for this
     	 * document.
+    	 *
     	 * @param accessBlock
     	 *            the xml access block. This is the same structure as that
     	 *            returned by the getdocumentinfo action in metacat.
     	 */
     	public void insertPermissions(String accessBlock) throws AccessControlException {
     		try {
     			XMLReader parser = null;
     			DocInfoHandler docInfoHandler = new DocInfoHandler();
     			ContentHandler chandler = docInfoHandler;
     			// Get an instance of the parser
     			String parserName = PropertyService.getProperty("xml.saxparser");
     			parser = XMLReaderFactory.createXMLReader(parserName);
     			// Turn off validation
     			parser.setFeature("http://xml.org/sax/features/validation", false);
     			parser.setContentHandler((ContentHandler)chandler);
     			parser.setErrorHandler((ErrorHandler)chandler);
     			parser.parse(new InputSource(new StringReader(accessBlock)));
     	        Vector<XMLAccessDAO> accessControlList = docInfoHandler.getAccessControlList();
     	        if (accessControlList != null) {
     	        	for (XMLAccessDAO xmlAccessDAO : accessControlList) {
             			insertPermissions(xmlAccessDAO);
     					logMetacat.debug("AccessControlForSingleFile.insertPermissions - document " + docId
     							+ " permissions added to DB");
+    	            }
+    	        }
     		} catch (PropertyNotFoundException pnfe) {
     			throw new AccessControlException("AccessControlForSingleFile.insertPermissions - "
     					+ "property error when inserting permissions: " + pnfe.getMessage());
     		} catch (SAXException se) {
     			throw new AccessControlException("AccessControlForSingleFile.insertPermissions - "
     					+ "SAX error when inserting permissions: " + se.getMessage());
     		} catch(IOException ioe) {
     			throw new AccessControlException("AccessControlForSingleFile.insertPermissions - "
     					+ "I/O error when inserting permissions: " + ioe.getMessage());
+    		}
+    	}
     	/**
+    	 *
     	 * @return true if the Access Control for this file already exists in the DB
     	 * @throws SQLException
     	 */
       public boolean accessControlExists() throws SQLException
+      {
     	  boolean exists = false;
         PreparedStatement pstmt = null;
         DBConnection conn = null;
         int serialNumber = -1;
         try
+        {
           //check out DBConnection
           conn=DBConnectionPool.getDBConnection
     	public boolean accessControlExists(XMLAccessDAO xmlAccessDAO) throws AccessControlException {
     		boolean exists = false;
     		PreparedStatement pstmt = null;
     		DBConnection conn = null;
     		int serialNumber = -1;
     		try {
     			//check out DBConnection
     			conn=DBConnectionPool.getDBConnection
                                    ("AccessControlForSingleFiel.accessControlExists");
           serialNumber=conn.getCheckOutSerialNumber();
           pstmt = conn.prepareStatement(
                   "SELECT * FROM xml_access " +
                   "WHERE docid = ? " +
                   "AND principal_name = ? " +
                   "AND permission = ? " +
                   "AND perm_type = ? " +
                   "AND perm_order =? ");
     			serialNumber=conn.getCheckOutSerialNumber();
     			pstmt = conn.prepareStatement(
     				"SELECT * FROM xml_access " +
     				"WHERE docid = ? " +
     				"AND principal_name = ? " +
     				"AND permission = ? " +
     				"AND perm_type = ? " +
     				"AND perm_order =? ");
           // Bind the values to the query
           pstmt.setString(1, docId);
           pstmt.setString(2, principal);
           pstmt.setInt(3, permission);
           pstmt.setString(4, permType);
           pstmt.setString(5, permOrder);
     			// Bind the values to the query
     			pstmt.setString(1, docId);
     			pstmt.setString(2, xmlAccessDAO.getPrincipalName());
     			pstmt.setLong(3, xmlAccessDAO.getPermission());
     			pstmt.setString(4, xmlAccessDAO.getPermType());
     			pstmt.setString(5, xmlAccessDAO.getPermOrder());
           pstmt.execute();
           ResultSet rs = pstmt.getResultSet();
           exists = rs.next();
     			pstmt.execute();
     			ResultSet rs = pstmt.getResultSet();
     			exists = rs.next();
         }//try
         catch (SQLException e)
+        {
           logMetacat.error("Error in AccessControlForSingleFile.accessControlExists: "
                                    + e.getMessage());
           throw e;
+        }
         finally
+        {
           try
+          {
             pstmt.close();
+          }
           finally
+          {
             DBConnectionPool.returnDBConnection(conn, serialNumber);
+          }
+        }
     		} catch (SQLException sqle){
     			throw new AccessControlException("AccessControlForSingleFile.accessControlExists - SQL error when " +
     					"checking if access control exists: " + sqle.getMessage());
     		} finally {
     			try {
     				if(pstmt != null) {
     					pstmt.close();
+    				}
     			} catch (SQLException sqle) {
     				logMetacat.error("AccessControlForSingleFile.accessControlExists - Could not close " +
     						"prepared statement: " +sqle.getMessage());
     			} finally {
     				DBConnectionPool.returnDBConnection(conn, serialNumber);
+    			}
+    		}
         return exists;
+      }
     		return exists;
+    	}
       public String getAccessString() {
     	  StringBuffer sb = new StringBuffer();
     	  sb.append("<access>");
     		  sb.append("<permOrder>");
     		  sb.append(this.permOrder);
     		  sb.append("</permOrder>");
     		  sb.append("<permType>");
     		  sb.append(this.permType);
     		  sb.append("</permType>");
     		  sb.append("<permission>");
     		  sb.append(AccessControlList.txtValue(this.permission));
     		  sb.append("</permission>");
     		  sb.append("<principal>");
     		  sb.append(this.principal);
     		  sb.append("</principal>");
     	/**
     	 * Get Access Control List information for document from db connetion. User
     	 * or Group should have permissions for reading access control information
     	 * for a document specified by
+    	 *
     	 * @docid.
     	 * @param docid
     	 *            document identifier which acl info to get
     	 * @param user
     	 *            name of user connected to Metacat system
     	 * @param groups
     	 *            names of user's groups to which user belongs
     	 */
     	public String getACL(String user, String[] groups, boolean emlCompliant)
     			throws AccessControlException {
     		StringBuffer output = new StringBuffer();
     		boolean hasPermission = false;
     	  sb.append("</access>");
     	  return sb.toString();
+      }
     		try {
     			// Get a list of all access dao objects for this docid
     			XMLAccessAccess xmlAccessAccess = new XMLAccessAccess();
     			Vector<XMLAccessDAO> xmlAccessDAOList = xmlAccessAccess.getXMLAccessForDoc(docId);
     			hasPermission = isOwned(docId, user);
     			if (!hasPermission) {
     				PermissionController controller = new PermissionController(docId);
     				hasPermission =
     					controller.hasPermission(user, groups, READSTRING);
+    			}
     			if (hasPermission) {
     				output.append(getAccessString(xmlAccessDAOList, emlCompliant));
+    			}
     			return output.toString();
     		} catch (SQLException sqle) {
     			throw new AccessControlException("AccessControlForSingleFile.getACL() - SQL error when " +
     					"getting ACL: " + sqle.getMessage());
     		} catch (AccessException ae) {
     			throw new AccessControlException("AccessControlForSingleFile.getACL() - DB access error when " +
     					"getting ACL: " + ae.getMessage());
     		} catch (McdbException mcdb) {
     			throw new AccessControlException("AccessControlForSingleFile.getACL() - MCDB error when " +
     					"getting ACL: " + mcdb.getMessage());
+    		}
+    	}
     	public String getAccessString() throws AccessControlException {
     		Vector<XMLAccessDAO> xmlAccessDAOList = null;
     		try {
     			// Get a list of all access dao objects for this docid
     			XMLAccessAccess xmlAccessAccess = new XMLAccessAccess();
     			xmlAccessDAOList = xmlAccessAccess.getXMLAccessForDoc(docId);
     		} catch (AccessException ae) {
     				throw new AccessControlException("AccessControlForSingleFile.getAccessString() - DB access error when " +
     						"getting access string: " + ae.getMessage());
+    		}
     		return getAccessString(xmlAccessDAOList, false);
+    	}
     	public String getAccessString(Vector<XMLAccessDAO> xmlAccessDAOList, boolean emlCompliant) throws AccessControlException {
     		StringBuffer output = new StringBuffer();
     		StringBuffer tmpOutput = new StringBuffer();
     		StringBuffer allowOutput = new StringBuffer();
     		StringBuffer denyOutput = new StringBuffer();
     		String principal = null;
     		int permission = -1;
     		String permOrder = ALLOWFIRST;
     		String permType = null;
     		// We assume that all the records will have the same permission order, so we can just
     		// grab the perm order from the first one.
     		if (xmlAccessDAOList.size() > 0) {
     			permOrder = xmlAccessDAOList.get(0).getPermOrder();
+    		}
     		if (emlCompliant) {
     			output.append("<?xml version=\"1.0\"?>\n<acc:access");
     		} else {
     			output.append("<access ");
+    		}
     		output.append(" authSystem=\"knb\" order=\"" + permOrder + "\" id=\"" + docId + "\" scope=\"document\"");
     		if (emlCompliant) {
     			output.append(" xmlns:acc=\"" + DocumentImpl.EML2_1_0NAMESPACE + "\"");
+    		}
     		output.append(">\n");
     		if (xmlAccessDAOList.size() > 0) {
     			// Since there should only be one permission order allowed per document,
     			// we can just grab the order off of the first xml access dao object
     			permOrder = xmlAccessDAOList.get(0).getPermOrder();
+    		}
     		for (XMLAccessDAO xmlAccessDAO : xmlAccessDAOList) {
     			principal = xmlAccessDAO.getPrincipalName();
     			permission = xmlAccessDAO.getPermission().intValue();
     			permType = xmlAccessDAO.getPermType();
     			tmpOutput.append("    <" + permType + ">\n");
     			tmpOutput.append("      <principal>" + principal + "</principal>\n");
     			if ((permission & READ) == READ) {
     				tmpOutput.append("      <permission>read</permission>\n");
+    			}
     			if ((permission & WRITE) == WRITE) {
     				tmpOutput.append("      <permission>write</permission>\n");
+    			}
     			if ((permission & ALL) == ALL) {
     				tmpOutput.append("      <permission>all</permission>\n");
+    			}
     			if ((permission & CHMOD) == CHMOD) {
     				tmpOutput.append("      <permission>chmod</permission>\n");
+    			}
     			tmpOutput.append("    </" + permType + ">\n");
     			if (permType.equals(ALLOW)) {
     				allowOutput.append(tmpOutput);
     			} else if (permType.equals(DENY)) {
     				denyOutput.append(tmpOutput);
+    			}
     			tmpOutput = new StringBuffer();
+    		}
     		// This just orders the allow/deny sections based on the permOrder.  Not
     		// required, but convenient later when parsing the output.
     		if (permOrder.equals(ALLOWFIRST)) {
     			output.append(allowOutput);
     			output.append(denyOutput);
     		} else if (permOrder.equals(DENYFIRST)) {
     			output.append(denyOutput);
     			output.append(allowOutput);
+    		}
     		if (emlCompliant) {
     			output.append("</acc:access>");
     		} else {
     			output.append("</access>");
+    		}
     		return output.toString();
+    	}
     	/* Check if @user is owner of @docid from db conn. */
     	private boolean isOwned(String docid, String user) throws SQLException {
     		PreparedStatement pstmt = null;
     		DBConnection conn = null;
     		int serialNumber = -1;
     		try {
     			// check out DBConnection
     			conn = DBConnectionPool.getDBConnection("AccessControlList.isOwned");
     			serialNumber = conn.getCheckOutSerialNumber();
     			pstmt = conn.prepareStatement("SELECT 'x' FROM xml_documents "
     					+ "WHERE docid = ? " + "AND user_owner = ?");
     			pstmt.setString(1, docid);
     			pstmt.setString(2, user);
     			pstmt.execute();
     			ResultSet rs = pstmt.getResultSet();
     			boolean hasRow = rs.next();
     			return hasRow;
     		} finally {
     			try {
     				if (pstmt != null) {
     					pstmt.close();
+    				}
     			} finally {
     				DBConnectionPool.returnDBConnection(conn, serialNumber);
+    			}
+    		}
+    	}
     // public String getAccessString() throws AccessControlException {
     // Vector<XMLAccessDAO> xmlAccessDAOList = null;
     // try {
     // XMLAccessAccess xmlAccessAccess = new XMLAccessAccess();
     //		  xmlAccessDAOList = xmlAccessAccess.getXMLAccessForDoc(docId);
     //	  } catch (AccessException ae) {
     //		  throw new AccessControlException("AccessControlForSingleFile.getAccessString - error when getting " +
     //				  "access DAO list: " + ae.getMessage());
     //	  }
     //
     //	  StringBuffer sb = new StringBuffer();
     //
     //	  for (XMLAccessDAO xmlAccessDAO : xmlAccessDAOList) {
     //		  sb.append("<access>");
     //
     //		  sb.append("<permOrder>");
     //		  sb.append(xmlAccessDAO.getPermOrder());
     //		  sb.append("</permOrder>");
     //
     //		  sb.append("<permType>");
     //		  sb.append(xmlAccessDAO.getPermType());
     //		  sb.append("</permType>");
     //
     //		  sb.append("<permission>");
     //		  sb.append(xmlAccessDAO.getPermission());
     //		  sb.append("</permission>");
     //
     //		  sb.append("<principal>");
     //		  sb.append(xmlAccessDAO.getPrincipalName());
     //		  sb.append("</principal>");
     //
     //		  sb.append("</access>");
     //	  }
     //
     //	  return sb.toString();
     //
     //  }
+    }

     import edu.ucsb.nceas.metacat.database.DBConnection;
     import edu.ucsb.nceas.metacat.database.DBConnectionPool;
     import edu.ucsb.nceas.metacat.properties.PropertyService;
     import edu.ucsb.nceas.metacat.shared.AccessException;
     import edu.ucsb.nceas.metacat.util.MetacatUtil;
     import edu.ucsb.nceas.metacat.util.SystemUtil;
     import edu.ucsb.nceas.utilities.PropertyNotFoundException;
-...
       private int    permission;
       private String permType;
       private String permOrder;
     //  private String publicAcc;
       private String beginTime;
       private String endTime;
       private int    ticketCount;
-...
     		return txtPerm.toString();
+    	}
     // /* Get the text value of READ, WRITE or ALL. */
     //  public static String txtValue ( int permission )
     //  {
     //    StringBuffer txtPerm = new StringBuffer();
     //    if (permission == READ) {
     //      txtPerm.append("READ");
     //    }
     //    if (permission == WRITE) {
     //      txtPerm.append("WRITE");
     //    }
     //    if (permission == ALL) {
     //      txtPerm.append("ALL");
     //    }
     //
     //    return txtPerm.toString();
     //  }
       /**
         * Get Access Control List information for document from db connetion.
         * User or Group should have permissions for reading
         * access control information for a document specified by @docid.
         * @param docid document identifier which acl info to get
         * @param user name of user connected to Metacat system
         * @param groups names of user's groups to which user belongs
         */
       public String getACL(String docid, String user, String[] groups)
               throws SQLException, Exception
+      {
         StringBuffer output = new StringBuffer();
         StringBuffer outTemp = new StringBuffer();
         String accDoctype = PropertyService.getProperty("xml.accessdoctype");
         String server = PropertyService.getProperty("server.name");
         String docurl = "metacat://" + server + "/?docid=" + docid;
         String systemID;
         boolean isOwned = false;
         boolean hasPermission = false;
         String publicAcc;
         String acfid = "";
         String acfid_prev = "";
         String principal;
         Vector principalArr = new Vector();
         int permission;
         int perm_prev = -1;
         String permType;
         String permOrder = "";
         String permOrder_prev = "";
         String beginTime = "";
         String begin_prev = "";
         String endTime = "";
         String end_prev = "";
         int ticketCount = -1;
         int ticket_prev = -1;
         DBConnection conn = null;
         int serialNumber = -1;
         PreparedStatement pstmt = null;
         try {
           //check out DBConnection
           conn=DBConnectionPool.getDBConnection("AccessControlList.getACL");
           serialNumber=conn.getCheckOutSerialNumber();
           isOwned = isOwned(docid, user);
           systemID = getSystemID((String)MetacatUtil.
                                           getOptionList(accDoctype).elementAt(0));
           publicAcc = getPublicAccess(docid);
           output.append("<?xml version=\"1.0\"?>\n");
           output.append("<!DOCTYPE acl PUBLIC \"" + accDoctype + "\" \"" +
                         systemID + "\">\n");
           output.append("<acl authSystem=\"\">\n");
           pstmt = conn.prepareStatement(
                   "SELECT distinct accessfileid, principal_name, permission, " +
                   "perm_type, perm_order, to_char(begin_time,'mm/dd/yyyy'), " +
                   "to_char(end_time,'mm/dd/yyyy'), ticket_count " +
                   "FROM xml_access WHERE docid = ? " +
                   "ORDER BY accessfileid, perm_order, perm_type, permission");
           // Bind the values to the query
           pstmt.setString(1, docid);
           logMetacat.debug("running sql: " + pstmt.toString());
           pstmt.execute();
           ResultSet rs = pstmt.getResultSet();
           boolean hasRows = rs.next();
           while (hasRows) {
             acfid = rs.getString(1);
             principal = rs.getString(2);
             permission = rs.getInt(3);
             permType = rs.getString(4);
             permOrder = rs.getString(5);
             beginTime = rs.getString(6);
             endTime = rs.getString(7);
             ticketCount = rs.getInt(8);
             // if @docid is not owned by @user, only ACL info from that
             // access files to which @user/@groups has "read" permission
             // is extracted
             if ( !isOwned ) {
               if ( !acfid.equals(acfid_prev) ) {
                 acfid_prev = acfid;
                 //hasPermission = this.hasPermission("READ",user,groups,acfid);
                  PermissionController controller = new PermissionController(acfid);
                  hasPermission = controller.hasPermission(user,groups,
                                                 AccessControlInterface.READSTRING);
+              }
               if ( !hasPermission ) {
                 rs.next();
                 continue;
+              }
+            }
             // open <resource> tag
             if ( !permOrder.equals(permOrder_prev) ) {
               // close </resource> tag if any was opened
               output.append(outTemp.toString());
               outTemp = new StringBuffer();
               if ( !permOrder_prev.equals("") ) {
                 output.append("  </resource>\n");
+              }
               output.append("  <resource order=\"" + permOrder + "\" public=\"" +
                             publicAcc + "\">\n");
               output.append("    <resourceIdentifier>" + docurl +
                             "</resourceIdentifier>\n");
               permOrder_prev = permOrder;
+            }
             // close </allow> or </deny> tag then open new one
             if ( permission != perm_prev ||
                  (endTime == null) && (end_prev != null) ||
                  (beginTime == null) && (begin_prev != null) ||
                  endTime != null && !endTime.equals(end_prev)  ||
                  beginTime != null && !beginTime.equals(begin_prev) ||
                  ticketCount != ticket_prev )  {
               output.append(outTemp.toString());
               outTemp = new StringBuffer();
               principalArr.removeAllElements();
               output.append("    <" + permType + ">\n");
+            }
             // put all principals here for the same
             // permission, duration and ticket_count
             if ( !principalArr.contains(principal) ) {
               principalArr.addElement(principal);
               output.append("      <principal>" + principal + "</principal>\n");
+            }
             // prepare <permission> tags, <duration> and <ticketCount>
             // if any to put within <allow> (<deny>) by next cicle
             if ( permission != perm_prev ||
                  (endTime == null) && (end_prev != null) ||
                  (beginTime == null) && (begin_prev != null) ||
                  endTime != null && !endTime.equals(end_prev)  ||
                  beginTime != null && !beginTime.equals(begin_prev) ||
                  ticketCount != ticket_prev )  {
               if ( (permission & READ) == READ ) {
                 outTemp.append("      <permission>read</permission>\n");
+              }
               if ( (permission & WRITE) == WRITE ) {
                 outTemp.append("      <permission>write</permission>\n");
+              }
               if ( (permission & ALL) == ALL ) {
                 outTemp.append("      <permission>all</permission>\n");
+              }
               if ( (permission & CHMOD) == CHMOD ) {
                   outTemp.append("      <permission>chmod</permission>\n");
+              }
               if ( (beginTime != null) || (endTime != null) ) {
                 outTemp.append("      <duration>" + beginTime + " " + endTime +
                               "</duration>\n");
+              }
               if ( ticketCount > 0 ) {
                 outTemp.append("      <ticketCount>" + ticketCount +
                               "</ticketCount>\n");
+              }
               outTemp.append("    </" + permType + ">\n");
               perm_prev = permission;
               ticket_prev = ticketCount;
               begin_prev = beginTime;
               end_prev = endTime;
+            }
             hasRows = rs.next();
+          }
           // close <allow> or <deny> if anything left in outTemp var
           output.append(outTemp.toString());
           // If there are no any acl info for @docid accessible by @user/@group,
           // extract only the following information
           if ( permOrder.equals("") ) {
             output.append("  <resource public=\"" + publicAcc + "\">\n");
             output.append("    <resourceIdentifier>" + docurl +
                           "</resourceIdentifier>\n");
+          }
           // always close them
           output.append("  </resource>\n");
           output.append("</acl>\n");
           pstmt.close();
           return output.toString();
         } catch (SQLException e) {
           throw new
           SQLException("AccessControlList.getACL(). " + e.getMessage());
+        }
         finally
+        {
           try
+          {
             pstmt.close();
+          }
           finally
+          {
             DBConnectionPool.returnDBConnection(conn, serialNumber);
+          }
+        }
+      }
       /* Check if @user is owner of @docid from db conn. */
       private boolean isOwned(String docid, String user) throws SQLException {
         PreparedStatement pstmt = null;
         DBConnection conn = null;
         int serialNumber = -1;
         try
+        {
           //check out DBConnection
           conn=DBConnectionPool.getDBConnection("AccessControlList.isOwned");
           serialNumber=conn.getCheckOutSerialNumber();
           pstmt = conn.prepareStatement("SELECT 'x' FROM xml_documents " +
                                       "WHERE docid = ? " +
                                       "AND user_owner = ?");
           pstmt.setString(1, docid);
           pstmt.setString(2, user);
           pstmt.execute();
           ResultSet rs = pstmt.getResultSet();
           boolean hasRow = rs.next();
           return hasRow;
+        }
         finally
+        {
           try
+          {
             pstmt.close();
+          }
           finally
+          {
             DBConnectionPool.returnDBConnection(conn, serialNumber);
+          }
+        }
+      }
       /* Get the flag for public "read" access for @docid from db conn. */
       private String getPublicAccess(String docid) throws SQLException {

     import com.oreilly.servlet.multipart.ParamPart;
     import com.oreilly.servlet.multipart.Part;
     import edu.ucsb.nceas.metacat.accesscontrol.AccessControlException;
     import edu.ucsb.nceas.metacat.accesscontrol.AccessControlForSingleFile;
     import edu.ucsb.nceas.metacat.accesscontrol.AccessControlInterface;
     import edu.ucsb.nceas.metacat.accesscontrol.AccessControlList;
-...
     import edu.ucsb.nceas.metacat.service.ServiceService;
     import edu.ucsb.nceas.metacat.service.SessionService;
     import edu.ucsb.nceas.metacat.service.XMLSchemaService;
     import edu.ucsb.nceas.metacat.shared.ServiceException;
     import edu.ucsb.nceas.metacat.shared.BaseException;
     import edu.ucsb.nceas.metacat.shared.HandlerException;
     import edu.ucsb.nceas.metacat.shared.MetacatUtilException;
     import edu.ucsb.nceas.metacat.shared.ServiceException;
     //import edu.ucsb.nceas.metacat.shared.AccessException;
     import edu.ucsb.nceas.metacat.spatial.SpatialHarvester;
     import edu.ucsb.nceas.metacat.spatial.SpatialQuery;
     import edu.ucsb.nceas.metacat.util.AuthUtil;
-...
+            }
             try {
                 // get connection from the pool
                 dbConn = DBConnectionPool
                         .getDBConnection("MetaCatServlet.handleGetAccessControlAction");
                 serialNumber = dbConn.getCheckOutSerialNumber();
                 AccessControlList aclobj = new AccessControlList(dbConn);
                 String acltext = aclobj.getACL(docid, username, groupnames);
             	AccessControlForSingleFile acfsf = new AccessControlForSingleFile(docid);
                 String acltext = acfsf.getACL(username, groupnames, true);
                 if (qformat.equals("xml")) {
                     response.setContentType("text/xml");
                 	out.println(acltext);
-...
         private void handleSetAccessAction(PrintWriter out, Hashtable<String, String[]> params,
                 String username, HttpServletRequest request, HttpServletResponse response) {
             Logger logMetacat = Logger.getLogger(MetaCatServlet.class);
             String[] docList = null;
             String[] principalList = null;
             String[] permissionList = null;
             String[] permTypeList = null;
             String[] permOrderList = null;
             String[] qformatList = null;
             String permission = null;
             String permType = null;
             String permOrder = null;
-...
             String success = null;
             boolean isEmlPkgMember = false;
             // Get parameters
             if (params.containsKey("docid")) {
                 docList = params.get("docid");
+            }
             if (params.containsKey("principal")) {
                 principalList = params.get("principal");
+            }
             if (params.containsKey("permission")) {
                 permissionList = params.get("permission");
+            }
             if (params.containsKey("permType")) {
                 permTypeList = params.get("permType");
+            }
             if (params.containsKey("permOrder")) {
                 permOrderList = params.get("permOrder");
+            }
             String[] docList = params.get("docid");
             String[] principalList = params.get("principal");
             String[] permissionList = params.get("permission");
             String[] permTypeList = params.get("permType");
             String[] permOrderList = params.get("permOrder");
             String[] qformatList = params.get("qformat");
             String[] accessBlock = params.get("accessBlock");
             if (params.containsKey("qformat")) {
                 qformatList = params.get("qformat");
             if(accessBlock != null) {
             	if (docList == null) {
             		errorList.addElement("MetaCatServlet.handleSetAccessAction - Please check your parameter list, it should look like: "
                         + "?action=setaccess&docid=<doc_id>&accessBlock=<access_section>");
                     outputResponse(successList, errorList, out);
                     return;
+            	}
             	try {
     	            AccessControlForSingleFile accessControl =
     	            	new AccessControlForSingleFile(docList[0]);
     	            accessControl.insertPermissions(accessBlock[0]);
             	} catch(AccessControlException ace) {
             		errorList.addElement("MetaCatServlet.handleSetAccessAction - access control error when setting " +
             			"access block: " + ace.getMessage());
+            	}
             	outputResponse(successList, errorList, out);
             	return;
+            }
             // Make sure the parameter is not null
-...
                 } catch (Exception e) {
                     logMetacat.error("MetaCatServlet.handleSetAccessAction - Error in handleSetAccessAction: "
                             + e.getMessage());
                     error = "Error in set access control for document - "
                             + accessionNumber + e.getMessage();
                     error = "Error in set access control for document - " + accessionNumber + e.getMessage();
                     errorList.addElement(error);
                     continue;
+                }
                 //check if user is the owner. Only owner can do owner
                 if (username == null || owner == null || !username.equals(owner)) {
                     error = "User - " + username
                             + " does not have permission to set "
                     error = "User - " + username + " does not have permission to set "
                             + "access control for docid - " + accessionNumber;
                     errorList.addElement(error);
                     continue;
-...
                 if (isEmlPkgMember == false)
                     isEmlPkgMember = (DBUtil.findDataSetDocIdForGivenDocument(accessionNumber) != null);
                 // If docid publicid is BIN data file or other beta4, 6 package
                 // document
                 // we could not do set access control. Because we don't want
                 // inconsistent
                 // If docid publicid is BIN data file or other beta4, 6 package document
                 // we could not do set access control. Because we don't want inconsistent
                 // to its access docuemnt
                 if (publicId != null && packageSet != null
                         && packageSet.contains(publicId) && isEmlPkgMember) {
                     error = "Could not set access control to document "
                             + accessionNumber
                     error = "Could not set access control to document " + accessionNumber
                             + "because it is in a pakcage and it has a access file for it";
                     errorList.addElement(error);
                     continue;
-...
                     String principal = principalList[j];
                     try {
                         //insert permission
                         AccessControlForSingleFile accessControl = new AccessControlForSingleFile(
                                 accessionNumber, principal, permission, permType, permOrder);
                         accessControl.insertPermissions();
                         AccessControlForSingleFile accessControl =
                         	new AccessControlForSingleFile(accessionNumber);
                         accessControl.insertPermissions(principal, Long.valueOf(permission), permType, permOrder);
                     } catch (Exception ee) {
                         logMetacat.error("MetaCatServlet.handleSetAccessAction - Error inserting permission: "
                                 + ee.getMessage());

                                                         // access for this docid
        private Vector subTreeList = new Vector();
        private long TOPLEVELSTARTNODEID = 0; //if start node is 0, means it is top
        private static final long TOPLEVELSTARTNODEID = 0; //if start node is 0, means it is top
                                              //level document
        private static Logger logMetacat = Logger.getLogger(PermissionController.class);
-...
       }//isAllowFirst
     /**
         * Check if the permission order for user at that documents is allowFirst
         * @param principals, list of names of principals to check for
         * @param docid, document identifier to check for
         */
       public Vector<AccessControlForSingleFile> getAccessControl()
                       throws SQLException, Exception
+      {
     	Vector<AccessControlForSingleFile> accessControl = new Vector<AccessControlForSingleFile>();
         boolean hasRow;
         PreparedStatement pStmt = null;
         DBConnection conn = null;
         int serialNumber = -1;
         String sql = null;
         boolean topLever =false;
         sql = "SELECT principal_name, permission, perm_type, perm_order FROM xml_access ";
         //TODO, need this?
         long startId = 0;
         if (startId == TOPLEVELSTARTNODEID)
+        {
           //top level
           topLever = true;
           sql += "WHERE docid = ? AND startnodeid is NULL";
+        }
         else
+        {
           //sub tree level
           sql += "WHERE docid = ? AND startnodeid = ?";
+        }
         try
+        {
           //check out DBConnection
           conn=DBConnectionPool.getDBConnection("AccessControlList.getPermissions");
           serialNumber=conn.getCheckOutSerialNumber();
           //select permission order from database
           pStmt = conn.prepareStatement(sql);
             //bind value
             pStmt.setString(1, docId);//docid
             // if subtree, we need set subtree id
             if (!topLever)
+            {
               pStmt.setLong(2, startId);
+            }
             pStmt.execute();
             ResultSet rs = pStmt.getResultSet();
             while (rs.next())
+            {
               //get the permission order from data base
               String principalName=rs.getString(1);
               String permission=rs.getString(2);
               String permType=rs.getString(3);
               String permOrder=rs.getString(4);
               //translate to string version
               String myPermission = AccessControlList.txtValue(Integer.parseInt(permission));
               //make it into an object
               AccessControlForSingleFile acfsf =
             	  new AccessControlForSingleFile(docId, principalName, myPermission, permType, permOrder);
               accessControl.add(acfsf);
+            }
             pStmt.close();
         }//try
         catch (SQLException e)
+        {
           throw e;
+        }
         finally
+        {
           try
+          {
             pStmt.close();
+          }
           finally
+          {
             DBConnectionPool.returnDBConnection(conn, serialNumber);
+          }
+        }
         return accessControl;
       }//getPermissions
       /**
         * Check if the users array has allow rules for given users, docid and
         * permission.

... This diff was truncated because it exceeds the maximum size that can be displayed.

Also available in: Unified diff

Project

General

Profile

Metacat

Revision 5098

Added by daigle about 15 years ago