Metacat

import edu.ucsb.nceas.metacat.DocInfoHandler;

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.accesscontrol.XMLAccessAccess;

import edu.ucsb.nceas.metacat.accesscontrol.XMLAccessDAO;

import edu.ucsb.nceas.metacat.shared.AccessException;

import edu.ucsb.nceas.metacat.util.DocumentUtil;

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;

    throws InsufficientKarmaException, MetacatException, MetacatInaccessibleException, AccessControlException{

            permOrder = "allowFirst";

        getMetacatClient().setAccess(metaDocId, "public", "read", permissionType, permOrder);*/

        setPublicReadAccess(permissionType, metaDocId) ;

            //getMetacatClient().setAccess(docId, "public", "read", permissionType, permOrder);

            setPublicReadAccess(permissionType, docId);

    /*

     * Set up public access by using accessblock to replace old success rules.

     * First, we need to get original access rules.

     * Second, remove all access rules of the user public, then add the new rules. 

     */

    private void setPublicReadAccess(String permissionType, String docid) 

        throws InsufficientKarmaException, MetacatException, MetacatInaccessibleException, AccessControlException{

      String originalAccessBlock = getMetacatClient().getAccessControl(docid);

      Vector<XMLAccessDAO> accessList = parseAccessXMLBlock(docid, originalAccessBlock);

      if(accessList != null  && !accessList.isEmpty()) {

        //there are some access rules in the metacat server for this docid

        XMLAccessDAO rule = accessList.elementAt(0);

        //we should persist the perm order from original access block

        String permOrder = rule.getPermOrder();

        //remove all public access rule but preserver other access rules.

        removeAllPublicAccessRules(accessList);

        //generate a new access rule and add it to the list

        XMLAccessDAO newRule = generateXMLAccessDAO(docid, AccessControlInterface.PUBLIC,

            AccessControlInterface.READSTRING, permissionType, permOrder);

        accessList.add(newRule);

      } else {

        //generate a new access rule and add it to the list

        accessList = new Vector<XMLAccessDAO>();

        XMLAccessDAO newRule = generateXMLAccessDAO(docid, AccessControlInterface.PUBLIC,

            AccessControlInterface.READSTRING, permissionType, AccessControlInterface.ALLOWFIRST);

        accessList.add(newRule);

      }

      //transform the new XMLAccessDAO object list to the String 

      AccessControlForSingleFile controller = new AccessControlForSingleFile(docid);

      String accessBlock = controller.getAccessString(accessList);

      //send the access block to the metacat

      getMetacatClient().setAccess(docid, accessBlock);

    }

    /*

     * Parse the access xml block to get access rule list object.

     */

    private Vector<XMLAccessDAO> parseAccessXMLBlock(String docId, String accessXMLBlock) throws AccessControlException{

      try { 

        // use DocInfoHandler to parse the access section into DAO objects

        XMLReader parser = null;

        DocInfoHandler docInfoHandler = new DocInfoHandler(docId); 

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

        XMLAccessAccess xmlAccessAccess = new XMLAccessAccess();

         Vector<XMLAccessDAO> accessRuleList = docInfoHandler.getAccessControlList();

         return accessRuleList;

      } catch (PropertyNotFoundException pnfe) {

        throw new AccessControlException("ClientViewHelper.parseAccessXMLBlock - "

            + "property error when replacing permissions: " + pnfe.getMessage());

      } catch (AccessException ae) {

        throw new AccessControlException("ClientViewHelper.parseAccessXMLBlock - "

            + "DB access error when replacing permissions: " + ae.getMessage());

      } catch (SAXException se) {

        throw new AccessControlException("ClientViewHelper.parseAccessXMLBlock - "

            + "SAX error when replacing permissions: " + se.getMessage());

      } catch(IOException ioe) {

        throw new AccessControlException("ClientViewHelper.parseAccessXMLBlock - "

            + "I/O error when replacing permissions: " + ioe.getMessage());

      }

    }

    /*

     * Populate xmlAccessDAO object with the some parameters.

     */

    private XMLAccessDAO generateXMLAccessDAO(String docid, String principalName,

        String permission, String permType, String permOrder) {

      String identifier = DocumentUtil.getDocIdFromString(docid);

      XMLAccessDAO xmlAccessDAO = new XMLAccessDAO();

      xmlAccessDAO.setDocId(identifier);

      xmlAccessDAO.setPrincipalName(principalName);

      xmlAccessDAO.setPermission(Integer.valueOf(AccessControlList.intValue(permission)).longValue());

      xmlAccessDAO.setPermType(permType);

      xmlAccessDAO.setPermOrder(permOrder);

      return xmlAccessDAO;

    }

    /*

     * Remove every access rule for user public from the specified access rule list

     */

    private void removeAllPublicAccessRules(Vector<XMLAccessDAO> accessList) {

      if(accessList != null && !accessList.isEmpty()) {

        Vector<Integer> removingIndexList = new Vector<Integer>();

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

          XMLAccessDAO rule = accessList.elementAt(i);

          if(rule != null && rule.getPrincipalName() != null && rule.getPrincipalName().equalsIgnoreCase(AccessControlInterface.PUBLIC)) {

            //store the index which should be remove

            removingIndexList.add(new Integer(i));

          }      

        }

        if(!removingIndexList.isEmpty()) {

          for(int i=removingIndexList.size()-1; i>=0; i--) {

            accessList.remove(removingIndexList.elementAt(i).intValue());

          }

       }

      }

    }