Metacat

      throws McdbException

     try {

        if (containDocumentOwner(userPackage, docId))

         {

           return true;

         }

         else

         {

             PermissionController controller =

                                   new PermissionController(inlineDataId, false);

             return controller.hasPermission(user, groups, myPermission);

         }

    } catch (SQLException e) {

        throw new McdbException(e.getMessage());

    }

                                                throws McdbException

                             throws McdbException

       Hashtable<String, String> unAccessibleIdList = new Hashtable();

       if (user == null) {

           return unAccessibleIdList;

       }

       Hashtable allIdList;

       try {

           allIdList = getAllInlineDataIdList(docid);

       } catch (SQLException e) {

           throw new McdbException(e.getMessage());

       }

       Enumeration<String> en = allIdList.keys();

		try {

            xmlFileContents = FileUtil.readFileToString(documentPath);

	     } catch (UtilException e) {

             throw new McdbException(e.getMessage());

         } catch (IOException e) {

             throw new McdbException(e.getMessage());

			throws McdbException {

        		throw new McdbException("Could not find end tag for distribution");

    private String stripInline21XData(String xmlFileContents, String inLineId) throws McdbException {

    			throw new McdbException("Could not find distribution number " + (i + 1));

    		throw new McdbException("Could not find end tag for distribution");

import java.io.OutputStream;

import edu.ucsb.nceas.metacat.client.InsufficientKarmaException;

                            readFromMetacat(request.getRemoteAddr(), response, response.getOutputStream(), docid, qformat,

                                    user, groups, withInlineData, params);

                        readFromMetacat(request.getRemoteAddr(), response, response.getOutputStream(), docid, qformat,

                                user, groups, withInlineData, params);

     * @throws PropertyNotFoundException 

     * @throws ParseLSIDException 

     * @throws InsufficientKarmaException 

    public void readFromMetacat(String ipAddress,

            HttpServletResponse response, OutputStream out, String docid, String qformat,

            String user, String[] groups, boolean withInlineData, 

            Hashtable<String, String[]> params) throws ClassNotFoundException, 

            IOException, SQLException, McdbException, PropertyNotFoundException, 

            ParseLSIDException, InsufficientKarmaException {

        Logger logMetacat = Logger.getLogger(MetacatHandler.class);

                InsufficientKarmaException e = new InsufficientKarmaException("User " + user

                // this is data file, so find the path on disk for the file

                if (response != null) {

                    // MIME type

                    String contentType = servletContext.getMimeType(filename);

                    if (contentType == null) {

                        ContentTypeProvider provider = new ContentTypeProvider(

                                docid);

                        contentType = provider.getContentType();

                        logMetacat.info("MetaCatServlet.readFromMetacat - Final contenttype is: "

                                + contentType);

                    }

                    response.setContentType(contentType);

                    // Set the output filename on the response

                    String outputname = generateOutputName(docid, params, doc);                    

                    response.setHeader("Content-Disposition",

                            "attachment; filename=\"" + outputname + "\"");

                // Write the data to the output stream

                    if (response != null) {

                        response.setContentType("text/xml"); //MIME type

                        response.setHeader("Content-Disposition",

                                "attachment; filename=" + docid + ".xml");

                    }

                        PrintWriter pw = new PrintWriter(out);

                        doc.toXml(pw, user, groups, withInlineData);               

                    } catch (McdbException e) {

                        PrintWriter pw = new PrintWriter(out);

                        doc.toXmlFromDb(pw, user, groups, withInlineData);

                    if (response != null) {

                        response.setContentType("text/html"); //MIME type

                    }

                    PrintWriter pw = new PrintWriter(out);

                            qformat, pw, params, null);

            EventLog.getInstance().log(ipAddress, user, docid, "read");

        } catch (PropertyNotFoundException except) {

    /**

     * Create a filename to be used for naming a downloaded document

     * @param docid the identifier of the document to be named

     * @param params the parameters of the request

     * @param doc the DocumentImpl of the document to be named

     * @return String containing a name for the download

     */

    private String generateOutputName(String docid,

            Hashtable<String, String[]> params, DocumentImpl doc) {

        String outputname = null;

        // check for the existence of a metadatadocid parameter,

        // if this is sent, then send a filename which contains both

        // the metadata docid and the data docid, so the link with

        // metadata is explicitly encoded in the filename.

        String metadatadocid = null;

        Vector<String> nameparts = new Vector<String>();

        if(params.containsKey("metadatadocid")) {

            metadatadocid = params.get("metadatadocid")[0];

        }

        if (metadatadocid != null && !metadatadocid.equals("")) {

            nameparts.add(metadatadocid);

        }

        // we'll always have the docid, include it in the name

        String doctype = doc.getDoctype();

        // TODO: fix this to lookup the associated FGDC metadata document,

        // and grab the doctype tag for it.  These should be set to something 

        // consistent, not 'metadata' as it stands...

        //if (!doctype.equals("metadata")) {

        //    nameparts.add(docid);

        //} 

        nameparts.add(docid);

        // Set the name of the data file to the entity name plus docid,

        // or if that is unavailable, use the docid alone

        String docname = doc.getDocname();

        if (docname != null && !docname.equals("")) {

            nameparts.add(docname); 

        }

        // combine the name elements with a dash, using a 'join' equivalent

        String delimiter = "-";

        Iterator<String> iter = nameparts.iterator();

        StringBuffer buffer = new StringBuffer(iter.next());

        while (iter.hasNext()) buffer.append(delimiter).append(iter.next());

        outputname = buffer.toString();

        return outputname;

    }

    private static String appendRev(String docid) throws PropertyNotFoundException, SQLException, McdbDocNotFoundException {

                throw new McdbDocNotFoundException("the requested docid '"

/**

 *  '$RCSfile$'

 *  Copyright: 2000 Regents of the University of California and the

 *              National Center for Ecological Analysis and Synthesis

 *

 *   '$Author: Serhan AKIN $'

 *     '$Date: 2009-06-13 15:28:13 +0300  $'

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 */

package edu.ucsb.nceas.metacat.dataone;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import java.sql.SQLException;

import java.util.Date;

import java.util.Enumeration;

import java.util.Hashtable;

import java.util.Timer;

import javax.servlet.ServletContext;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import org.dataone.service.exceptions.IdentifierNotUnique;

import org.dataone.service.exceptions.InsufficientResources;

import org.dataone.service.exceptions.InvalidRequest;

import org.dataone.service.exceptions.InvalidSystemMetadata;

import org.dataone.service.exceptions.InvalidToken;

import org.dataone.service.exceptions.NotAuthorized;

import org.dataone.service.exceptions.NotFound;

import org.dataone.service.exceptions.NotImplemented;

import org.dataone.service.exceptions.ServiceFailure;

import org.dataone.service.exceptions.UnsupportedType;

import org.dataone.service.mn.MemberNodeCrud;

import org.dataone.service.types.AuthToken;

import org.dataone.service.types.Checksum;

import org.dataone.service.types.DescribeResponse;

import org.dataone.service.types.IdentifierType;

import org.dataone.service.types.LogRecordSet;

import org.dataone.service.types.SystemMetadata;

import com.gc.iotools.stream.is.InputStreamFromOutputStream;

import edu.ucsb.nceas.metacat.IdentifierManager;

import edu.ucsb.nceas.metacat.McdbDocNotFoundException;

import edu.ucsb.nceas.metacat.McdbException;

import edu.ucsb.nceas.metacat.MetacatHandler;

import edu.ucsb.nceas.metacat.client.InsufficientKarmaException;

import edu.ucsb.nceas.metacat.service.SessionService;

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

import edu.ucsb.nceas.utilities.ParseLSIDException;

import edu.ucsb.nceas.utilities.PropertyNotFoundException;

/**

 * 

 * Implements DataONE MemberNode CRUD API for Metacat. 

 * 

 * @author Matthew Jones

 */

public class CrudService implements MemberNodeCrud {

    private ServletContext servletContext;

    private HttpServletRequest request;

    private HttpServletResponse response;

//    private Logger logMetacat;

    private MetacatHandler handler;

//    private String username;

//    private String password;

//    private String sessionId;

//    private String[] groupNames;

    private Hashtable<String, String[]> params;

    /**

     * Initializes new instance by setting servlet context,request and response.

     * TODO: remove dependency on Servlet infrastructure

     * TODO: Make this a real service, and make it a Singleton

     */

    public CrudService(ServletContext servletContext,

            HttpServletRequest request, HttpServletResponse response) {

        this.servletContext = servletContext;

        this.request = request;

        this.response = response;

        handler = new MetacatHandler(this.servletContext, new Timer());

        initParams();

//        loadSessionData();

    }

    /**

     *  copies request parameters to a Hashtable which is given as argument to 

     *  native MetacatHandler functions  

     */

    private void initParams() {

        String name = null;

        String[] value = null;

        params = new Hashtable<String, String[]>();

        Enumeration paramlist = request.getParameterNames();

        while (paramlist.hasMoreElements()) {

            name = (String) paramlist.nextElement();

            value = request.getParameterValues(name);

            params.put(name, value);

        }

    }

    /**

     * 

     * Load user details of metacat session from the request 

     * 

     */

//    private void loadSessionData() {

//        SessionData sessionData = RequestUtil.getSessionData(request);

//

//        // TODO: validate the session before allowing these values to be set

//        username = sessionData.getUserName();

//        password = sessionData.getPassword();

//        groupNames = sessionData.getGroupNames();

//        sessionId = sessionData.getId();

//

//        if (username == null) {

//            username = "public";

//        }

//    }

    /*

     * Look up the information on the session using the token provided in

     * the AuthToken.  The Session should have all relevant user information.

     * If the session has expired or is invalid, the 'public' session will

     * be returned, giving the user anonymous access.

     */

    private static SessionData getSessionData(AuthToken token) {

        SessionData sessionData = null;

        String sessionId = token.getToken();

        // if the session id is registered in SessionService, get the

        // SessionData for it. Otherwise, use the public session.

        if (SessionService.isSessionRegistered(sessionId)) {

            sessionData = SessionService.getRegisteredSession(sessionId);

        } else {

            sessionData = SessionService.getPublicSession();

        }

        return sessionData;

    }

    public IdentifierType create(AuthToken token, IdentifierType guid, 

            InputStream object, SystemMetadata sysmeta) throws InvalidToken, 

            ServiceFailure, NotAuthorized, IdentifierNotUnique, UnsupportedType, 

            InsufficientResources, InvalidSystemMetadata, NotImplemented {

        throw new NotImplemented(1000, "This method not yet implemented.");

    }

    public IdentifierType delete(AuthToken token, IdentifierType guid)

            throws InvalidToken, ServiceFailure, NotAuthorized, NotFound, 

            NotImplemented {

        throw new NotImplemented(1000, "This method not yet implemented.");

    }

    public DescribeResponse describe(AuthToken token, IdentifierType guid)

            throws InvalidToken, ServiceFailure, NotAuthorized, NotFound, 

            NotImplemented {

        throw new NotImplemented(1000, "This method not yet implemented.");

    }

    public InputStream get(AuthToken token, IdentifierType guid)

            throws InvalidToken, ServiceFailure, NotAuthorized, NotFound, 

            NotImplemented {

        // Retrieve the session information from the AuthToken

        // If the session is expired, then the user is 'public'

        final SessionData sessionData = getSessionData(token);

        // Look up the localId for this global identifier

        IdentifierManager im = IdentifierManager.getInstance();

        try {

            final String localId = im.getLocalId(guid.getIdentifier());

            final InputStreamFromOutputStream<String> objectStream = 

                new InputStreamFromOutputStream<String>() {

                @Override

                public String produce(final OutputStream dataSink) throws Exception {

                    try {

                        handler.readFromMetacat(request.getRemoteAddr(), null, 

                                dataSink, localId, "xml",

                                sessionData.getUserName(), 

                                sessionData.getGroupNames(), true, params);

                    } catch (PropertyNotFoundException e) {

                        throw new ServiceFailure(1030, e.getMessage());

                    } catch (ClassNotFoundException e) {

                        throw new ServiceFailure(1030, e.getMessage());

                    } catch (IOException e) {

                        throw new ServiceFailure(1030, e.getMessage());

                    } catch (SQLException e) {

                        throw new ServiceFailure(1030, e.getMessage());

                    } catch (McdbException e) {

                        throw new ServiceFailure(1030, e.getMessage());

                    } catch (ParseLSIDException e) {

                        throw new NotFound(1020, e.getMessage());

                    } catch (InsufficientKarmaException e) {

                        throw new NotAuthorized(1000, "Not authorized for get().");

                    }

                    return "Completed";

                }

            };

            return objectStream;

        } catch (McdbDocNotFoundException e) {

            throw new NotFound(1020, e.getMessage());

        }

/*    

 *      Alternative approach that uses Piped streams, but requires thread handling

 *      which makes exception handling difficult (because exceptions fall off the

 *      calling thread, terminating the thread.

 *      

        // Look up the localId for this global identifier

        IdentifierManager im = IdentifierManager.getInstance();

        try {

            final String localId = im.getLocalId(guid.getIdentifier());

            // Now use that localId to read the object and return it

            params.put("docid", new String[] { localId });        

            final PipedInputStream in = new PipedInputStream();

            new Thread(

                    new Runnable() {

                        public void run() {

                            try {

                                PipedOutputStream out = new PipedOutputStream(in);

                                handler.readFromMetacat(request.getRemoteAddr(), null, 

                                        out, localId, "xml",

                                        username, groupNames, true, params);

                            } catch (PropertyNotFoundException e) {

                                throw new ServiceFailure(1030, e.getMessage());

                            } catch (ClassNotFoundException e) {

                                throw new ServiceFailure(1030, e.getMessage());

                            } catch (IOException e) {

                                throw new ServiceFailure(1030, e.getMessage());

                            } catch (SQLException e) {

                                throw new ServiceFailure(1030, e.getMessage());

                            } catch (McdbException e) {

                                throw new ServiceFailure(1030, e.getMessage());

                            } catch (ParseLSIDException e) {

                                throw new NotFound(1020, e.getMessage());

                            } catch (InsufficientKarmaException e) {

                                throw new NotAuthorized(1000, "Not authorized for get().");

                            }

                        }

                    }

            ).start();

            return in;

        } catch (McdbDocNotFoundException e) {

            throw new NotFound(1020, e.getMessage());

        }        

*/

    }

    public Checksum getChecksum(AuthToken token, IdentifierType guid)

            throws InvalidToken, ServiceFailure, NotAuthorized, NotFound, 

            InvalidRequest, NotImplemented {

        throw new NotImplemented(1000, "This method not yet implemented.");

    }

    public Checksum getChecksum(AuthToken token, IdentifierType guid, 

            String checksumAlgorithm) throws InvalidToken, ServiceFailure, 

            NotAuthorized, NotFound, InvalidRequest, NotImplemented {

        throw new NotImplemented(1000, "This method not yet implemented.");

    }

    public LogRecordSet getLogRecords(AuthToken token, Date fromDate, Date toDate)

            throws InvalidToken, ServiceFailure, NotAuthorized, InvalidRequest, 

            NotImplemented {

        throw new NotImplemented(1000, "This method not yet implemented.");

    }

    public SystemMetadata getSystemMetadata(AuthToken token, IdentifierType guid)

            throws InvalidToken, ServiceFailure, NotAuthorized, NotFound, 

            InvalidRequest, NotImplemented {

        throw new NotImplemented(1000, "This method not yet implemented.");

    }

    public IdentifierType update(AuthToken token, IdentifierType guid, 

            InputStream object, IdentifierType obsoletedGuid, SystemMetadata sysmeta) 

            throws InvalidToken, ServiceFailure, NotAuthorized, IdentifierNotUnique, 

            UnsupportedType, InsufficientResources, NotFound, InvalidSystemMetadata, 

            NotImplemented {

        throw new NotImplemented(1000, "This method not yet implemented.");

    }

}